stimulus_reflex 3.4.1 → 3.5.0.pre3

data/lib/generators/stimulus_reflex/templates/config/initializers/stimulus_reflex.rb

@@ -1,21 +1,41 @@
 # frozen_string_literal: true
 
+# The ActionCable logger is REALLY noisy, and might even impact performance.
+# Uncomment the line below to silence the ActionCable logger.
+
+# ActionCable.server.config.logger = Logger.new(nil)
+
 StimulusReflex.configure do |config|
   # Enable/disable exiting / warning when the sanity checks fail options:
   # `:exit` or `:warn` or `:ignore`
 
   # config.on_failed_sanity_checks = :exit
 
+  # Enable/disable exiting / warning when there's a new StimulusReflex release
+  # `:exit` or `:warn` or `:ignore`
+
+  # config.on_new_version_available = :ignore
+
+  # Enable/disable exiting / warning when there is no default URLs specified in environment config
+  # `:warn` or `:ignore`
+
+  # config.on_missing_default_urls = :warn
+
   # Override the parent class that the StimulusReflex ActionCable channel inherits from
 
   # config.parent_channel = "ApplicationCable::Channel"
 
+  # Override the logger that the StimulusReflex uses; default is Rails' logger
+  # eg. Logger.new(RAILS_ROOT + "/log/reflex.log")
+
+  # config.logger = Rails.logger
+
   # Customize server-side Reflex logging format, with optional colorization:
   # Available tokens: session_id, session_id_full, reflex_info, operation, reflex_id, reflex_id_full, mode, selector, operation_counter, connection_id, connection_id_full, timestamp
   # Available colors: red, green, yellow, blue, magenta, cyan, white
   # You can also use attributes from your ActionCable Connection's identifiers that resolve to valid ActiveRecord models
   # eg. if your connection is `identified_by :current_user` and your User model has an email attribute, you can access r.email (it will display `-` if the user isn't logged in)
-  # Learn more at: https://docs.stimulusreflex.com/troubleshooting#stimulusreflex-logging
+  # Learn more at: https://docs.stimulusreflex.com/appendices/troubleshooting#stimulusreflex-logging
 
   # config.logging = proc { "[#{session_id}] #{operation_counter.magenta} #{reflex_info.green} -> #{selector.cyan} via #{mode} Morph (#{operation.yellow})" }
 

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,33 +26,34 @@ module StimulusReflex
       false
     end
 
-    def broadcast_message(subject:, body: nil, data: {}, error: nil)
-      logger.error "\e[31m#{body}\e[0m" if subject == "error"
+    def halted(data: {})
       operations << ["document", :dispatch_event]
       cable_ready.dispatch_event(
-        name: "stimulus-reflex:server-message",
-        detail: {
-          reflexId: data["reflexId"],
-          stimulus_reflex: data.merge(
-            morph: to_sym,
-            server_message: {subject: subject, body: error&.to_s}
-          )
-        }
-      )
-      cable_ready.broadcast
-    end
-
-    # abstract method to be implemented by subclasses
+        name: "stimulus-reflex:morph-halted",
+        payload: payload,
+        stimulus_reflex: data.merge(morph: to_sym)
+      ).broadcast
+    end
+
+    def error(data: {}, body: nil)
+      operations << ["document", :dispatch_event]
+      cable_ready.dispatch_event(
+        name: "stimulus-reflex:morph-error",
+        payload: payload,
+        stimulus_reflex: data.merge(morph: to_sym),
+        body: body&.to_s
+      ).broadcast
+    end
+
+    # abstract methods to be implemented by subclasses
     def broadcast(*args)
       raise NotImplementedError
     end
 
-    # abstract method to be implemented by subclasses
     def to_sym
       raise NotImplementedError
     end
 
-    # abstract method to be implemented by subclasses
     def to_s
       raise NotImplementedError
     end

data/lib/stimulus_reflex/broadcasters/nothing_broadcaster.rb

@@ -3,7 +3,12 @@
 module StimulusReflex
   class NothingBroadcaster < Broadcaster
     def broadcast(_, data)
-      broadcast_message subject: "nothing", data: data
+      operations << ["document", :dispatch_event]
+      cable_ready.dispatch_event(
+        name: "stimulus-reflex:morph-nothing",
+        payload: payload,
+        stimulus_reflex: data.merge(morph: to_sym)
+      ).broadcast
     end
 
     def nothing?

data/lib/stimulus_reflex/broadcasters/page_broadcaster.rb

@@ -12,18 +12,16 @@ 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({
-            morph: to_sym
-          })
+          stimulus_reflex: data.merge(morph: to_sym)
         )
       end
-
       cable_ready.broadcast
     end
 

data/lib/stimulus_reflex/broadcasters/selector_broadcaster.rb

@@ -5,30 +5,27 @@ module StimulusReflex
     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)
-          match = fragment.at_css(selector)
+        updates = create_update_collection(selectors, html)
+        updates.each do |update|
+          fragment = Nokogiri::HTML.fragment(update.html.to_s)
+          match = fragment.at_css(update.selector)
           if match.present?
-            operations << [selector, :morph]
+            operations << [update.selector, :morph]
             cable_ready.morph(
-              selector: selector,
-              html: match.inner_html,
+              selector: update.selector,
+              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({
-                morph: to_sym
-              })
+              stimulus_reflex: data.merge(morph: to_sym)
             )
           else
-            operations << [selector, :inner_html]
+            operations << [update.selector, :inner_html]
             cable_ready.inner_html(
-              selector: selector,
+              selector: update.selector,
               html: fragment.to_html,
-              stimulus_reflex: data.merge({
-                morph: to_sym
-              })
+              payload: payload,
+              stimulus_reflex: data.merge(morph: to_sym)
             )
           end
         end
@@ -57,5 +54,14 @@ module StimulusReflex
     def to_s
       "Selector"
     end
+
+    private
+
+    def create_update_collection(selectors, html)
+      updates = selectors.is_a?(Hash) ? selectors : {selectors => html}
+      updates.map do |key, value|
+        StimulusReflex::Broadcasters::Update.new(key, value, reflex)
+      end
+    end
   end
 end

data/lib/stimulus_reflex/broadcasters/update.rb

@@ -0,0 +1,23 @@
+module StimulusReflex
+  module Broadcasters
+    class Update
+      include CableReady::Identifiable
+
+      def initialize(key, value, reflex)
+        @key = key
+        @value = value
+        @reflex = reflex
+      end
+
+      def selector
+        @selector ||= identifiable?(@key) ? dom_id(@key) : @key.to_s
+      end
+
+      def html
+        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
+      end
+    end
+  end
+end

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,14 @@ 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)
+        if (options = args.find_index { |a| a.is_a? Hash })
+          args[options][:reflex_id] = @reflex_id
+        elsif args.any?
+          args << {reflex_id: @reflex_id}
+        end
+        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,14 +14,17 @@ 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, :on_missing_default_urls, :parent_channel, :logging, :logger, :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
+      @on_missing_default_urls = :warn
       @parent_channel = "ApplicationCable::Channel"
       @logging = DEFAULT_LOGGING
+      @logger = Rails.logger
       @middleware = ActionDispatch::MiddlewareStack.new
     end
   end

data/lib/stimulus_reflex/dataset.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "stimulus_reflex/utils/attribute_builder"
+
+class StimulusReflex::Dataset < OpenStruct
+  include StimulusReflex::AttributeBuilder
+
+  attr_accessor :attrs, :data_attrs
+
+  def initialize(data = {})
+    datasets = data["dataset"] || {}
+    regular_dataset = datasets["dataset"] || {}
+    @attrs = build_data_attrs(regular_dataset, datasets["datasetAll"] || {})
+    @data_attrs = @attrs.transform_keys { |key| key.delete_prefix "data-" }
+
+    super build_underscored(@data_attrs)
+  end
+
+  def signed
+    @signed ||= ->(accessor) { GlobalID::Locator.locate_signed(self[accessor]) }
+  end
+
+  def unsigned
+    @unsigned ||= ->(accessor) { GlobalID::Locator.locate(self[accessor]) }
+  end
+
+  def boolean
+    @boolean ||= ->(accessor) { ActiveModel::Type::Boolean.new.cast(self[accessor]) || self[accessor].blank? }
+  end
+
+  def numeric
+    @numeric ||= ->(accessor) { Float(self[accessor]) }
+  end
+end

data/lib/stimulus_reflex/element.rb

@@ -1,25 +1,32 @@
 # frozen_string_literal: true
 
+require "stimulus_reflex/dataset"
+require "stimulus_reflex/utils/attribute_builder"
+
 class StimulusReflex::Element < OpenStruct
-  attr_reader :attributes, :data_attributes
+  include StimulusReflex::AttributeBuilder
+
+  attr_reader :attrs, :dataset
+
+  alias_method :data_attributes, :dataset
+
+  delegate :signed, :unsigned, :numeric, :boolean, :data_attrs, to: :dataset
 
   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-" }
-  end
+    @attrs = HashWithIndifferentAccess.new(data["attrs"] || {})
+    @dataset = StimulusReflex::Dataset.new(data)
 
-  def signed
-    @signed ||= ->(accessor) { GlobalID::Locator.locate_signed(dataset[accessor]) }
+    all_attributes = @attrs.merge(@dataset.attrs)
+    super build_underscored(all_attributes)
   end
 
-  def unsigned
-    @unsigned ||= ->(accessor) { GlobalID::Locator.locate(dataset[accessor]) }
+  def attributes
+    @attributes ||= OpenStruct.new(build_underscored(attrs))
   end
 
-  def dataset
-    @dataset ||= OpenStruct.new(data_attributes.merge(data_attributes.transform_keys(&:underscore)))
+  def to_dom_id
+    raise NoIDError.new "The element `morph` is called on must have a valid DOM ID" if id.blank?
+
+    "##{id}"
   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,20 +1,22 @@
 # 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, :headers
   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
 
   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 :broadcast, :halted, :error, to: :broadcaster
+  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,9 @@ 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 = {}
+    @headers = {}
     self.params
   end
 
@@ -70,17 +74,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 +97,29 @@ 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|
+      request.headers.merge!(headers)
+      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)
+    options = args.extract_options!
+    (options[:locals] ||= {}).reverse_merge!(params: params)
+    args << options.reverse_merge(layout: false)
+    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 +144,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