stimulus_reflex 3.4.0 → 3.5.0.pre2

data/lib/stimulus_reflex/configuration.rb

@@ -14,12 +14,14 @@ 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, :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
       @middleware = ActionDispatch::MiddlewareStack.new

data/lib/stimulus_reflex/element.rb

@@ -1,14 +1,20 @@
 # frozen_string_literal: true
 
 class StimulusReflex::Element < OpenStruct
-  attr_reader :attributes, :data_attributes
+  attr_reader :attrs, :data_attrs, :inner_html, :text_content
 
   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"] || {})
+    @inner_html = data["inner_html"]
+    @text_content = data["text_content"]
+
+    datasets = data["dataset"] || {}
+    regular_dataset = datasets["dataset"] || {}
+    @data_attrs = build_data_attrs(regular_dataset, datasets["datasetAll"] || {})
+
+    super build_underscored(all_attributes)
+
+    @data_attrs.transform_keys! { |key| key.delete_prefix "data-" }
   end
 
   def signed
@@ -19,7 +25,42 @@ 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
+
+  def to_dom_id
+    raise NoIDError.new "The element `morph` is called on must have a valid DOM ID" if id.blank?
+
+    "##{id}"
+  end
+
+  alias_method :data_attributes, :dataset
+
+  private
+
+  def all_attributes
+    @attrs.merge(@data_attrs)
+  end
+
+  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
+
+  class NoIDError < StandardError
   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,49 +1,14 @@
 # frozen_string_literal: true
 
-ClientAttributes = Struct.new(:reflex_id, :reflex_controller, :xpath, :c_xpath, :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 ActiveSupport::Callbacks
-
-  define_callbacks :process, skip_after_callbacks_if_terminated: true
-
-  class << self
-    def before_reflex(*args, &block)
-      add_callback(:before, *args, &block)
-    end
-
-    def after_reflex(*args, &block)
-      add_callback(:after, *args, &block)
-    end
-
-    def around_reflex(*args, &block)
-      add_callback(:around, *args, &block)
-    end
-
-    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)
-    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 }
-        options[to] = Array(options[to]).unshift(from)
-      end
-    end
-  end
+  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
@@ -51,11 +16,20 @@ 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, :c_xpath, :permanent_attribute_name, to: :client_attributes
-  delegate :render, to: :controller_class
-  delegate :dom_id, to: "ActionView::RecordIdentifier"
+  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
+      message = <<~MSG
+
+        #{self.class.name} includes CableReady::Broadcaster, and you need to remove it.
+        Reflexes have their own CableReady interface. You can just assume that it's present.
+        See https://docs.stimulusreflex.com/rtfm/cableready#using-cableready-inside-a-reflex-action for more details.
+
+      MSG
+      raise TypeError.new(message.strip)
+    end
+
     @channel = channel
     @url = url
     @element = element
@@ -65,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
 
@@ -98,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?
@@ -123,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) {
@@ -156,4 +138,13 @@ class StimulusReflex::Reflex
   def params
     @_params ||= ActionController::Parameters.new(request.parameters)
   end
+
+  # 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

@@ -0,0 +1,31 @@
+class StimulusReflex::ReflexFactory
+  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
+
+    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
+
+    def is_reflex?(klass)
+      klass.ancestors.include? StimulusReflex::Reflex
+    end
+  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
@@ -79,22 +77,22 @@ module StimulusReflex
       Time.now.strftime("%Y-%m-%d %H:%M:%S")
     end
 
-    def method_missing method
-      return send(method.to_sym) if private_instance_methods.include?(method.to_sym)
+    def method_missing(name, *args)
+      return send(name) if private_instance_methods.include?(name.to_sym)
 
       reflex.connection.identifiers.each do |identifier|
         ident = reflex.connection.send(identifier)
-        return ident.send(method) if ident.respond_to?(:attributes) && ident.attributes.key?(method.to_s)
+        return ident.send(name) if ident.respond_to?(:attributes) && ident.attributes.key?(name.to_s)
       end
       "-"
     end
 
-    def respond_to_missing? method
-      return true if private_instance_methods.include?(method.to_sym)
+    def respond_to_missing?(name, include_all)
+      return true if private_instance_methods.include?(name.to_sym)
 
       reflex.connection.identifiers.each do |identifier|
         ident = reflex.connection.send(identifier)
-        return true if ident.respond_to?(:attributes) && ident.attributes.key?(method.to_s)
+        return true if ident.respond_to?(:attributes) && ident.attributes.key?(name.to_s)
       end
       false
     end