Do not wrap simple values in procs

Author: skryukov

lib/inertia_rails/lazy.rb

@@ -1,28 +1,20 @@
+# frozen_string_literal: true
+
 module InertiaRails
   class Lazy
     def initialize(value = nil, &block)
+      raise ArgumentError, 'You must provide either a value or a block, not both' if value && block
+
       @value = value
       @block = block
     end
 
-    def call
-      to_proc.call
+    def call(controller)
+      value.respond_to?(:call) ? controller.instance_exec(&value) : value
     end
 
-    def to_proc
-      # This is called by controller.instance_exec, which changes self to the
-      # controller instance. That makes the instance variables unavailable to the
-      # proc via closure. Copying the instance variables to local variables before
-      # the proc is returned keeps them in scope for the returned proc.
-      value = @value
-      block = @block
-      if value.respond_to?(:call)
-        value
-      elsif value
-        Proc.new { value }
-      else
-        block
-      end
+    def value
+      @value.nil? ? @block : @value
     end
   end
 end

lib/inertia_rails/renderer.rb

@@ -76,12 +76,16 @@ def computed_props
         end
       end
 
-      deep_transform_values(
-        _props,
-        lambda do |prop|
-          prop.respond_to?(:call) ? controller.instance_exec(&prop) : prop
+      deep_transform_values _props do |prop|
+        case prop
+        when Lazy
+          prop.call(controller)
+        when Proc
+          controller.instance_exec(&prop)
+        else
+          prop
         end
-      )
+      end
     end
 
     def page
@@ -93,10 +97,10 @@ def page
       }
     end
 
-    def deep_transform_values(hash, proc)
-      return proc.call(hash) unless hash.is_a? Hash
+    def deep_transform_values(hash, &block)
+      return block.call(hash) unless hash.is_a? Hash
 
-      hash.transform_values {|value| deep_transform_values(value, proc)}
+      hash.transform_values {|value| deep_transform_values(value, &block)}
     end
 
     def partial_keys

spec/dummy/app/controllers/application_controller.rb

@@ -1,2 +1,5 @@
 class ApplicationController < ActionController::Base
+  def controller_method
+    'controller_method value'
+  end
 end

spec/inertia/lazy_spec.rb

@@ -1,20 +1,44 @@
 RSpec.describe InertiaRails::Lazy do
   describe '#call' do
-    context 'with a value' do
-      it 'returns the value' do
-        expect(InertiaRails::Lazy.new('thing').call).to eq('thing')
-      end
-    end
+    subject(:call) { prop.call(controller) }
+    let(:prop) { described_class.new('value') }
+    let(:controller) { ApplicationController.new }
+
+    it { is_expected.to eq('value') }
 
     context 'with a callable value' do
-      it 'returns the result of the callable value' do
-        expect(InertiaRails::Lazy.new(->{ 'thing' }).call).to eq('thing')
+      let(:prop) { described_class.new(-> { 'callable' }) }
+
+      it { is_expected.to eq('callable') }
+
+      context "with false as value" do
+        let(:prop) { described_class.new(false) }
+
+        it { is_expected.to eq(false) }
+      end
+
+      context "with nil as value" do
+        let(:prop) { described_class.new(nil) }
+
+        it { is_expected.to eq(nil) }
+      end
+
+      context "with dependency on the context of a controller" do
+        let(:prop) { described_class.new(-> { controller_method }) }
+
+        it { is_expected.to eq('controller_method value') }
       end
     end
 
     context 'with a block' do
-      it 'returns the result of the block' do
-        expect(InertiaRails::Lazy.new{'thing'}.call).to eq('thing')
+      let(:prop) { described_class.new { 'block' } }
+
+      it { is_expected.to eq('block') }
+
+      context "with dependency on the context of a controller" do
+        let(:prop) { described_class.new { controller_method } }
+
+        it { is_expected.to eq('controller_method value') }
       end
     end
   end