stimulus_reflex 3.5.0.pre9 → 3.5.0.rc1

data/app/channels/stimulus_reflex/channel.rb

@@ -4,7 +4,7 @@ class StimulusReflex::Channel < StimulusReflex.configuration.parent_channel.cons
   attr_reader :reflex_data
 
   def stream_name
-    [params[:channel], connection.connection_identifier].join(":")
+    [params[:channel], connection.connection_identifier].reject(&:blank?).join(":")
   end
 
   def subscribed
@@ -25,30 +25,13 @@ class StimulusReflex::Channel < StimulusReflex.configuration.parent_channel.cons
         if reflex
           reflex.rescue_with_handler(exception)
           reflex.logger&.error error_message
-          reflex.error data: data, body: "#{exception} #{exception.backtrace.first.split(":in ")[0] if Rails.env.development?}"
+          reflex.broadcast_error data: data, error: "#{exception} #{exception.backtrace.first.split(":in ")[0] if Rails.env.development?}"
         else
-          if exception.is_a? StimulusReflex::Reflex::VersionMismatchError
-            mismatch = "Reflex failed due to stimulus_reflex gem/NPM package version mismatch. Package versions must match exactly.\nNote that if you are using pre-release builds, gems use the \"x.y.z.preN\" version format, while NPM packages use \"x.y.z-preN\".\n\nstimulus_reflex gem: #{StimulusReflex::VERSION}\nstimulus_reflex NPM: #{data["version"]}"
-
-            StimulusReflex.config.logger.error("\n\e[31m#{mismatch}\e[0m") unless StimulusReflex.config.on_failed_sanity_checks == :ignore
-
-            if Rails.env.development?
-              CableReady::Channels.instance[stream_name].console_log(
-                message: mismatch,
-                level: "error",
-                reflex_id: data["reflexId"]
-              ).broadcast
-            end
-
-            if StimulusReflex.config.on_failed_sanity_checks == :exit
-              sleep 0.1
-              exit!
-            end
-          else
+          unless exception.is_a?(StimulusReflex::Reflex::VersionMismatchError)
             StimulusReflex.config.logger.error error_message
           end
 
-          if body.to_s.include? "No route matches"
+          if error_message.to_s.include? "No route matches"
             initializer_path = Rails.root.join("config", "initializers", "stimulus_reflex.rb")
 
             StimulusReflex.config.logger.warn <<~NOTE
@@ -73,14 +56,16 @@ class StimulusReflex::Channel < StimulusReflex.configuration.parent_channel.cons
       end
 
       if reflex.halted?
-        reflex.halted data: data
+        reflex.broadcast_halt data: data
+      elsif reflex.forbidden?
+        reflex.broadcast_forbid data: data
       else
         begin
           reflex.broadcast(reflex_data.selectors, data)
         rescue => exception
           reflex.rescue_with_handler(exception)
           error = exception_with_backtrace(exception)
-          reflex.error data: data, body: "#{exception} #{exception.backtrace.first.split(":in ")[0] if Rails.env.development?}"
+          reflex.broadcast_error data: data, error: "#{exception} #{exception.backtrace.first.split(":in ")[0] if Rails.env.development?}"
           reflex.logger&.error "\e[31mReflex failed to re-render: #{error[:message]} [#{reflex_data.url}]\e[0m\n#{error[:stack]}"
         end
       end
@@ -112,7 +97,7 @@ class StimulusReflex::Channel < StimulusReflex.configuration.parent_channel.cons
   end
 
   def commit_session(reflex)
-    store = reflex.request.session.instance_variable_get("@by")
+    store = reflex.request.session.instance_variable_get(:@by)
     store.commit_session reflex.request, reflex.controller.response
   rescue => exception
     error = exception_with_backtrace(exception)

data/bin/console

@@ -2,7 +2,5 @@
 
 require "bundler/setup"
 require "stimulus_reflex"
-require "pry"
 
 StimulusReflex.configuration.parent_channel = "ActionCable::Channel::Base"
-Pry.start

data/bin/standardize

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
 
+bundle exec magic_frozen_string_literal
 bundle exec standardrb --fix
-yarn run prettier-standard:format
+yarn format

data/lib/generators/stimulus_reflex/stimulus_reflex_generator.rb

@@ -1,27 +1,86 @@
 # frozen_string_literal: true
 
 require "rails/generators"
+require "stimulus_reflex/version"
 
 class StimulusReflexGenerator < Rails::Generators::NamedBase
   source_root File.expand_path("templates", __dir__)
 
   argument :name, type: :string, required: true, banner: "NAME"
   argument :actions, type: :array, default: [], banner: "action action"
-  class_options skip_stimulus: false, skip_app_reflex: false, skip_reflex: false, skip_app_controller: false
+  class_options skip_stimulus: false, skip_reflex: false
 
   def execute
     actions.map!(&:underscore)
 
-    copy_application_files if behavior == :invoke
+    cached_entrypoint = Rails.root.join("tmp/stimulus_reflex_installer/entrypoint")
+    if cached_entrypoint.exist?
+      entrypoint = File.read(cached_entrypoint)
+    else
+      entrypoint = [
+        Rails.root.join("app/javascript"),
+        Rails.root.join("app/frontend")
+      ].find(&:exist?) || "app/javascript"
+      puts "Where do JavaScript files live in your app? Our best guess is: \e[1#{entrypoint}\e[22m 🤔"
+      puts "Press enter to accept this, or type a different path."
+      print "> "
+      input = Rails.env.test? ? "tmp/app/javascript" : $stdin.gets.chomp
+      entrypoint = input unless input.blank?
+    end
 
-    template "app/reflexes/%file_name%_reflex.rb" unless options[:skip_reflex]
-    template "app/javascript/controllers/%file_name%_controller.js" unless options[:skip_stimulus]
-  end
+    if !options[:skip_stimulus] && entrypoint.blank?
+      puts "❌ You must specify a valid JavaScript entrypoint."
+      exit
+    end
+
+    reflex_entrypoint = Rails.env.test? ? "tmp/app/reflexes" : "app/reflexes"
+    reflex_src = "app/reflexes/%file_name%_reflex.rb.tt"
+    reflex_path = Rails.root.join(reflex_entrypoint, "#{file_name}_reflex.rb")
+    stimulus_controller_src = "app/javascript/controllers/%file_name%_controller.js.tt"
+    stimulus_controller_path = Rails.root.join(entrypoint, "controllers/#{file_name}_controller.js")
+
+    template(reflex_src, reflex_path) unless options[:skip_reflex]
+    template(stimulus_controller_src, stimulus_controller_path) unless options[:skip_stimulus]
+
+    if file_name == "example"
+      controller_src = "app/controllers/examples_controller.rb.tt"
+      controller_path = Rails.root.join("app/controllers/examples_controller.rb")
+      template(controller_src, controller_path)
+
+      view_src = "app/views/examples/show.html.erb.tt"
+      view_path = Rails.root.join("app/views/examples/show.html.erb")
+      template(view_src, view_path)
+
+      example_path = Rails.root.join("app/views/examples")
+      FileUtils.remove_dir(example_path) if behavior == :revoke && example_path.exist? && Dir.empty?(example_path)
+
+      route "resource :example, constraints: -> { Rails.env.development? }"
+
+      importmap_path = Rails.root.join("config/importmap.rb")
+
+      if importmap_path.exist?
+        importmap = importmap_path.read
 
-  private
+        if behavior == :revoke
+          if importmap.include?("pin \"fireworks-js\"")
+            importmap_path.write importmap_path.readlines.reject { |line| line.include?("pin \"fireworks-js\"") }.join
+            say "✅ unpin fireworks-js"
+          else
+            say "⏩ fireworks-js not pinned. Skipping."
+          end
+        end
 
-  def copy_application_files
-    template "app/reflexes/application_reflex.rb" unless options[:skip_app_reflex]
-    template "app/javascript/controllers/application_controller.js" unless options[:skip_app_controller]
+        if behavior == :invoke
+          if importmap.include?("pin \"fireworks-js\"")
+            say "⏩ fireworks-js already pinnned. Skipping."
+          else
+            append_file(importmap_path, <<~RUBY, verbose: false)
+              pin "fireworks-js", to: "https://ga.jspm.io/npm:fireworks-js@2.10.0/dist/index.es.js"
+            RUBY
+            say "✅ pin fireworks-js"
+          end
+        end
+      end
+    end
   end
 end

data/lib/generators/stimulus_reflex/templates/app/controllers/examples_controller.rb.tt

@@ -0,0 +1,9 @@
+class ExamplesController < ApplicationController
+  layout false
+
+  def show
+    respond_to do |format|
+      format.html
+    end
+  end
+end

data/lib/generators/stimulus_reflex/templates/app/javascript/channels/consumer.js.tt

@@ -0,0 +1,6 @@
+// Action Cable provides the framework to deal with WebSockets in Rails.
+// You can generate new channels where WebSocket features live using the `bin/rails generate channel` command.
+
+import { createConsumer } from '@rails/actioncable'
+
+export default createConsumer()

data/lib/generators/stimulus_reflex/templates/app/javascript/channels/index.js.esbuild.tt

@@ -0,0 +1,4 @@
+// Load all the channels within this directory and all subdirectories.
+// Channel files must be named *_channel.js.
+
+import './**/*_channel.js'

data/lib/generators/stimulus_reflex/templates/app/javascript/channels/index.js.importmap.tt

@@ -0,0 +1,2 @@
+// app/channels/index.js
+// Importmaps don't require anything here

data/lib/generators/stimulus_reflex/templates/app/javascript/channels/index.js.shakapacker.tt

@@ -0,0 +1,5 @@
+// Load all the channels within this directory and all subdirectories.
+// Channel files must be named *_channel.js.
+
+const channels = require.context('.', true, /_channel\.js$/)
+channels.keys().forEach(channels)

data/lib/generators/stimulus_reflex/templates/app/javascript/channels/index.js.vite.tt

@@ -0,0 +1 @@
+const channels = import.meta.globEager('./**/*_channel.js')

data/lib/generators/stimulus_reflex/templates/app/javascript/channels/index.js.webpacker.tt

@@ -0,0 +1,5 @@
+// Load all the channels within this directory and all subdirectories.
+// Channel files must be named *_channel.js.
+
+const channels = require.context('.', true, /_channel\.js$/)
+channels.keys().forEach(channels)

data/lib/generators/stimulus_reflex/templates/app/javascript/config/cable_ready.js.tt

@@ -0,0 +1,4 @@
+import consumer from '../channels/consumer'
+import CableReady from 'cable_ready'
+
+CableReady.initialize({ consumer })

data/lib/generators/stimulus_reflex/templates/app/javascript/config/index.js.tt

@@ -0,0 +1,2 @@
+import './cable_ready'
+import './stimulus_reflex'

data/lib/generators/stimulus_reflex/templates/app/javascript/config/mrujs.js.tt

@@ -0,0 +1,9 @@
+import CableReady from "cable_ready"
+import mrujs from "mrujs"
+import { CableCar } from "mrujs/plugins"
+
+mrujs.start({
+  plugins: [
+    new CableCar(CableReady)
+  ]
+})

data/lib/generators/stimulus_reflex/templates/app/javascript/config/stimulus_reflex.js.tt

@@ -0,0 +1,5 @@
+import { application } from "../controllers/application"
+import controller from "../controllers/application_controller"
+import StimulusReflex from "stimulus_reflex"
+
+StimulusReflex.initialize(application, { controller, isolate: true })

data/lib/generators/stimulus_reflex/templates/app/javascript/controllers/%file_name%_controller.js.tt

@@ -0,0 +1,141 @@
+import ApplicationController from './application_controller'
+
+<%- if class_name == "Example" -%>
+// 
+// This is the Stimulus controller for the Example Reflex.
+//
+// It corresponds to the server-side Reflex class located at /app/reflexes/example.rb
+//
+// Learn more at: https://docs.stimulusreflex.com/guide/reflexes
+//
+
+<%- end -%>
+export default class extends ApplicationController {
+  connect () {
+<%- if class_name == "Example" -%>
+    //
+    // StimulusReflex overrides the Stimulus `connect` method. Make sure to call
+    // `super.connect()` so that any code in your superclass `connect` is run.
+    //
+<%- end -%>
+    super.connect()
+  }
+<%- if class_name == "Example" -%>
+
+  // With StimulusReflex active in your project, it will continuously scan your DOM for
+  // `data-reflex` attributes on your elements, even if they are dynamically created.
+  //
+  //   <a href="#" data-reflex="click->Example#dance">Dance!</a>
+  //
+  // We call this a "declared" Reflex, because it doesn't require any JS to run.
+  //
+  // When your user clicks this link, a Reflex is launched and it calls the `dance` method
+  // on your Example Reflex class. You don't have to do anything else!
+  //
+  // This Stimulus controller doesn't even need to exist for StimulusReflex to work its magic.
+  // https://docs.stimulusreflex.com/guide/reflexes#declaring-a-reflex-in-html-with-data-attributes
+  //
+  // However...
+  //
+  // If we do create an `example` Stimulus controller that extends `ApplicationController`,
+  // we can unlock several additional capabilities, including creating Reflexes with code.
+  //
+  //   <a href="#" data-controller="example" data-action="example#dance">Dance!</a>
+  //
+  // StimulusReflex gives our controller a new method, `stimulate`:
+  //
+  // dance() {
+  //   this.stimulate('Example#dance')
+  // }
+  //
+  // The `stimulate` method is very flexible, and it gives you the opportunity to pass
+  // parameter options that will be passed to the `dance` method on the server.
+  // https://docs.stimulusreflex.com/guide/reflexes#calling-a-reflex-in-a-stimulus-controller
+  //
+  // Reflex lifecycle methods
+  //
+  // For every method defined in your Reflex class, a matching set of optional
+  // lifecycle callback methods become available in this javascript controller.
+  // https://docs.stimulusreflex.com/guide/lifecycle#client-side-reflex-callbacks
+  //
+  //   <a href="#" data-reflex="click->Example#dance" data-controller="example">Dance!</a>
+  //
+  // StimulusReflex will check for the presence of several methods:
+  //
+  //   afterReflex(element, reflex, noop, id) {
+  //     // fires after every Example Reflex action
+  //   }
+  //
+  //   afterDance(element, reflex, noop, id) {
+  //     // fires after Example Reflexes calling the dance action
+  //   }
+  //
+  // 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. "Example#dance"
+  //
+  //   error/noop - the error message (for reflexError), otherwise null
+  //
+  //   id - a UUID4 or developer-provided unique identifier for each Reflex
+  //
+  // Access to the client-side Reflex objects created by this controller
+  //
+  // Every Reflex you create is represented by an object in the global Reflexes collection.
+  // You can access the Example Reflexes created by this controller via the `reflexes` proxy.
+  //
+  //   this.reflexes.last
+  //   this.reflexes.all
+  //   this.reflexes.all[id]
+  //   this.reflexes.error
+  //
+  // The proxy allows you to access the most recent Reflex, an array of all Reflexes, a specific
+  // Reflex specified by its `id` and an array of all Reflexes in a given lifecycle stage.
+  //
+  // If you explore the Reflex object, you'll see all relevant details,
+  // including the `data` that is being delivered to the server.
+  //
+  // Pretty cool, right?
+  //
+<%- end -%>
+<%- actions.each do |action| -%>
+
+  // <%= "before_#{action}".camelize(:lower) %>(element, reflex, noop, id) {
+  //  console.log("before <%= action %>", element, reflex, id)
+  // }
+
+  // <%= "#{action}_queued".camelize(:lower) %>(element, reflex, noop, id) {
+  //   console.log("<%= action %> enqueued for delivery upon connection", element, reflex, id)
+  // }
+
+  // <%= "#{action}_delivered".camelize(:lower) %>(element, reflex, noop, id) {
+  //   console.log("<%= action %> delivered to the server", element, reflex, id)
+  // }
+
+  // <%= "#{action}_success".camelize(:lower) %>(element, reflex, noop, id) {
+  //   console.log("<%= action %> successfully executed", element, reflex, id)
+  // }
+
+  // <%= "#{action}_error".camelize(:lower) %>(element, reflex, error, id) {
+  //   console.error("<%= action %> server-side error", element, reflex, error, id)
+  // }
+
+  // <%= "#{action}_halted".camelize(:lower) %>(element, reflex, noop, id) {
+  //   console.warn("<%= action %> halted before execution", element, reflex, id)
+  // }
+
+  // <%= "#{action}_forbidden".camelize(:lower) %>(element, reflex, noop, id) {
+  //   console.warn("<%= action %> forbidden from executing", element, reflex, id)
+  // }
+
+  // <%= "after_#{action}".camelize(:lower) %>(element, reflex, noop, id) {
+  //   console.log("<%= action %> has been executed by the server", element, reflex, id)
+  // }
+
+  // <%= "finalize_#{action}".camelize(:lower) %>(element, reflex, noop, id) {
+  //   console.log("<%= action %> changes have been applied", element, reflex, id)
+  // }
+<%- end -%>
+}

data/lib/generators/stimulus_reflex/templates/app/javascript/controllers/application.js.tt

@@ -0,0 +1,11 @@
+import { Application } from "@hotwired/stimulus"
+import consumer from "../channels/consumer"
+
+const application = Application.start()
+
+// Configure Stimulus development experience
+application.debug = false
+application.consumer = consumer
+window.Stimulus   = application
+
+export { application }

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

@@ -0,0 +1,74 @@
+import { Controller } from '@hotwired/stimulus'
+import StimulusReflex from 'stimulus_reflex'
+
+// This is the Stimulus ApplicationController.
+// All StimulusReflex controllers should inherit from this class.
+//
+// Example:
+//
+//   import ApplicationController from './application_controller'
+//
+//   export default class extends ApplicationController { ... }
+//
+// Learn more at: https://docs.stimulusreflex.com
+//
+
+export default class extends Controller {
+  connect () {
+    StimulusReflex.register(this)
+  }
+
+  // Application-wide lifecycle methods
+  //
+  // Use these methods to handle lifecycle callbacks for all controllers.
+  // Using lifecycle methods is optional, so feel free to delete these if you don't need them.
+  //
+  // 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. "Example#demo"
+  //
+  //   error/noop - the error message (for reflexError), otherwise null
+  //
+  //   id - a UUID4 or developer-provided unique identifier for each Reflex
+  //
+
+  beforeReflex (element, reflex, noop, id) {
+    // document.body.classList.add('wait')
+  }
+
+  reflexQueued (element, reflex, noop, id) {
+    // Reflex will be delivered to server upon reconnection
+  }
+
+  reflexDelivered (element, reflex, noop, id) {
+    // Reflex has been delivered to the server
+  }
+
+  reflexSuccess (element, reflex, noop, id) {
+    // show success message
+  }
+
+  reflexError (element, reflex, error, id) {
+    // show error message
+  }
+
+  reflexForbidden (element, reflex, noop, id) {
+    // Reflex action did not have permission to run
+    // window.location = '/'
+  }
+
+  reflexHalted (element, reflex, noop, id) {
+    // handle aborted Reflex action
+  }
+
+  afterReflex (element, reflex, noop, id) {
+    // document.body.classList.remove('wait')
+  }
+
+  finalizeReflex (element, reflex, noop, id) {
+    // all operations have completed, animation etc is now safe
+  }
+}

data/lib/generators/stimulus_reflex/templates/app/javascript/controllers/index.js.esbuild.tt

@@ -0,0 +1,7 @@
+import { application } from "./application"
+
+import controllers from "./**/*_controller.js"
+
+controllers.forEach((controller) => {
+  application.register(controller.name, controller.module.default)
+})

data/lib/generators/stimulus_reflex/templates/app/javascript/controllers/index.js.importmap.tt

@@ -0,0 +1,5 @@
+import { application } from "./application"
+
+// Eager load all controllers defined in the import map under controllers/**/*_controller
+import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading"
+eagerLoadControllersFrom("controllers", application)

data/lib/generators/stimulus_reflex/templates/app/javascript/controllers/index.js.shakapacker.tt

@@ -0,0 +1,5 @@
+import { application } from "./application"
+import { definitionsFromContext } from "@hotwired/stimulus-webpack-helpers"
+
+const controllers = definitionsFromContext(require.context("controllers", true, /_controller\.js$/))
+application.load(controllers)

data/lib/generators/stimulus_reflex/templates/app/javascript/controllers/index.js.vite.tt

@@ -0,0 +1,5 @@
+import { application } from "./application"
+import { registerControllers } from "stimulus-vite-helpers"
+
+const controllers = import.meta.globEager("./**/*_controller.js");
+registerControllers(application, controllers)

data/lib/generators/stimulus_reflex/templates/app/javascript/controllers/index.js.webpacker.tt

@@ -0,0 +1,5 @@
+import { application } from "./application"
+import { definitionsFromContext } from "@hotwired/stimulus-webpack-helpers"
+
+const controllers = definitionsFromContext(require.context("controllers", true, /_controller\.js$/))
+application.load(controllers)

data/{test/tmp/app/reflexes/user_reflex.rb → lib/generators/stimulus_reflex/templates/app/reflexes/%file_name%_reflex.rb.tt}

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-class UserReflex < ApplicationReflex
+class <%= class_name %>Reflex < ApplicationReflex
+<%- if class_name == "Example" -%>
   # Add Reflex methods in this file.
   #
   # All Reflex instances include CableReady::Broadcaster and expose the following properties:
@@ -16,28 +17,56 @@ class UserReflex < ApplicationReflex
   #     - signed    - use a signed Global ID to map dataset attribute to a model eg. element.signed[:foo]
   #     - 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
+  #   - id          - a UUIDv4 that uniquely identifies 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/rtfm/lifecycle
+  #     # learn more about callbacks at https://docs.stimulusreflex.com/guide/lifecycle
   #   end
   #
   #   def example(argument=true)
-  #     # Your logic here...
+  #     # Your logic here! Update models, launch jobs, poll Redis...
+  #
+  #     # By default, Reflexes call the controller action for the current page and render the view.
   #     # Any declared instance variables will be made available to the Rails controller and view.
+  #
+  #     # You can also use the `morph` method to mark a Reflex as Selector or Nothing.
+  #     # https://docs.stimulusreflex.com/guide/morph-modes#introducing-morphs
   #   end
   #
-  # Learn more at: https://docs.stimulusreflex.com/rtfm/reflex-classes
+  # Learn more at: https://docs.stimulusreflex.com/guide/reflex-classes
 
-  def update
-  end
+<%- end -%>
+<%- if class_name == "Example" -%>
+  def increment
+    count = session[:count] || 0
+    session[:count] = count + 1
+
+    morph "#time", Time.now
+    morph "#count", session[:count]
 
-  def do_stuff
+    cable_ready.set_value(selector: "progress", value: session[:count])
+
+    if session[:count] == 5
+      cable_ready.text_content(selector: "#reload", text: "Try reloading your browser window. The count is persisted in the session!")
+    end
+
+    if session[:count] >= 10
+      cable_ready.dispatch_event(name: "fireworks")
+    end
   end
 
-  def do_more_stuff
+  def reset
+    session[:count] = 0
+  end
+<%- else -%>
+  <%- actions.each do |action| -%>
+  def <%= action %>
   end
+<%= "\n" unless action == actions.last -%>
+  <%- end -%>
+<%- end -%>
 end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ApplicationReflex < StimulusReflex::Reflex
+  # Put application-wide Reflex behavior and callbacks in this file.
+  #
+  # Learn more at: https://docs.stimulusreflex.com/guide/reflex-classes
+  #
+  # If your ActionCable connection is: `identified_by :current_user`
+  #   delegate :current_user, to: :connection
+  #
+  # current_user delegation allows you to use the Current pattern, too:
+  #   before_reflex do
+  #     Current.user = current_user
+  #   end
+  #
+  # To access view helpers inside Reflexes:
+  #   delegate :helpers, to: :ApplicationController
+  #
+  # If you need to localize your Reflexes, you can set the I18n locale here:
+  #
+  #   before_reflex do
+  #     I18n.locale = :fr
+  #   end
+  #
+  # For code examples, considerations and caveats, see:
+  # https://docs.stimulusreflex.com/guide/patterns#internationalization
+end