stimulus_reflex 3.4.0.pre1 → 3.4.0.pre6

data/lib/generators/stimulus_reflex/templates/app/reflexes/application_reflex.rb.tt

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 class ApplicationReflex < StimulusReflex::Reflex
-  # Put application wide Reflex behavior in this file.
+  # Put application-wide Reflex behavior and callbacks in this file. 
   #
   # Example:
   #
   #   # If your ActionCable connection is: `identified_by :current_user`
   #   delegate :current_user, to: :connection
   #
-  # Learn more at: https://docs.stimulusreflex.com
+  # Learn more at: https://docs.stimulusreflex.com/reflexes#reflex-classes
 end

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

@@ -1,9 +1,20 @@
 # frozen_string_literal: true
 
 StimulusReflex.configure do |config|
-  # Enable/disable whether startup should be aborted when the sanity checks fail
-  # config.exit_on_failed_sanity_checks = true
+  # 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,6 +9,7 @@ require "action_cable"
 require "nokogiri"
 require "cable_ready"
 require "stimulus_reflex/version"
+require "stimulus_reflex/cable_ready_channels"
 require "stimulus_reflex/configuration"
 require "stimulus_reflex/reflex"
 require "stimulus_reflex/element"
@@ -17,6 +18,8 @@ require "stimulus_reflex/broadcasters/broadcaster"
 require "stimulus_reflex/broadcasters/nothing_broadcaster"
 require "stimulus_reflex/broadcasters/page_broadcaster"
 require "stimulus_reflex/broadcasters/selector_broadcaster"
+require "stimulus_reflex/utils/colorize"
+require "stimulus_reflex/logger"
 
 module StimulusReflex
   class Engine < Rails::Engine

data/lib/stimulus_reflex/broadcasters/broadcaster.rb

@@ -2,14 +2,13 @@
 
 module StimulusReflex
   class Broadcaster
-    include CableReady::Broadcaster
-
-    attr_reader :reflex, :logger
-    delegate :permanent_attribute_name, :stream_name, to: :reflex
+    attr_reader :reflex, :logger, :operations
+    delegate :cable_ready, :permanent_attribute_name, to: :reflex
 
     def initialize(reflex)
       @reflex = reflex
-      @logger = Rails.logger
+      @logger = Rails.logger if defined?(Rails.logger)
+      @operations = []
     end
 
     def nothing?
@@ -26,7 +25,8 @@ module StimulusReflex
 
     def broadcast_message(subject:, body: nil, data: {}, error: nil)
       logger.error "\e[31m#{body}\e[0m" if subject == "error"
-      cable_ready[stream_name].dispatch_event(
+      operations << ["document", :dispatch_event]
+      cable_ready.dispatch_event(
         name: "stimulus-reflex:server-message",
         detail: {
           reflexId: data["reflexId"],
@@ -48,5 +48,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

@@ -8,11 +8,12 @@ module StimulusReflex
 
       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(
+        cable_ready.morph(
           selector: selector,
           html: html,
           children_only: true,
@@ -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,7 +11,8 @@ module StimulusReflex
           fragment = Nokogiri::HTML.fragment(html)
           match = fragment.at_css(selector)
           if match.present?
-            cable_ready[stream_name].morph(
+            operations << [selector, :morph]
+            cable_ready.morph(
               selector: selector,
               html: match.inner_html,
               children_only: true,
@@ -21,7 +22,8 @@ module StimulusReflex
               })
             )
           else
-            cable_ready[stream_name].inner_html(
+            operations << [selector, :inner_html]
+            cable_ready.inner_html(
               selector: selector,
               html: fragment.to_html,
               stimulus_reflex: data.merge({
@@ -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/cable_ready_channels.rb

@@ -0,0 +1,18 @@
+module StimulusReflex
+  class CableReadyChannels
+    def initialize(stream_name)
+      @cable_ready_channels = CableReady::Channels.instance
+      @stimulus_reflex_channel = @cable_ready_channels[stream_name]
+    end
+
+    def method_missing(name, *args)
+      return @stimulus_reflex_channel.send(name, *args) if @stimulus_reflex_channel.respond_to?(name)
+      @cable_ready_channels.send(name, *args)
+    end
+
+    def respond_to_missing?(name, include_all)
+      @stimulus_reflex_channel.respond_to?(name, include_all) ||
+        @cable_ready_channels.respond_to?(name, include_all)
+    end
+  end
+end

data/lib/stimulus_reflex/configuration.rb

@@ -14,11 +14,14 @@ module StimulusReflex
   end
 
   class Configuration
-    attr_accessor :exit_on_failed_sanity_checks, :parent_channel
+    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
-      @exit_on_failed_sanity_checks = true
+      @on_failed_sanity_checks = :exit
       @parent_channel = "ApplicationCable::Channel"
+      @logging = DEFAULT_LOGGING
     end
   end
 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,9 +1,10 @@
 # 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
-  include CableReady::Broadcaster
 
   define_callbacks :process, skip_after_callbacks_if_terminated: true
 
@@ -43,23 +44,26 @@ class StimulusReflex::Reflex
     end
   end
 
-  attr_reader :channel, :url, :element, :selectors, :method_name, :broadcaster, :permanent_attribute_name
+  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 :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)
+    @cable_ready = StimulusReflex::CableReadyChannels.new(stream_name)
     self.params
   end
 
@@ -104,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
 

data/lib/stimulus_reflex/sanity_checker.rb

@@ -3,10 +3,28 @@
 class StimulusReflex::SanityChecker
   JSON_VERSION_FORMAT = /(\d+\.\d+\.\d+.*)"/
 
-  def self.check!
-    instance = new
-    instance.check_caching_enabled
-    instance.check_javascript_package_version
+  class << self
+    def check!
+      return if StimulusReflex.config.on_failed_sanity_checks == :ignore
+      return if called_by_installer?
+      return if called_by_generate_config?
+
+      instance = new
+      instance.check_caching_enabled
+      instance.check_javascript_package_version
+    end
+
+    private
+
+    def called_by_installer?
+      Rake.application.top_level_tasks.include? "stimulus_reflex:install"
+    rescue
+      false
+    end
+
+    def called_by_generate_config?
+      ARGV.include? "stimulus_reflex:config"
+    end
   end
 
   def check_caching_enabled
@@ -80,19 +98,50 @@ class StimulusReflex::SanityChecker
     Rails.root.join("node_modules", "stimulus_reflex", "package.json")
   end
 
+  def initializer_path
+    @_initializer_path ||= Rails.root.join("config", "initializers", "stimulus_reflex.rb")
+  end
+
   def warn_and_exit(text)
     puts "WARNING:"
     puts text
-    exit_with_info if StimulusReflex.config.exit_on_failed_sanity_checks
+    exit_with_info if StimulusReflex.config.on_failed_sanity_checks == :exit
   end
 
   def exit_with_info
     puts
-    puts <<~INFO
-      If you know what you are doing and you want to start the application anyway,
-      you can add the following directive to an initializer:
-            StimulusReflex.config.exit_on_failed_sanity_checks = false
-    INFO
-    exit
+
+    # bundle exec rails generate stimulus_reflex:config
+    if File.exist?(initializer_path)
+      puts <<~INFO
+        If you know what you are doing and you want to start the application anyway,
+        you can add the following directive to the StimulusReflex initializer,
+        which is located at #{initializer_path}
+
+          StimulusReflex.configure do |config|
+            config.on_failed_sanity_checks = :warn
+          end
+
+      INFO
+    else
+      puts <<~INFO
+        If you know what you are doing and you want to start the application anyway,
+        you can create a StimulusReflex initializer with the command:
+
+        bundle exec rails generate stimulus_reflex:config
+
+        Then open your initializer at
+
+        <RAILS_ROOT>/config/initializers/stimulus_reflex.rb
+
+        and then add the following directive:
+
+          StimulusReflex.configure do |config|
+            config.on_failed_sanity_checks = :warn
+          end
+
+      INFO
+    end
+    exit false
   end
 end