stimulus_reflex 3.3.0.pre4 → 3.4.0.pre1

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/app/javascript/controllers/%file_name%_controller.js.tt

@@ -0,0 +1,89 @@
+import ApplicationController from './application_controller'
+
+/* This is the custom StimulusReflex controller for the <%= class_name %> Reflex.
+ * Learn more at: https://docs.stimulusreflex.com
+ */
+export default class extends ApplicationController {
+  /*
+   * Regular Stimulus lifecycle methods
+   * Learn more at: https://stimulusjs.org/reference/lifecycle-callbacks
+   *
+   * If you intend to use this controller as a regular stimulus controller as well,
+   * make sure any Stimulus lifecycle methods overridden in ApplicationController call super.
+   *
+   * Important:
+   * By default, StimulusReflex overrides the -connect- method so make sure you
+   * call super if you intend to do anything else when this controller connects.
+  */
+
+  connect () {
+    super.connect()
+    // add your code here, if applicable
+  }
+
+  /* Reflex specific lifecycle methods.
+   *
+   * For every method defined in your Reflex class, a matching set of lifecycle methods become available
+   * in this javascript controller. These are optional, so feel free to delete these stubs if you don't
+   * need them.
+   *
+   * Important:
+   * Make sure to add data-controller="<%= class_name.underscore.dasherize %>" to your markup alongside
+   * data-reflex="<%= class_name %>#dance" for the lifecycle methods to fire properly.
+   *
+   * Example:
+   *
+   *   <a href="#" data-reflex="click-><%= class_name %>#dance" data-controller="<%= class_name.underscore.dasherize %>">Dance!</a>
+   *
+   * Arguments:
+   *
+   *   element - the element that triggered the reflex
+   *             may be different than the Stimulus controller's this.element
+   *
+   *   reflex - the name of the reflex e.g. "<%= class_name %>#dance"
+   *
+   *   error/noop - the error message (for reflexError), otherwise null
+   *
+   *   reflexId - a UUID4 or developer-provided unique identifier for each Reflex
+   */
+
+<% if actions.empty? -%>
+  // Assuming you create a "<%= class_name %>#dance" action in your Reflex class
+  // you'll be able to use the following lifecycle methods:
+
+  // beforeDance(element, reflex, noop, reflexId) {
+  //  element.innerText = 'Putting dance shoes on...'
+  // }
+
+  // danceSuccess(element, reflex, noop, reflexId) {
+  //   element.innerText = 'Danced like no one was watching! Was someone watching?'
+  // }
+
+  // danceError(element, reflex, error, reflexId) {
+  //   console.error('danceError', error);
+  //   element.innerText = "Couldn't dance!"
+  // }
+<% end -%>
+<% actions.each do |action| -%>
+  // <%= "before_#{action}".camelize(:lower) %>(element, reflex, noop, reflexId) {
+  //  console.log("before <%= action %>", element, reflex, reflexId)
+  // }
+
+  // <%= "#{action}_success".camelize(:lower) %>(element, reflex, noop, reflexId) {
+  //   console.log("<%= action %> success", element, reflex, reflexId)
+  // }
+
+  // <%= "#{action}_error".camelize(:lower) %>(element, reflex, error, reflexId) {
+  //   console.error("<%= action %> error", element, reflex, error, reflexId)
+  // }
+
+  // <%= "#{action}_halted".camelize(:lower) %>(element, reflex, noop, reflexId) {
+  //   console.warn("<%= action %> halted", element, reflex, reflexId)
+  // }
+
+  // <%= "after_#{action}".camelize(:lower) %>(element, reflex, noop, reflexId) {
+  //   console.log("after <%= action %>", element, reflex, reflexId)
+  // }
+<%= "\n" unless action == actions.last -%>
+<% end -%>
+}

data/lib/generators/{templates → stimulus_reflex/templates}/app/javascript/controllers/application_controller.js.tt

@@ -1,7 +1,7 @@
 import { Controller } from 'stimulus'
 import StimulusReflex from 'stimulus_reflex'
 
-/* This is your application's ApplicationController.
+/* This is your ApplicationController.
  * All StimulusReflex controllers should inherit from this class.
  *
  * Example:
@@ -17,7 +17,8 @@ export default class extends Controller {
     StimulusReflex.register(this)
   }
 
-  /* Application wide lifecycle methods.
+  /* Application-wide lifecycle methods
+   *
    * Use these methods to handle lifecycle concerns for the entire application.
    * Using the lifecycle is optional, so feel free to delete these stubs if you don't need them.
    *
@@ -26,24 +27,26 @@ export default class extends Controller {
    *   element - the element that triggered the reflex
    *             may be different than the Stimulus controller's this.element
    *
-   *   reflex - the name of the reflex e.g. "ExampleReflex#demo"
+   *   reflex - the name of the reflex e.g. "Example#demo"
+   *
+   *   error/noop - the error message (for reflexError), otherwise null
    *
-   *   error - error message from the server
+   *   reflexId - a UUID4 or developer-provided unique identifier for each Reflex
    */
 
-  beforeReflex (element, reflex) {
+  beforeReflex (element, reflex, noop, reflexId) {
     // document.body.classList.add('wait')
   }
 
-  reflexSuccess (element, reflex, error) {
+  reflexSuccess (element, reflex, noop, reflexId) {
     // show success message etc...
   }
 
-  reflexError (element, reflex, error) {
+  reflexError (element, reflex, error, reflexId) {
     // show error message etc...
   }
 
-  afterReflex (element, reflex) {
+  afterReflex (element, reflex, noop, reflexId) {
     // document.body.classList.remove('wait')
   }
 }

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

@@ -0,0 +1,9 @@
+# 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
+
+  # Override the parent class that the StimulusReflex ActionCable channel inherits from
+  # config.parent_channel = "ApplicationCable::Channel"
+end

data/lib/stimulus_reflex.rb

@@ -9,16 +9,19 @@ 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"
 
 module StimulusReflex
   class Engine < Rails::Engine
+    initializer "stimulus_reflex.sanity_check" do
+      SanityChecker.check!
+    end
   end
 end

data/lib/stimulus_reflex/broadcasters/broadcaster.rb

@@ -24,22 +24,18 @@ 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"
       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
 

data/lib/stimulus_reflex/broadcasters/page_broadcaster.rb

@@ -3,7 +3,7 @@
 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?
@@ -18,7 +18,7 @@ module StimulusReflex
           children_only: true,
           permanent_attribute_name: permanent_attribute_name,
           stimulus_reflex: data.merge({
-            broadast_type: to_sym
+            morph: to_sym
           })
         )
       end

data/lib/stimulus_reflex/broadcasters/selector_broadcaster.rb

@@ -17,7 +17,7 @@ module StimulusReflex
               children_only: true,
               permanent_attribute_name: permanent_attribute_name,
               stimulus_reflex: data.merge({
-                broadast_type: to_sym
+                morph: to_sym
               })
             )
           else
@@ -25,7 +25,7 @@ module StimulusReflex
               selector: selector,
               html: fragment.to_html,
               stimulus_reflex: data.merge({
-                broadast_type: to_sym
+                morph: to_sym
               })
             )
           end

data/lib/stimulus_reflex/configuration.rb

@@ -0,0 +1,24 @@
+# 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 :exit_on_failed_sanity_checks, :parent_channel
+
+    def initialize
+      @exit_on_failed_sanity_checks = true
+      @parent_channel = "ApplicationCable::Channel"
+    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/reflex.rb

@@ -45,8 +45,10 @@ class StimulusReflex::Reflex
 
   attr_reader :channel, :url, :element, :selectors, :method_name, :broadcaster, :permanent_attribute_name
 
+  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
 
   def initialize(channel, url: nil, element: nil, selectors: [], method_name: nil, permanent_attribute_name: nil, params: {})
@@ -66,21 +68,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! }
@@ -112,10 +119,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) {

data/lib/stimulus_reflex/sanity_checker.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+class StimulusReflex::SanityChecker
+  JSON_VERSION_FORMAT = /(\d+\.\d+\.\d+.*)"/
+
+  def self.check!
+    instance = new
+    instance.check_caching_enabled
+    instance.check_javascript_package_version
+  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.
+        To enable caching in development, run:
+            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.
+        But your config.cache_store is set to :null_store, so it won't work.
+      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.
+        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}
+      WARN
+    end
+  end
+
+  private
+
+  def caching_enabled?
+    Rails.application.config.action_controller.perform_caching
+  end
+
+  def not_null_store?
+    Rails.application.config.cache_store != :null_store
+  end
+
+  def javascript_version_matches?
+    javascript_package_version == gem_version
+  end
+
+  def gem_version
+    @_gem_version ||= StimulusReflex::VERSION.gsub(".pre", "-pre")
+  end
+
+  def javascript_package_version
+    @_js_version ||= find_javascript_package_version
+  end
+
+  def find_javascript_package_version
+    if (match = search_file(package_json_path, regex: /version/))
+      match[JSON_VERSION_FORMAT, 1]
+    end
+  end
+
+  def search_file(path, regex:)
+    return unless File.exist?(path)
+    File.foreach(path).grep(regex).first
+  end
+
+  def package_json_path
+    Rails.root.join("node_modules", "stimulus_reflex", "package.json")
+  end
+
+  def warn_and_exit(text)
+    puts "WARNING:"
+    puts text
+    exit_with_info if StimulusReflex.config.exit_on_failed_sanity_checks
+  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
+  end
+end