stimulus_reflex 3.4.1 → 3.5.0.pre3

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/utils/attribute_builder.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module StimulusReflex::AttributeBuilder
+  def build_data_attrs(dataset, dataset_all)
+    dataset_all.transform_keys! { |key| "data-#{key.delete_prefix("data-").pluralize}" }
+
+    dataset.each { |key, value| dataset_all[key]&.prepend(value) }
+
+    data_attrs = dataset.merge(dataset_all)
+
+    HashWithIndifferentAccess.new(data_attrs || {})
+  end
+
+  def build_underscored(attrs)
+    attrs.merge(attrs.transform_keys(&:underscore))
+  end
+end

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

@@ -2,22 +2,24 @@
 
 module StimulusReflex
   class Logger
+    attr_reader :logger
     attr_accessor :reflex, :current_operation
 
+    delegate :debug, :info, :warn, :error, :fatal, :unknown, to: :logger
+
     def initialize(reflex)
       @reflex = reflex
       @current_operation = 1
+      @logger = StimulusReflex.config.logger
     end
 
-    def print
+    def log_all_operations
       return unless config_logging.instance_of?(Proc)
 
-      puts
       reflex.broadcaster.operations.each do
-        puts instance_eval(&config_logging) + "\e[0m"
+        logger.info instance_eval(&config_logging) + "\e[0m"
         @current_operation += 1
       end
-      puts
     end
 
     private

data/lib/stimulus_reflex/utils/sanity_checker.rb

@@ -0,0 +1,210 @@
+# 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
+    def check!
+      return if ENV["SKIP_SANITY_CHECK"]
+      return if StimulusReflex.config.on_failed_sanity_checks == :ignore
+      return if called_by_installer?
+      return if called_by_generate_config?
+      return if called_by_rake?
+
+      instance = new
+      instance.check_caching_enabled
+      instance.check_package_versions_match
+      # instance.check_default_url_config
+      instance.check_new_version_available
+    end
+
+    private
+
+    def called_by_installer?
+      Rake.application.top_level_tasks.include? "stimulus_reflex:install"
+    rescue
+      false
+    end
+
+    def called_by_generate_config?
+      ARGV.include? "stimulus_reflex:initializer"
+    end
+
+    def called_by_rake?
+      File.basename($PROGRAM_NAME) == "rake"
+    end
+  end
+
+  def check_caching_enabled
+    if caching_not_enabled?
+      warn_and_exit <<~WARN
+        👉 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
+      WARN
+    end
+
+    if using_null_store?
+      warn_and_exit <<~WARN
+        👉 StimulusReflex requires caching to be enabled.
+        
+        Caching allows the session to be modified during ActionCable requests. Your config.cache_store is set to :null_store, so it won't work.
+      WARN
+    end
+  end
+
+  def check_default_url_config
+    return if StimulusReflex.config.on_missing_default_urls == :ignore
+    if default_url_config_set? == false
+      puts <<~WARN
+        👉 StimulusReflex strongly suggests that you set default_url_options in your environment files. Otherwise, ActionController #{"and ActionMailer " if defined?(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}\n" if defined?(ActionMailer)}
+        Please update every environment with the appropriate URL. Typically, no port is necessary in production.
+
+      WARN
+    end
+  end
+
+  def check_package_versions_match
+    if npm_version.nil?
+      warn_and_exit <<~WARN
+        👉 Can't locate the stimulus_reflex npm package.
+
+          yarn add stimulus_reflex@#{gem_version}
+
+        Either add it to your package.json as a dependency or use "yarn link stimulus_reflex" if you are doing development.
+      WARN
+    end
+
+    if package_version_mismatch?
+      warn_and_exit <<~WARN
+        👉 The stimulus_reflex npm package version (#{npm_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 if StimulusReflex.config.on_new_version_available == :ignore
+    return if Rails.env.development? == false
+    return if using_preview_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
+
+  def caching_not_enabled?
+    Rails.application.config.action_controller.perform_caching == false
+  end
+
+  def using_null_store?
+    Rails.application.config.cache_store == :null_store
+  end
+
+  def default_url_config_set?
+    if defined?(ActionMailer)
+      Rails.application.config.action_controller.default_url_options.blank? && Rails.application.config.action_mailer.default_url_options.blank?
+    else
+      Rails.application.config.action_controller.default_url_options.blank?
+    end
+  end
+
+  def package_version_mismatch?
+    npm_version != gem_version
+  end
+
+  def using_preview_release?
+    preview = StimulusReflex::VERSION.match?(LATEST_VERSION_FORMAT) == false
+    puts "👉 StimulusReflex #{StimulusReflex::VERSION} update check skipped: pre-release build" if preview
+    preview
+  end
+
+  def gem_version
+    @_gem_version ||= StimulusReflex::VERSION.gsub(".pre", "-pre")
+  end
+
+  def npm_version
+    @_npm_version ||= find_npm_version
+  end
+
+  def find_npm_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
+
+  def search_file(path, regex:)
+    return if File.exist?(path) == false
+    File.foreach(path).grep(regex).first
+  end
+
+  def package_json_path
+    Rails.root.join("node_modules", "stimulus_reflex", "package.json")
+  end
+
+  def yarn_lock_path
+    Rails.root.join("yarn.lock")
+  end
+
+  def initializer_missing?
+    File.exist?(Rails.root.join("config", "initializers", "stimulus_reflex.rb")) == false
+  end
+
+  def warn_and_exit(text)
+    puts
+    puts "Heads up! 🔥"
+    puts
+    puts text
+    puts
+    if StimulusReflex.config.on_failed_sanity_checks == :exit
+      puts <<~INFO
+        To ignore any warnings and start the application anyway, you can set the SKIP_SANITY_CHECK environment variable:
+
+          SKIP_SANITY_CHECK=true rails
+
+        To do this permanently, add the following directive to the StimulusReflex initializer:
+
+          StimulusReflex.configure do |config|
+            config.on_failed_sanity_checks = :warn
+          end
+
+      INFO
+      if initializer_missing?
+        puts <<~INFO
+          You can create a StimulusReflex initializer with the command:
+
+            bundle exec rails generate stimulus_reflex:initializer
+
+        INFO
+      end
+      exit false if Rails.env.test? == false
+    end
+  end
+end

data/lib/stimulus_reflex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StimulusReflex
-  VERSION = "3.4.1"
+  VERSION = "3.5.0.pre3"
 end

data/lib/stimulus_reflex.rb

@@ -1,26 +1,34 @@
 # frozen_string_literal: true
 
 require "uri"
+require "open-uri"
 require "rack"
 require "rails/engine"
 require "active_support/all"
 require "action_dispatch"
 require "action_cable"
+require "action_view"
 require "nokogiri"
 require "cable_ready"
 require "stimulus_reflex/version"
 require "stimulus_reflex/cable_ready_channels"
+require "stimulus_reflex/concern_enhancer"
 require "stimulus_reflex/configuration"
 require "stimulus_reflex/callbacks"
+require "stimulus_reflex/request_parameters"
 require "stimulus_reflex/reflex"
+require "stimulus_reflex/reflex_data"
+require "stimulus_reflex/reflex_factory"
 require "stimulus_reflex/element"
-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 "stimulus_reflex/broadcasters/update"
+require "stimulus_reflex/policies/reflex_invocation_policy"
 require "stimulus_reflex/utils/colorize"
-require "stimulus_reflex/logger"
+require "stimulus_reflex/utils/logger"
+require "stimulus_reflex/utils/sanity_checker"
 
 module StimulusReflex
   class Engine < Rails::Engine

data/lib/tasks/stimulus_reflex/install.rake

@@ -4,7 +4,7 @@ require "fileutils"
 require "stimulus_reflex/version"
 
 namespace :stimulus_reflex do
-  desc "Install StimulusReflex in this application"
+  desc "✨ Install StimulusReflex in this application"
   task install: :environment do
     system "rails dev:cache" unless Rails.root.join("tmp", "caching-dev.txt").exist?
     gem_version = StimulusReflex::VERSION.gsub(".pre", "-pre")
@@ -25,8 +25,8 @@ namespace :stimulus_reflex do
       .map { |path| Rails.root.join(path) }
       .first
 
-    puts "Updating #{filepath}"
-    lines = File.open(filepath, "r") { |f| f.readlines }
+    puts "✨ Updating #{filepath}"
+    lines = File.readlines(filepath)
 
     unless lines.find { |line| line.start_with?("import StimulusReflex") }
       matches = lines.select { |line| line =~ /\A(require|import)/ }
@@ -44,34 +44,73 @@ namespace :stimulus_reflex do
     end
 
     initialize_line = lines.find { |line| line.start_with?("StimulusReflex.initialize") }
-    lines << "StimulusReflex.initialize(application, { consumer, controller, isolate: true })\n" unless initialize_line
+    lines << "application.consumer = consumer\n"
+    lines << "StimulusReflex.initialize(application, { controller, isolate: true })\n" unless initialize_line
     lines << "StimulusReflex.debug = process.env.RAILS_ENV === 'development'\n" unless initialize_line
-    File.open(filepath, "w") { |f| f.write lines.join }
+    File.write(filepath, lines.join)
 
+    puts
+    puts "✨ Updating config/environments/development.rb"
     filepath = Rails.root.join("config/environments/development.rb")
-    lines = File.open(filepath, "r") { |f| f.readlines }
+    lines = File.readlines(filepath)
     unless lines.find { |line| line.include?("config.session_store") }
-      lines.insert 3, "  config.session_store :cache_store\n\n"
-      File.open(filepath, "w") { |f| f.write lines.join }
+      matches = lines.select { |line| line =~ /\A(Rails.application.configure do)/ }
+      lines.insert lines.index(matches.last).to_i + 1, "  config.session_store :cache_store\n\n"
+      puts
+      puts "✨ Using :cache_store for session storage. We recommend switching to Redis for cache and session storage."
+      puts
+      puts "https://docs.stimulusreflex.com/appendices/deployment#use-redis-as-your-cache-store"
+      File.write(filepath, lines.join)
+    end
+
+    if defined?(ActionMailer)
+      lines = File.readlines(filepath)
+      unless lines.find { |line| line.include?("config.action_mailer.default_url_options") }
+        matches = lines.select { |line| line =~ /\A(Rails.application.configure do)/ }
+        lines.insert lines.index(matches.last).to_i + 1, "  config.action_mailer.default_url_options = {host: \"localhost\", port: 3000}\n\n"
+        File.write(filepath, lines.join)
+      end
     end
 
+    lines = File.readlines(filepath)
+    unless lines.find { |line| line.include?("config.action_controller.default_url_options") }
+      matches = lines.select { |line| line =~ /\A(Rails.application.configure do)/ }
+      lines.insert lines.index(matches.last).to_i + 1, "  config.action_controller.default_url_options = {host: \"localhost\", port: 3000}\n"
+      File.write(filepath, lines.join)
+    end
+
+    puts
+    puts "✨ Updating config/cable.yml to use Redis in development"
     filepath = Rails.root.join("config/cable.yml")
-    lines = File.open(filepath, "r") { |f| f.readlines }
+    lines = File.readlines(filepath)
     if lines[1].include?("adapter: async")
       lines.delete_at 1
       lines.insert 1, "  adapter: redis\n"
       lines.insert 2, "  url: <%= ENV.fetch(\"REDIS_URL\") { \"redis://localhost:6379/1\" } %>\n"
-      lines.insert 3, "  channel_prefix: " + File.basename(Rails.root.to_s).underscore + "_development\n"
-      File.open(filepath, "w") { |f| f.write lines.join }
+      lines.insert 3, "  channel_prefix: " + File.basename(Rails.root.to_s).tr("\\", "").tr("-. ", "_").underscore + "_development\n"
+      File.write(filepath, lines.join)
     end
 
+    puts
+    puts "✨ Generating default StimulusReflex and CableReady configuration files"
+    puts
+    system "bundle exec rails generate stimulus_reflex:initializer"
+    system "bundle exec rails generate cable_ready:initializer"
+    system "bundle exec rails generate cable_ready:helpers"
+
+    puts
+    puts "✨ Generating ApplicationReflex class and Stimulus controllers, plus an example Reflex class and controller"
+    puts
     system "bundle exec rails generate stimulus_reflex example"
-    puts "Generating default StimulusReflex configuration file into your application config/initializers directory"
-    system "bundle exec rails generate stimulus_reflex:config"
 
     puts
-    puts "StimulusReflex and CableReady have been successfully installed!"
-    puts "Go to https://docs.stimulusreflex.com/quickstart if you need help getting started."
+    puts "🎉 StimulusReflex and CableReady have been successfully installed! 🎉"
+    puts
+    puts "https://docs.stimulusreflex.com/hello-world/quickstart"
+    puts
+    puts "😊 The fastest way to get support is to say hello on Discord:"
+    puts
+    puts "https://discord.gg/stimulus-reflex"
     puts
   end
 end

data/test/broadcasters/broadcaster_test.rb

@@ -7,6 +7,5 @@ class StimulusReflex::BroadcasterTest < StimulusReflex::BroadcasterTestCase
     broadcaster = StimulusReflex::Broadcaster.new(@reflex)
 
     assert_raises(NotImplementedError) { broadcaster.broadcast }
-    assert_raises(NotImplementedError) { broadcaster.broadcast_message(subject: "Test") }
   end
 end

data/test/broadcasters/broadcaster_test_case.rb

@@ -5,11 +5,35 @@ require_relative "../test_helper"
 class StimulusReflex::BroadcasterTestCase < ActionCable::Channel::TestCase
   tests StimulusReflex::Channel
 
+  def assert_broadcast_on(stream, data, &block)
+    serialized_msg = ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(data))
+
+    new_messages = broadcasts(stream)
+    if block
+      old_messages = new_messages
+      clear_messages(stream)
+
+      yield
+      new_messages = broadcasts(stream)
+      clear_messages(stream)
+
+      (old_messages + new_messages).each { |m| pubsub_adapter.broadcast(stream, m) }
+    end
+
+    message = new_messages.find { |msg| ActiveSupport::JSON.decode(msg) == serialized_msg }
+
+    unless message
+      puts "\n\n#{ActiveSupport::JSON.decode(new_messages.first)}\n#{data}\n\n"
+    end
+
+    assert message, "No messages sent with #{data} to #{stream}"
+  end
+
   setup do
     stub_connection(session_id: SecureRandom.uuid)
     def connection.env
       @env ||= {}
     end
-    @reflex = StimulusReflex::Reflex.new(subscribe, url: "https://test.stimulusreflex.com")
+    @reflex = StimulusReflex::Reflex.new(subscribe, url: "https://test.stimulusreflex.com", client_attributes: {reflex_id: "666"})
   end
 end

data/test/broadcasters/nothing_broadcaster_test.rb

@@ -3,33 +3,27 @@
 require_relative "broadcaster_test_case"
 
 class StimulusReflex::NothingBroadcasterTest < StimulusReflex::BroadcasterTestCase
-  test "broadcasts a server message when called" do
+  test "broadcasts a nothing morph when called" do
     broadcaster = StimulusReflex::NothingBroadcaster.new(@reflex)
 
     expected = {
       "cableReady" => true,
-      "operations" => {
-        "dispatchEvent" => [
-          {
-            "name" => "stimulus-reflex:server-message",
-            "detail" => {
-              "reflexId" => nil,
-              "stimulusReflex" => {
-                "some" => :data,
-                "morph" => :nothing,
-                "serverMessage" => {
-                  "subject" => "nothing",
-                  "body" => nil
-                }
-              }
-            }
-          }
-        ]
-      }
+      "operations" => [
+        {
+          "name" => "stimulus-reflex:morph-nothing",
+          "payload" => {},
+          "stimulusReflex" => {
+            "some" => "data",
+            "morph" => "nothing"
+          },
+          "reflexId" => "666",
+          "operation" => "dispatchEvent"
+        }
+      ]
     }
 
     assert_broadcast_on @reflex.stream_name, expected do
-      broadcaster.broadcast nil, some: :data
+      broadcaster.broadcast nil, {some: :data}
     end
   end
 end