view_component_reflex 2.5.0 → 3.0.1

data/app/components/view_component_reflex/component.rb

@@ -1,214 +1,211 @@
-module ViewComponentReflex
-  class Component < ViewComponent::Base
-    class << self
-      def init_stimulus_reflex
-        factory = ViewComponentReflex::ReflexFactory.new(self)
-        @stimulus_reflex ||= factory.reflex
-        wire_up_callbacks if factory.new?
-      end
-
-      def reflex_base_class(new_base_class = nil)
-        if new_base_class.nil?
-          @reflex_base_class ||= ViewComponentReflex::Reflex
-        else
-          if new_base_class <= ViewComponentReflex::Reflex
-            @reflex_base_class = new_base_class
-          else
-            raise StandardError.new("The reflex base class must inherit from ViewComponentReflex::Reflex")
-          end
-        end
-      end
-
-      def queue_callback(key, args, blk)
-        callbacks(key).push({
-          args: args,
-          blk: blk
-        })
-      end
-
-      def callbacks(key)
-        @callbacks ||= {}
-        @callbacks[key] ||= []
-      end
-
-      def register_callbacks(key)
-        callbacks(key).each do |cb|
-          @stimulus_reflex.send("#{key}_reflex", *cb[:args], &cb[:blk])
-        end
-      end
-
-      def before_reflex(*args, &blk)
-        queue_callback(:before, args, blk)
-      end
-
-      def after_reflex(*args, &blk)
-        queue_callback(:after, args, blk)
-      end
-
-      def around_reflex(*args, &blk)
-        queue_callback(:around, args, blk)
-      end
-
-      def wire_up_callbacks
-        register_callbacks(:before)
-        register_callbacks(:after)
-        register_callbacks(:around)
-      end
-    end
-
-    def self.stimulus_controller
-      name.chomp("Component").underscore.dasherize
-    end
-
-    def stimulus_reflex?
-      helpers.controller.instance_variable_get(:@stimulus_reflex)
-    end
-
-    def component_controller(opts_or_tag = :div, opts = {}, &blk)
-      init_key
-
-      tag = :div
-      options = if opts_or_tag.is_a? Hash
-        opts_or_tag
-      else
-        tag = opts_or_tag
-        opts
-      end
-
-      options[:data] = {
-        controller: self.class.stimulus_controller,
-        key: key,
-        **(options[:data] || {})
-      }
-      content_tag tag, capture(&blk), options
-    end
-
-    def can_render_to_string?
-      omitted_from_state.empty?
-    end
-
-    # key is required if you're using state
-    # We can't initialize the session state in the initial method
-    # because it doesn't have a view_context yet
-    # This is the next best place to do it
-    def init_key
-      # we want the erb file that renders the component. `caller` gives the file name,
-      # and line number, which should be unique. We hash it to make it a nice number
-      erb_file = caller.select { |p| p.match? /.\.html\.(haml|erb|slim)/ }[1]
-      key = if erb_file
-        Digest::SHA2.hexdigest(erb_file.split(":in")[0])
-      else
-        ""
-      end
-      key += collection_key.to_s if collection_key
-      @key = key
-    end
-
-    # Helper to use to create the proper reflex data attributes for an element
-    def reflex_data_attributes(reflex)
-      action, method = reflex.to_s.split("->")
-      if method.nil?
-        method = action
-        action = "click"
-      end
-
-      {
-        reflex: "#{action}->#{self.class.name}##{method}",
-        key: key
-      }
-    end
-
-    def reflex_tag(reflex, name, content_or_options_with_block = {}, options = {}, escape = true, &block)
-      if content_or_options_with_block.is_a?(Hash)
-        merge_data_attributes(content_or_options_with_block, reflex_data_attributes(reflex))
-      else
-        merge_data_attributes(options, reflex_data_attributes(reflex))
-      end
-      content_tag(name, content_or_options_with_block, options, escape, &block)
-    end
-
-    def collection_key
-      nil
-    end
-
-    def permit_parameter?(initial_param, new_param)
-      initial_param != new_param
-    end
-
-    def omitted_from_state
-      []
-    end
-
-    def after_state_initialized(parameters_changed)
-      # called after state component has been hydrated
-    end
-
-    # def receive_params(old_state, params)
-    #   # no op
-    # end
-
-    def key
-      # initialize session state
-      if !stimulus_reflex? || ViewComponentReflex::Engine.state_adapter.state(request, @key).empty?
-
-        new_state = create_safe_state
-
-        ViewComponentReflex::Engine.state_adapter.store_state(request, @key, new_state)
-        ViewComponentReflex::Engine.state_adapter.store_state(request, "#{@key}_initial", new_state)
-      elsif !@initialized_state
-        initial_state = ViewComponentReflex::Engine.state_adapter.state(request, "#{@key}_initial")
-
-        # incoming_params = safe_instance_variables.each_with_object({}) { |var, obj| obj[var] = instance_variable_get(var) }
-        # receive_params(ViewComponentReflex::Engine.state_adapter.state(request, @key), incoming_params)
-
-        parameters_changed = []
-        ViewComponentReflex::Engine.state_adapter.state(request, @key).each do |k, v|
-          instance_value = instance_variable_get(k)
-          if permit_parameter?(initial_state[k], instance_value)
-            parameters_changed << k
-            ViewComponentReflex::Engine.state_adapter.set_state(request, controller, "#{@key}_initial", {k => instance_value})
-            ViewComponentReflex::Engine.state_adapter.set_state(request, controller, @key, {k => instance_value})
-          else
-            instance_variable_set(k, v)
-          end
-        end
-        after_state_initialized(parameters_changed)
-        @initialized_state = true
-      end
-      @key
-    end
-
-    def safe_instance_variables
-      instance_variables - unsafe_instance_variables
-    end
-
-    private
-
-    def unsafe_instance_variables
-      [
-        :@view_context, :@lookup_context, :@view_renderer, :@view_flow,
-        :@virtual_path, :@variant, :@current_template, :@output_buffer, :@key,
-        :@helpers, :@controller, :@request, :@tag_builder, :@initialized_state
-      ]
-    end
-
-    def create_safe_state
-      new_state = {}
-
-      # this will almost certainly break
-      safe_instance_variables.each do |k|
-        new_state[k] = instance_variable_get(k) unless omitted_from_state.include?(k)
-      end
-      new_state
-    end
-
-    def merge_data_attributes(options, attributes)
-      data = options[:data]
-      if data.nil?
-        options[:data] = attributes
-      else
-        options[:data].merge! attributes
-      end
-    end
-  end
-end
+module ViewComponentReflex
+  class Component < ViewComponent::Base
+    class_attribute :reflex_base_class, default: ViewComponentReflex::Reflex
+
+    class << self
+      def init_stimulus_reflex
+        factory = ViewComponentReflex::ReflexFactory.new(self)
+        @stimulus_reflex ||= factory.reflex
+        wire_up_callbacks if factory.new?
+      end
+
+      def queue_callback(key, args, blk)
+        callbacks(key).push({
+          args: args,
+          blk: blk
+        })
+      end
+
+      def callbacks(key)
+        @callbacks ||= {}
+        @callbacks[key] ||= []
+      end
+
+      def register_callbacks(key)
+        callbacks(key).each do |cb|
+          @stimulus_reflex.send("#{key}_reflex", *cb[:args], &cb[:blk])
+        end
+      end
+
+      def before_reflex(*args, &blk)
+        queue_callback(:before, args, blk)
+      end
+
+      def after_reflex(*args, &blk)
+        queue_callback(:after, args, blk)
+      end
+
+      def around_reflex(*args, &blk)
+        queue_callback(:around, args, blk)
+      end
+
+      def wire_up_callbacks
+        register_callbacks(:before)
+        register_callbacks(:after)
+        register_callbacks(:around)
+      end
+    end
+
+    def self.stimulus_controller
+      name.chomp("Component").underscore.dasherize
+    end
+
+    def stimulus_reflex?
+      helpers.controller.instance_variable_get(:@stimulus_reflex)
+    end
+
+    def component_controller(opts_or_tag = :div, opts = {}, &blk)
+      init_key
+
+      tag = :div
+      options = if opts_or_tag.is_a? Hash
+        opts_or_tag
+      else
+        tag = opts_or_tag
+        opts
+      end
+
+      options[:data] = {
+        controller: self.class.stimulus_controller,
+        key: key,
+        **(options[:data] || {})
+      }
+      content_tag tag, capture(&blk), options
+    end
+
+    def can_render_to_string?
+      omitted_from_state.empty?
+    end
+
+    # key is required if you're using state
+    # We can't initialize the session state in the initial method
+    # because it doesn't have a view_context yet
+    # This is the next best place to do it
+    def init_key
+      # we want the erb file that renders the component. `caller` gives the file name,
+      # and line number, which should be unique. We hash it to make it a nice number
+      erb_file = caller.select { |p| p.match? /.\.html\.(haml|erb|slim)/ }[1]
+      key = if erb_file
+        Digest::SHA2.hexdigest(erb_file.split(":in")[0])
+      else
+        ""
+      end
+      key += collection_key.to_s if collection_key
+      @key = key
+    end
+
+    # Helper to use to create the proper reflex data attributes for an element
+    def reflex_data_attributes(reflex)
+      action, method = reflex.to_s.split("->")
+      if method.nil?
+        method = action
+        action = "click"
+      end
+
+      {
+        reflex: "#{action}->#{self.class.name}##{method}",
+        key: key
+      }
+    end
+
+    def reflex_tag(reflex, name, content_or_options_with_block = {}, options = {}, escape = true, &block)
+      if content_or_options_with_block.is_a?(Hash)
+        merge_data_attributes(content_or_options_with_block, reflex_data_attributes(reflex))
+      else
+        merge_data_attributes(options, reflex_data_attributes(reflex))
+      end
+      content_tag(name, content_or_options_with_block, options, escape, &block)
+    end
+
+    def collection_key
+      nil
+    end
+
+    def permit_parameter?(initial_param, new_param)
+      initial_param != new_param
+    end
+
+    def omitted_from_state
+      []
+    end
+
+    def after_state_initialized(parameters_changed)
+      # called after state component has been hydrated
+    end
+
+    # def receive_params(old_state, params)
+    #   # no op
+    # end
+
+    def key
+      adapter = ViewComponentReflex::Engine.state_adapter
+
+      # initialize session state
+      if (!stimulus_reflex? || adapter.state(request, @key).empty?) && !@initialized_state
+
+        new_state = create_safe_state
+
+        adapter.wrap_write_async do
+          adapter.store_state(request, @key, new_state)
+          adapter.store_state(request, "#{@key}_initial", new_state)
+        end
+      elsif !@initialized_state
+        initial_state = adapter.state(request, "#{@key}_initial")
+
+        # incoming_params = safe_instance_variables.each_with_object({}) { |var, obj| obj[var] = instance_variable_get(var) }
+        # receive_params(ViewComponentReflex::Engine.state_adapter.state(request, @key), incoming_params)
+
+        parameters_changed = []
+        adapter.state(request, @key).each do |k, v|
+          instance_value = instance_variable_get(k)
+          if permit_parameter?(initial_state[k], instance_value)
+            parameters_changed << k
+            adapter.wrap_write_async do
+              adapter.set_state(request, controller, "#{@key}_initial", {k => instance_value})
+              adapter.set_state(request, controller, @key, {k => instance_value})
+            end
+          else
+            instance_variable_set(k, v)
+          end
+        end
+        after_state_initialized(parameters_changed)
+      end
+
+      @initialized_state = true
+      @key
+    end
+
+    def safe_instance_variables
+      instance_variables - unsafe_instance_variables - omitted_from_state
+    end
+
+    private
+
+    def unsafe_instance_variables
+      [
+        :@view_context, :@lookup_context, :@view_renderer, :@view_flow,
+        :@virtual_path, :@variant, :@current_template, :@output_buffer, :@key,
+        :@helpers, :@controller, :@request, :@tag_builder, :@initialized_state
+      ]
+    end
+
+    def create_safe_state
+      new_state = {}
+
+      # this will almost certainly break
+      safe_instance_variables.each do |k|
+        new_state[k] = instance_variable_get(k)
+      end
+      new_state
+    end
+
+    def merge_data_attributes(options, attributes)
+      data = options[:data]
+      if data.nil?
+        options[:data] = attributes
+      else
+        options[:data].merge! attributes
+      end
+    end
+  end
+end

data/lib/view_component_reflex.rb

@@ -1,10 +1,11 @@
-require "stimulus_reflex"
-require 'view_component_reflex/reflex_factory'
-require "view_component_reflex/state_adapter/session"
-require "view_component_reflex/state_adapter/memory"
-require "view_component_reflex/reflex"
-require "view_component_reflex/engine"
-
-module ViewComponentReflex
-  # Your code goes here...
-end
+require "stimulus_reflex"
+require 'view_component_reflex/reflex_factory'
+require "view_component_reflex/state_adapter/session"
+require "view_component_reflex/state_adapter/memory"
+require "view_component_reflex/state_adapter/redis"
+require "view_component_reflex/reflex"
+require "view_component_reflex/engine"
+
+module ViewComponentReflex
+  # Your code goes here...
+end

data/lib/view_component_reflex/engine.rb

@@ -1,36 +1,37 @@
-module ViewComponentReflex
-  class Engine < ::Rails::Engine
-    class << self
-      mattr_accessor :state_adapter
-
-      self.state_adapter = StateAdapter::Session
-    end
-
-    config.to_prepare do
-      StimulusReflex::Channel.class_eval do
-        unless instance_methods.include?(:receive_original)
-          alias_method :receive_original, :receive
-          def receive(data)
-            target = data["target"].to_s
-            reflex_name, _ = target.split("#")
-            reflex_name = reflex_name.camelize
-            component_name = reflex_name.end_with?("Reflex") ? reflex_name[0...-6] : reflex_name
-            if component_name.end_with?("Component")
-              begin
-                component_name.constantize.init_stimulus_reflex
-              rescue
-                p "Tried to initialize view_component_reflex on #{component_name}, but it's not a view_component_reflex"
-              end
-
-            end
-            receive_original(data)
-          end
-        end
-      end
-    end
-
-    def self.configure
-      yield self if block_given?
-    end
-  end
-end
+module ViewComponentReflex
+  class Engine < ::Rails::Engine
+
+    mattr_accessor :state_adapter
+    Engine.state_adapter = StateAdapter::Session
+
+    config.to_prepare do
+      StimulusReflex::Channel.class_eval do
+        unless instance_methods.include?(:receive_original)
+          alias_method :receive_original, :receive
+          def receive(data)
+            target = data["target"].to_s
+            reflex_name, _ = target.split("#")
+            reflex_name = reflex_name.camelize
+            component_name = reflex_name.end_with?("Reflex") ? reflex_name[0...-6] : reflex_name
+            component = begin
+              component_name.constantize
+            rescue
+              # Since every reflex runs through this monkey patch, we're just going to ignore the ones that aren't for components
+            end
+
+            if component&.respond_to?(:init_stimulus_reflex)
+              component.init_stimulus_reflex
+            else
+              p "Tried to initialize view_component_reflex on #{component_name}, but it's not a view_component_reflex"
+            end
+            receive_original(data)
+          end
+        end
+      end
+    end
+
+    def self.configure
+      yield self if block_given?
+    end
+  end
+end