view_component_reflex 3.1.10 → 3.1.11

data/lib/view_component_reflex.rb

@@ -1,12 +1,12 @@
-require "stimulus_reflex"
-require 'view_component_reflex/reflex_factory'
-require "view_component_reflex/state_adapter/base"
-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
+require "stimulus_reflex"
+require 'view_component_reflex/reflex_factory'
+require "view_component_reflex/state_adapter/base"
+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,37 +1,37 @@
-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
+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

data/lib/view_component_reflex/reflex.rb

@@ -1,223 +1,223 @@
-module ViewComponentReflex
-  class Reflex < StimulusReflex::Reflex
-
-    class << self
-      attr_accessor :component_class
-    end
-
-    # pretty sure I can't memoize this because we need
-    # to re-render every time
-    def controller_document
-      controller.process(params[:action])
-      Nokogiri::HTML(controller.response.body)
-    end
-
-    def refresh!(primary_selector = nil, *rest)
-      save_state
-
-      if primary_selector.nil? && !component.can_render_to_string?
-        primary_selector = selector
-      end
-      if primary_selector
-        prevent_refresh!
-        
-        document = controller_document
-        [primary_selector, *rest].each do |s|
-          html = document.css(s)
-          if html.present?
-            CableReady::Channels.instance[stream].morph(
-              selector: s,
-              html: html.inner_html,
-              children_only: true,
-              permanent_attribute_name: "data-reflex-permanent",
-            )
-          end
-        end
-      else
-        refresh_component!
-      end
-      CableReady::Channels.instance[stream].broadcast
-    end
-
-    def stream
-      @stream ||= stream_name
-    end
-
-    def stream_to(channel)
-      @stream = channel
-    end
-
-    def component_document
-      component.tap do |k|
-        k.define_singleton_method(:initialize_component) do
-          @key = element.dataset[:key]
-        end
-      end
-
-      document = Nokogiri::HTML(component.render_in(controller.view_context))
-    end
-
-    def refresh_component!
-      CableReady::Channels.instance[stream].morph(
-        selector: selector,
-        children_only: true,
-        html: component_document.css(selector).inner_html,
-        permanent_attribute_name: "data-reflex-permanent",
-      )
-    end
-
-    def default_morph
-      save_state
-      html = if component.can_render_to_string?
-        component_document.css(selector).to_html
-      else
-        controller_document.css(selector).to_html
-      end
-      morph selector, html
-    end
-
-    def stimulus_reflex_data
-      {
-        reflex_id: reflex_id,
-        xpath_controller: xpath_controller,
-        xpath_element: xpath_element,
-        target: target,
-        reflex_controller: reflex_controller,
-        url: url,
-        morph: :page,
-        attrs: {
-          key: element.dataset[:key]
-        }
-      }
-    end
-
-    def target
-      "#{component_class}##{method_name}"
-    end
-
-    def refresh_all!
-      refresh!("body")
-    end
-
-    def selector
-      "[data-controller~=\"#{stimulus_controller}\"][data-key=\"#{element.dataset[:key]}\"]"
-    end
-
-    # SR's delegate_call_to_reflex in channel.rb
-    # uses method to gather the method parameters, but since we're abusing
-    # method_missing here, that'll always fail
-    def method(name)
-      component.method(name.to_sym)
-    end
-
-    def respond_to_missing?(name, _ = false)
-      !!name.to_proc
-    end
-
-    def method_missing(name, *args, &blk)
-      super unless respond_to_missing?(name)
-
-      state.each do |k, v|
-        component.instance_variable_set(k, v)
-      end
-
-      component.send(name, *args, &blk)
-      
-      if @prevent_refresh
-        morph :nothing
-      else
-        default_morph      
-      end
-    end
-
-    def prevent_refresh!
-      @prevent_refresh = true
-    end
-
-    private
-
-    def component_class
-      self.class.component_class
-    end
-
-    def stimulus_controller
-      component_class.stimulus_controller
-    end
-
-    def stimulate(target, data)
-      data_to_receive = {}
-
-      stimulus_reflex_data.each do |k, v|
-        data_to_receive[k.to_s.camelize(:lower)] = v
-      end
-
-      data_to_receive["dataset"] = data.each_with_object({}) do |(k, v), o|
-        o["data-#{k}"] = v
-      end
-
-      data_to_receive["attrs"] = element.attributes.to_h.symbolize_keys
-      data_to_receive["target"] = target
-
-      channel.receive data_to_receive
-    end
-
-    def component
-      return @component if @component
-      @component = component_class.allocate
-      reflex = self
-      exposed_methods = [
-        :params,
-        :request,
-        :connection,
-        :element,
-        :refresh!,
-        :refresh_all!,
-        :stimulus_controller,
-        :session,
-        :prevent_refresh!,
-        :selector,
-        :stimulate,
-        :stream_to
-      ]
-      exposed_methods.each do |meth|
-        @component.define_singleton_method(meth) do |*a|
-          reflex.send(meth, *a)
-        end
-      end
-
-      @component.define_singleton_method(:reflex) do
-        reflex
-      end
-
-      @component
-    end
-
-    def set_state(new_state = {})
-      state_adapter.set_state(request, controller, key, new_state)
-    end
-
-    def key
-      element.dataset[:key]
-    end
-
-    def state_adapter
-      ViewComponentReflex::Engine.state_adapter
-    end
-
-    def state
-      state_adapter.state(request, key)
-    end
-
-    def initial_state
-      state_adapter.state(request, "#{key}_initial")
-    end
-
-    def save_state
-      new_state = {}
-      component.safe_instance_variables.each do |k|
-        new_state[k] = component.instance_variable_get(k)
-      end
-      set_state(new_state)
-    end
-  end
-end
+module ViewComponentReflex
+  class Reflex < StimulusReflex::Reflex
+
+    class << self
+      attr_accessor :component_class
+    end
+
+    # pretty sure I can't memoize this because we need
+    # to re-render every time
+    def controller_document
+      controller.process(params[:action])
+      Nokogiri::HTML(controller.response.body)
+    end
+
+    def refresh!(primary_selector = nil, *rest)
+      save_state
+
+      if primary_selector.nil? && !component.can_render_to_string?
+        primary_selector = selector
+      end
+      if primary_selector
+        prevent_refresh!
+        
+        document = controller_document
+        [primary_selector, *rest].each do |s|
+          html = document.css(s)
+          if html.present?
+            CableReady::Channels.instance[stream].morph(
+              selector: s,
+              html: html.inner_html,
+              children_only: true,
+              permanent_attribute_name: "data-reflex-permanent",
+            )
+          end
+        end
+      else
+        refresh_component!
+      end
+      CableReady::Channels.instance[stream].broadcast
+    end
+
+    def stream
+      @stream ||= stream_name
+    end
+
+    def stream_to(channel)
+      @stream = channel
+    end
+
+    def component_document
+      component.tap do |k|
+        k.define_singleton_method(:initialize_component) do
+          @key = element.dataset[:key]
+        end
+      end
+
+      document = Nokogiri::HTML(component.render_in(controller.view_context))
+    end
+
+    def refresh_component!
+      CableReady::Channels.instance[stream].morph(
+        selector: selector,
+        children_only: true,
+        html: component_document.css(selector).inner_html,
+        permanent_attribute_name: "data-reflex-permanent",
+      )
+    end
+
+    def default_morph
+      save_state
+      html = if component.can_render_to_string?
+        component_document.css(selector).to_html
+      else
+        controller_document.css(selector).to_html
+      end
+      morph selector, html
+    end
+
+    def stimulus_reflex_data
+      {
+        reflex_id: reflex_id,
+        xpath_controller: xpath_controller,
+        xpath_element: xpath_element,
+        target: target,
+        reflex_controller: reflex_controller,
+        url: url,
+        morph: :page,
+        attrs: {
+          key: element.dataset[:key]
+        }
+      }
+    end
+
+    def target
+      "#{component_class}##{method_name}"
+    end
+
+    def refresh_all!
+      refresh!("body")
+    end
+
+    def selector
+      "[data-controller~=\"#{stimulus_controller}\"][data-key=\"#{element.dataset[:key]}\"]"
+    end
+
+    # SR's delegate_call_to_reflex in channel.rb
+    # uses method to gather the method parameters, but since we're abusing
+    # method_missing here, that'll always fail
+    def method(name)
+      component.method(name.to_sym)
+    end
+
+    def respond_to_missing?(name, _ = false)
+      !!name.to_proc
+    end
+
+    def method_missing(name, *args, &blk)
+      super unless respond_to_missing?(name)
+
+      state.each do |k, v|
+        component.instance_variable_set(k, v)
+      end
+
+      component.send(name, *args, &blk)
+      
+      if @prevent_refresh
+        morph :nothing
+      else
+        default_morph      
+      end
+    end
+
+    def prevent_refresh!
+      @prevent_refresh = true
+    end
+
+    private
+
+    def component_class
+      self.class.component_class
+    end
+
+    def stimulus_controller
+      component_class.stimulus_controller
+    end
+
+    def stimulate(target, data)
+      data_to_receive = {}
+
+      stimulus_reflex_data.each do |k, v|
+        data_to_receive[k.to_s.camelize(:lower)] = v
+      end
+
+      data_to_receive["dataset"] = data.each_with_object({}) do |(k, v), o|
+        o["data-#{k}"] = v
+      end
+
+      data_to_receive["attrs"] = element.attributes.to_h.symbolize_keys
+      data_to_receive["target"] = target
+
+      channel.receive data_to_receive
+    end
+
+    def component
+      return @component if @component
+      @component = component_class.allocate
+      reflex = self
+      exposed_methods = [
+        :params,
+        :request,
+        :connection,
+        :element,
+        :refresh!,
+        :refresh_all!,
+        :stimulus_controller,
+        :session,
+        :prevent_refresh!,
+        :selector,
+        :stimulate,
+        :stream_to
+      ]
+      exposed_methods.each do |meth|
+        @component.define_singleton_method(meth) do |*a|
+          reflex.send(meth, *a)
+        end
+      end
+
+      @component.define_singleton_method(:reflex) do
+        reflex
+      end
+
+      @component
+    end
+
+    def set_state(new_state = {})
+      state_adapter.set_state(request, controller, key, new_state)
+    end
+
+    def key
+      element.dataset[:key]
+    end
+
+    def state_adapter
+      ViewComponentReflex::Engine.state_adapter
+    end
+
+    def state
+      state_adapter.state(request, key)
+    end
+
+    def initial_state
+      state_adapter.state(request, "#{key}_initial")
+    end
+
+    def save_state
+      new_state = {}
+      component.safe_instance_variables.each do |k|
+        new_state[k] = component.instance_variable_get(k)
+      end
+      set_state(new_state)
+    end
+  end
+end