Add support for always and except

docs/guide/partial-reloads.md

@@ -46,9 +46,6 @@ router.visit(url, {
 
 ## Except certain props
 
-> [!WARNING]
-> The `except` option is not yet supported by the Inertia Rails.
-
 :::tabs key:frameworks
 == Vue
 
@@ -204,13 +201,7 @@ On the inverse, you can use the `InertiaRails.always` method to specify that a p
 class UsersController < ApplicationController
   def index
     render inertia: 'Users/Index', props: {
-      users: InertiaRails.always(User.all),
-
-      # Also works with block:
-      # users: InertiaRails.always { User.all },
-
-      # Also works with a lambda:
-      # users: InertiaRails.always(-> { User.all }),
+      users: InertiaRails.always { User.all },
     }
   end
 end
@@ -236,6 +227,11 @@ class UsersController < ApplicationController
       # OPTIONALLY included on partial reloads
       # ONLY evaluated when needed
       users: InertiaRails.lazy { User.all },
+
+      # ALWAYS included on standard visits
+      # ALWAYS included on partial reloads
+      # ALWAYS evaluated
+      users: InertiaRails.always(User.all),
     }
   end
 end

lib/inertia_rails/always_prop.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module InertiaRails
+  class AlwaysProp < BaseProp
+  end
+end

lib/inertia_rails/base_prop.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module InertiaRails
+  # Base class for all props.
+  class BaseProp
+    def initialize(&block)
+      @block = block
+    end
+
+    def call(controller)
+      controller.instance_exec(&@block)
+    end
+  end
+end

lib/inertia_rails/inertia_rails.rb

@@ -1,20 +1,26 @@
-# Needed for `thread_mattr_accessor`
-require 'active_support/core_ext/module/attribute_accessors_per_thread'
-require 'inertia_rails/lazy'
+require 'inertia_rails/base_prop'
+require 'inertia_rails/always_prop'
+require 'inertia_rails/lazy_prop'
 require 'inertia_rails/configuration'
 
 module InertiaRails
-  CONFIGURATION = Configuration.default
+  class << self
+    CONFIGURATION = Configuration.default
 
-  def self.configure
-    yield(CONFIGURATION)
-  end
+    def configure
+      yield(CONFIGURATION)
+    end
 
-  def self.configuration
-    CONFIGURATION
-  end
+    def configuration
+      CONFIGURATION
+    end
+
+    def lazy(value = nil, &block)
+      LazyProp.new(value, &block)
+    end
 
-  def self.lazy(value = nil, &block)
-    InertiaRails::Lazy.new(value, &block)
+    def always(&block)
+      AlwaysProp.new(&block)
+    end
   end
 end

lib/inertia_rails/lazy_prop.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module InertiaRails
+  class LazyProp < BaseProp
+    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(controller)
+      value.respond_to?(:call) ? controller.instance_exec(&value) : value
+    end
+
+    def value
+      @value.nil? ? @block : @value
+    end
+  end
+end

lib/inertia_rails/renderer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'net/http'
 require 'json'
 require_relative "inertia_rails"
@@ -64,24 +66,34 @@ def shared_data
     # Functionally, this permits using either string or symbol keys in the controller. Since the results
     # is cast to json, we should treat string/symbol keys as identical.
     def merge_props(shared_data, props)
-      shared_data.deep_symbolize_keys.send(@deep_merge ? :deep_merge : :merge, props.deep_symbolize_keys)
+      if @deep_merge
+        shared_data.deep_symbolize_keys.deep_merge!(props.deep_symbolize_keys)
+      else
+        shared_data.symbolize_keys.merge(props.symbolize_keys)
+      end
     end
 
     def computed_props
       _props = merge_props(shared_data, props).select do |key, prop|
         if rendering_partial_component?
-          key.in? partial_keys
+          partial_keys.none? || key.in?(partial_keys) || prop.is_a?(AlwaysProp)
         else
-          !prop.is_a?(InertiaRails::Lazy)
+          !prop.is_a?(LazyProp)
         end
       end
 
-      deep_transform_values(
-        _props,
-        lambda do |prop|
-          prop.respond_to?(:call) ? controller.instance_exec(&prop) : prop
+      drop_partial_except_keys(_props) if rendering_partial_component?
+
+      deep_transform_values _props do |prop|
+        case prop
+        when BaseProp
+          prop.call(controller)
+        when Proc
+          controller.instance_exec(&prop)
+        else
+          prop
         end
-      )
+      end
     end
 
     def page
@@ -93,18 +105,32 @@ 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 drop_partial_except_keys(hash)
+      partial_except_keys.each do |key|
+        parts = key.to_s.split('.').map(&:to_sym)
+        *initial_keys, last_key = parts
+        current = initial_keys.any? ? hash.dig(*initial_keys) : hash
+
+        current.delete(last_key) if current.is_a?(Hash) && !current[last_key].is_a?(AlwaysProp)
+      end
     end
 
     def partial_keys
       (@request.headers['X-Inertia-Partial-Data'] || '').split(',').compact.map(&:to_sym)
     end
 
+    def partial_except_keys
+      (@request.headers['X-Inertia-Partial-Except'] || '').split(',').filter_map(&:to_sym)
+    end
+
     def rendering_partial_component?
-      @request.inertia_partial? && @request.headers['X-Inertia-Partial-Component'] == component
+      @request.headers['X-Inertia-Partial-Component'] == component
     end
 
     def resolve_component(component)

lib/patches/request.rb

@@ -4,6 +4,6 @@ def inertia?
   end
 
   def inertia_partial?
-    key? 'HTTP_X_INERTIA_PARTIAL_DATA'
+    key?('HTTP_X_INERTIA_PARTIAL_COMPONENT')
   end
 end

spec/dummy/app/controllers/application_controller.rb

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

spec/dummy/app/controllers/inertia_render_test_controller.rb

@@ -7,6 +7,23 @@ def props
     }
   end
 
+  def except_props
+    render inertia: 'TestComponent', props: {
+      flat: 'flat param',
+      lazy: InertiaRails.lazy('lazy param'),
+      nested_lazy: InertiaRails.lazy do
+        {
+          first: 'first nested lazy param',
+        }
+      end,
+      nested: {
+        first: 'first nested param',
+        second: 'second nested param'
+      },
+      always: InertiaRails.always { 'always prop' }
+    }
+  end
+
   def view_data
     render inertia: 'TestComponent', view_data: {
       name: 'Brian',
@@ -34,4 +51,15 @@ def lazy_props
       grit: InertiaRails.lazy(->{ 'intense' })
     }
   end
+
+  def always_props
+    render inertia: 'TestComponent', props: {
+      always: InertiaRails.always { 'always prop' },
+      regular: 'regular prop',
+      lazy: InertiaRails.lazy do
+        'lazy prop'
+      end,
+      another_lazy: InertiaRails.lazy(->{ 'another lazy prop' })
+    }
+  end
 end

spec/dummy/config/routes.rb

@@ -30,6 +30,8 @@
   get 'error_500' => 'inertia_test#error_500'
   get 'content_type_test' => 'inertia_test#content_type_test'
   get 'lazy_props' => 'inertia_render_test#lazy_props'
+  get 'always_props' => 'inertia_render_test#always_props'
+  get 'except_props' => 'inertia_render_test#except_props'
   get 'non_inertiafied' => 'inertia_test#non_inertiafied'
 
   get 'instance_props_test' => 'inertia_rails_mimic#instance_props_test'

spec/inertia/always_prop_spec.rb

@@ -0,0 +1,3 @@
+RSpec.describe InertiaRails::AlwaysProp do
+  it_behaves_like 'base prop'
+end

spec/inertia/base_prop_spec.rb

@@ -0,0 +1,3 @@
+RSpec.describe InertiaRails::BaseProp do
+  it_behaves_like 'base prop'
+end

spec/inertia/lazy_prop_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe InertiaRails::LazyProp do
+  it_behaves_like 'base prop'
+
+  describe '#call' do
+    subject(:call) { prop.call(controller) }
+    let(:prop) { described_class.new('value') }
+    let(:controller) { ApplicationController.new }
+
+    it { is_expected.to eq('value') }
+
+    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 a callable value' do
+      let(:prop) { described_class.new(-> { 'callable' }) }
+
+      it { is_expected.to eq('callable') }
+
+      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
+end