vident 1.0.2 → 2.0.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vident
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Stephen Ierodiaconou
@@ -86,72 +86,50 @@ files:
 - lib/generators/vident/install/templates/vident.rb
 - lib/vident.rb
 - lib/vident/caching.rb
-- lib/vident/child_element_helper.rb
-- lib/vident/class_list_builder.rb
+- lib/vident/capabilities/caching.rb
+- lib/vident/capabilities/child_element_rendering.rb
+- lib/vident/capabilities/class_list_building.rb
+- lib/vident/capabilities/declarable.rb
+- lib/vident/capabilities/identifiable.rb
+- lib/vident/capabilities/inspectable.rb
+- lib/vident/capabilities/root_element_rendering.rb
+- lib/vident/capabilities/stimulus_data_emitting.rb
+- lib/vident/capabilities/stimulus_declaring.rb
+- lib/vident/capabilities/stimulus_draft.rb
+- lib/vident/capabilities/stimulus_mutation.rb
+- lib/vident/capabilities/stimulus_parsing.rb
+- lib/vident/capabilities/tailwind.rb
 - lib/vident/component.rb
-- lib/vident/component_attribute_resolver.rb
-- lib/vident/component_class_lists.rb
 - lib/vident/engine.rb
+- lib/vident/error.rb
+- lib/vident/internals/action_builder.rb
+- lib/vident/internals/attribute_writer.rb
+- lib/vident/internals/class_list_builder.rb
+- lib/vident/internals/declaration.rb
+- lib/vident/internals/declarations.rb
+- lib/vident/internals/draft.rb
+- lib/vident/internals/dsl.rb
+- lib/vident/internals/plan.rb
+- lib/vident/internals/registry.rb
+- lib/vident/internals/resolver.rb
+- lib/vident/internals/target_builder.rb
 - lib/vident/stable_id.rb
-- lib/vident/stimulus.rb
+- lib/vident/stimulus/action.rb
+- lib/vident/stimulus/base.rb
+- lib/vident/stimulus/class_map.rb
+- lib/vident/stimulus/collection.rb
+- lib/vident/stimulus/combinable.rb
+- lib/vident/stimulus/controller.rb
 - lib/vident/stimulus/naming.rb
-- lib/vident/stimulus/primitive.rb
-- lib/vident/stimulus_action.rb
-- lib/vident/stimulus_action_collection.rb
-- lib/vident/stimulus_attribute_base.rb
-- lib/vident/stimulus_attributes.rb
-- lib/vident/stimulus_builder.rb
-- lib/vident/stimulus_class.rb
-- lib/vident/stimulus_class_collection.rb
-- lib/vident/stimulus_collection_base.rb
-- lib/vident/stimulus_component.rb
-- lib/vident/stimulus_controller.rb
-- lib/vident/stimulus_controller_collection.rb
-- lib/vident/stimulus_data_attribute_builder.rb
-- lib/vident/stimulus_helper.rb
+- lib/vident/stimulus/null.rb
+- lib/vident/stimulus/outlet.rb
+- lib/vident/stimulus/param.rb
+- lib/vident/stimulus/target.rb
+- lib/vident/stimulus/value.rb
 - lib/vident/stimulus_null.rb
-- lib/vident/stimulus_outlet.rb
-- lib/vident/stimulus_outlet_collection.rb
-- lib/vident/stimulus_param.rb
-- lib/vident/stimulus_param_collection.rb
-- lib/vident/stimulus_target.rb
-- lib/vident/stimulus_target_collection.rb
-- lib/vident/stimulus_value.rb
-- lib/vident/stimulus_value_collection.rb
 - lib/vident/tailwind.rb
+- lib/vident/types.rb
 - lib/vident/version.rb
-- lib/vident2.rb
-- lib/vident2/caching.rb
-- lib/vident2/component.rb
-- lib/vident2/engine.rb
-- lib/vident2/error.rb
-- lib/vident2/internals/action_builder.rb
-- lib/vident2/internals/attribute_writer.rb
-- lib/vident2/internals/class_list_builder.rb
-- lib/vident2/internals/declaration.rb
-- lib/vident2/internals/declarations.rb
-- lib/vident2/internals/draft.rb
-- lib/vident2/internals/dsl.rb
-- lib/vident2/internals/plan.rb
-- lib/vident2/internals/registry.rb
-- lib/vident2/internals/resolver.rb
-- lib/vident2/internals/target_builder.rb
-- lib/vident2/phlex.rb
-- lib/vident2/phlex/html.rb
-- lib/vident2/stimulus/action.rb
-- lib/vident2/stimulus/class_map.rb
-- lib/vident2/stimulus/collection.rb
-- lib/vident2/stimulus/controller.rb
-- lib/vident2/stimulus/naming.rb
-- lib/vident2/stimulus/null.rb
-- lib/vident2/stimulus/outlet.rb
-- lib/vident2/stimulus/param.rb
-- lib/vident2/stimulus/target.rb
-- lib/vident2/stimulus/value.rb
-- lib/vident2/tailwind.rb
-- lib/vident2/version.rb
-- lib/vident2/view_component.rb
-- lib/vident2/view_component/base.rb
 - skills/vident/SKILL.md
 - skills/vident/api-reference.md
 - skills/vident/examples.md

data/lib/vident/child_element_helper.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  module ChildElementHelper
-    # Explicit kwargs (14 of them, 1 plural + 1 singular per primitive) are the
-    # public API — keep them so call-sites get typo-checking and IDE support.
-    # The body is registry-driven via `Stimulus::PRIMITIVES`.
-    def child_element(
-      tag_name,
-      stimulus_controllers: nil,
-      stimulus_targets: nil,
-      stimulus_actions: nil,
-      stimulus_outlets: nil,
-      stimulus_values: nil,
-      stimulus_params: nil,
-      stimulus_classes: nil,
-      stimulus_controller: nil,
-      stimulus_target: nil,
-      stimulus_action: nil,
-      stimulus_outlet: nil,
-      stimulus_value: nil,
-      stimulus_param: nil,
-      stimulus_class: nil,
-      **options,
-      &block
-    )
-      inputs = {
-        controllers: [stimulus_controllers, stimulus_controller],
-        actions: [stimulus_actions, stimulus_action],
-        targets: [stimulus_targets, stimulus_target],
-        outlets: [stimulus_outlets, stimulus_outlet],
-        values: [stimulus_values, stimulus_value],
-        params: [stimulus_params, stimulus_param],
-        classes: [stimulus_classes, stimulus_class]
-      }
-
-      collections = Stimulus::PRIMITIVES.to_h do |primitive|
-        plural, singular = inputs.fetch(primitive.name)
-        child_element_attribute_must_be_collection!(plural, primitive.key.to_s)
-        args = primitive.keyed? ? [plural || singular] : child_element_wrap_single_stimulus_attribute(plural, singular)
-        [primitive.name, send(primitive.key, *Array.wrap(args))]
-      end
-
-      data_attrs = StimulusDataAttributeBuilder.new(**collections).build
-      generate_child_element(tag_name, data_attrs, options, &block)
-    end
-
-    private
-
-    def child_element_attribute_must_be_collection!(collection, name)
-      return unless collection
-      raise ArgumentError, "'#{name}:' must be an enumerable. Did you mean '#{name.to_s.singularize}:'?" unless collection.is_a?(Enumerable)
-    end
-
-    def child_element_wrap_single_stimulus_attribute(plural, singular)
-      return plural if plural
-      singular.nil? ? nil : [singular]
-    end
-
-    def generate_child_element(tag_name, stimulus_data_attributes, options, &block)
-      raise NoMethodError, "Not implemented"
-    end
-  end
-end

data/lib/vident/class_list_builder.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-
-module Vident
-  class ClassListBuilder
-    CLASSNAME_SEPARATOR = " "
-
-    # If the HTML "class" option is provided, it is taken in order of precedence of source.
-    # The order of precedence is:
-    # lowest  | root_element_classes => whatever is returned
-    # ....... | root_element_attributes => the `html_options[:class]` value
-    # ....... | root_element(class: ...) => the `class` value of the arguments passed to the root element
-    # highest | render MyComponent.new(html_options: { class: ... }) => the `html_options[:class]` value
-    # The "classes" prop on the component on the other hand is used to add additional classes to the component.
-    # eg: render MyComponent.new(classes: "my-additional-class another-class")
-    def initialize(tailwind_merger: nil, component_name: nil, root_element_attributes_classes: nil, root_element_classes: nil, root_element_html_class: nil, html_class: nil, additional_classes: nil)
-      @class_list = component_name ? [component_name] : []
-      @class_list.concat(Array.wrap(root_element_classes)) if root_element_classes && !root_element_attributes_classes && !root_element_html_class && !html_class
-      @class_list.concat(Array.wrap(root_element_attributes_classes)) if root_element_attributes_classes && !root_element_html_class && !html_class
-      @class_list.concat(Array.wrap(root_element_html_class)) if root_element_html_class && !html_class
-      @class_list.concat(Array.wrap(html_class)) if html_class
-      @class_list.concat(Array.wrap(additional_classes)) if additional_classes
-      @class_list.compact!
-
-      @tailwind_merger = tailwind_merger
-
-      if @tailwind_merger && !defined?(::TailwindMerge::Merger)
-        raise LoadError, "TailwindMerge gem is required when using tailwind_merger:. Add 'gem \"tailwind_merge\"' to your Gemfile."
-      end
-    end
-
-    # Main method to build a final class list from multiple sources
-    # @param class_lists [Array<String, Array, StimulusClass, nil>] Multiple class sources to merge
-    # @param stimulus_class_names [Array<Symbol, String>] Optional names of stimulus classes to include
-    # @return [String, nil] Final space-separated class string or nil if no classes
-    def build(extra_classes = nil, stimulus_class_names: [])
-      class_list = @class_list + Array.wrap(extra_classes).compact
-      flattened_classes = flatten_and_normalize_classes(class_list, stimulus_class_names)
-      return nil if flattened_classes.empty?
-
-      deduplicated_classes = dedupe_classes(flattened_classes)
-      return nil if deduplicated_classes.blank?
-
-      class_string = deduplicated_classes.join(CLASSNAME_SEPARATOR)
-
-      if @tailwind_merger
-        dedupe_with_tailwind(class_string)
-      else
-        class_string
-      end
-    end
-
-    private
-
-    # Flatten and normalize all input class sources
-    def flatten_and_normalize_classes(class_lists, stimulus_class_names)
-      stimulus_class_names_set = stimulus_class_names.map { |name| name.to_s.dasherize }.to_set
-
-      class_lists.compact.flat_map do |class_source|
-        case class_source
-        when String
-          class_source.split(CLASSNAME_SEPARATOR).reject(&:empty?)
-        when Array
-          class_source.flat_map { |item| normalize_single_class_item(item, stimulus_class_names_set) }
-        else
-          normalize_single_class_item(class_source, stimulus_class_names_set)
-        end
-      end.compact
-    end
-
-    # Normalize a single class item (could be string, StimulusClass, object with to_s, etc.)
-    def normalize_single_class_item(item, stimulus_class_names_set)
-      return [] if item.blank?
-
-      # Handle StimulusClass instances
-      if stimulus_class_instance?(item)
-        # Only include if the class name matches one of the requested names
-        # If stimulus_class_names_set is empty, exclude all stimulus classes
-        if stimulus_class_names_set.present? && stimulus_class_names_set.include?(item.class_name)
-          class_value = item.to_s
-          class_value.include?(CLASSNAME_SEPARATOR) ?
-            class_value.split(CLASSNAME_SEPARATOR).reject(&:empty?) :
-            [class_value]
-        else
-          []
-        end
-      else
-        # Handle regular strings and other objects
-        item_string = item.to_s
-        item_string.include?(CLASSNAME_SEPARATOR) ?
-          item_string.split(CLASSNAME_SEPARATOR).reject(&:empty?) :
-          [item_string]
-      end
-    end
-
-    # Check if an item is a StimulusClass instance
-    def stimulus_class_instance?(item)
-      item.respond_to?(:class_name) && item.respond_to?(:to_s)
-    end
-
-    # Deduplicate classes while preserving order (first occurrence wins)
-    def dedupe_classes(class_array)
-      class_array.reject(&:blank?).uniq
-    end
-
-    # Merge classes using Tailwind CSS merge
-    def dedupe_with_tailwind(class_string)
-      @tailwind_merger.merge(class_string)
-    end
-  end
-end

data/lib/vident/component_attribute_resolver.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  module ComponentAttributeResolver
-    include Stimulus::Naming
-
-    private
-
-    # Prepare attributes set at initialization. The DSL's static entries are
-    # merged in here so user-land `after_component_initialize` mutators append
-    # after them (preserving DSL-first ordering). DSL procs are NOT resolved
-    # here — they run at render time via `resolve_stimulus_attributes_at_render_time`
-    # so they can reach `helpers` / `view_context`.
-    def prepare_component_attributes
-      prepare_stimulus_collections
-
-      add_stimulus_attributes_from_dsl(phase: :static)
-
-      extra = root_element_attributes
-      @html_options = (extra[:html_options] || {}).merge(@html_options) if extra.key?(:html_options)
-      @root_element_attributes_classes = extra[:classes]
-      @root_element_attributes_id = extra[:id] || id
-      @element_tag = extra[:element_tag] if extra.key?(:element_tag)
-
-      Stimulus::PRIMITIVES.each do |primitive|
-        send(mutator_method(primitive), extra[primitive.key]) if extra.key?(primitive.key)
-      end
-
-      @stimulus_proc_attributes_resolved = false
-    end
-
-    # Render-phase: resolve DSL proc entries against the component instance,
-    # now that `helpers` / `view_context` are wired. Triggered by Phlex's
-    # `before_template` and ViewComponent's `before_render`. Idempotent —
-    # `stimulus_data_attributes` also calls this as a safety net.
-    def resolve_stimulus_attributes_at_render_time
-      return if @stimulus_proc_attributes_resolved
-      @stimulus_proc_attributes_resolved = true
-
-      add_stimulus_attributes_from_dsl(phase: :procs)
-    end
-
-    def resolve_root_element_attributes_before_render(root_element_html_options = nil)
-      extra = root_element_html_options || {}
-
-      # Options set on component at render time take precedence over attributes set by methods on the component
-      # or attributes passed to root_element in the template
-      final_attributes = {
-        data: stimulus_data_attributes  # Lowest precedence
-      }
-      if root_element_html_options.present? # Mid precedence
-        root_element_tag_html_options_merge(final_attributes, root_element_html_options)
-      end
-      if @html_options.present? # Highest precedence
-        root_element_tag_html_options_merge(final_attributes, @html_options)
-      end
-      final_attributes[:class] = render_classes(extra[:class])
-      final_attributes[:id] = (extra[:id] || @root_element_attributes_id) unless final_attributes.key?(:id)
-      final_attributes
-    end
-
-    def root_element_tag_html_options_merge(final_attributes, other_html_options)
-      if other_html_options[:data].present?
-        final_attributes[:data].merge!(other_html_options[:data])
-      end
-      final_attributes.merge!(other_html_options.except(:data))
-    end
-
-    # Run DSL attributes through their `add_stimulus_*` mutators. `phase:` is
-    # forwarded to the builder: `:static` skips procs (init-time), `:procs`
-    # skips non-procs (render-time), `:all` resolves everything.
-    # `values_from_props` is a sidecar on values, resolved at instance
-    # render time (only during the static phase since it has no procs).
-    def add_stimulus_attributes_from_dsl(phase: :all)
-      dsl_attrs = self.class.stimulus_dsl_attributes(self, phase:)
-      return if dsl_attrs.empty?
-
-      Stimulus::PRIMITIVES.each do |primitive|
-        value = dsl_attrs[primitive.key]
-        send(mutator_method(primitive), value) if value
-      end
-
-      if dsl_attrs[:stimulus_values_from_props]
-        resolved_values = resolve_values_from_props(dsl_attrs[:stimulus_values_from_props])
-        add_stimulus_values(resolved_values) unless resolved_values.empty?
-      end
-    end
-
-    # Seed the collection ivars from each prop's raw value.
-    def prepare_stimulus_collections
-      Stimulus::PRIMITIVES.each do |primitive|
-        raw = instance_variable_get(prop_ivar(primitive))
-        collection = send(primitive.key, *Array.wrap(raw))
-        instance_variable_set(collection_ivar(primitive), collection)
-      end
-
-      @stimulus_outlet_host.add_stimulus_outlets(self) if @stimulus_outlet_host
-    end
-
-    def stimulus_data_attributes
-      resolve_stimulus_attributes_at_render_time
-      collections = Stimulus::PRIMITIVES.to_h { |primitive| [primitive.name, instance_variable_get(collection_ivar(primitive))] }
-      StimulusDataAttributeBuilder.new(**collections).build
-    end
-  end
-end

data/lib/vident/component_class_lists.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  module ComponentClassLists
-    # Generates the full list of HTML classes for the component
-    def render_classes(root_element_html_class = nil) = class_list_builder(root_element_html_class).build
-
-    # Getter for a stimulus classes list so can be used in view to set initial state on SSR
-    # Returns a String of classes that can be used in a `class` attribute.
-    def class_list_for_stimulus_classes(*names)
-      # DSL proc entries are resolved lazily at render time; trigger them now
-      # so procs that use only instance state work from ERB/template.
-      resolve_stimulus_attributes_at_render_time if respond_to?(:resolve_stimulus_attributes_at_render_time, true)
-      ClassListBuilder.new(tailwind_merger:).build(
-        @stimulus_classes_collection&.to_a,
-        stimulus_class_names: names
-      ) || ""
-    end
-
-    private
-
-    # Not memoised: the per-thread TailwindMerger is the only expensive piece
-    # and it's already cached; the builder itself just copies a few ivars.
-    # Memoising here would latch the first caller's `root_element_html_class:`.
-    def class_list_builder(root_element_html_class = nil)
-      ClassListBuilder.new(
-        tailwind_merger:,
-        component_name:,
-        root_element_attributes_classes: @root_element_attributes_classes,
-        root_element_classes:,
-        root_element_html_class:,
-        additional_classes: @classes,
-        html_class: @html_options&.fetch(:class, nil)
-      )
-    end
-  end
-end

data/lib/vident/stimulus/primitive.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  module Stimulus
-    # A Stimulus primitive kind: name, plus the Value/Collection classes that
-    # back it. Two concrete subclasses distinguish how the primitive behaves
-    # when a Hash is passed to the plural parser:
-    #
-    #   - `Keyed`      — `{a: 1, b: 2}` expands to one value object per pair.
-    #                    Used for values / params / classes / outlets.
-    #   - `Positional` — `{...}` is a single-arg descriptor (e.g. Action's
-    #                    `{event:, method:, ...}` short form).
-    #                    Used for controllers / actions / targets.
-    class Primitive < ::Data.define(:name, :value_class, :collection_class)
-      # Short forms. `name` (Data field) is the plural — `:values`; `plural`
-      # is an alias for symmetry with `singular`.
-      alias_method :plural, :name
-      def singular = name.to_s.singularize.to_sym
-
-      # The primitive's key in Vident's attribute namespace. Used both as the
-      # parser method name (`def stimulus_values(...)`) and as the hash key
-      # in DSL attrs / component props / `root_element_attributes` — the same
-      # Symbol serves all three roles.
-      def key = :"stimulus_#{name}"
-      def singular_key = :"stimulus_#{singular}"
-
-      def keyed? = raise NotImplementedError
-    end
-
-    class KeyedPrimitive < Primitive
-      def keyed? = true
-    end
-
-    class PositionalPrimitive < Primitive
-      def keyed? = false
-    end
-  end
-end

data/lib/vident/stimulus.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  module Stimulus
-    # Registry of primitive kinds. Add an entry (paired with a Value/Collection
-    # class pair) to extend; plural parsers, mutators, and the data-attribute
-    # builder pick it up. Array order = data attribute emission order.
-    PRIMITIVES = [
-      PositionalPrimitive.new(:controllers, StimulusController, StimulusControllerCollection),
-      PositionalPrimitive.new(:actions, StimulusAction, StimulusActionCollection),
-      PositionalPrimitive.new(:targets, StimulusTarget, StimulusTargetCollection),
-      KeyedPrimitive.new(:outlets, StimulusOutlet, StimulusOutletCollection),
-      KeyedPrimitive.new(:values, StimulusValue, StimulusValueCollection),
-      KeyedPrimitive.new(:params, StimulusParam, StimulusParamCollection),
-      KeyedPrimitive.new(:classes, StimulusClass, StimulusClassCollection)
-    ].freeze
-
-    PRIMITIVES_BY_NAME = PRIMITIVES.to_h { |primitive| [primitive.name, primitive] }.freeze
-
-    class << self
-      def primitive(name)
-        PRIMITIVES_BY_NAME[name] or
-          raise ArgumentError, "Unknown stimulus primitive #{name.inspect}; valid: #{PRIMITIVES_BY_NAME.keys.inspect}"
-      end
-
-      def each(&block) = PRIMITIVES.each(&block)
-
-      def names = PRIMITIVES.map(&:name)
-    end
-  end
-end

data/lib/vident/stimulus_action.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  class StimulusAction < StimulusAttributeBase
-    # https://stimulus.hotwired.dev/reference/actions#options
-    VALID_OPTIONS = [:once, :prevent, :stop, :passive, :"!passive", :capture, :self].freeze
-
-    # Typed descriptor for modifiers (`:once`/`:prevent`/etc., keyboard filter,
-    # `@window`) that the plain Array form can't express. Hash input to the
-    # parsers (`{event:, method:, ...}`) is desugared into one of these.
-    class Descriptor < ::Literal::Data
-      prop :method, _Union(Symbol, String)
-      prop :event, _Nilable(_Union(Symbol, String)), default: nil
-      prop :controller, _Nilable(String), default: nil
-      prop :options, _Array(Symbol), default: -> { [] }
-      prop :keyboard, _Nilable(String), default: nil
-      prop :window, _Boolean, default: false
-    end
-
-    attr_reader :event, :controller, :action, :options, :keyboard, :window
-
-    def initialize(*args, implied_controller: nil)
-      @options = []
-      @keyboard = nil
-      @window = false
-      super
-    end
-
-    def to_s
-      head =
-        if @event
-          ev = @event.to_s
-          ev = "#{ev}.#{@keyboard}" if @keyboard
-          ev = "#{ev}#{@options.map { |o| ":#{o}" }.join}" if @options.any?
-          ev = "#{ev}@window" if @window
-          "#{ev}->"
-        else
-          ""
-        end
-      "#{head}#{@controller}##{@action}"
-    end
-
-    def data_attribute_name = "action"
-
-    def data_attribute_value = to_s
-
-    private
-
-    def parse_arguments(*args)
-      part1, part2, part3 = args
-
-      case args.size
-      when 1
-        parse_single_argument(part1)
-      when 2
-        parse_two_arguments(part1, part2)
-      when 3
-        parse_three_arguments(part1, part2, part3)
-      else
-        raise ArgumentError, "Invalid number of 'action' arguments: #{args.size}"
-      end
-    end
-
-    def parse_single_argument(arg)
-      case arg
-      when Descriptor then apply_descriptor(arg)
-      when Hash then apply_descriptor(Descriptor.new(**arg))
-      when Symbol
-        @event = nil
-        @controller = implied_controller_name
-        @action = js_name(arg)
-      when String then parse_qualified_action_string(arg)
-      else raise ArgumentError, "Invalid 'action' argument type (1): #{arg.class}"
-      end
-    end
-
-    # (:event, :method) or ("controller/path", :method)
-    def parse_two_arguments(part1, part2)
-      if part1.is_a?(Symbol) && part2.is_a?(Symbol)
-        @event = part1.to_s
-        @controller = implied_controller_name
-        @action = js_name(part2)
-      elsif part1.is_a?(String) && part2.is_a?(Symbol)
-        @event = nil
-        @controller = stimulize_path(part1)
-        @action = js_name(part2)
-      else
-        raise ArgumentError, "Invalid 'action' argument types (2): #{part1.class}, #{part2.class}"
-      end
-    end
-
-    # (:event, "controller/path", :method)
-    def parse_three_arguments(part1, part2, part3)
-      if part1.is_a?(Symbol) && part2.is_a?(String) && part3.is_a?(Symbol)
-        @event = part1.to_s
-        @controller = stimulize_path(part2)
-        @action = js_name(part3)
-      else
-        raise ArgumentError, "Invalid 'action' argument types (3): #{part1.class}, #{part2.class}, #{part3.class}"
-      end
-    end
-
-    def apply_descriptor(d)
-      invalid = d.options - VALID_OPTIONS
-      unless invalid.empty?
-        raise ArgumentError,
-          "Invalid action option(s) #{invalid.inspect}. Valid: #{VALID_OPTIONS.inspect}"
-      end
-
-      @event = d.event&.to_s
-      @controller = d.controller ? stimulize_path(d.controller) : implied_controller_name
-      @action = d.method.is_a?(Symbol) ? js_name(d.method) : d.method.to_s
-      @options = d.options
-      @keyboard = d.keyboard
-      @window = d.window
-    end
-
-    def parse_qualified_action_string(action_string)
-      if action_string.include?("->")
-        event_part, controller_action = action_string.split("->", 2)
-        @event = event_part
-        controller_part, action_part = controller_action.split("#", 2)
-        @controller = controller_part
-        @action = action_part
-      else
-        @event = nil
-        controller_part, action_part = action_string.split("#", 2)
-        @controller = controller_part
-        @action = action_part
-      end
-    end
-  end
-end

data/lib/vident/stimulus_action_collection.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  class StimulusActionCollection < StimulusCollectionBase
-    def to_h
-      return {} if items.empty?
-
-      {action: items.map(&:to_s).join(" ")}
-    end
-  end
-end