stimulus_reflex 3.4.0.pre8 → 3.5.0.pre1

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,10 +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 :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
@@ -64,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
 
@@ -87,19 +63,25 @@ class StimulusReflex::Reflex
       )
 
       env = connection.env.merge(mock_env)
+
+      middleware = StimulusReflex.config.middleware
+
+      if middleware.any?
+        stack = middleware.build(Rails.application.routes)
+        stack.call(env)
+      end
+
       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?
@@ -114,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) {
@@ -147,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

data/lib/stimulus_reflex/{sanity_checker.rb → utils/sanity_checker.rb}

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class StimulusReflex::SanityChecker
+  LATEST_VERSION_FORMAT = /^(\d+\.\d+\.\d+)$/
+  NODE_VERSION_FORMAT = /(\d+\.\d+\.\d+.*):/
   JSON_VERSION_FORMAT = /(\d+\.\d+\.\d+.*)"/
 
   class << self
@@ -12,6 +14,8 @@ class StimulusReflex::SanityChecker
       instance = new
       instance.check_caching_enabled
       instance.check_javascript_package_version
+      instance.check_default_url_config
+      instance.check_new_version_available
     end
 
     private
@@ -23,44 +27,80 @@ class StimulusReflex::SanityChecker
     end
 
     def called_by_generate_config?
-      ARGV.include? "stimulus_reflex:config"
+      ARGV.include? "stimulus_reflex:initializer"
     end
   end
 
   def check_caching_enabled
     unless caching_enabled?
       warn_and_exit <<~WARN
-        Stimulus Reflex requires caching to be enabled. Caching allows the session to be modified during ActionCable requests.
+        StimulusReflex requires caching to be enabled. Caching allows the session to be modified during ActionCable requests.
         To enable caching in development, run:
-            rails dev:cache
+          rails dev:cache
       WARN
     end
 
     unless not_null_store?
       warn_and_exit <<~WARN
-        Stimulus Reflex requires caching to be enabled. Caching allows the session to be modified during ActionCable requests.
+        StimulusReflex requires caching to be enabled. Caching allows the session to be modified during ActionCable requests.
         But your config.cache_store is set to :null_store, so it won't work.
       WARN
     end
   end
 
+  def check_default_url_config
+    unless default_url_config_set?
+      warn_and_exit <<~WARN
+        StimulusReflex strongly suggests that you set default_url_options in your environment files.
+        Otherwise, ActionController and ActionMailer will default to example.com when rendering route helpers.
+        You can set your URL options in config/environments/#{Rails.env}.rb
+          config.action_controller.default_url_options = {host: "localhost", port: 3000}
+          config.action_mailer.default_url_options = {host: "localhost", port: 3000}
+        Please update every environment with the appropriate URL. Typically, no port is necessary in production.
+      WARN
+    end
+  end
+
   def check_javascript_package_version
     if javascript_package_version.nil?
       warn_and_exit <<~WARN
-        Can't locate the stimulus_reflex NPM package.
+        Can't locate the stimulus_reflex npm package.
         Either add it to your package.json as a dependency or use "yarn link stimulus_reflex" if you are doing development.
       WARN
     end
 
     unless javascript_version_matches?
       warn_and_exit <<~WARN
-        The Stimulus Reflex javascript package version (#{javascript_package_version}) does not match the Rubygem version (#{gem_version}).
-        To update the Stimulus Reflex npm package:
-            yarn upgrade stimulus_reflex@#{gem_version}
+        The stimulus_reflex npm package version (#{javascript_package_version}) does not match the Rubygem version (#{gem_version}).
+        To update the stimulus_reflex npm package:
+          yarn upgrade stimulus_reflex@#{gem_version}
       WARN
     end
   end
 
+  def check_new_version_available
+    return unless Rails.env.development?
+    return if StimulusReflex.config.on_new_version_available == :ignore
+    return unless using_stable_release
+    begin
+      latest_version = URI.open("https://raw.githubusercontent.com/stimulusreflex/stimulus_reflex/master/LATEST", open_timeout: 1, read_timeout: 1).read.strip
+      if latest_version != StimulusReflex::VERSION
+        puts <<~WARN
+
+          There is a new version of StimulusReflex available!
+          Current: #{StimulusReflex::VERSION} Latest: #{latest_version}
+
+          If you upgrade, it is very important that you update BOTH Gemfile and package.json
+          Then, run `bundle install && yarn install` to update to #{latest_version}.
+
+        WARN
+        exit if StimulusReflex.config.on_new_version_available == :exit
+      end
+    rescue
+      puts "StimulusReflex #{StimulusReflex::VERSION} update check skipped: connection timeout"
+    end
+  end
+
   private
 
   def caching_enabled?
@@ -71,10 +111,20 @@ class StimulusReflex::SanityChecker
     Rails.application.config.cache_store != :null_store
   end
 
+  def default_url_config_set?
+    Rails.application.config.action_controller.default_url_options
+  end
+
   def javascript_version_matches?
     javascript_package_version == gem_version
   end
 
+  def using_stable_release
+    stable = StimulusReflex::VERSION.match?(LATEST_VERSION_FORMAT)
+    puts "StimulusReflex #{StimulusReflex::VERSION} update check skipped: pre-release build" unless stable
+    stable
+  end
+
   def gem_version
     @_gem_version ||= StimulusReflex::VERSION.gsub(".pre", "-pre")
   end
@@ -86,6 +136,8 @@ class StimulusReflex::SanityChecker
   def find_javascript_package_version
     if (match = search_file(package_json_path, regex: /version/))
       match[JSON_VERSION_FORMAT, 1]
+    elsif (match = search_file(yarn_lock_path, regex: /^stimulus_reflex/))
+      match[NODE_VERSION_FORMAT, 1]
     end
   end
 
@@ -98,6 +150,10 @@ class StimulusReflex::SanityChecker
     Rails.root.join("node_modules", "stimulus_reflex", "package.json")
   end
 
+  def yarn_lock_path
+    Rails.root.join("yarn.lock")
+  end
+
   def initializer_path
     @_initializer_path ||= Rails.root.join("config", "initializers", "stimulus_reflex.rb")
   end
@@ -111,7 +167,6 @@ class StimulusReflex::SanityChecker
   def exit_with_info
     puts
 
-    # 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,
@@ -132,7 +187,7 @@ class StimulusReflex::SanityChecker
 
         Then open your initializer at
 
-        <RAILS_ROOT>/config/initializers/stimulus_reflex.rb
+        #{initializer_path}
 
         and then add the following directive: