stimulus_reflex 3.3.0 → 3.4.0.pre4

data/lib/generators/stimulus_reflex/config_generator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module StimulusReflex
+  class ConfigGenerator < Rails::Generators::Base
+    desc "Creates an StimulusReflex configuration file in config/initializers"
+    source_root File.expand_path("templates", __dir__)
+
+    def copy_config_file
+      copy_file "config/initializers/stimulus_reflex.rb"
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+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
+
+  # Override the parent class that the StimulusReflex ActionCable channel inherits from
+
+  # config.parent_channel = "ApplicationCable::Channel"
+
+  # 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: 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)
+
+  # config.logging = proc { "[#{session_id}] #{operation_counter.magenta} #{reflex_info.green} -> #{selector.cyan} via #{mode} Morph (#{operation.yellow})" }
+end

data/lib/stimulus_reflex.rb

@@ -9,15 +9,16 @@ require "action_cable"
 require "nokogiri"
 require "cable_ready"
 require "stimulus_reflex/version"
+require "stimulus_reflex/configuration"
 require "stimulus_reflex/reflex"
 require "stimulus_reflex/element"
-require "stimulus_reflex/channel"
 require "stimulus_reflex/sanity_checker"
 require "stimulus_reflex/broadcasters/broadcaster"
 require "stimulus_reflex/broadcasters/nothing_broadcaster"
 require "stimulus_reflex/broadcasters/page_broadcaster"
 require "stimulus_reflex/broadcasters/selector_broadcaster"
-require "generators/stimulus_reflex_generator"
+require "stimulus_reflex/utils/colorize"
+require "stimulus_reflex/logger"
 
 module StimulusReflex
   class Engine < Rails::Engine

data/lib/stimulus_reflex/broadcasters/broadcaster.rb

@@ -4,12 +4,13 @@ module StimulusReflex
   class Broadcaster
     include CableReady::Broadcaster
 
-    attr_reader :reflex, :logger
+    attr_reader :reflex, :logger, :operations
     delegate :permanent_attribute_name, :stream_name, to: :reflex
 
     def initialize(reflex)
       @reflex = reflex
-      @logger = Rails.logger
+      @logger = Rails.logger if defined?(Rails.logger)
+      @operations = []
     end
 
     def nothing?
@@ -24,22 +25,19 @@ module StimulusReflex
       false
     end
 
-    def enqueue_message(subject:, body: nil, data: {})
+    def broadcast_message(subject:, body: nil, data: {}, error: nil)
       logger.error "\e[31m#{body}\e[0m" if subject == "error"
+      @operations << ["document", :dispatch_event]
       cable_ready[stream_name].dispatch_event(
         name: "stimulus-reflex:server-message",
         detail: {
           reflexId: data["reflexId"],
           stimulus_reflex: data.merge(
-            broadcaster: to_sym,
-            server_message: {subject: subject, body: body}
+            morph: to_sym,
+            server_message: {subject: subject, body: error&.to_s}
           )
         }
       )
-    end
-
-    def broadcast_message(subject:, body: nil, data: {})
-      enqueue_message subject: subject, body: body, data: data
       cable_ready.broadcast
     end
 
@@ -52,5 +50,10 @@ module StimulusReflex
     def to_sym
       raise NotImplementedError
     end
+
+    # abstract method to be implemented by subclasses
+    def to_s
+      raise NotImplementedError
+    end
   end
 end

data/lib/stimulus_reflex/broadcasters/nothing_broadcaster.rb

@@ -13,5 +13,9 @@ module StimulusReflex
     def to_sym
       :nothing
     end
+
+    def to_s
+      "Nothing"
+    end
   end
 end

data/lib/stimulus_reflex/broadcasters/page_broadcaster.rb

@@ -3,14 +3,15 @@
 module StimulusReflex
   class PageBroadcaster < Broadcaster
     def broadcast(selectors, data)
-      reflex.controller.process reflex.url_params[:action]
+      reflex.controller.process reflex.params[:action]
       page_html = reflex.controller.response.body
 
       return unless page_html.present?
 
-      document = Nokogiri::HTML(page_html)
+      document = Nokogiri::HTML.parse(page_html)
       selectors = selectors.select { |s| document.css(s).present? }
       selectors.each do |selector|
+        @operations << [selector, :morph]
         html = document.css(selector).inner_html
         cable_ready[stream_name].morph(
           selector: selector,
@@ -18,7 +19,7 @@ module StimulusReflex
           children_only: true,
           permanent_attribute_name: permanent_attribute_name,
           stimulus_reflex: data.merge({
-            broadcaster: to_sym
+            morph: to_sym
           })
         )
       end
@@ -32,5 +33,9 @@ module StimulusReflex
     def page?
       true
     end
+
+    def to_s
+      "Page"
+    end
   end
 end

data/lib/stimulus_reflex/broadcasters/selector_broadcaster.rb

@@ -11,21 +11,23 @@ module StimulusReflex
           fragment = Nokogiri::HTML.fragment(html)
           match = fragment.at_css(selector)
           if match.present?
+            @operations << [selector, :morph]
             cable_ready[stream_name].morph(
               selector: selector,
               html: match.inner_html,
               children_only: true,
               permanent_attribute_name: permanent_attribute_name,
               stimulus_reflex: data.merge({
-                broadcaster: to_sym
+                morph: to_sym
               })
             )
           else
+            @operations << [selector, :inner_html]
             cable_ready[stream_name].inner_html(
               selector: selector,
               html: fragment.to_html,
               stimulus_reflex: data.merge({
-                broadcaster: to_sym
+                morph: to_sym
               })
             )
           end
@@ -40,6 +42,10 @@ module StimulusReflex
       @morphs ||= []
     end
 
+    def append_morph(selectors, html)
+      morphs << [selectors, html]
+    end
+
     def to_sym
       :selector
     end
@@ -47,5 +53,9 @@ module StimulusReflex
     def selector?
       true
     end
+
+    def to_s
+      "Selector"
+    end
   end
 end

data/lib/stimulus_reflex/configuration.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module StimulusReflex
+  class << self
+    def configure
+      yield configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    alias_method :config, :configuration
+  end
+
+  class Configuration
+    attr_accessor :on_failed_sanity_checks, :parent_channel, :logging
+
+    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
+      @parent_channel = "ApplicationCable::Channel"
+      @logging = DEFAULT_LOGGING
+    end
+  end
+end

data/lib/stimulus_reflex/element.rb

@@ -11,6 +11,14 @@ class StimulusReflex::Element < OpenStruct
     @data_attributes.transform_keys! { |key| key.delete_prefix "data-" }
   end
 
+  def signed
+    @signed ||= ->(accessor) { GlobalID::Locator.locate_signed(dataset[accessor]) }
+  end
+
+  def unsigned
+    @unsigned ||= ->(accessor) { GlobalID::Locator.locate(dataset[accessor]) }
+  end
+
   def dataset
     @dataset ||= OpenStruct.new(data_attributes.merge(data_attributes.transform_keys(&:underscore)))
   end

data/lib/stimulus_reflex/logger.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module StimulusReflex
+  class Logger
+    attr_accessor :reflex, :current_operation
+
+    def initialize(reflex)
+      @reflex = reflex
+      @current_operation = 1
+    end
+
+    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
+
+    def config_logging
+      return @config_logging if @config_logging
+
+      StimulusReflex.config.logging.binding.eval("using StimulusReflex::Utils::Colorize")
+      @config_logging = StimulusReflex.config.logging
+    end
+
+    def session_id_full
+      session = reflex.request&.session
+      session.nil? ? "-" : session.id
+    end
+
+    def session_id
+      session_id_full.to_s[0..7]
+    end
+
+    def reflex_info
+      reflex.class.to_s + "#" + reflex.method_name
+    end
+
+    def reflex_id_full
+      reflex.reflex_id
+    end
+
+    def reflex_id
+      reflex_id_full[0..7]
+    end
+
+    def mode
+      reflex.broadcaster.to_s
+    end
+
+    def selector
+      reflex.broadcaster.operations[current_operation - 1][0]
+    end
+
+    def operation
+      reflex.broadcaster.operations[current_operation - 1][1].to_s
+    end
+
+    def operation_counter
+      current_operation.to_s + "/" + reflex.broadcaster.operations.size.to_s
+    end
+
+    def connection_id_full
+      identifier = reflex.connection&.connection_identifier
+      identifier.empty? ? "-" : identifier
+    end
+
+    def connection_id
+      connection_id_full[0..7]
+    end
+
+    def timestamp
+      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)
+
+      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)
+      end
+      "-"
+    end
+
+    def respond_to_missing? method
+      return true if private_instance_methods.include?(method.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)
+      end
+      false
+    end
+
+    def private_instance_methods
+      StimulusReflex::Logger.private_instance_methods(false)
+    end
+  end
+end

data/lib/stimulus_reflex/reflex.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+ClientAttributes = Struct.new(:reflex_id, :reflex_controller, :xpath, :c_xpath, :permanent_attribute_name, keyword_init: true)
+
 class StimulusReflex::Reflex
   include ActiveSupport::Rescuable
   include ActiveSupport::Callbacks
@@ -43,21 +45,25 @@ class StimulusReflex::Reflex
     end
   end
 
-  attr_reader :channel, :url, :element, :selectors, :method_name, :broadcaster, :permanent_attribute_name
+  attr_reader :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 :session, to: :request
+  delegate :flash, :session, to: :request
   delegate :broadcast, :broadcast_message, to: :broadcaster
+  delegate :reflex_id, :reflex_controller, :xpath, :c_xpath, :permanent_attribute_name, to: :client_attributes
 
-  def initialize(channel, url: nil, element: nil, selectors: [], method_name: nil, permanent_attribute_name: nil, params: {})
+  def initialize(channel, url: nil, element: nil, selectors: [], method_name: nil, params: {}, client_attributes: {})
     @channel = channel
     @url = url
     @element = element
     @selectors = selectors
     @method_name = method_name
     @params = params
-    @permanent_attribute_name = permanent_attribute_name
     @broadcaster = StimulusReflex::PageBroadcaster.new(self)
+    @logger = StimulusReflex::Logger.new(self)
+    @client_attributes = ClientAttributes.new(client_attributes)
     self.params
   end
 
@@ -66,21 +72,26 @@ class StimulusReflex::Reflex
       uri = URI.parse(url)
       path = ActionDispatch::Journey::Router::Utils.normalize_path(uri.path)
       query_hash = Rack::Utils.parse_nested_query(uri.query)
-      req = ActionDispatch::Request.new(
-        connection.env.merge(
-          Rack::MockRequest.env_for(uri.to_s).merge(
-            "rack.request.query_hash" => query_hash,
-            "rack.request.query_string" => uri.query,
-            "ORIGINAL_SCRIPT_NAME" => "",
-            "ORIGINAL_FULLPATH" => path,
-            Rack::SCRIPT_NAME => "",
-            Rack::PATH_INFO => path,
-            Rack::REQUEST_PATH => path,
-            Rack::QUERY_STRING => uri.query
-          )
-        )
+      mock_env = Rack::MockRequest.env_for(uri.to_s)
+
+      mock_env.merge!(
+        "rack.request.query_hash" => query_hash,
+        "rack.request.query_string" => uri.query,
+        "ORIGINAL_SCRIPT_NAME" => "",
+        "ORIGINAL_FULLPATH" => path,
+        Rack::SCRIPT_NAME => "",
+        Rack::PATH_INFO => path,
+        Rack::REQUEST_PATH => path,
+        Rack::QUERY_STRING => uri.query
       )
+
+      env = connection.env.merge(mock_env)
+      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")
+
       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! }
@@ -97,7 +108,7 @@ class StimulusReflex::Reflex
     else
       raise StandardError.new("Cannot call :selector morph after :nothing morph") if broadcaster.nothing?
       @broadcaster = StimulusReflex::SelectorBroadcaster.new(self) unless broadcaster.selector?
-      broadcaster.morphs << [selectors, html]
+      broadcaster.append_morph(selectors, html)
     end
   end
 
@@ -112,10 +123,6 @@ class StimulusReflex::Reflex
     end
   end
 
-  def url_params
-    @url_params ||= Rails.application.routes.recognize_path_with_request(request, request.path, request.env[:extras] || {})
-  end
-
   def process(name, *args)
     reflex_invoked = false
     result = run_callbacks(:process) {