stimulus_reflex 3.5.0.pre9 → 3.5.0.pre10

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

@@ -6,44 +6,49 @@
 # ActionCable.server.config.logger = Logger.new(nil)
 
 StimulusReflex.configure do |config|
-  # Enable/disable exiting / warning when the sanity checks fail options:
+  # Enable/disable exiting / warning when the sanity checks fail:
   # `:exit` or `:warn` or `:ignore`
-
+  #
   # 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
-
   # Enable/disable exiting / warning when there is no default URLs specified in environment config
   # `:warn` or `:ignore`
-
+  #
   # config.on_missing_default_urls = :warn
 
-  # Override the parent class that the StimulusReflex ActionCable channel inherits from
+  # Enable/disable assets compilation
+  # `true` or `false`
+  #
+  # config.precompile_assets = true
 
+  # Override the CableReady operation used for morphing and replacing content
+  #
+  # config.morph_operation = :morph
+  # config.replace_operation = :inner_html
+
+  # Override the parent class that the StimulusReflex ActionCable channel inherits from
+  #
   # config.parent_channel = "ApplicationCable::Channel"
 
   # Override the logger that the StimulusReflex uses; default is Rails' logger
   # eg. Logger.new(RAILS_ROOT + "/log/reflex.log")
-
+  #
   # config.logger = Rails.logger
 
   # 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 tokens: session_id, session_id_full, reflex_info, operation, id, id_full, mode, selector, operation_counter, connection_id, connection_id_full, timestamp
   # 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/generators/stimulus_reflex/templates/esbuild.config.mjs.tt

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+// Esbuild is configured with 3 modes:
+//
+// `yarn build` - Build JavaScript and exit
+// `yarn build --watch` - Rebuild JavaScript on change
+// `yarn build --reload` - Reloads page when views, JavaScript, or stylesheets change
+//
+// Minify is enabled when "RAILS_ENV=production"
+// Sourcemaps are enabled in non-production environments
+
+import * as esbuild from "esbuild"
+import path from "path"
+import rails from "esbuild-rails"
+import chokidar from "chokidar"
+import http from "http"
+import { setTimeout } from "timers/promises"
+
+const clients = []
+
+const entryPoints = [
+  "application.js"
+]
+
+const watchDirectories = [
+  "./app/javascript/**/*.js",
+  "./app/views/**/*.html.erb",
+  "./app/assets/builds/**/*.css", // Wait for cssbundling changes
+]
+
+const config = {
+  absWorkingDir: path.join(process.cwd(), "app/javascript"),
+  bundle: true,
+  entryPoints: entryPoints,
+  minify: process.env.RAILS_ENV == "production",
+  outdir: path.join(process.cwd(), "app/assets/builds"),
+  plugins: [rails()],
+  sourcemap: process.env.RAILS_ENV != "production"
+}
+
+async function buildAndReload() {
+  // Foreman & Overmind assign a separate PORT for each process
+  const port = parseInt(process.env.PORT)
+  const context = await esbuild.context({
+    ...config,
+    banner: {
+      js: ` (() => new EventSource("http://localhost:${port}").onmessage = () => location.reload())();`,
+    }
+  })
+
+  // Reload uses an HTTP server as an even stream to reload the browser
+  http.createServer((req, res) => {
+    return clients.push(
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Access-Control-Allow-Origin": "*",
+        Connection: "keep-alive",
+      })
+    )
+  }).listen(port)
+
+  await context.rebuild()
+  console.log("[reload] initial build succeeded")
+
+  let ready = false
+  chokidar.watch(watchDirectories).on("ready", () => {
+    console.log("[reload] ready")
+    ready = true
+  }).on("all", async (event, path) => {
+    if (ready === false)  return
+
+    if (path.includes("javascript")) {
+      try {
+        await setTimeout(20)
+        await context.rebuild()
+        console.log("[reload] build succeeded")
+      } catch (error) {
+        console.error("[reload] build failed", error)
+      }
+    }
+    clients.forEach((res) => res.write("data: update\n\n"))
+    clients.length = 0
+  })
+}
+
+if (process.argv.includes("--reload")) {
+  buildAndReload()
+} else if (process.argv.includes("--watch")) {
+  let context = await esbuild.context({...config, logLevel: 'info'})
+  context.watch()
+} else {
+  esbuild.build(config)
+}

data/lib/install/action_cable.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "stimulus_reflex/installer"
+
+# verify that Action Cable is installed
+if defined?(ActionCable::Engine)
+  say "⏩ ActionCable::Engine is already loaded and in scope. Skipping"
+else
+  halt "ActionCable::Engine is not loaded, please add or uncomment `require \"action_cable/engine\"` to your `config/application.rb`"
+  return
+end
+
+return if pack_path_missing?
+
+# verify that the Action Cable pubsub config is created
+cable_config = Rails.root.join("config/cable.yml")
+
+if cable_config.exist?
+  say "⏩ config/cable.yml is already present. Skipping."
+else
+  inside "config" do
+    template "cable.yml"
+  end
+
+  say "✅ Created config/cable.yml"
+end
+
+# verify that the Action Cable pubsub is set to use redis in development
+yaml = YAML.safe_load(cable_config.read)
+app_name = Rails.application.class.module_parent.name.underscore
+
+if yaml["development"]["adapter"] == "redis"
+  say "⏩ config/cable.yml is already configured to use the redis adapter in development. Skipping."
+elsif yaml["development"]["adapter"] == "async"
+  yaml["development"] = {
+    "adapter" => "redis",
+    "url" => "<%= ENV.fetch(\"REDIS_URL\") { \"redis://localhost:6379/1\" } %>",
+    "channel_prefix" => "#{app_name}_development"
+  }
+  backup(cable_config) do
+    cable_config.write(yaml.to_yaml)
+  end
+  say "✅ config/cable.yml was updated to use the redis adapter in development"
+else
+  say "🤷 config/cable.yml should use the redis adapter - or something like it - in development. You have something else specified, and we trust that you know what you're doing."
+end
+
+if gemfile.match?(/gem ['"]redis['"]/)
+  say "⏩ redis gem is already present in Gemfile. Skipping."
+elsif Rails::VERSION::MAJOR >= 7
+  add_gem "redis@~> 5"
+else
+  add_gem "redis@~> 4"
+end
+
+# install action-cable-redis-backport gem if using Action Cable < 7.1
+unless ActionCable::VERSION::MAJOR >= 7 && ActionCable::VERSION::MINOR >= 1
+  if gemfile.match?(/gem ['"]action-cable-redis-backport['"]/)
+    say "⏩ action-cable-redis-backport gem is already present in Gemfile. Skipping."
+  else
+    add_gem "action-cable-redis-backport@~> 1"
+  end
+end
+
+# verify that the Action Cable channels folder and consumer class is available
+step_path = "/app/javascript/channels/"
+channels_path = Rails.root.join(entrypoint, "channels")
+consumer_src = fetch(step_path, "consumer.js.tt")
+consumer_path = channels_path / "consumer.js"
+index_src = fetch(step_path, "index.js.#{bundler}.tt")
+index_path = channels_path / "index.js"
+friendly_index_path = index_path.relative_path_from(Rails.root).to_s
+
+empty_directory channels_path unless channels_path.exist?
+
+copy_file(consumer_src, consumer_path) unless consumer_path.exist?
+
+if index_path.exist?
+  if index_path.read == index_src.read
+    say "⏩ #{friendly_index_path} is already present. Skipping."
+  else
+    backup(index_path) do
+      copy_file(index_src, index_path, verbose: false)
+    end
+    say "✅ #{friendly_index_path} has been updated"
+  end
+else
+  copy_file(index_src, index_path)
+  say "✅ #{friendly_index_path} has been created"
+end
+
+# import Action Cable channels into application pack
+channels_pattern = /import ['"](\.\.\/|\.\/)?channels['"]/
+channels_commented_pattern = /\s*\/\/\s*#{channels_pattern}/
+channel_import = "import \"#{prefix}channels\"\n"
+
+if pack.match?(channels_pattern)
+  if pack.match?(channels_commented_pattern)
+    proceed = if options.key? "uncomment"
+      options["uncomment"]
+    else
+      !no?("✨ Action Cable seems to be commented out in your application.js. Do you want to uncomment it? (Y/n)")
+    end
+
+    if proceed
+      # uncomment_lines only works with Ruby comments 🙄
+      lines = pack_path.readlines
+      matches = lines.select { |line| line =~ channels_commented_pattern }
+      lines[lines.index(matches.last).to_i] = channel_import
+      pack_path.write lines.join
+      say "✅ Uncommented channels import in #{friendly_pack_path}"
+    else
+      say "🤷 your Action Cable channels are not being imported in your application.js. We trust that you have a reason for this."
+    end
+  else
+    say "⏩ channels are already being imported in #{friendly_pack_path}. Skipping."
+  end
+else
+  lines = pack_path.readlines
+  matches = lines.select { |line| line =~ /^import / }
+  lines.insert lines.index(matches.last).to_i + 1, channel_import
+  pack_path.write lines.join
+  say "✅ channels imported in #{friendly_pack_path}"
+end
+
+# create working copy of Action Cable initializer in tmp
+if action_cable_initializer_path.exist?
+  FileUtils.cp(action_cable_initializer_path, action_cable_initializer_working_path)
+
+  say "⏩ Action Cable initializer already exists. Skipping"
+else
+  # create Action Cable initializer if it doesn't already exist
+  create_file(action_cable_initializer_working_path, verbose: false) do
+    <<~RUBY
+      # frozen_string_literal: true
+
+    RUBY
+  end
+  say "✅ Action Cable initializer created"
+end
+
+# silence notoriously chatty Action Cable logs
+if action_cable_initializer_working_path.read.match?(/^[^#]*ActionCable.server.config.logger/)
+  say "⏩ Action Cable logger is already being silenced. Skipping"
+else
+  append_file(action_cable_initializer_working_path, verbose: false) do
+    <<~RUBY
+      ActionCable.server.config.logger = Logger.new(nil)
+
+    RUBY
+  end
+  say "✅ Action Cable logger silenced for performance and legibility"
+end
+
+complete_step :action_cable

data/lib/install/broadcaster.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "stimulus_reflex/installer"
+
+def needs_broadcaster?(path)
+  return false unless path.exist?
+
+  !path.readlines.index { |line| line =~ /^\s*include CableReady::Broadcaster/ }
+end
+
+channel_path = Rails.root.join("app/channels/application_cable/channel.rb")
+controller_path = Rails.root.join("app/controllers/application_controller.rb")
+job_path = Rails.root.join("app/jobs/application_job.rb")
+model_path = Rails.root.join(application_record_path)
+
+include_in_channel = needs_broadcaster?(channel_path)
+include_in_controller = needs_broadcaster?(controller_path)
+include_in_job = needs_broadcaster?(job_path)
+include_in_model = needs_broadcaster?(model_path)
+
+proceed = [include_in_channel, include_in_controller, include_in_job, include_in_model].reduce(:|)
+
+unless proceed
+  complete_step :broadcaster
+
+  puts "⏩ CableReady::Broadcaster already included in all files. Skipping."
+  return
+end
+
+proceed = if options.key? "broadcaster"
+  options["broadcaster"]
+else
+  !no?("✨ Make CableReady::Broadcaster available to channels, controllers, jobs and models? (Y/n)")
+end
+
+unless proceed
+  complete_step :broadcaster
+
+  puts "⏩ Skipping."
+  return
+end
+
+broadcaster_include = "\n    include CableReady::Broadcaster\n"
+
+# include CableReady::Broadcaster in Action Cable Channel classes
+if include_in_channel
+  backup(channel_path) do
+    inject_into_file channel_path, broadcaster_include, after: /class (ApplicationCable::)?Channel < ActionCable::Channel::Base/, verbose: false
+  end
+
+  puts "✅ include CableReady::Broadcaster in ApplicationCable::Channel"
+else
+  puts "⏩ Not including CableReady::Broadcaster in ApplicationCable::Channel channels. Skipping."
+end
+
+# include CableReady::Broadcaster in Action Controller classes
+if include_in_controller
+  backup(controller_path) do
+    inject_into_class controller_path, "ApplicationController", broadcaster_include, verbose: false
+  end
+
+  puts "✅ include CableReady::Broadcaster in ApplicationController"
+else
+  puts "⏩ Not including CableReady::Broadcaster in ApplicationController. Skipping."
+end
+
+# include CableReady::Broadcaster in Active Job classes, if present
+
+if include_in_job
+  backup(job_path) do
+    inject_into_class job_path, "ApplicationJob", broadcaster_include, verbose: false
+  end
+
+  puts "✅ include CableReady::Broadcaster in ApplicationJob"
+else
+  puts "⏩ Not including CableReady::Broadcaster in ApplicationJob. Skipping."
+end
+
+# include CableReady::Broadcaster in Active Record model classes
+if include_in_model
+  backup(application_record_path) do
+    inject_into_class application_record_path, "ApplicationRecord", broadcaster_include, verbose: false
+  end
+
+  puts "✅ include CableReady::Broadcaster in ApplicationRecord"
+else
+  puts "⏩ Not including CableReady::Broadcaster in ApplicationRecord. Skipping"
+end
+
+complete_step :broadcaster

data/lib/install/bundle.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "stimulus_reflex/installer"
+
+hash = gemfile_hash
+
+# run bundle only when gems are waiting to be added or removed
+add = add_gem_list.exist? ? add_gem_list.readlines.map(&:chomp) : []
+remove = remove_gem_list.exist? ? remove_gem_list.readlines.map(&:chomp) : []
+
+if add.present? || remove.present?
+  lines = gemfile_path.readlines
+
+  remove.each do |name|
+    index = lines.index { |line| line =~ /gem ['"]#{name}['"]/ }
+    if index
+      if /^[^#]*gem ['"]#{name}['"]/.match?(lines[index])
+        lines[index] = "# #{lines[index]}"
+        say "✅ #{name} gem has been disabled"
+      else
+        say "⏩ #{name} gem is already disabled. Skipping."
+      end
+    end
+  end
+
+  add.each do |package|
+    matches = package.match(/(.+)@(.+)/)
+    name, version = matches[1], matches[2]
+
+    index = lines.index { |line| line =~ /gem ['"]#{name}['"]/ }
+    if index
+      if !lines[index].match(/^[^#]*gem ['"]#{name}['"].*#{version}['"]/)
+        lines[index] = "\ngem \"#{name}\", \"#{version}\"\n"
+        say "✅ #{name} gem has been installed"
+      else
+        say "⏩ #{name} gem is already installed. Skipping."
+      end
+    else
+      lines << "\ngem \"#{name}\", \"#{version}\"\n"
+    end
+  end
+
+  gemfile_path.write lines.join
+
+  bundle_command("install --quiet", "BUNDLE_IGNORE_MESSAGES" => "1") if hash != gemfile_hash
+else
+  say "⏩ No rubygems depedencies to install. Skipping."
+end
+
+FileUtils.cp(development_working_path, development_path)
+say "✅ development environment configuration installed"
+
+FileUtils.cp(action_cable_initializer_working_path, action_cable_initializer_path)
+say "✅ Action Cable initializer installed"
+
+complete_step :bundle

data/lib/install/compression.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "stimulus_reflex/installer"
+
+initializer = action_cable_initializer_working_path.read
+
+if gemfile.match?(/gem ['"]permessage_deflate['"]/)
+  say "⏩ permessage_deflate already present in Gemfile. Skipping."
+else
+  add_gem "permessage_deflate@>= 0.1"
+end
+
+# add permessage_deflate config to Action Cable initializer
+if initializer.exclude? "PermessageDeflate.configure"
+  create_or_append(action_cable_initializer_working_path, verbose: false) do
+    <<~RUBY
+      module ActionCable
+        module Connection
+          class ClientSocket
+            alias_method :old_initialize, :initialize
+            def initialize(env, event_target, event_loop, protocols)
+              old_initialize(env, event_target, event_loop, protocols)
+              @driver.add_extension(
+                PermessageDeflate.configure(
+                  level: Zlib::BEST_COMPRESSION,
+                  max_window_bits: 13
+                )
+              )
+            end
+          end
+        end
+      end
+    RUBY
+  end
+
+  say "✅ Action Cable initializer patched to deflate websocket traffic"
+else
+  say "⏩ Action Cable initializer is already patched to deflate websocket traffic. Skipping."
+end
+
+complete_step :compression

data/lib/install/config.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "stimulus_reflex/installer"
+
+return if pack_path_missing?
+
+step_path = "/app/javascript/config/"
+index_src = fetch(step_path, "index.js.tt")
+index_path = config_path / "index.js"
+friendly_index_path = index_path.relative_path_from(Rails.root).to_s
+stimulus_reflex_src = fetch(step_path, "stimulus_reflex.js.tt")
+stimulus_reflex_path = config_path / "stimulus_reflex.js"
+friendly_stimulus_reflex_path = stimulus_reflex_path.relative_path_from(Rails.root).to_s
+cable_ready_src = fetch(step_path, "cable_ready.js.tt")
+cable_ready_path = config_path / "cable_ready.js"
+
+empty_directory config_path unless config_path.exist?
+
+if index_path.exist?
+  say "⏩ #{friendly_index_path} already exists. Skipping"
+else
+  backup(index_path, delete: true) do
+    copy_file(index_src, index_path)
+  end
+  say "✅ Created #{friendly_index_path}"
+end
+
+index_pattern = /import ['"](\.\.\/|\.\/)?config['"]/
+index_commented_pattern = /\s*\/\/\s*#{index_pattern}/
+index_import = "import \"#{prefix}config\"\n"
+
+if pack.match?(index_pattern)
+  if pack.match?(index_commented_pattern)
+    lines = pack_path.readlines
+    matches = lines.select { |line| line =~ index_commented_pattern }
+    lines[lines.index(matches.last).to_i] = index_import
+    pack_path.write lines.join
+
+    say "✅ Uncommented StimulusReflex and CableReady configs imports in #{friendly_pack_path}"
+  else
+    say "⏩ StimulusReflex and CableReady configs are already being imported in #{friendly_pack_path}. Skipping"
+  end
+else
+  lines = pack_path.readlines
+  matches = lines.select { |line| line =~ /^import / }
+  lines.insert lines.index(matches.last).to_i + 1, index_import
+  pack_path.write lines.join
+
+  say "✅ StimulusReflex and CableReady configs will be imported in #{friendly_pack_path}"
+end
+
+# create entrypoint/config/cable_ready.js and make sure it's imported in application.js
+copy_file(cable_ready_src, cable_ready_path) unless cable_ready_path.exist?
+
+# create entrypoint/config/stimulus_reflex.js and make sure it's imported in application.js
+copy_file(stimulus_reflex_src, stimulus_reflex_path) unless stimulus_reflex_path.exist?
+
+if stimulus_reflex_path.read.include?("StimulusReflex.debug =")
+  say "⏩ Development environment options are already set in #{friendly_stimulus_reflex_path}. Skipping"
+else
+  if ["webpacker", "shakapacker"].include?(bundler)
+    append_file(stimulus_reflex_path, <<~JS, verbose: false)
+
+      if (process.env.RAILS_ENV === 'development') {
+        StimulusReflex.debug = true
+      }
+    JS
+  elsif bundler == "vite"
+    append_file(stimulus_reflex_path, <<~JS, verbose: false) unless stimulus_reflex_path.read.include?("StimulusReflex.debug")
+
+      if (import.meta.env.MODE === "development") {
+        StimulusReflex.debug = true
+      }
+    JS
+  else
+    append_file(stimulus_reflex_path, <<~JS, verbose: false)
+
+      // consider removing these options in production
+      StimulusReflex.debug = true
+      // end remove
+    JS
+  end
+
+  say "✅ Set useful development environment options in #{friendly_stimulus_reflex_path}"
+end
+
+complete_step :config