vident 1.0.0.beta1 → 1.0.0

data/lib/vident/stimulus_attributes.rb

@@ -3,10 +3,14 @@
 module Vident
   module StimulusAttributes
     extend ActiveSupport::Concern
+    # `extend` + `include` so Naming helpers are callable both in the module
+    # body (outside define_method args) and inside define_method blocks
+    # (at instance call-time).
+    extend Stimulus::Naming
+    include Stimulus::Naming
 
     class_methods do
-      # Class methods for generating scoped event names. Returns a symbol
-      # so that the action parser will see it as a Stimulus event.
+      # Symbol so the action parser treats it as a Stimulus event type.
       def stimulus_scoped_event(event)
         :"#{component_name}:#{stimulus_js_name(event)}"
       end
@@ -17,229 +21,95 @@ module Vident
 
       private
 
-      def stimulus_js_name(name)
-        name.to_s.camelize(:lower)
-      end
+      def stimulus_js_name(name) = name.to_s.camelize(:lower)
     end
 
-    # Parse inputs to create a StimulusController instance representing a Stimulus controller attribute
-    #   examples:
-    #   stimulus_controller("my_controller") => StimulusController that converts to {"controller" => "my-controller"}
-    #   stimulus_controller("path/to/controller") => StimulusController that converts to {"controller" => "path--to--controller"}
-    #   stimulus_controller() => StimulusController that uses implied controller name
     def stimulus_controller(*args)
       return args.first if args.length == 1 && args.first.is_a?(StimulusController)
       StimulusController.new(*args, implied_controller: implied_controller_path)
     end
 
-    # Parse inputs to create a StimulusControllerCollection instance representing multiple Stimulus controllers
-    #   examples:
-    #   stimulus_controllers(:my_controller) => StimulusControllerCollection with one controller that converts to {"controller" => "my-controller"}
-    #   stimulus_controllers(:my_controller, "path/to/another") => StimulusControllerCollection with two controllers that converts to {"controller" => "my-controller path--to--another"}
-    def stimulus_controllers(*controllers)
-      return StimulusControllerCollection.new if controllers.empty? || controllers.all?(&:blank?)
-
-      converted_controllers = controllers.map do |controller|
-        controller.is_a?(Array) ? stimulus_controller(*controller) : stimulus_controller(controller)
+    # Plural parsers `stimulus_<kind>s(*args)` — generated from the primitives
+    # registry below. Each accepts: pre-built Value (pass-through), pre-built
+    # Collection (unwrapped; a single one is returned as-is), Array (splatted
+    # into the singular builder), Hash (expanded per-pair for
+    # `hash_expands: true`, single-arg descriptor otherwise), else passed to
+    # the singular builder. Methods defined this way: `stimulus_controllers`,
+    # `stimulus_actions`, `stimulus_targets`, `stimulus_outlets`,
+    # `stimulus_values`, `stimulus_params`, `stimulus_classes`.
+    Stimulus::PRIMITIVES.each do |primitive|
+      define_method(primitive.key) do |*args|
+        collection_class = primitive.collection_class
+        return collection_class.new if args.empty? || args.all?(&:blank?)
+        return args.first if args.length == 1 && args.first.is_a?(collection_class)
+
+        singular = primitive.singular_key
+        converted = []
+        args.each do |arg|
+          case arg
+          when primitive.value_class then converted << arg
+          when collection_class then converted.concat(arg.to_a)
+          when Hash
+            if primitive.keyed?
+              arg.each { |name, val| converted << send(singular, name, val) }
+            else
+              converted << send(singular, arg)
+            end
+          when Array then converted << send(singular, *arg)
+          else converted << send(singular, arg)
+          end
+        end
+        collection_class.new(converted)
       end
-      StimulusControllerCollection.new(converted_controllers)
     end
 
-    # Parse inputs to create a StimulusAction instance representing a Stimulus action attribute
-    #   examples:
-    #   stimulus_action(:my_thing) => StimulusAction that converts to "current_controller#myThing"
-    #   stimulus_action(:click, :my_thing) => StimulusAction that converts to "click->current_controller#myThing"
-    #   stimulus_action("click->current_controller#myThing") => StimulusAction that converts to "click->current_controller#myThing"
-    #   stimulus_action("path/to/current", :my_thing) => StimulusAction that converts to "path--to--current_controller#myThing"
-    #   stimulus_action(:click, "path/to/current", :my_thing) => StimulusAction that converts to "click->path--to--current_controller#myThing"
     def stimulus_action(*args)
       return args.first if args.length == 1 && args.first.is_a?(StimulusAction)
       StimulusAction.new(*args, implied_controller:)
     end
 
-    # Parse inputs to create a StimulusActionCollection instance representing multiple Stimulus actions
-    def stimulus_actions(*actions)
-      return StimulusActionCollection.new if actions.empty? || actions.all?(&:blank?)
-
-      converted_actions = actions.map do |action|
-        action.is_a?(Array) ? stimulus_action(*action) : stimulus_action(action)
-      end
-      StimulusActionCollection.new(converted_actions)
-    end
-
-    # Parse inputs to create a StimulusTarget instance representing a Stimulus target attribute
-    #   examples:
-    #   stimulus_target(:my_target) => StimulusTarget that converts to {"current_controller-target" => "myTarget"}
-    #   stimulus_target("path/to/current", :my_target) => StimulusTarget that converts to {"path--to--current-target" => "myTarget"}
     def stimulus_target(*args)
       return args.first if args.length == 1 && args.first.is_a?(StimulusTarget)
       StimulusTarget.new(*args, implied_controller:)
     end
 
-    # Parse inputs to create a StimulusTargetCollection instance representing multiple Stimulus targets
-    def stimulus_targets(*targets)
-      return StimulusTargetCollection.new if targets.empty? || targets.all?(&:blank?)
-
-      converted_targets = targets.map do |target|
-        target.is_a?(Array) ? stimulus_target(*target) : stimulus_target(target)
-      end
-      StimulusTargetCollection.new(converted_targets)
-    end
-
-    # Parse inputs to create a StimulusOutlet instance representing a Stimulus outlet attribute
-    #   examples:
-    #   stimulus_outlet(:user_status, ".online-user") => StimulusOutlet that converts to {"current_controller-user-status-outlet" => ".online-user"}
-    #   stimulus_outlet("path/to/current", :user_status, ".online-user") => StimulusOutlet that converts to {"path--to--current-user-status-outlet" => ".online-user"}
-    #   stimulus_outlet(:user_status) => StimulusOutlet with auto-generated selector
-    #   stimulus_outlet(component_instance) => StimulusOutlet from component
+    # `component_id: @id` scopes the auto-generated selector to this component
+    # instance (e.g. `#<host-id> [data-controller~=<outlet>]`).
     def stimulus_outlet(*args)
       return args.first if args.length == 1 && args.first.is_a?(StimulusOutlet)
       StimulusOutlet.new(*args, implied_controller:, component_id: @id)
     end
 
-    # Parse inputs to create a StimulusOutletCollection instance representing multiple Stimulus outlets
-    def stimulus_outlets(*outlets)
-      return StimulusOutletCollection.new if outlets.empty? || outlets.all?(&:blank?)
-
-      converted_outlets = []
-      outlets.each do |outlet|
-        if outlet.is_a?(Hash)
-          # Hash format: {name: selector, other_name: other_selector} - expands to multiple outlets
-          outlet.each { |name, selector| converted_outlets << stimulus_outlet(name, selector) }
-        elsif outlet.is_a?(Array)
-          # Array format: [name, selector] - splat into stimulus_outlet
-          converted_outlets << stimulus_outlet(*outlet)
-        else
-          converted_outlets << stimulus_outlet(outlet)
-        end
-      end
-      StimulusOutletCollection.new(converted_outlets)
-    end
-
-    # Parse inputs to create a StimulusValue instance representing a Stimulus value attribute
-    #   examples:
-    #   stimulus_value(:url, "https://example.com") => StimulusValue that converts to {"current_controller-url-value" => "https://example.com"}
-    #   stimulus_value("path/to/current", :url, "https://example.com") => StimulusValue that converts to {"path--to--current-url-value" => "https://example.com"}
     def stimulus_value(*args)
       return args.first if args.length == 1 && args.first.is_a?(StimulusValue)
       StimulusValue.new(*args, implied_controller:)
     end
 
-    # Parse inputs to create a StimulusValueCollection instance representing multiple Stimulus values
-    def stimulus_values(*values)
-      return StimulusValueCollection.new if values.empty? || values.all?(&:blank?)
-
-      converted_values = []
-
-      values.each do |value|
-        if value.is_a?(Hash)
-          # Hash format: {name: value, other_name: other_value} - expands to multiple values
-          value.each { |name, val| converted_values << stimulus_value(name, val) }
-        elsif value.is_a?(Array)
-          # Array format: [controller, name, value] or [name, value] - splat into stimulus_value
-          converted_values << stimulus_value(*value)
-        else
-          converted_values << stimulus_value(value)
-        end
-      end
-
-      StimulusValueCollection.new(converted_values)
+    def stimulus_param(*args)
+      return args.first if args.length == 1 && args.first.is_a?(StimulusParam)
+      StimulusParam.new(*args, implied_controller:)
     end
 
-    # Parse inputs to create a StimulusClass instance representing a Stimulus class attribute
-    #   examples:
-    #   stimulus_class(:loading, "spinner active") => StimulusClass that converts to {"current_controller-loading-class" => "spinner active"}
-    #   stimulus_class("path/to/current", :loading, ["spinner", "active"]) => StimulusClass that converts to {"path--to--current-loading-class" => "spinner active"}
     def stimulus_class(*args)
       return args.first if args.length == 1 && args.first.is_a?(StimulusClass)
       StimulusClass.new(*args, implied_controller:)
     end
 
-    # Parse inputs to create a StimulusClassCollection instance representing multiple Stimulus classes
-    def stimulus_classes(*classes)
-      return StimulusClassCollection.new if classes.empty? || classes.all?(&:blank?)
-
-      converted_classes = []
-
-      classes.each do |cls|
-        if cls.is_a?(Hash)
-          # Hash format: {loading: "spinner active", error: "text-red-500"} - expands to multiple classes
-          cls.each { |name, class_list| converted_classes << stimulus_class(name, class_list) }
-        elsif cls.is_a?(Array)
-          # Array format: [controller, name, classes] or [name, classes] - splat into stimulus_class
-          converted_classes << stimulus_class(*cls)
-        else
-          converted_classes << stimulus_class(cls)
-        end
-      end
-
-      StimulusClassCollection.new(converted_classes)
-    end
-
-    # Methods to add to the stimulus collections
-
-    def add_stimulus_controllers(controllers)
-      s_controllers = stimulus_controllers(*Array.wrap(controllers))
-      @stimulus_controllers_collection = if @stimulus_controllers_collection
-        @stimulus_controllers_collection.merge(s_controllers)
-      else
-        s_controllers
-      end
-    end
-
-    def add_stimulus_actions(actions)
-      s_actions = stimulus_actions(*Array.wrap(actions))
-      @stimulus_actions_collection = if @stimulus_actions_collection
-        @stimulus_actions_collection.merge(s_actions)
-      else
-        s_actions
+    # Mutators `add_stimulus_<kind>s` — build from input, merge into the
+    # per-kind collection ivar. Methods defined: `add_stimulus_controllers`,
+    # `add_stimulus_actions`, `add_stimulus_targets`, `add_stimulus_outlets`,
+    # `add_stimulus_values`, `add_stimulus_params`, `add_stimulus_classes`.
+    Stimulus::PRIMITIVES.each do |primitive|
+      define_method(mutator_method(primitive)) do |input|
+        added = send(primitive.key, *Array.wrap(input))
+        existing = instance_variable_get(collection_ivar(primitive))
+        instance_variable_set(collection_ivar(primitive), existing ? existing.merge(added) : added)
       end
     end
 
-    def add_stimulus_targets(targets)
-      s_targets = stimulus_targets(*Array.wrap(targets))
-      @stimulus_targets_collection = if @stimulus_targets_collection
-        @stimulus_targets_collection.merge(s_targets)
-      else
-        s_targets
-      end
-    end
+    def stimulus_scoped_event(event) = self.class.stimulus_scoped_event(event)
 
-    def add_stimulus_outlets(outlets)
-      s_outlets = stimulus_outlets(*Array.wrap(outlets))
-      @stimulus_outlets_collection = if @stimulus_outlets_collection
-        @stimulus_outlets_collection.merge(s_outlets)
-      else
-        s_outlets
-      end
-    end
-
-    def add_stimulus_values(values)
-      s_values = stimulus_values(values)
-      @stimulus_values_collection = if @stimulus_values_collection
-        @stimulus_values_collection.merge(s_values)
-      else
-        s_values
-      end
-    end
-
-    def add_stimulus_classes(named_classes)
-      classes = stimulus_classes(named_classes)
-      @stimulus_classes_collection = if @stimulus_classes_collection
-        @stimulus_classes_collection.merge(classes)
-      else
-        classes
-      end
-    end
-
-    # Stimulus events name for this component
-    def stimulus_scoped_event(event)
-      self.class.stimulus_scoped_event(event)
-    end
-
-    def stimulus_scoped_event_on_window(event)
-      self.class.stimulus_scoped_event_on_window(event)
-    end
+    def stimulus_scoped_event_on_window(event) = self.class.stimulus_scoped_event_on_window(event)
 
     private
 
@@ -247,7 +117,8 @@ module Vident
       StimulusController.new(implied_controller: implied_controller_path)
     end
 
-    # When using the DSL if you dont specify, the first controller is implied
+    # The first registered controller path becomes the implied controller for
+    # unqualified DSL entries (e.g. `actions :click` → `implied#click`).
     def implied_controller_path
       return @implied_controller_path if defined?(@implied_controller_path)
       path = Array.wrap(@stimulus_controllers).first

data/lib/vident/stimulus_builder.rb

@@ -2,139 +2,118 @@
 
 module Vident
   class StimulusBuilder
+    # Primitives the DSL block tracks. Controllers are set via the component's
+    # `stimulus_controllers:` prop, not the DSL, so they're skipped here.
+    # Storage shape per primitive is an Array for positional kinds (actions,
+    # targets) and a Hash for keyed kinds (values, params, classes, outlets).
+    DSL_PRIMITIVES = Stimulus::PRIMITIVES.reject { |primitive| primitive.name == :controllers }.freeze
+
     def initialize
-      @actions = []
-      @targets = []
-      @values = {}
+      @entries = DSL_PRIMITIVES.to_h { |primitive| [primitive.name, primitive.keyed? ? {} : []] }
       @values_from_props = []
-      @classes = {}
-      @outlets = {}
     end
 
-    def merge_with(other_builder)
-      @actions.concat(other_builder.actions_list)
-      @targets.concat(other_builder.targets_list)
-      @values.merge!(other_builder.values_hash)
-      @values_from_props.concat(other_builder.values_from_props_list)
-      @classes.merge!(other_builder.classes_hash)
-      @outlets.merge!(other_builder.outlets_hash)
+    def merge_with(other)
+      DSL_PRIMITIVES.each do |primitive|
+        mine = @entries[primitive.name]
+        theirs = other.entries_for(primitive.name)
+        primitive.keyed? ? mine.merge!(theirs) : mine.concat(theirs)
+      end
+      @values_from_props.concat(other.values_from_props_list)
+      self
+    end
+
+    def actions(*names)
+      @entries[:actions].concat(names)
       self
     end
 
-    def actions(*action_names)
-      @actions.concat(action_names)
+    def targets(*names)
+      @entries[:targets].concat(names)
       self
     end
 
-    def targets(*target_names)
-      @targets.concat(target_names)
+    def values(**hash)
+      @entries[:values].merge!(hash) unless hash.empty?
       self
     end
 
-    def values(**value_hash)
-      @values.merge!(value_hash) unless value_hash.empty?
+    def params(**hash)
+      @entries[:params].merge!(hash) unless hash.empty?
       self
     end
 
-    def values_from_props(*prop_names)
-      @values_from_props.concat(prop_names)
+    def classes(**hash)
+      @entries[:classes].merge!(hash) unless hash.empty?
       self
     end
 
-    def classes(**class_mappings)
-      @classes.merge!(class_mappings)
+    def values_from_props(*names)
+      @values_from_props.concat(names)
       self
     end
 
-    def outlets(positional = nil, **outlet_mappings)
-      @outlets.merge!(positional) if positional.is_a?(Hash)
-      @outlets.merge!(outlet_mappings) unless outlet_mappings.empty?
+    # `outlets({"admin--users" => ".sel"})` accepts a positional Hash for
+    # identifiers that can't be Ruby kwarg keys (contain `--`).
+    def outlets(positional = nil, **hash)
+      bucket = @entries[:outlets]
+      bucket.merge!(positional) if positional.is_a?(Hash)
+      bucket.merge!(hash) unless hash.empty?
       self
     end
 
     def to_attributes(component_instance)
       attrs = {}
-      attrs[:stimulus_actions] = resolve_attributes_filtering_nil(@actions, component_instance) unless @actions.empty?
-      attrs[:stimulus_targets] = resolve_attributes_filtering_nil(@targets, component_instance) unless @targets.empty?
-      attrs[:stimulus_values] = resolve_hash_values_allowing_nil(@values, component_instance) unless @values.empty?
+      DSL_PRIMITIVES.each do |primitive|
+        entries = @entries[primitive.name]
+        next if entries.empty?
+        attrs[primitive.key] = resolve_entries(primitive, entries, component_instance)
+      end
       attrs[:stimulus_values_from_props] = @values_from_props.dup unless @values_from_props.empty?
-      attrs[:stimulus_classes] = resolve_hash_classes_filtering_nil(@classes, component_instance) unless @classes.empty?
-      attrs[:stimulus_outlets] = @outlets.dup unless @outlets.empty?
       attrs
     end
 
-    def to_hash(component_instance)
-      to_attributes(component_instance)
-    end
+    def to_hash(component_instance) = to_attributes(component_instance)
     alias_method :to_h, :to_hash
 
     protected
 
-    def actions_list
-      @actions
-    end
-
-    def targets_list
-      @targets
-    end
-
-    def values_hash
-      @values
-    end
-
-    def values_from_props_list
-      @values_from_props
-    end
-
-    def classes_hash
-      @classes
-    end
+    def entries_for(name) = @entries[name]
 
-    def outlets_hash
-      @outlets
-    end
+    def values_from_props_list = @values_from_props
 
     private
 
-    # For actions, targets - filter out nil values from procs AND static
-    def resolve_attributes_filtering_nil(array, component_instance)
-      result = []
-      array.each do |value|
-        if callable?(value)
-          resolved_value = component_instance.instance_exec(&value)
-          # Exclude nil from procs (nil is not valid for actions/targets)
-          result << resolved_value unless resolved_value.nil?
-        else
-          # Exclude static nil values (nil is not valid for actions/targets)
-          result << value unless value.nil?
-        end
+    # Outlets don't support procs — static merge only. The other keyed kinds
+    # and the positional (Array-shaped) kinds resolve procs in the component
+    # instance and drop nil results.
+    def resolve_entries(primitive, entries, component_instance)
+      return entries.dup if primitive.name == :outlets
+
+      if primitive.keyed?
+        resolve_hash_filtering_nil(entries, component_instance)
+      else
+        resolve_array_filtering_nil(entries, component_instance)
       end
-      result
     end
 
-    # For values - allow nil values from procs and static (will become "null" in JavaScript)
-    def resolve_hash_values_allowing_nil(hash, component_instance)
-      hash.transform_values { |value| callable?(value) ? component_instance.instance_exec(&value) : value }
+    def resolve_array_filtering_nil(array, component_instance)
+      array.each_with_object([]) do |value, out|
+        resolved = callable?(value) ? component_instance.instance_exec(&value) : value
+        out << resolved unless resolved.nil?
+      end
     end
 
-    # For classes - filter out nil values from procs AND static
-    def resolve_hash_classes_filtering_nil(hash, component_instance)
-      result = {}
-      hash.each do |key, value|
-        if callable?(value)
-          resolved_value = component_instance.instance_exec(&value)
-          # Exclude nil from procs (nil is not valid for classes)
-          result[key] = resolved_value unless resolved_value.nil?
-        else
-          # Exclude static nil values (nil is not valid for classes)
-          result[key] = value unless value.nil?
-        end
+    # Dropping nil matters because Stimulus's Boolean value parser reads an
+    # empty data attribute as `true` — so `-> { flag? || nil }` would silently
+    # flip a Boolean value on. Omitting the entry keeps the attribute off.
+    def resolve_hash_filtering_nil(hash, component_instance)
+      hash.each_with_object({}) do |(key, value), out|
+        resolved = callable?(value) ? component_instance.instance_exec(&value) : value
+        out[key] = resolved unless resolved.nil?
       end
-      result
     end
 
-    def callable?(value)
-      value.respond_to?(:call)
-    end
+    def callable?(value) = value.respond_to?(:call)
   end
 end

data/lib/vident/stimulus_class.rb

@@ -4,17 +4,11 @@ module Vident
   class StimulusClass < StimulusAttributeBase
     attr_reader :controller, :class_name, :css_classes
 
-    def to_s
-      @css_classes.join(" ")
-    end
+    def to_s = @css_classes.join(" ")
 
-    def data_attribute_name
-      "#{@controller}-#{@class_name}-class"
-    end
+    def data_attribute_name = "#{@controller}-#{@class_name}-class"
 
-    def data_attribute_value
-      to_s
-    end
+    def data_attribute_value = to_s
 
     private
 

data/lib/vident/stimulus_class_collection.rb

@@ -5,11 +5,7 @@ module Vident
     def to_h
       return {} if items.empty?
 
-      merged = {}
-      items.each do |css_class|
-        merged.merge!(css_class.to_h)
-      end
-      merged
+      items.each_with_object({}) { |css_class, merged| merged.merge!(css_class.to_h) }
     end
   end
 end

data/lib/vident/stimulus_collection_base.rb

@@ -15,21 +15,13 @@ module Vident
       raise NoMethodError, "Subclasses must implement to_h"
     end
 
-    def to_a
-      @items.dup
-    end
+    def to_a = @items.dup
 
-    def to_hash
-      to_h
-    end
+    def to_hash = to_h
 
-    def empty?
-      @items.empty?
-    end
+    def empty? = @items.empty?
 
-    def any?
-      !empty?
-    end
+    def any? = !empty?
 
     def merge(*other_collections)
       merged = self.class.new

data/lib/vident/stimulus_component.rb

@@ -6,10 +6,10 @@ module Vident
 
     include StimulusAttributes
 
-    # Module utilities for working with Stimulus identifiers
-
+    # Thin back-compat alias; see `Vident::StimulusAttributeBase.stimulize_path`
+    # for the canonical implementation.
     def stimulus_identifier_from_path(path)
-      path.split("/").map { |p| p.to_s.dasherize }.join("--")
+      StimulusAttributeBase.stimulize_path(path)
     end
     module_function :stimulus_identifier_from_path
 
@@ -26,7 +26,7 @@ module Vident
       def stimulus_identifier_path = name&.underscore || "anonymous_component"
 
       # Stimulus controller identifier
-      def stimulus_identifier = ::Vident::StimulusComponent.stimulus_identifier_from_path(stimulus_identifier_path)
+      def stimulus_identifier = StimulusComponent.stimulus_identifier_from_path(stimulus_identifier_path)
 
       # The "name" of the component from its class name and namespace. This is used to generate an HTML class name
       # that can helps identify the component type in the DOM or for styling purposes.
@@ -48,12 +48,13 @@ module Vident
           []
         end
       end
-      prop :stimulus_actions, _Array(_Union(String, Symbol, Array, Hash, StimulusAction, StimulusActionCollection)), default: -> { [] }
+      prop :stimulus_actions, _Array(_Union(String, Symbol, Array, Hash, StimulusAction, StimulusAction::Descriptor, StimulusActionCollection)), default: -> { [] }
       prop :stimulus_targets, _Array(_Union(String, Symbol, Array, Hash, StimulusTarget, StimulusTargetCollection)), default: -> { [] }
       prop :stimulus_outlets, _Array(_Union(String, Symbol, StimulusOutlet, StimulusOutletCollection)), default: -> { [] }
       prop :stimulus_outlet_host, _Nilable(Vident::Component) # A component that will host this component as an outlet
-      prop :stimulus_values, _Union(_Hash(Symbol, _Any), StimulusValue, StimulusValueCollection), default: -> { {} } # TODO: instead of _Any, is it _Interface(:to_s)?
-      prop :stimulus_classes, _Union(_Hash(Symbol, String), StimulusClass, StimulusClassCollection), default: -> { {} }
+      prop :stimulus_values, _Union(_Hash(Symbol, _Any), Array, StimulusValue, StimulusValueCollection), default: -> { {} } # TODO: instead of _Any, is it _Interface(:to_s)?
+      prop :stimulus_params, _Union(_Hash(Symbol, _Any), Array, StimulusParam, StimulusParamCollection), default: -> { {} }
+      prop :stimulus_classes, _Union(_Hash(Symbol, String), Array, StimulusClass, StimulusClassCollection), default: -> { {} }
     end
 
     # If connecting an outlet to this specific component instance, use this ID

data/lib/vident/stimulus_controller.rb

@@ -4,38 +4,35 @@ module Vident
   class StimulusController < StimulusAttributeBase
     attr_reader :path, :name
 
-    def to_s
-      name
-    end
+    def to_s = name
 
-    def data_attribute_name
-      "controller"
-    end
+    def data_attribute_name = "controller"
 
-    def data_attribute_value
-      name
-    end
+    def data_attribute_value = name
 
     private
 
+    # `@implied_controller` on this class is a raw path String (not a
+    # StimulusController instance as on the base), so the base class's
+    # `.path` / `.name` accessors don't apply and we override.
     def implied_controller_path
+      raise ArgumentError, "implied_controller is required to get implied controller path" unless @implied_controller
       @implied_controller
     end
 
     def implied_controller_name
+      raise ArgumentError, "implied_controller is required to get implied controller name" unless @implied_controller
       stimulize_path(@implied_controller)
     end
 
     def parse_arguments(*args)
       case args.size
       when 0
-        # No arguments: use implied controller path
         @path = implied_controller_path
         @name = implied_controller_name
       when 1
-        # Single argument: controller path
-        @path = args[0]
-        @name = stimulize_path(args[0])
+        @path = args[0].to_s
+        @name = stimulize_path(@path)
       else
         raise ArgumentError, "Invalid number of arguments: #{args.size}. Expected 0 or 1 argument."
       end