feat: add inertia_config to enable controller-specific config

.gitignore

@@ -20,3 +20,6 @@
 
 # Appraisal
 gemfiles/*.gemfile.lock
+
+# Local files, such as .env.development.local
+*.local

bin/console

@@ -1,14 +1,13 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "inertia_rails/rails"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
+require "rubygems"
+require "bundler/setup"
+require "rails/all"
+require "inertia_rails"
 
 require "irb"
 IRB.start(__FILE__)

lib/inertia_rails/configuration.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module InertiaRails
+  class Configuration
+    DEFAULTS = {
+      default_render: false,
+
+      # Let Rails decide which layout should be used based on the controller configuration.
+      layout: true,
+
+      deep_merge_shared_data: false,
+      ssr_enabled: false,
+      ssr_url: 'http://localhost:13714',
+      version: nil,
+    }.freeze
+
+    OPTION_NAMES = DEFAULTS.keys.freeze
+
+    protected attr_reader :controller
+    protected attr_reader :options
+
+    def initialize(controller: nil, **attrs)
+      @controller = controller
+      @options = attrs.extract!(*OPTION_NAMES)
+
+      unless attrs.empty?
+        raise ArgumentError, "Unknown options for #{self.class}: #{attrs.keys}"
+      end
+    end
+
+    def bind_controller(controller)
+      Configuration.new(**@options, controller: controller)
+    end
+
+    def to_h
+      @options.to_h
+    end
+
+    def merge(config)
+      Configuration.new(**@options.merge(config.options))
+    end
+
+    OPTION_NAMES.each do |option|
+      define_method(option) {
+        evaluate_option @options[option]
+      }
+      define_method("#{option}=") { |value|
+        @options[option] = value
+      }
+    end
+
+    def self.default
+      new(**DEFAULTS)
+    end
+
+  private
+
+    def evaluate_option(value)
+      return value unless value.respond_to?(:call)
+      return value.call unless controller
+      controller.instance_exec(&value)
+    end
+  end
+end

lib/inertia_rails/controller.rb

@@ -5,33 +5,25 @@ module Controller
     extend ActiveSupport::Concern
 
     included do
-      helper_method :inertia_headers
-
-      before_action do
-        error_sharing = proc do
-          # :inertia_errors are deleted from the session by the middleware
-          if @_request && session[:inertia_errors].present?
-            { errors: session[:inertia_errors] }
-          else
-            {}
-          end
-        end
-
-        @_inertia_shared_plain_data ||= {}
-        @_inertia_shared_blocks ||= [error_sharing]
-        @_inertia_html_headers ||= []
-      end
-
       after_action do
-        cookies['XSRF-TOKEN'] = form_authenticity_token unless !protect_against_forgery?
+        cookies['XSRF-TOKEN'] = form_authenticity_token if protect_against_forgery?
       end
     end
 
     module ClassMethods
-      def inertia_share(hash = nil, &block)
-        before_action do
-          @_inertia_shared_plain_data = @_inertia_shared_plain_data.merge(hash) if hash
-          @_inertia_shared_blocks = @_inertia_shared_blocks + [block] if block_given?
+      def inertia_share(**attrs, &block)
+        @inertia_shared_data ||= []
+        @inertia_shared_data << attrs unless attrs.empty?
+        @inertia_shared_data << block if block
+      end
+
+      def inertia_config(**attrs)
+        config = InertiaRails::Configuration.new(**attrs)
+
+        if @inertia_configuration
+          @inertia_configuration.merge!(config)
+        else
+          @inertia_configuration = config
         end
       end
 
@@ -41,28 +33,25 @@ def use_inertia_instance_props
           @_inertia_skip_props = view_assigns.keys + ['_inertia_skip_props']
         end
       end
-    end
 
-    def inertia_headers
-      @_inertia_html_headers.join.html_safe
-    end
+      def _inertia_configuration
+        config = superclass.try(:_inertia_configuration) || ::InertiaRails.configuration
+        @inertia_configuration ? config.merge(@inertia_configuration) : config
+      end
 
-    def inertia_headers=(value)
-      @_inertia_html_headers = value
+      def _inertia_shared_data
+        [*superclass.try(:_inertia_shared_data), *@inertia_shared_data]
+      end
     end
 
     def default_render
-      if InertiaRails.default_render?
+      if inertia_configuration.default_render
         render(inertia: true)
       else
         super
       end
     end
 
-    def shared_data
-      (@_inertia_shared_plain_data || {}).merge(evaluated_blocks)
-    end
-
     def redirect_to(options = {}, response_options = {})
       capture_inertia_errors(response_options)
       super(options, response_options)
@@ -77,19 +66,27 @@ def redirect_back(fallback_location:, allow_other_host: true, **options)
       )
     end
 
+    private
+
     def inertia_view_assigns
       return {} unless @_inertia_instance_props
       view_assigns.except(*@_inertia_skip_props)
     end
 
-    private
+    def inertia_configuration
+      self.class._inertia_configuration.bind_controller(self)
+    end
 
-    def inertia_layout
-      layout = ::InertiaRails.layout
+    def inertia_shared_data
+      initial_data = session[:inertia_errors].present? ? {errors: session[:inertia_errors]} : {}
 
-      # When the global configuration is not set, let Rails decide which layout
-      # should be used based on the controller configuration.
-      layout.nil? ? true : layout
+      self.class._inertia_shared_data.filter_map { |shared_data|
+        if shared_data.respond_to?(:call)
+          instance_exec(&shared_data)
+        else
+          shared_data
+        end
+      }.reduce(initial_data, &:merge)
     end
 
     def inertia_location(url)
@@ -102,9 +99,5 @@ def capture_inertia_errors(options)
         session[:inertia_errors] = inertia_errors
       end
     end
-
-    def evaluated_blocks
-      (@_inertia_shared_blocks || []).map { |block| instance_exec(&block) }.reduce(&:merge) || {}
-    end
   end
 end

lib/inertia_rails/inertia_rails.rb

@@ -1,52 +1,20 @@
 # Needed for `thread_mattr_accessor`
 require 'active_support/core_ext/module/attribute_accessors_per_thread'
 require 'inertia_rails/lazy'
+require 'inertia_rails/configuration'
 
 module InertiaRails
-  def self.configure
-    yield(Configuration)
-  end
-
-  def self.version
-    Configuration.evaluated_version
-  end
-
-  def self.layout
-    Configuration.layout
-  end
-
-  def self.ssr_enabled?
-    Configuration.ssr_enabled
-  end
+  CONFIGURATION = Configuration.default
 
-  def self.ssr_url
-    Configuration.ssr_url
-  end
-
-  def self.default_render?
-    Configuration.default_render
+  def self.configure
+    yield(CONFIGURATION)
   end
 
-  def self.deep_merge_shared_data?
-    Configuration.deep_merge_shared_data
+  def self.configuration
+    CONFIGURATION
   end
 
   def self.lazy(value = nil, &block)
     InertiaRails::Lazy.new(value, &block)
   end
-
-  private
-
-  module Configuration
-    mattr_accessor(:layout) { nil }
-    mattr_accessor(:version) { nil }
-    mattr_accessor(:ssr_enabled) { false }
-    mattr_accessor(:ssr_url) { 'http://localhost:13714' }
-    mattr_accessor(:default_render) { false }
-    mattr_accessor(:deep_merge_shared_data) { false }
-
-    def self.evaluated_version
-      self.version.respond_to?(:call) ? self.version.call : self.version
-    end
-  end
 end

lib/inertia_rails/middleware.rb

@@ -5,8 +5,7 @@ def initialize(app)
     end
 
     def call(env)
-      InertiaRailsRequest.new(@app, env)
-                         .response
+      InertiaRailsRequest.new(@app, env).response
     end
 
     class InertiaRailsRequest
@@ -58,11 +57,15 @@ def get?
         request_method == 'GET'
       end
 
+      def controller
+        @env["action_controller.instance"]
+      end
+
       def request_method
         @env['REQUEST_METHOD']
       end
 
-      def inertia_version
+      def client_version
         @env['HTTP_X_INERTIA_VERSION']
       end
 
@@ -71,17 +74,15 @@ def inertia_request?
       end
 
       def version_stale?
-        sent_version != saved_version
+        coerce_version(client_version) != coerce_version(server_version)
       end
 
-      def sent_version
-        return nil if inertia_version.nil?
-
-        InertiaRails.version.is_a?(Numeric) ? inertia_version.to_f : inertia_version
+      def server_version
+        controller.send(:inertia_configuration).version
       end
 
-      def saved_version
-        InertiaRails.version.is_a?(Numeric) ? InertiaRails.version.to_f : InertiaRails.version
+      def coerce_version(version)
+        server_version.is_a?(Numeric) ? version.to_f : version
       end
 
       def force_refresh(request)