stimulus_reflex 3.4.0.pre8 → 3.5.0.pre1

data/lib/generators/USAGE

@@ -11,4 +11,4 @@ Example:
         app/reflexes/application_reflex.rb
         app/reflexes/user_reflex.rb
 
-    Don't forget to setup the application: https://docs.stimulusreflex.com/setup
+    Don't forget to setup the application: https://docs.stimulusreflex.com/hello-world/setup

data/lib/generators/stimulus_reflex/{config_generator.rb → initializer_generator.rb}

@@ -3,11 +3,11 @@
 require "rails/generators"
 
 module StimulusReflex
-  class ConfigGenerator < Rails::Generators::Base
-    desc "Creates an StimulusReflex configuration file in config/initializers"
+  class InitializerGenerator < Rails::Generators::Base
+    desc "Creates a StimulusReflex initializer in config/initializers"
     source_root File.expand_path("templates", __dir__)
 
-    def copy_config_file
+    def copy_initializer_file
       copy_file "config/initializers/stimulus_reflex.rb"
     end
   end

data/lib/generators/stimulus_reflex/templates/app/reflexes/%file_name%_reflex.rb.tt

@@ -17,12 +17,13 @@ class <%= class_name %>Reflex < ApplicationReflex
   #     - unsigned  - use an unsigned Global ID to map dataset attribute to a model  eg. element.unsigned[:foo]
   #   - cable_ready - a special cable_ready that can broadcast to the current visitor (no brackets needed)
   #   - reflex_id   - a UUIDv4 that uniquely identies each Reflex
+  #   - tab_id      - a UUIDv4 that uniquely identifies the browser tab
   #
   # Example:
   #
   #   before_reflex do
   #     # throw :abort # this will prevent the Reflex from continuing
-  #     # learn more about callbacks at https://docs.stimulusreflex.com/lifecycle
+  #     # learn more about callbacks at https://docs.stimulusreflex.com/rtfm/lifecycle
   #   end
   #
   #   def example(argument=true)
@@ -30,7 +31,7 @@ class <%= class_name %>Reflex < ApplicationReflex
   #     # Any declared instance variables will be made available to the Rails controller and view.
   #   end
   #
-  # Learn more at: https://docs.stimulusreflex.com/reflexes#reflex-classes
+  # Learn more at: https://docs.stimulusreflex.com/rtfm/reflex-classes
 
 <% actions.each do |action| -%>
   def <%= action %>

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

@@ -8,5 +8,5 @@ class ApplicationReflex < StimulusReflex::Reflex
   #   # If your ActionCable connection is: `identified_by :current_user`
   #   delegate :current_user, to: :connection
   #
-  # Learn more at: https://docs.stimulusreflex.com/reflexes#reflex-classes
+  # Learn more at: https://docs.stimulusreflex.com/rtfm/reflex-classes
 end

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

@@ -6,6 +6,11 @@ StimulusReflex.configure do |config|
 
   # 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
+
   # Override the parent class that the StimulusReflex ActionCable channel inherits from
 
   # config.parent_channel = "ApplicationCable::Channel"
@@ -15,6 +20,15 @@ StimulusReflex.configure do |config|
   # 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/appendices/troubleshooting#stimulusreflex-logging
 
   # config.logging = proc { "[#{session_id}] #{operation_counter.magenta} #{reflex_info.green} -> #{selector.cyan} via #{mode} Morph (#{operation.yellow})" }
+
+  # Optimized for speed, StimulusReflex doesn't enable Rack middleware by default.
+  # If you are using Page Morphs and your app uses Rack middleware to rewrite part of the request path, you must enable those middleware modules in StimulusReflex.
+  #
+  # Learn more about registering Rack middleware in Rails here: https://guides.rubyonrails.org/rails_on_rack.html#configuring-middleware-stack
+
+  # config.middleware.use FirstRackMiddleware
+  # config.middleware.use SecondRackMiddleware
 end

data/lib/stimulus_reflex.rb

@@ -1,30 +1,38 @@
 # frozen_string_literal: true
 
 require "uri"
+require "open-uri"
 require "rack"
 require "rails/engine"
 require "active_support/all"
 require "action_dispatch"
 require "action_cable"
+require "action_view"
 require "nokogiri"
 require "cable_ready"
 require "stimulus_reflex/version"
 require "stimulus_reflex/cable_ready_channels"
+require "stimulus_reflex/concern_enhancer"
 require "stimulus_reflex/configuration"
+require "stimulus_reflex/callbacks"
+require "stimulus_reflex/request_parameters"
 require "stimulus_reflex/reflex"
+require "stimulus_reflex/reflex_data"
+require "stimulus_reflex/reflex_factory"
 require "stimulus_reflex/element"
-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 "stimulus_reflex/policies/reflex_invocation_policy"
 require "stimulus_reflex/utils/colorize"
-require "stimulus_reflex/logger"
+require "stimulus_reflex/utils/logger"
+require "stimulus_reflex/utils/sanity_checker"
 
 module StimulusReflex
   class Engine < Rails::Engine
     initializer "stimulus_reflex.sanity_check" do
-      SanityChecker.check!
+      SanityChecker.check! unless Rails.env.production?
     end
   end
 end

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

@@ -1,12 +1,36 @@
+# frozen_string_literal: true
+
 module StimulusReflex
   class CableReadyChannels
-    stimulus_reflex_channel_methods = CableReady::Channels.instance.operations.keys + [:broadcast, :broadcast_to]
-    delegate(*stimulus_reflex_channel_methods, to: "@stimulus_reflex_channel")
-    delegate :[], to: "@cable_ready_channels"
+    delegate :[], to: "cable_ready_channels"
+
+    def initialize(stream_name, reflex_id)
+      @stream_name = stream_name
+      @reflex_id = reflex_id
+    end
+
+    def cable_ready_channels
+      CableReady::Channels.instance
+    end
+
+    def stimulus_reflex_channel
+      CableReady::Channels.instance[@stream_name]
+    end
+
+    def method_missing(name, *args)
+      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
 
-    def initialize(stream_name)
-      @cable_ready_channels = CableReady::Channels.instance
-      @stimulus_reflex_channel = @cable_ready_channels[stream_name]
+    def respond_to_missing?(name, include_all)
+      stimulus_reflex_channel.respond_to?(name) || super
     end
   end
 end

data/lib/stimulus_reflex/callbacks.rb

@@ -0,0 +1,98 @@
+require "active_support/concern"
+
+module StimulusReflex
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveSupport::Callbacks
+      define_callbacks :process, skip_after_callbacks_if_terminated: true
+    end
+
+    class_methods do
+      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
+
+      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)
+        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
+      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.to_s }
+          options[to] = Array(options[to]).unshift(from)
+        end
+      end
+    end
+  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,16 @@ module StimulusReflex
   end
 
   class Configuration
-    attr_accessor :on_failed_sanity_checks, :parent_channel, :logging
+    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
     end
   end
 end

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