refactor: avoid using global variables for shared data

Author: ElMassimo

lib/inertia_rails/controller.rb

@@ -5,22 +5,16 @@ module Controller
     extend ActiveSupport::Concern
 
     included do
-      before_action do
-        # :inertia_errors are deleted from the session by the middleware
-        InertiaRails.share(errors: session[:inertia_errors]) if session[:inertia_errors].present?
-      end
-
       after_action do
         cookies['XSRF-TOKEN'] = form_authenticity_token if protect_against_forgery?
       end
     end
 
     module ClassMethods
-      def inertia_share(**args, &block)
-        before_action do
-          InertiaRails.share(**args) if args
-          InertiaRails.share_block(block) if block
-        end
+      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)
@@ -44,6 +38,10 @@ def _inertia_configuration
         config = superclass.try(:_inertia_configuration) || ::InertiaRails.configuration
         @inertia_configuration ? config.merge(@inertia_configuration) : config
       end
+
+      def _inertia_shared_data
+        [*superclass.try(:_inertia_shared_data), *@inertia_shared_data]
+      end
     end
 
     def default_render
@@ -80,7 +78,15 @@ def inertia_configuration
     end
 
     def inertia_shared_data
-      ::InertiaRails.shared_data(self)
+      initial_data = session[:inertia_errors].present? ? {errors: session[:inertia_errors]} : {}
+
+      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)

lib/inertia_rails/inertia_rails.rb

@@ -4,9 +4,6 @@
 require 'inertia_rails/configuration'
 
 module InertiaRails
-  thread_mattr_accessor :threadsafe_shared_plain_data
-  thread_mattr_accessor :threadsafe_shared_blocks
-
   CONFIGURATION = Configuration.default
 
   def self.configure
@@ -17,50 +14,10 @@ def self.configuration
     CONFIGURATION
   end
 
-  # "Getters"
-  def self.shared_data(controller)
-    shared_plain_data.
-      merge!(evaluated_blocks(controller, shared_blocks))
-  end
-
-  # "Setters"
-  def self.share(**args)
-    self.shared_plain_data = self.shared_plain_data.merge(args)
-  end
-
-  def self.share_block(block)
-    self.shared_blocks = self.shared_blocks + [block]
-  end
-
   def self.reset!
-    self.shared_plain_data = {}
-    self.shared_blocks = []
   end
 
   def self.lazy(value = nil, &block)
     InertiaRails::Lazy.new(value, &block)
   end
-
-  private
-
-  # Getters and setters to provide default values for the threadsafe attributes
-  def self.shared_plain_data
-    self.threadsafe_shared_plain_data || {}
-  end
-
-  def self.shared_plain_data=(val)
-    self.threadsafe_shared_plain_data = val
-  end
-
-  def self.shared_blocks
-    self.threadsafe_shared_blocks || []
-  end
-
-  def self.shared_blocks=(val)
-    self.threadsafe_shared_blocks = val
-  end
-
-  def self.evaluated_blocks(controller,  blocks)
-    blocks.flat_map { |block| controller.instance_exec(&block) }.reduce(&:merge) || {}
-  end
 end

spec/inertia/sharing_spec.rb

@@ -54,52 +54,6 @@
     it { is_expected.to eq props.merge({ errors: errors }) }
   end
 
-  context 'multithreaded intertia share' do
-    let(:props) { { name: 'Michael', has_goat_status: true } }
-    it 'is expected to render props even when another thread shares Inertia data' do
-      start_thread1 = false
-      start_thread2 = false
-
-      thread1 = Thread.new do
-        sleep 0.1 until start_thread1
-
-        get share_multithreaded_path, headers: {'X-Inertia' => true}
-        expect(subject).to eq props
-      end
-
-      thread2 = Thread.new do
-        sleep 0.1 until start_thread2
-
-        # Would prefer to make this a second get request, but RSpec will overwrite
-        # the @response variable if another request is made in the second thread.
-        # This simulates the relevant effects of another call to a different
-        # controller with different values for inertia_share
-        InertiaRails.reset!
-        InertiaRails.share(name: 'Brian', has_goat_status: false)
-      end
-
-      # Thread 1 starts. The controller method runs inertia_share, then sleeps.
-      # Thread 2 then modifies the shared inertia data before Thread 1 stops sleeping
-      start_thread1 = true
-      sleep 0.5
-      start_thread2 = true
-
-      # Make sure that both threads finish before the block returns
-      thread1.join
-      thread2.join
-    end
-
-    it 'is expected not to leak shared data across requests' do
-      begin
-        get share_multithreaded_error_path, headers: {'X-Inertia' => true}
-      rescue Exception
-      end
-
-      expect(InertiaRails.shared_plain_data).to be_empty
-      expect(InertiaRails.shared_blocks).to be_empty
-    end
-  end
-
   describe 'deep or shallow merging shared data' do
     context 'with default settings (shallow merge)' do
       describe 'shallow merging by default' do