stimulus_reflex 3.4.2 → 3.5.0.pre0

data/lib/stimulus_reflex/broadcasters/broadcaster.rb

@@ -3,7 +3,10 @@
 module StimulusReflex
   class Broadcaster
     attr_reader :reflex, :logger, :operations
-    delegate :cable_ready, :permanent_attribute_name, to: :reflex
+    delegate :cable_ready, :permanent_attribute_name, :payload, to: :reflex
+
+    DEFAULT_HTML_WITHOUT_FORMAT = Nokogiri::XML::Node::SaveOptions::DEFAULT_HTML &
+      ~Nokogiri::XML::Node::SaveOptions::FORMAT
 
     def initialize(reflex)
       @reflex = reflex
@@ -23,13 +26,13 @@ module StimulusReflex
       false
     end
 
-    def broadcast_message(subject:, body: nil, data: {}, error: nil)
-      logger.error "\e[31m#{body}\e[0m" if subject == "error"
+    def broadcast_message(subject:, data: {}, error: nil)
       operations << ["document", :dispatch_event]
       cable_ready.dispatch_event(
         name: "stimulus-reflex:server-message",
         detail: {
-          reflexId: data["reflexId"],
+          reflexId: data.delete("reflexId"),
+          payload: payload,
           stimulus_reflex: data.merge(
             morph: to_sym,
             server_message: {subject: subject, body: error&.to_s}

data/lib/stimulus_reflex/broadcasters/page_broadcaster.rb

@@ -12,10 +12,11 @@ module StimulusReflex
       selectors = selectors.select { |s| document.css(s).present? }
       selectors.each do |selector|
         operations << [selector, :morph]
-        html = document.css(selector).inner_html
+        html = document.css(selector).inner_html(save_with: Broadcaster::DEFAULT_HTML_WITHOUT_FORMAT)
         cable_ready.morph(
           selector: selector,
           html: html,
+          payload: payload,
           children_only: true,
           permanent_attribute_name: permanent_attribute_name,
           stimulus_reflex: data.merge({
@@ -23,7 +24,6 @@ module StimulusReflex
           })
         )
       end
-
       cable_ready.broadcast
     end
 

data/lib/stimulus_reflex/broadcasters/selector_broadcaster.rb

@@ -2,19 +2,25 @@
 
 module StimulusReflex
   class SelectorBroadcaster < Broadcaster
+    include CableReady::Identifiable
+
     def broadcast(_, data = {})
       morphs.each do |morph|
         selectors, html = morph
-        updates = selectors.is_a?(Hash) ? selectors : Hash[selectors, html]
-        updates.each do |selector, html|
-          html = html.to_s
-          fragment = Nokogiri::HTML.fragment(html)
+        updates = selectors.is_a?(Hash) ? selectors : {selectors => html}
+        updates.each do |key, value|
+          html = reflex.render(key) if key.is_a?(ActiveRecord::Base) && value.nil?
+          html = reflex.render_collection(key) if key.is_a?(ActiveRecord::Relation) && value.nil?
+          html ||= value
+          fragment = Nokogiri::HTML.fragment(html.to_s)
+          selector = key.is_a?(ActiveRecord::Base) || key.is_a?(ActiveRecord::Relation) ? dom_id(key) : key.to_s
           match = fragment.at_css(selector)
           if match.present?
             operations << [selector, :morph]
             cable_ready.morph(
               selector: selector,
-              html: match.inner_html,
+              html: match.inner_html(save_with: Broadcaster::DEFAULT_HTML_WITHOUT_FORMAT),
+              payload: payload,
               children_only: true,
               permanent_attribute_name: permanent_attribute_name,
               stimulus_reflex: data.merge({
@@ -26,6 +32,7 @@ module StimulusReflex
             cable_ready.inner_html(
               selector: selector,
               html: fragment.to_html,
+              payload: payload,
               stimulus_reflex: data.merge({
                 morph: to_sym
               })

data/lib/stimulus_reflex/cable_ready_channels.rb

@@ -4,8 +4,9 @@ module StimulusReflex
   class CableReadyChannels
     delegate :[], to: "cable_ready_channels"
 
-    def initialize(stream_name)
+    def initialize(stream_name, reflex_id)
       @stream_name = stream_name
+      @reflex_id = reflex_id
     end
 
     def cable_ready_channels
@@ -17,7 +18,10 @@ module StimulusReflex
     end
 
     def method_missing(name, *args)
-      return stimulus_reflex_channel.public_send(name, *args) if stimulus_reflex_channel.respond_to?(name)
+      if stimulus_reflex_channel.respond_to?(name)
+        args[0][:reflex_id] = @reflex_id if args.any?
+        return stimulus_reflex_channel.public_send(name, *args)
+      end
       super
     end
 

data/lib/stimulus_reflex/callbacks.rb

@@ -22,24 +22,74 @@ module StimulusReflex
         add_callback(:around, *args, &block)
       end
 
+      def prepend_before_reflex(*args, &block)
+        prepend_callback(:before, *args, &block)
+      end
+
+      def prepend_after_reflex(*args, &block)
+        prepend_callback(:after, *args, &block)
+      end
+
+      def prepend_around_reflex(*args, &block)
+        prepend_callback(:around, *args, &block)
+      end
+
+      def skip_before_reflex(*args, &block)
+        omit_callback(:before, *args, &block)
+      end
+
+      def skip_after_reflex(*args, &block)
+        omit_callback(:after, *args, &block)
+      end
+
+      def skip_around_reflex(*args, &block)
+        omit_callback(:around, *args, &block)
+      end
+
+      alias_method :append_before_reflex, :before_reflex
+      alias_method :append_around_reflex, :around_reflex
+      alias_method :append_after_reflex, :after_reflex
+
       private
 
       def add_callback(kind, *args, &block)
-        options = args.extract_options!
-        options.assert_valid_keys :if, :unless, :only, :except
-        set_callback(*[:process, kind, args, normalize_callback_options!(options)].flatten, &block)
+        insert_callbacks(args, block) do |name, options|
+          set_callback(:process, kind, name, options)
+        end
+      end
+
+      def prepend_callback(kind, *args, &block)
+        insert_callbacks(args, block) do |name, options|
+          set_callback(:process, kind, name, options.merge(prepend: true))
+        end
+      end
+
+      def omit_callback(kind, *args, &block)
+        insert_callbacks(args) do |name, options|
+          skip_callback(:process, kind, name, options)
+        end
+      end
+
+      def insert_callbacks(callbacks, block = nil)
+        options = callbacks.extract_options!
+        normalize_callback_options!(options)
+
+        callbacks.push(block) if block
+
+        callbacks.each do |callback|
+          yield callback, options
+        end
       end
 
       def normalize_callback_options!(options)
         normalize_callback_option! options, :only, :if
         normalize_callback_option! options, :except, :unless
-        options
       end
 
       def normalize_callback_option!(options, from, to)
         if (from = options.delete(from))
           from_set = Array(from).map(&:to_s).to_set
-          from = proc { |reflex| from_set.include? reflex.method_name }
+          from = proc { |reflex| from_set.include? reflex.method_name.to_s }
           options[to] = Array(options[to]).unshift(from)
         end
       end

data/lib/stimulus_reflex/concern_enhancer.rb

@@ -0,0 +1,37 @@
+module StimulusReflex
+  module ConcernEnhancer
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def method_missing(name, *args)
+        case ancestors
+        when ->(a) { !(a & [StimulusReflex::Reflex]).empty? }
+          if (ActiveRecord::Base.public_methods + ActionController::Base.public_methods).include? name
+            nil
+          else
+            super
+          end
+        when ->(a) { !(a & [ActiveRecord::Base, ActionController::Base]).empty? }
+          if StimulusReflex::Reflex.public_methods.include? name
+            nil
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        case ancestors
+        when ->(a) { !(a & [StimulusReflex::Reflex]).empty? }
+          (ActiveRecord::Base.public_methods + ActionController::Base.public_methods).include?(name) || super
+        when ->(a) { !(a & [ActiveRecord::Base, ActionController::Base]).empty? }
+          StimulusReflex::Reflex.public_methods.include?(name) || super
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_reflex/configuration.rb

@@ -14,12 +14,13 @@ module StimulusReflex
   end
 
   class Configuration
-    attr_accessor :on_failed_sanity_checks, :parent_channel, :logging, :middleware
+    attr_accessor :on_failed_sanity_checks, :on_new_version_available, :parent_channel, :logging, :middleware
 
     DEFAULT_LOGGING = proc { "[#{session_id}] #{operation_counter.magenta} #{reflex_info.green} -> #{selector.cyan} via #{mode} Morph (#{operation.yellow})" }
 
     def initialize
       @on_failed_sanity_checks = :exit
+      @on_new_version_available = :ignore
       @parent_channel = "ApplicationCable::Channel"
       @logging = DEFAULT_LOGGING
       @middleware = ActionDispatch::MiddlewareStack.new

data/lib/stimulus_reflex/element.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
 class StimulusReflex::Element < OpenStruct
-  attr_reader :attributes, :data_attributes
+  attr_reader :attrs, :data_attrs
 
   def initialize(data = {})
-    @attributes = HashWithIndifferentAccess.new(data["attrs"] || {})
-    @data_attributes = HashWithIndifferentAccess.new(data["dataset"] || {})
-    all_attributes = @attributes.merge(@data_attributes)
-    super all_attributes.merge(all_attributes.transform_keys(&:underscore))
-    @data_attributes.transform_keys! { |key| key.delete_prefix "data-" }
+    @attrs = HashWithIndifferentAccess.new(data["attrs"] || {})
+    datasets = data["dataset"] || {}
+    regular_dataset = datasets["dataset"] || {}
+    @data_attrs = build_data_attrs(regular_dataset, datasets["datasetAll"] || {})
+    all_attributes = @attrs.merge(@data_attrs)
+    super build_underscored(all_attributes)
+    @data_attrs.transform_keys! { |key| key.delete_prefix "data-" }
   end
 
   def signed
@@ -19,7 +21,29 @@ class StimulusReflex::Element < OpenStruct
     @unsigned ||= ->(accessor) { GlobalID::Locator.locate(dataset[accessor]) }
   end
 
+  def attributes
+    @attributes ||= OpenStruct.new(build_underscored(attrs))
+  end
+
   def dataset
-    @dataset ||= OpenStruct.new(data_attributes.merge(data_attributes.transform_keys(&:underscore)))
+    @dataset ||= OpenStruct.new(build_underscored(data_attrs))
+  end
+
+  alias_method :data_attributes, :dataset
+
+  private
+
+  def build_data_attrs(dataset, dataset_all)
+    dataset_all.transform_keys! { |key| "data-#{key.delete_prefix("data-").pluralize}" }
+
+    dataset.each { |key, value| dataset_all[key]&.prepend(value) }
+
+    data_attrs = dataset.merge(dataset_all)
+
+    HashWithIndifferentAccess.new(data_attrs || {})
+  end
+
+  def build_underscored(attrs)
+    attrs.merge(attrs.transform_keys(&:underscore))
   end
 end

data/lib/stimulus_reflex/policies/reflex_invocation_policy.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module StimulusReflex
+  class ReflexMethodInvocationPolicy
+    attr_reader :arguments, :required_params, :optional_params
+
+    def initialize(method, arguments)
+      @arguments = arguments
+      @required_params = method.parameters.select { |(kind, _)| kind == :req }
+      @optional_params = method.parameters.select { |(kind, _)| kind == :opt }
+    end
+
+    def no_arguments?
+      arguments.size == 0 && required_params.size == 0
+    end
+
+    def arguments?
+      arguments.size >= required_params.size && arguments.size <= required_params.size + optional_params.size
+    end
+
+    def unknown?
+      return false if no_arguments?
+      return false if arguments?
+
+      true
+    end
+  end
+end

data/lib/stimulus_reflex/reflex.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
-ClientAttributes = Struct.new(:reflex_id, :reflex_controller, :xpath_controller, :xpath_element, :permanent_attribute_name, keyword_init: true)
+ClientAttributes = Struct.new(:reflex_id, :tab_id, :reflex_controller, :xpath_controller, :xpath_element, :permanent_attribute_name, keyword_init: true)
 
 class StimulusReflex::Reflex
   include ActiveSupport::Rescuable
   include StimulusReflex::Callbacks
+  include ActionView::Helpers::TagHelper
+  include CableReady::Identifiable
 
+  attr_accessor :payload
   attr_reader :cable_ready, :channel, :url, :element, :selectors, :method_name, :broadcaster, :client_attributes, :logger
 
   alias_method :action_name, :method_name # for compatibility with controller libraries like Pundit that expect an action name
@@ -13,8 +16,7 @@ class StimulusReflex::Reflex
   delegate :connection, :stream_name, to: :channel
   delegate :controller_class, :flash, :session, to: :request
   delegate :broadcast, :broadcast_message, to: :broadcaster
-  delegate :reflex_id, :reflex_controller, :xpath_controller, :xpath_element, :permanent_attribute_name, to: :client_attributes
-  delegate :render, to: :controller_class
+  delegate :reflex_id, :tab_id, :reflex_controller, :xpath_controller, :xpath_element, :permanent_attribute_name, to: :client_attributes
 
   def initialize(channel, url: nil, element: nil, selectors: [], method_name: nil, params: {}, client_attributes: {})
     if is_a? CableReady::Broadcaster
@@ -37,7 +39,8 @@ class StimulusReflex::Reflex
     @broadcaster = StimulusReflex::PageBroadcaster.new(self)
     @logger = StimulusReflex::Logger.new(self)
     @client_attributes = ClientAttributes.new(client_attributes)
-    @cable_ready = StimulusReflex::CableReadyChannels.new(stream_name)
+    @cable_ready = StimulusReflex::CableReadyChannels.new(stream_name, reflex_id)
+    @payload = {}
     self.params
   end
 
@@ -70,17 +73,15 @@ class StimulusReflex::Reflex
 
       req = ActionDispatch::Request.new(env)
 
-      path_params = Rails.application.routes.recognize_path_with_request(req, url, req.env[:extras] || {})
-      path_params[:controller] = path_params[:controller].force_encoding("UTF-8")
-      path_params[:action] = path_params[:action].force_encoding("UTF-8")
+      # fetch path params (controller, action, ...) and apply them
+      request_params = StimulusReflex::RequestParameters.new(params: @params, req: req, url: url)
+      req = request_params.apply!
 
-      req.env.merge(ActionDispatch::Http::Parameters::PARAMETERS_KEY => path_params)
-      req.env["action_dispatch.request.parameters"] = req.parameters.merge(@params)
-      req.tap { |r| r.session.send :load! }
+      req
     end
   end
 
-  def morph(selectors, html = "")
+  def morph(selectors, html = nil)
     case selectors
     when :page
       raise StandardError.new("Cannot call :page morph after :#{broadcaster.to_sym} morph") unless broadcaster.page?
@@ -95,16 +96,25 @@ class StimulusReflex::Reflex
   end
 
   def controller
-    @controller ||= begin
-      controller_class.new.tap do |c|
-        c.instance_variable_set :"@stimulus_reflex", true
-        instance_variables.each { |name| c.instance_variable_set name, instance_variable_get(name) }
-        c.set_request! request
-        c.set_response! controller_class.make_response!(request)
-      end
+    @controller ||= controller_class.new.tap do |c|
+      c.instance_variable_set :@stimulus_reflex, true
+      c.set_request! request
+      c.set_response! controller_class.make_response!(request)
     end
+
+    instance_variables.each { |name| @controller.instance_variable_set name, instance_variable_get(name) }
+    @controller
+  end
+
+  def controller?
+    !!defined? @controller
+  end
+
+  def render(*args)
+    controller_class.renderer.new(connection.env.merge("SCRIPT_NAME" => "")).render(*args)
   end
 
+  # Invoke the reflex action specified by `name` and run all callbacks
   def process(name, *args)
     reflex_invoked = false
     result = run_callbacks(:process) {
@@ -129,7 +139,12 @@ class StimulusReflex::Reflex
     @_params ||= ActionController::Parameters.new(request.parameters)
   end
 
-  def dom_id(record_or_class, prefix = nil)
-    "#" + ActionView::RecordIdentifier.dom_id(record_or_class, prefix).to_s
+  # morphdom needs content to be wrapped in an element with the same id when children_only: true
+  # Oddly, it doesn't matter if the target element is a div! See: https://docs.stimulusreflex.com/appendices/troubleshooting#different-element-type-altogether-who-cares-so-long-as-the-css-selector-matches
+  # Used internally to allow automatic partial collection rendering, but also useful to library users
+  # eg. `morph dom_id(@posts), render_collection(@posts)`
+  def render_collection(resource, content = nil)
+    content ||= render(resource)
+    tag.div(content.html_safe, id: dom_id(resource).from(1))
   end
 end

data/lib/stimulus_reflex/reflex_data.rb

@@ -0,0 +1,79 @@
+class StimulusReflex::ReflexData
+  attr_reader :data
+
+  def initialize(data)
+    @data = data
+  end
+
+  def reflex_name
+    reflex_name = target.split("#").first
+    reflex_name = reflex_name.camelize
+    reflex_name.end_with?("Reflex") ? reflex_name : "#{reflex_name}Reflex"
+  end
+
+  def selectors
+    selectors = (data["selectors"] || []).select(&:present?)
+    selectors = data["selectors"] = ["body"] if selectors.blank?
+    selectors
+  end
+
+  def target
+    data["target"].to_s
+  end
+
+  def method_name
+    target.split("#").second
+  end
+
+  def arguments
+    (data["args"] || []).map { |arg| object_with_indifferent_access arg } || []
+  end
+
+  def url
+    data["url"].to_s
+  end
+
+  def element
+    StimulusReflex::Element.new(data)
+  end
+
+  def permanent_attribute_name
+    data["permanentAttributeName"]
+  end
+
+  def form_data
+    Rack::Utils.parse_nested_query(data["formData"])
+  end
+
+  def form_params
+    form_data.deep_merge(data["params"] || {})
+  end
+
+  def reflex_id
+    data["reflexId"]
+  end
+
+  def tab_id
+    data["tabId"]
+  end
+
+  def xpath_controller
+    data["xpathController"]
+  end
+
+  def xpath_element
+    data["xpathElement"]
+  end
+
+  def reflex_controller
+    data["reflexController"]
+  end
+
+  private
+
+  def object_with_indifferent_access(object)
+    return object.with_indifferent_access if object.respond_to?(:with_indifferent_access)
+    object.map! { |obj| object_with_indifferent_access obj } if object.is_a?(Array)
+    object
+  end
+end

data/lib/stimulus_reflex/reflex_factory.rb

@@ -1,62 +1,31 @@
-# frozen_string_literal: true
-
 class StimulusReflex::ReflexFactory
-  attr_reader :reflex_name, :method_name
-
-  def initialize(target)
-    reflex_name, method_name = target.split("#")
-    reflex_name = reflex_name.camelize
-    reflex_name = reflex_name.end_with?("Reflex") ? reflex_name : "#{reflex_name}Reflex"
-
-    @method_name = method_name
-    @reflex_name = reflex_name
-  end
-
-  def call
-    verify_method_name!
-
-    reflex_class
-  end
-
-  private
-
-  def verify_method_name!
-    return if default_reflex?
-
-    argument_error = ArgumentError.new("Reflex method '#{method_name}' is not defined on class '#{reflex_name}' or on any of its ancestors")
-
-    if reflex_method.nil?
-      raise argument_error
+  class << self
+    attr_reader :reflex_data
+
+    def create_reflex_from_data(channel, reflex_data)
+      @reflex_data = reflex_data
+      reflex_class.new(channel,
+        url: reflex_data.url,
+        element: reflex_data.element,
+        selectors: reflex_data.selectors,
+        method_name: reflex_data.method_name,
+        params: reflex_data.form_params,
+        client_attributes: {
+          reflex_id: reflex_data.reflex_id,
+          tab_id: reflex_data.tab_id,
+          xpath_controller: reflex_data.xpath_controller,
+          xpath_element: reflex_data.xpath_element,
+          reflex_controller: reflex_data.reflex_controller,
+          permanent_attribute_name: reflex_data.permanent_attribute_name
+        })
     end
 
-    if !safe_ancestors.include?(reflex_method.owner)
-      raise argument_error
+    def reflex_class
+      reflex_data.reflex_name.constantize.tap { |klass| raise ArgumentError.new("#{reflex_name} is not a StimulusReflex::Reflex") unless is_reflex?(klass) }
     end
-  end
-
-  def reflex_class
-    @reflex_class ||= reflex_name.constantize.tap do |klass|
-      unless klass.ancestors.include?(StimulusReflex::Reflex)
-        raise ArgumentError.new("#{reflex_name} is not a StimulusReflex::Reflex")
-      end
-    end
-  end
 
-  def reflex_method
-    if reflex_class.public_instance_methods.include?(method_name.to_sym)
-      reflex_class.public_instance_method(method_name)
+    def is_reflex?(klass)
+      klass.ancestors.include? StimulusReflex::Reflex
     end
   end
-
-  def default_reflex?
-    method_name == "default_reflex" && reflex_method.owner == ::StimulusReflex::Reflex
-  end
-
-  def safe_ancestors
-    # We want to include every class and module up to the `StimulusReflex::Reflex` class,
-    # but not the StimulusReflex::Reflex itself
-    reflex_class_index = reflex_class.ancestors.index(StimulusReflex::Reflex) - 1
-
-    reflex_class.ancestors.to(reflex_class_index)
-  end
 end

data/lib/stimulus_reflex/request_parameters.rb

@@ -0,0 +1,19 @@
+module StimulusReflex
+  class RequestParameters
+    def initialize(params:, req:, url:)
+      @params = params
+      @req = req
+      @url = url
+    end
+
+    def apply!
+      path_params = Rails.application.routes.recognize_path_with_request(@req, @url, @req.env[:extras] || {})
+      path_params[:controller] = path_params[:controller].force_encoding("UTF-8")
+      path_params[:action] = path_params[:action].force_encoding("UTF-8")
+
+      @req.env.merge(ActionDispatch::Http::Parameters::PARAMETERS_KEY => path_params)
+      @req.env["action_dispatch.request.parameters"] = @req.parameters.merge(@params)
+      @req.tap { |r| r.session.send :load! }
+    end
+  end
+end

data/lib/stimulus_reflex/{logger.rb → utils/logger.rb}

@@ -12,12 +12,10 @@ module StimulusReflex
     def print
       return unless config_logging.instance_of?(Proc)
 
-      puts
       reflex.broadcaster.operations.each do
         puts instance_eval(&config_logging) + "\e[0m"
         @current_operation += 1
       end
-      puts
     end
 
     private