stimulus_reflex 3.4.0 → 3.4.2

data/lib/stimulus_reflex/reflex.rb

@@ -1,48 +1,10 @@
 # frozen_string_literal: true
 
-ClientAttributes = Struct.new(:reflex_id, :reflex_controller, :xpath, :c_xpath, :permanent_attribute_name, keyword_init: true)
+ClientAttributes = Struct.new(:reflex_id, :reflex_controller, :xpath_controller, :xpath_element, :permanent_attribute_name, keyword_init: true)
 
 class StimulusReflex::Reflex
   include ActiveSupport::Rescuable
-  include ActiveSupport::Callbacks
-
-  define_callbacks :process, skip_after_callbacks_if_terminated: true
-
-  class << self
-    def before_reflex(*args, &block)
-      add_callback(:before, *args, &block)
-    end
-
-    def after_reflex(*args, &block)
-      add_callback(:after, *args, &block)
-    end
-
-    def around_reflex(*args, &block)
-      add_callback(:around, *args, &block)
-    end
-
-    private
-
-    def add_callback(kind, *args, &block)
-      options = args.extract_options!
-      options.assert_valid_keys :if, :unless, :only, :except
-      set_callback(*[:process, kind, args, normalize_callback_options!(options)].flatten, &block)
-    end
-
-    def normalize_callback_options!(options)
-      normalize_callback_option! options, :only, :if
-      normalize_callback_option! options, :except, :unless
-      options
-    end
-
-    def normalize_callback_option!(options, from, to)
-      if (from = options.delete(from))
-        from_set = Array(from).map(&:to_s).to_set
-        from = proc { |reflex| from_set.include? reflex.method_name }
-        options[to] = Array(options[to]).unshift(from)
-      end
-    end
-  end
+  include StimulusReflex::Callbacks
 
   attr_reader :cable_ready, :channel, :url, :element, :selectors, :method_name, :broadcaster, :client_attributes, :logger
 
@@ -51,11 +13,21 @@ 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, :c_xpath, :permanent_attribute_name, to: :client_attributes
+  delegate :reflex_id, :reflex_controller, :xpath_controller, :xpath_element, :permanent_attribute_name, to: :client_attributes
   delegate :render, to: :controller_class
-  delegate :dom_id, to: "ActionView::RecordIdentifier"
 
   def initialize(channel, url: nil, element: nil, selectors: [], method_name: nil, params: {}, client_attributes: {})
+    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/rtfm/cableready#using-cableready-inside-a-reflex-action for more details.
+
+      MSG
+      raise TypeError.new(message.strip)
+    end
+
     @channel = channel
     @url = url
     @element = element
@@ -156,4 +128,8 @@ class StimulusReflex::Reflex
   def params
     @_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
+  end
 end

data/lib/stimulus_reflex/reflex_factory.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+class StimulusReflex::ReflexFactory
+  attr_reader :reflex_name, :method_name
+
+  def initialize(target)
+    reflex_name, method_name = target.split("#")
+    reflex_name = reflex_name.camelize
+    reflex_name = reflex_name.end_with?("Reflex") ? reflex_name : "#{reflex_name}Reflex"
+
+    @method_name = method_name
+    @reflex_name = reflex_name
+  end
+
+  def call
+    verify_method_name!
+
+    reflex_class
+  end
+
+  private
+
+  def verify_method_name!
+    return if default_reflex?
+
+    argument_error = ArgumentError.new("Reflex method '#{method_name}' is not defined on class '#{reflex_name}' or on any of its ancestors")
+
+    if reflex_method.nil?
+      raise argument_error
+    end
+
+    if !safe_ancestors.include?(reflex_method.owner)
+      raise argument_error
+    end
+  end
+
+  def reflex_class
+    @reflex_class ||= reflex_name.constantize.tap do |klass|
+      unless klass.ancestors.include?(StimulusReflex::Reflex)
+        raise ArgumentError.new("#{reflex_name} is not a StimulusReflex::Reflex")
+      end
+    end
+  end
+
+  def reflex_method
+    if reflex_class.public_instance_methods.include?(method_name.to_sym)
+      reflex_class.public_instance_method(method_name)
+    end
+  end
+
+  def default_reflex?
+    method_name == "default_reflex" && reflex_method.owner == ::StimulusReflex::Reflex
+  end
+
+  def safe_ancestors
+    # We want to include every class and module up to the `StimulusReflex::Reflex` class,
+    # but not the StimulusReflex::Reflex itself
+    reflex_class_index = reflex_class.ancestors.index(StimulusReflex::Reflex) - 1
+
+    reflex_class.ancestors.to(reflex_class_index)
+  end
+end

data/lib/stimulus_reflex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StimulusReflex
-  VERSION = "3.4.0"
+  VERSION = "3.4.2"
 end

data/lib/stimulus_reflex.rb

@@ -11,7 +11,9 @@ require "cable_ready"
 require "stimulus_reflex/version"
 require "stimulus_reflex/cable_ready_channels"
 require "stimulus_reflex/configuration"
+require "stimulus_reflex/callbacks"
 require "stimulus_reflex/reflex"
+require "stimulus_reflex/reflex_factory"
 require "stimulus_reflex/element"
 require "stimulus_reflex/sanity_checker"
 require "stimulus_reflex/broadcasters/broadcaster"

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stimulus_reflex",
-  "version": "3.4.0-pre9",
+  "version": "3.4.2",
   "description": "Build reactive applications with the Rails tooling you already know and love.",
   "keywords": [
     "ruby",
@@ -41,7 +41,7 @@
   },
   "dependencies": {
     "@rails/actioncable": ">= 6.0",
-    "cable_ready": ">= 4.4"
+    "cable_ready": "^4.5.0"
   },
   "devDependencies": {
     "@babel/core": "^7.6.2",

data/stimulus_reflex.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency "nokogiri"
   gem.add_dependency "rails", ">= 5.2"
   gem.add_dependency "redis"
-  gem.add_dependency "cable_ready", ">= 4.4"
+  gem.add_dependency "cable_ready", "~> 4.5"
 
   gem.add_development_dependency "bundler", "~> 2.0"
   gem.add_development_dependency "pry-nav"

data/test/reflex_factory_test.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class StimulusReflex::ReflexFactoryTest < ActionCable::Channel::TestCase
+  tests StimulusReflex::Channel
+
+  test "reflex class needs to be an ancestor of StimulusReflex::Reflex" do
+    exception = assert_raises(NameError) { StimulusReflex::ReflexFactory.new("Object#inspect").call }
+    assert_equal "uninitialized constant ObjectReflex Did you mean? ObjectSpace", exception.message.squish
+
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("NoReflex#no_reflex").call }
+    assert_equal "NoReflex is not a StimulusReflex::Reflex", exception.message
+
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("No#no_reflex").call }
+    assert_equal "NoReflex is not a StimulusReflex::Reflex", exception.message
+  end
+
+  test "doesn't raise if owner of method is ancestor of reflex class and descendant of StimulusReflex::Reflex" do
+    assert_nothing_raised { StimulusReflex::ReflexFactory.new("ApplicationReflex#default_reflex").call }
+    assert_nothing_raised { StimulusReflex::ReflexFactory.new("ApplicationReflex#application_reflex").call }
+
+    assert_nothing_raised { StimulusReflex::ReflexFactory.new("PostReflex#default_reflex").call }
+    assert_nothing_raised { StimulusReflex::ReflexFactory.new("PostReflex#application_reflex").call }
+    assert_nothing_raised { StimulusReflex::ReflexFactory.new("PostReflex#post_reflex").call }
+
+    assert_nothing_raised { StimulusReflex::ReflexFactory.new("CounterReflex#default_reflex").call }
+    assert_nothing_raised { StimulusReflex::ReflexFactory.new("CounterReflex#application_reflex").call }
+    assert_nothing_raised { StimulusReflex::ReflexFactory.new("CounterReflex#increment").call }
+  end
+
+  test "raises if method is not owned by a descendant of StimulusReflex::Reflex" do
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("ApplicationReflex#itself").call }
+    assert_equal "Reflex method 'itself' is not defined on class 'ApplicationReflex' or on any of its ancestors", exception.message
+
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("ApplicationReflex#itself").call }
+    assert_equal "Reflex method 'itself' is not defined on class 'ApplicationReflex' or on any of its ancestors", exception.message
+
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("PostReflex#itself").call }
+    assert_equal "Reflex method 'itself' is not defined on class 'PostReflex' or on any of its ancestors", exception.message
+
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("PostReflex#binding").call }
+    assert_equal "Reflex method 'binding' is not defined on class 'PostReflex' or on any of its ancestors", exception.message
+
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("PostReflex#byebug").call }
+    assert_equal "Reflex method 'byebug' is not defined on class 'PostReflex' or on any of its ancestors", exception.message
+
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("PostReflex#debug").call }
+    assert_equal "Reflex method 'debug' is not defined on class 'PostReflex' or on any of its ancestors", exception.message
+
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("ApplicationReflex#post_reflex").call }
+    assert_equal "Reflex method 'post_reflex' is not defined on class 'ApplicationReflex' or on any of its ancestors", exception.message
+  end
+
+  test "raises if method is a private method" do
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("ApplicationReflex#private_application_reflex").call }
+    assert_equal "Reflex method 'private_application_reflex' is not defined on class 'ApplicationReflex' or on any of its ancestors", exception.message
+
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("PostReflex#private_application_reflex").call }
+    assert_equal "Reflex method 'private_application_reflex' is not defined on class 'PostReflex' or on any of its ancestors", exception.message
+
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("PostReflex#private_post_reflex").call }
+    assert_equal "Reflex method 'private_post_reflex' is not defined on class 'PostReflex' or on any of its ancestors", exception.message
+
+    exception = assert_raises(ArgumentError) { StimulusReflex::ReflexFactory.new("CounterReflex#private_post_reflex").call }
+    assert_equal "Reflex method 'private_post_reflex' is not defined on class 'CounterReflex' or on any of its ancestors", exception.message
+  end
+
+  test "safe_ancestors" do
+    reflex_factory = StimulusReflex::ReflexFactory.new("ApplicationReflex#default_reflex")
+    assert_equal [ApplicationReflex], reflex_factory.send(:safe_ancestors)
+
+    reflex_factory = StimulusReflex::ReflexFactory.new("PostReflex#default_reflex")
+    assert_equal [PostReflex, ApplicationReflex], reflex_factory.send(:safe_ancestors)
+
+    reflex_factory = StimulusReflex::ReflexFactory.new("CounterReflex#increment")
+    assert_equal [CounterReflex, CounterConcern, ApplicationReflex], reflex_factory.send(:safe_ancestors)
+  end
+end

data/test/reflex_test.rb

@@ -27,6 +27,6 @@ class StimulusReflex::ReflexTest < ActionCable::Channel::TestCase
   end
 
   test "dom_id" do
-    assert @reflex.dom_id(TestModel.new(id: 123)) == "test_model_123"
+    assert @reflex.dom_id(TestModel.new(id: 123)) == "#test_model_123"
   end
 end

data/test/test_helper.rb

@@ -29,6 +29,40 @@ class SessionMock
   end
 end
 
+class ApplicationReflex < StimulusReflex::Reflex
+  def application_reflex
+  end
+
+  private
+
+  def private_application_reflex
+  end
+end
+
+class PostReflex < ApplicationReflex
+  def post_reflex
+  end
+
+  private
+
+  def private_post_reflex
+  end
+end
+
+class NoReflex
+  def no_reflex
+  end
+end
+
+module CounterConcern
+  def increment
+  end
+end
+
+class CounterReflex < ApplicationReflex
+  include CounterConcern
+end
+
 class ActionDispatch::Request
   def session
     @session ||= SessionMock.new