stimulus_reflex 3.5.0.pre8 → 3.5.0.pre10

data/lib/stimulus_reflex/broadcasters/update.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StimulusReflex
   module Broadcasters
     class Update
@@ -14,6 +16,7 @@ module StimulusReflex
       end
 
       def html
+        return @value unless defined?(ActiveRecord)
         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

data/lib/stimulus_reflex/cable_readiness.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module StimulusReflex
+  module CableReadiness
+    extend ActiveSupport::Concern
+
+    prepended do
+      attr_reader :cable_ready
+    end
+
+    def initialize(*args, **kwargs)
+      super(*args, **kwargs)
+
+      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/guide/cableready#using-cableready-inside-a-reflex-action for more details.
+
+        MSG
+        raise TypeError.new(message.strip)
+      end
+      @cable_ready = StimulusReflex::CableReadyChannels.new(self)
+    end
+  end
+end

data/lib/stimulus_reflex/cable_ready_channels.rb

@@ -4,9 +4,9 @@ module StimulusReflex
   class CableReadyChannels
     delegate :[], to: "cable_ready_channels"
 
-    def initialize(stream_name, reflex_id)
-      @stream_name = stream_name
-      @reflex_id = reflex_id
+    def initialize(reflex)
+      @stream_name = reflex.stream_name
+      @id = reflex.id
     end
 
     def cable_ready_channels
@@ -20,9 +20,9 @@ module StimulusReflex
     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
+          args[options][:reflex_id] = @id
         elsif args.any?
-          args << {reflex_id: @reflex_id}
+          args << {reflex_id: @id}
         end
         return stimulus_reflex_channel.public_send(name, *args)
       end

data/lib/stimulus_reflex/callbacks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/concern"
 
 module StimulusReflex
@@ -6,7 +8,21 @@ module StimulusReflex
 
     included do
       include ActiveSupport::Callbacks
-      define_callbacks :process, skip_after_callbacks_if_terminated: true
+      define_callbacks :process, skip_after_callbacks_if_terminated: true, terminator: ->(target, result_lambda) do
+        halted = true
+        forbidden = true
+        catch(:abort) do
+          catch(:forbidden) do
+            result_lambda.call
+            forbidden = false
+          end
+          halted = false
+        end
+        forbidden = false if halted == true
+        target.instance_variable_set(:@halted, halted)
+        target.instance_variable_set(:@forbidden, forbidden)
+        halted || forbidden
+      end
     end
 
     class_methods do

data/lib/stimulus_reflex/concern_enhancer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module StimulusReflex
   module ConcernEnhancer
     extend ActiveSupport::Concern
@@ -6,12 +8,12 @@ module StimulusReflex
       def method_missing(name, *args)
         case ancestors
         when ->(a) { !(a & [StimulusReflex::Reflex]).empty? }
-          if (ActiveRecord::Base.public_methods + ActionController::Base.public_methods).include? name
+          if ((defined?(ActiveRecord) ? ActiveRecord::Base.public_methods : []) + ActionController::Base.public_methods).include? name
             nil
           else
             super
           end
-        when ->(a) { !(a & [ActiveRecord::Base, ActionController::Base]).empty? }
+        when ->(a) { !(a & (defined?(ActiveRecord) ? [ActiveRecord::Base, ActionController::Base] : [ActionController::Base])).empty? }
           if StimulusReflex::Reflex.public_methods.include? name
             nil
           else
@@ -25,8 +27,8 @@ module StimulusReflex
       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? }
+          ((defined?(ActiveRecord) ? ActiveRecord::Base.public_methods : []) + ActionController::Base.public_methods).include?(name) || super
+        when ->(a) { !(a & (defined?(ActiveRecord) ? [ActiveRecord::Base, ActionController::Base] : [ActionController::Base])).empty? }
           StimulusReflex::Reflex.public_methods.include?(name) || super
         else
           super

data/lib/stimulus_reflex/configuration.rb

@@ -14,18 +14,28 @@ module StimulusReflex
   end
 
   class Configuration
-    attr_accessor :on_failed_sanity_checks, :on_new_version_available, :on_missing_default_urls, :parent_channel, :logging, :logger, :middleware
+    attr_accessor :on_failed_sanity_checks, :on_missing_default_urls, :parent_channel, :logging, :logger, :middleware, :morph_operation, :replace_operation, :precompile_assets
 
     DEFAULT_LOGGING = proc { "[#{session_id}] #{operation_counter.magenta} #{reflex_info.green} -> #{selector.cyan} via #{mode} Morph (#{operation.yellow})" }
 
+    def on_new_version_available
+      warn "NOTICE: The `config.on_new_version_available` option has been removed from the StimulusReflex initializer. You can safely remove this option from your initializer."
+    end
+
+    def on_new_version_available=(_)
+      warn "NOTICE: The `config.on_new_version_available` option has been removed from the StimulusReflex initializer. You can safely remove this option from your initializer."
+    end
+
     def initialize
       @on_failed_sanity_checks = :exit
-      @on_new_version_available = :ignore
       @on_missing_default_urls = :warn
       @parent_channel = "ApplicationCable::Channel"
       @logging = DEFAULT_LOGGING
       @logger = Rails.logger
       @middleware = ActionDispatch::MiddlewareStack.new
+      @morph_operation = :morph
+      @replace_operation = :inner_html
+      @precompile_assets = true
     end
   end
 end

data/lib/stimulus_reflex/dataset.rb

@@ -25,10 +25,20 @@ class StimulusReflex::Dataset < OpenStruct
   end
 
   def boolean
-    @boolean ||= ->(accessor) { ActiveModel::Type::Boolean.new.cast(self[accessor]) || self[accessor].blank? }
+    @boolean ||= ->(accessor) { cast_boolean(self[accessor]) || self[accessor].blank? }
   end
 
   def numeric
     @numeric ||= ->(accessor) { Float(self[accessor]) }
   end
+
+  private
+
+  def cast_boolean(value)
+    ((value == "") ? nil : !false_values.include?(value)) unless value.nil?
+  end
+
+  def false_values
+    @false_values ||= [false, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"].to_set
+  end
 end

data/lib/stimulus_reflex/engine.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+module StimulusReflex
+  class Engine < ::Rails::Engine
+    initializer "stimulus_reflex.sanity_check" do
+      SanityChecker.check! unless Rails.env.production?
+    end
+
+    # If you don't want to precompile StimulusReflex's assets (eg. because you're using webpack),
+    # you can do this in an initializer:
+    #
+    # config.after_initialize do
+    #   config.assets.precompile -= StimulusReflex::Engine::PRECOMPILE_ASSETS
+    # end
+    #
+    PRECOMPILE_ASSETS = %w[
+      stimulus_reflex.js
+      stimulus_reflex.min.js
+      stimulus_reflex.min.js.map
+      stimulus_reflex.umd.js
+      stimulus_reflex.umd.min.js
+      stimulus_reflex.umd.min.js.map
+    ]
+
+    initializer "stimulus_reflex.assets" do |app|
+      if app.config.respond_to?(:assets) && StimulusReflex.config.precompile_assets
+        app.config.assets.precompile += PRECOMPILE_ASSETS
+      end
+    end
+
+    initializer "stimulus_reflex.importmap", before: "importmap" do |app|
+      if app.config.respond_to?(:importmap)
+        app.config.importmap.paths << Engine.root.join("lib/stimulus_reflex/importmap.rb")
+        app.config.importmap.cache_sweepers << Engine.root.join("app/assets/javascripts")
+      end
+    end
+  end
+end

data/lib/stimulus_reflex/html/document.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module StimulusReflex
+  module HTML
+    class Document
+      DEFAULT_HTML_WITHOUT_FORMAT = Nokogiri::XML::Node::SaveOptions::DEFAULT_HTML & ~Nokogiri::XML::Node::SaveOptions::FORMAT
+
+      delegate :element, to: :@document
+
+      def document_element
+        @document&.root
+      end
+
+      def outer_html
+        document_element ? document_element.to_html(save_with: DEFAULT_HTML_WITHOUT_FORMAT) : ""
+      end
+      alias_method :to_html, :outer_html
+
+      def inner_html
+        document_element ? document_element.inner_html(save_with: DEFAULT_HTML_WITHOUT_FORMAT) : ""
+      end
+
+      def initialize(html)
+        @document = parsing_class.parse(html.to_s)
+        @matches = {
+          "body" => Match.new(@document.at_css("body"))
+        }
+      end
+
+      def empty?
+        @document.content.empty?
+      end
+
+      def parsing_class
+        Nokogiri::HTML5::Document
+      end
+
+      def match(selector)
+        @matches[selector] ||= Match.new(@document.at_css(selector))
+      end
+
+      Match = Struct.new(:element) do
+        delegate :present?, to: :element
+
+        def outer_html
+          element&.to_html(save_with: DEFAULT_HTML_WITHOUT_FORMAT)
+        end
+
+        def to_html
+          element&.to_html(save_with: DEFAULT_HTML_WITHOUT_FORMAT)
+        end
+
+        def inner_html
+          element&.inner_html(save_with: DEFAULT_HTML_WITHOUT_FORMAT)
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_reflex/html/document_fragment.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# forzen_string_literal: true
+
+module StimulusReflex
+  module HTML
+    class DocumentFragment < Document
+      def parsing_class
+        Nokogiri
+      end
+    end
+  end
+end

data/lib/stimulus_reflex/importmap.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+pin "@rails/actioncable", to: "actioncable.esm.js", preload: true
+pin "@hotwired/stimulus", to: "stimulus.min.js", preload: true
+pin "morphdom", to: "https://ga.jspm.io/npm:morphdom@2.6.1/dist/morphdom.js", preload: true
+pin "cable_ready", to: "cable_ready.min.js", preload: true
+pin "stimulus_reflex", to: "stimulus_reflex.min.js", preload: true

data/lib/stimulus_reflex/installer.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+### general utilities
+
+def fetch(step_path, file)
+  relative_path = step_path + file
+  location = template_src + relative_path
+
+  Pathname.new(location)
+end
+
+def complete_step(step)
+  create_file "tmp/stimulus_reflex_installer/#{step}", verbose: false
+end
+
+def create_or_append(path, *args, &block)
+  FileUtils.touch(path)
+  append_file(path, *args, &block)
+end
+
+def current_template
+  ENV["LOCATION"].split("/").last.gsub(".rb", "")
+end
+
+def pack_path_missing?
+  return false unless pack_path.nil?
+  halt "#{friendly_pack_path} is missing. You need a valid application pack file to proceed."
+end
+
+def halt(message)
+  say "❌ #{message}", :red
+  create_file "tmp/stimulus_reflex_installer/halt", verbose: false
+end
+
+def backup(path, delete: false)
+  if !path.exist?
+    yield
+    return
+  end
+
+  backup_path = Pathname.new("#{path}.bak")
+  old_path = path.relative_path_from(Rails.root).to_s
+  filename = path.to_path.split("/").last
+
+  if backup_path.exist?
+    if backup_path.read == path.read
+      path.delete if delete
+      yield
+      return
+    end
+    backup_path.delete
+  end
+
+  copy_file(path, backup_path, verbose: false)
+  path.delete if delete
+
+  yield
+
+  if path.read != backup_path.read
+    create_or_append(backups_path, "#{old_path}\n", verbose: false)
+  end
+  say "📦 #{old_path} backed up as #{filename}.bak"
+end
+
+def add_gem(name)
+  create_or_append(add_gem_list, "#{name}\n", verbose: false)
+  say "☑️  Added #{name} to the Gemfile"
+end
+
+def remove_gem(name)
+  create_or_append(remove_gem_list, "#{name}\n", verbose: false)
+  say "❎ Removed #{name} from Gemfile"
+end
+
+def add_package(name)
+  create_or_append(package_list, "#{name}\n", verbose: false)
+  say "☑️  Enqueued #{name} to be added to dependencies"
+end
+
+def add_dev_package(name)
+  create_or_append(dev_package_list, "#{name}\n", verbose: false)
+  say "☑️  Enqueued #{name} to be added to dev dependencies"
+end
+
+def drop_package(name)
+  create_or_append(drop_package_list, "#{name}\n", verbose: false)
+  say "❎ Enqueued #{name} to be removed from dependencies"
+end
+
+def gemfile_hash
+  Digest::MD5.hexdigest(gemfile_path.read)
+end
+
+### memoized values
+
+def sr_npm_version
+  @sr_npm_version ||= StimulusReflex::VERSION.gsub(".pre", "-pre")
+end
+
+def cr_npm_version
+  @cr_npm_version ||= CableReady::VERSION.gsub(".pre", "-pre")
+end
+
+def package_json
+  @package_json ||= Rails.root.join("package.json")
+end
+
+def entrypoint
+  @entrypoint ||= File.read("tmp/stimulus_reflex_installer/entrypoint")
+end
+
+def bundler
+  @bundler ||= File.read("tmp/stimulus_reflex_installer/bundler")
+end
+
+def network_issue_path
+  @network_issue_path ||= Rails.root.join("tmp/stimulus_reflex_installer/network_issue")
+end
+
+def config_path
+  @config_path ||= Rails.root.join(entrypoint, "config")
+end
+
+def importmap_path
+  @importmap_path ||= Rails.root.join("config/importmap.rb")
+end
+
+def friendly_importmap_path
+  @friendly_importmap_path ||= importmap_path.relative_path_from(Rails.root).to_s
+end
+
+def pack
+  @pack ||= pack_path.read
+end
+
+def friendly_pack_path
+  @friendly_pack_path ||= pack_path.relative_path_from(Rails.root).to_s
+end
+
+def pack_path
+  @pack_path ||= [
+    Rails.root.join(entrypoint, "application.js"),
+    Rails.root.join(entrypoint, "packs/application.js"),
+    Rails.root.join(entrypoint, "entrypoints/application.js")
+  ].find(&:exist?)
+end
+
+def package_list
+  @package_list ||= Rails.root.join("tmp/stimulus_reflex_installer/npm_package_list")
+end
+
+def dev_package_list
+  @dev_package_list ||= Rails.root.join("tmp/stimulus_reflex_installer/npm_dev_package_list")
+end
+
+def drop_package_list
+  @drop_package_list ||= Rails.root.join("tmp/stimulus_reflex_installer/drop_npm_package_list")
+end
+
+def template_src
+  @template_src ||= File.read("tmp/stimulus_reflex_installer/template_src")
+end
+
+def controllers_path
+  @controllers_path ||= Rails.root.join(entrypoint, "controllers")
+end
+
+def gemfile_path
+  @gemfile_path ||= Rails.root.join("Gemfile")
+end
+
+def gemfile
+  @gemfile ||= gemfile_path.read
+end
+
+def prefix
+  # standard:disable Style/RedundantStringEscape
+  @prefix ||= {
+    "vite" => "..\/",
+    "webpacker" => "",
+    "shakapacker" => "",
+    "importmap" => "",
+    "esbuild" => ".\/"
+  }[bundler]
+  # standard:enable Style/RedundantStringEscape
+end
+
+def application_record_path
+  @application_record_path ||= Rails.root.join("app/models/application_record.rb")
+end
+
+def action_cable_initializer_path
+  @action_cable_initializer_path ||= Rails.root.join("config/initializers/action_cable.rb")
+end
+
+def action_cable_initializer_working_path
+  @action_cable_initializer_working_path ||= Rails.root.join(working, "action_cable.rb")
+end
+
+def development_path
+  @development_path ||= Rails.root.join("config/environments/development.rb")
+end
+
+def development_working_path
+  @development_working_path ||= Rails.root.join(working, "development.rb")
+end
+
+def backups_path
+  @backups_path ||= Rails.root.join("tmp/stimulus_reflex_installer/backups")
+end
+
+def add_gem_list
+  @add_gem_list ||= Rails.root.join("tmp/stimulus_reflex_installer/add_gem_list")
+end
+
+def remove_gem_list
+  @remove_gem_list ||= Rails.root.join("tmp/stimulus_reflex_installer/remove_gem_list")
+end
+
+def options_path
+  @options_path ||= Rails.root.join("tmp/stimulus_reflex_installer/options")
+end
+
+def options
+  @options ||= YAML.safe_load(File.read(options_path))
+end
+
+def working
+  @working ||= Rails.root.join("tmp/stimulus_reflex_installer/working")
+end
+
+### support for development step
+
+def write_redis_recommendation(development_working, lines, index, gemfile)
+  # provide a recommendation for using redis-session-store, including commented source code
+  if !lines.index { |line| line.include?("StimulusReflex does not support :cookie_store") }
+    lines.insert index + 1, <<RUBY
+
+  # StimulusReflex does not support :cookie_store, and we recommend switching to Redis.
+  # To use `redis-session-store`, make sure to add it to your Gemfile and run `bundle install`.
+
+  # config.session_store :redis_session_store,
+  #   serializer: :json,
+  #   on_redis_down: ->(*a) { Rails.logger.error("Redis down! \#{a.inspect}") },
+  #   redis: {
+  #     expire_after: 120.minutes,
+  #     key_prefix: "session:",
+  #     url: ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" }
+  # }
+RUBY
+    development_working.write lines.join
+    # add redis-session-store to Gemfile, but comment it out
+    if !gemfile.match?(/gem ['"]redis-session-store['"]/)
+      append_file(gemfile_path, verbose: false) do
+        <<~RUBY
+
+          # StimulusReflex recommends using Redis for session storage
+          # gem "redis-session-store", "0.11.5"
+        RUBY
+      end
+      say "💡 Added redis-session-store 0.11.5 to the Gemfile, commented out"
+    end
+  end
+end
+
+def find_index(lines)
+  # accomodate devs who modify their development.rb file structure
+  if (index = lines.index { |line| line =~ /caching-dev/ })
+    index += 3
+  else
+    index = lines.index { |line| line =~ /^Rails.application.configure do/ } + 1
+  end
+  index
+end

data/lib/stimulus_reflex/open_struct_fix.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+#
+# Temporary fix until this PR gets merged:
+# https://github.com/ruby/ostruct/pull/37
+# Thanks to @Laykou
+#
+# Calling this in OpenStruct 0.5.2 fails:
+# os = OpenStruct.new(class: "my-class", method: "post")
+
+if defined?(OpenStruct::VERSION) && OpenStruct::VERSION == "0.5.2"
+  class OpenStruct
+    private def is_method_protected!(name)
+      if !respond_to?(name, true)
+        false
+      elsif name.match?(/!$/)
+        true
+      else
+        owner = method!(name).owner
+        if owner.instance_of?(::Class)
+          owner < ::OpenStruct
+        else
+          class!.ancestors.any? do |mod|
+            return false if mod == ::OpenStruct
+            mod == owner
+          end
+        end
+      end
+    end
+  end
+end