stimulus_reflex 3.4.1 → 3.5.0.pre0

data/lib/stimulus_reflex/reflex.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
-ClientAttributes = Struct.new(:reflex_id, :reflex_controller, :xpath_controller, :xpath_element, :permanent_attribute_name, keyword_init: true)
+ClientAttributes = Struct.new(:reflex_id, :tab_id, :reflex_controller, :xpath_controller, :xpath_element, :permanent_attribute_name, keyword_init: true)
 
 class StimulusReflex::Reflex
   include ActiveSupport::Rescuable
   include StimulusReflex::Callbacks
+  include ActionView::Helpers::TagHelper
+  include CableReady::Identifiable
 
+  attr_accessor :payload
   attr_reader :cable_ready, :channel, :url, :element, :selectors, :method_name, :broadcaster, :client_attributes, :logger
 
   alias_method :action_name, :method_name # for compatibility with controller libraries like Pundit that expect an action name
@@ -13,8 +16,7 @@ class StimulusReflex::Reflex
   delegate :connection, :stream_name, to: :channel
   delegate :controller_class, :flash, :session, to: :request
   delegate :broadcast, :broadcast_message, to: :broadcaster
-  delegate :reflex_id, :reflex_controller, :xpath_controller, :xpath_element, :permanent_attribute_name, to: :client_attributes
-  delegate :render, to: :controller_class
+  delegate :reflex_id, :tab_id, :reflex_controller, :xpath_controller, :xpath_element, :permanent_attribute_name, to: :client_attributes
 
   def initialize(channel, url: nil, element: nil, selectors: [], method_name: nil, params: {}, client_attributes: {})
     if is_a? CableReady::Broadcaster
@@ -37,7 +39,8 @@ class StimulusReflex::Reflex
     @broadcaster = StimulusReflex::PageBroadcaster.new(self)
     @logger = StimulusReflex::Logger.new(self)
     @client_attributes = ClientAttributes.new(client_attributes)
-    @cable_ready = StimulusReflex::CableReadyChannels.new(stream_name)
+    @cable_ready = StimulusReflex::CableReadyChannels.new(stream_name, reflex_id)
+    @payload = {}
     self.params
   end
 
@@ -70,17 +73,15 @@ class StimulusReflex::Reflex
 
       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")
+      # fetch path params (controller, action, ...) and apply them
+      request_params = StimulusReflex::RequestParameters.new(params: @params, req: req, url: url)
+      req = request_params.apply!
 
-      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! }
+      req
     end
   end
 
-  def morph(selectors, html = "")
+  def morph(selectors, html = nil)
     case selectors
     when :page
       raise StandardError.new("Cannot call :page morph after :#{broadcaster.to_sym} morph") unless broadcaster.page?
@@ -95,16 +96,25 @@ class StimulusReflex::Reflex
   end
 
   def controller
-    @controller ||= begin
-      controller_class.new.tap do |c|
-        c.instance_variable_set :"@stimulus_reflex", true
-        instance_variables.each { |name| c.instance_variable_set name, instance_variable_get(name) }
-        c.set_request! request
-        c.set_response! controller_class.make_response!(request)
-      end
+    @controller ||= controller_class.new.tap do |c|
+      c.instance_variable_set :@stimulus_reflex, true
+      c.set_request! request
+      c.set_response! controller_class.make_response!(request)
     end
+
+    instance_variables.each { |name| @controller.instance_variable_set name, instance_variable_get(name) }
+    @controller
+  end
+
+  def controller?
+    !!defined? @controller
+  end
+
+  def render(*args)
+    controller_class.renderer.new(connection.env.merge("SCRIPT_NAME" => "")).render(*args)
   end
 
+  # Invoke the reflex action specified by `name` and run all callbacks
   def process(name, *args)
     reflex_invoked = false
     result = run_callbacks(:process) {
@@ -129,7 +139,12 @@ class StimulusReflex::Reflex
     @_params ||= ActionController::Parameters.new(request.parameters)
   end
 
-  def dom_id(record_or_class, prefix = nil)
-    "#" + ActionView::RecordIdentifier.dom_id(record_or_class, prefix).to_s
+  # morphdom needs content to be wrapped in an element with the same id when children_only: true
+  # Oddly, it doesn't matter if the target element is a div! See: https://docs.stimulusreflex.com/appendices/troubleshooting#different-element-type-altogether-who-cares-so-long-as-the-css-selector-matches
+  # Used internally to allow automatic partial collection rendering, but also useful to library users
+  # eg. `morph dom_id(@posts), render_collection(@posts)`
+  def render_collection(resource, content = nil)
+    content ||= render(resource)
+    tag.div(content.html_safe, id: dom_id(resource).from(1))
   end
 end

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/{logger.rb → utils/logger.rb}

@@ -12,12 +12,10 @@ module StimulusReflex
     def print
       return unless config_logging.instance_of?(Proc)
 
-      puts
       reflex.broadcaster.operations.each do
         puts instance_eval(&config_logging) + "\e[0m"
         @current_operation += 1
       end
-      puts
     end
 
     private

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

@@ -1,6 +1,7 @@
 # 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+.*)"/
 
@@ -13,6 +14,8 @@ class StimulusReflex::SanityChecker
       instance = new
       instance.check_caching_enabled
       instance.check_javascript_package_version
+      instance.check_default_url_config
+      instance.check_new_version_available
     end
 
     private
@@ -24,44 +27,80 @@ class StimulusReflex::SanityChecker
     end
 
     def called_by_generate_config?
-      ARGV.include? "stimulus_reflex:config"
+      ARGV.include? "stimulus_reflex:initializer"
     end
   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.
+        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
+          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.
+        StimulusReflex 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_default_url_config
+    unless default_url_config_set?
+      warn_and_exit <<~WARN
+        StimulusReflex strongly suggests that you set default_url_options in your environment files.
+        Otherwise, ActionController and 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}
+        Please update every environment with the appropriate URL. Typically, no port is necessary in production.
+      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.
+        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}
+        The stimulus_reflex npm 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
 
+  def check_new_version_available
+    return unless Rails.env.development?
+    return if StimulusReflex.config.on_new_version_available == :ignore
+    return unless using_stable_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
+
   private
 
   def caching_enabled?
@@ -72,10 +111,20 @@ class StimulusReflex::SanityChecker
     Rails.application.config.cache_store != :null_store
   end
 
+  def default_url_config_set?
+    Rails.application.config.action_controller.default_url_options
+  end
+
   def javascript_version_matches?
     javascript_package_version == gem_version
   end
 
+  def using_stable_release
+    stable = StimulusReflex::VERSION.match?(LATEST_VERSION_FORMAT)
+    puts "StimulusReflex #{StimulusReflex::VERSION} update check skipped: pre-release build" unless stable
+    stable
+  end
+
   def gem_version
     @_gem_version ||= StimulusReflex::VERSION.gsub(".pre", "-pre")
   end
@@ -118,7 +167,6 @@ class StimulusReflex::SanityChecker
   def exit_with_info
     puts
 
-    # bundle exec rails generate stimulus_reflex:config
     if File.exist?(initializer_path)
       puts <<~INFO
         If you know what you are doing and you want to start the application anyway,
@@ -139,7 +187,7 @@ class StimulusReflex::SanityChecker
 
         Then open your initializer at
 
-        <RAILS_ROOT>/config/initializers/stimulus_reflex.rb
+        #{initializer_path}
 
         and then add the following directive:
 

data/lib/stimulus_reflex/version.rb

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

data/lib/tasks/stimulus_reflex/install.rake

@@ -44,14 +44,16 @@ 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 }
 
     filepath = Rails.root.join("config/environments/development.rb")
     lines = File.open(filepath, "r") { |f| f.readlines }
     unless lines.find { |line| line.include?("config.session_store") }
-      lines.insert 3, "  config.session_store :cache_store\n\n"
+      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"
       File.open(filepath, "w") { |f| f.write lines.join }
     end
 
@@ -61,7 +63,7 @@ namespace :stimulus_reflex do
       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"
+      lines.insert 3, "  channel_prefix: " + File.basename(Rails.root.to_s).tr("\\", "").tr("-. ", "_").underscore + "_development\n"
       File.open(filepath, "w") { |f| f.write lines.join }
     end
 
@@ -71,7 +73,7 @@ namespace :stimulus_reflex do
 
     puts
     puts "StimulusReflex and CableReady have been successfully installed!"
-    puts "Go to https://docs.stimulusreflex.com/quickstart if you need help getting started."
+    puts "Go to https://docs.stimulusreflex.com/hello-world/quickstart if you need help getting started."
     puts
   end
 end

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stimulus_reflex",
-  "version": "3.4.0",
+  "version": "3.4.1",
   "description": "Build reactive applications with the Rails tooling you already know and love.",
   "keywords": [
     "ruby",
@@ -20,11 +20,11 @@
   ],
   "homepage": "https://docs.stimulusreflex.com/",
   "bugs": {
-    "url": "https://github.com/hopsoft/stimulus_reflex/issues"
+    "url": "https://github.com/stimulusreflex/stimulus_reflex/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com:hopsoft/stimulus_reflex.git"
+    "url": "git+https://github.com:stimulusreflex/stimulus_reflex.git"
   },
   "license": "MIT",
   "author": "Nathan Hopkins <natehop@gmail.com>",
@@ -34,14 +34,14 @@
     "postinstall": "node ./javascript/scripts/post_install.js",
     "prettier-standard:check": "yarn run prettier-standard --check ./javascript/*.js ./javascript/**/*.js",
     "prettier-standard:format": "yarn run prettier-standard ./javascript/*.js ./javascript/**/*.js",
-    "test": "yarn run mocha --require @babel/register --require esm ./javascript/test"
+    "test": "yarn run mocha --require @babel/register --require jsdom-global/register --require esm ./javascript/test"
   },
   "peerDependencies": {
     "stimulus": ">= 1.1"
   },
   "dependencies": {
     "@rails/actioncable": ">= 6.0",
-    "cable_ready": ">= 4.5.0"
+    "cable_ready": "5.0.0-pre0"
   },
   "devDependencies": {
     "@babel/core": "^7.6.2",
@@ -50,6 +50,7 @@
     "assert": "^2.0.0",
     "esm": "^3.2.25",
     "jsdom": "^16.0.1",
+    "jsdom-global": "^3.0.2",
     "mocha": "^8.0.1",
     "prettier-standard": "^16.1.0",
     "stimulus": ">= 1.1"