vident 0.13.0 → 1.0.0.alpha1

data/lib/vident/stimulus_data_attribute_builder.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Vident
+  # Builds a hash of Stimulus data attributes from collections of stimulus objects
+  # Handles merging multiple actions, targets, outlets, values, and classes
+  # into the final data-* attributes needed for HTML elements
+  class StimulusDataAttributeBuilder
+    def initialize(controllers: [], actions: [], targets: [], outlets: [], values: [], classes: [])
+      @controllers = Array(controllers)
+      @actions = Array(actions)
+      @targets = Array(targets)
+      @outlets = Array(outlets)
+      @values = Array(values)
+      @classes = Array(classes)
+    end
+
+    # Build the final data attributes hash
+    def build
+      {
+        **merged_controllers,
+        **merged_actions,
+        **merged_targets,
+        **merged_outlets,
+        **merged_values,
+        **merged_classes
+      }.transform_keys(&:to_s).compact
+    end
+
+    private
+
+    def merged_controllers
+      return {} if @controllers.empty?
+
+      if @controllers.first.is_a?(StimulusControllerCollection)
+        StimulusControllerCollection.merge(*@controllers).to_h
+      else
+        StimulusControllerCollection.new(@controllers).to_h
+      end
+    end
+
+    def merged_actions
+      return {} if @actions.empty?
+
+      if @actions.first.is_a?(StimulusActionCollection)
+        StimulusActionCollection.merge(*@actions).to_h
+      else
+        StimulusActionCollection.new(@actions).to_h
+      end
+    end
+
+    def merged_targets
+      return {} if @targets.empty?
+
+      if @targets.first.is_a?(StimulusTargetCollection)
+        StimulusTargetCollection.merge(*@targets).to_h
+      else
+        StimulusTargetCollection.new(@targets).to_h
+      end
+    end
+
+    def merged_outlets
+      return {} if @outlets.empty?
+
+      if @outlets.first.is_a?(StimulusOutletCollection)
+        StimulusOutletCollection.merge(*@outlets).to_h
+      else
+        StimulusOutletCollection.new(@outlets).to_h
+      end
+    end
+
+    def merged_values
+      return {} if @values.empty?
+
+      if @values.first.is_a?(StimulusValueCollection)
+        StimulusValueCollection.merge(*@values).to_h
+      else
+        StimulusValueCollection.new(@values).to_h
+      end
+    end
+
+    def merged_classes
+      return {} if @classes.empty?
+
+      if @classes.first.is_a?(StimulusClassCollection)
+        StimulusClassCollection.merge(*@classes).to_h
+      else
+        StimulusClassCollection.new(@classes).to_h
+      end
+    end
+  end
+end

data/lib/vident/stimulus_dsl.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Vident
+  module StimulusDSL
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def stimulus(&block)
+        # Initialize stimulus builder if not already present
+        if @stimulus_builder.nil?
+          @stimulus_builder = StimulusBuilder.new
+          @inheritance_merged = false
+        end
+        
+        # Ensure inheritance is applied
+        ensure_inheritance_merged
+        
+        # Execute the new block to add/merge new attributes
+        @stimulus_builder.instance_eval(&block)
+      end
+
+      def stimulus_dsl_attributes(component_instance)
+        # If no stimulus blocks have been defined on this class, check parent
+        if @stimulus_builder.nil? && superclass.respond_to?(:stimulus_dsl_attributes)
+          return superclass.stimulus_dsl_attributes(component_instance)
+        end
+        
+        # Ensure inheritance is applied at access time
+        ensure_inheritance_merged
+        
+        @stimulus_builder&.to_attributes(component_instance) || {}
+      end
+
+      private
+
+      def ensure_inheritance_merged
+        return if @inheritance_merged || @stimulus_builder.nil?
+        
+        if superclass.respond_to?(:stimulus_dsl_builder, true)
+          parent_builder = superclass.send(:stimulus_dsl_builder)
+          if parent_builder
+            @stimulus_builder.merge_with(parent_builder)
+          end
+        end
+        @inheritance_merged = true
+      end
+
+      protected
+
+      def stimulus_dsl_builder
+        @stimulus_builder
+      end
+    end
+
+    # Instance method to get DSL attributes for this component instance
+    def stimulus_dsl_attributes
+      self.class.stimulus_dsl_attributes(self)
+    end
+
+    # Instance method to resolve prop-mapped values at runtime
+    def resolve_values_from_props(prop_names)
+      return {} if prop_names.empty?
+
+      resolved = {}
+      prop_names.each do |name|
+        # Map from instance variable if it exists
+        if instance_variable_defined?("@#{name}")
+          resolved[name] = instance_variable_get("@#{name}")
+        end
+      end
+      resolved
+    end
+  end
+end

data/lib/vident/stimulus_outlet.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Vident
+  class StimulusOutlet < StimulusAttributeBase
+    attr_reader :controller, :outlet_name, :selector
+
+    def initialize(*args, implied_controller:, component_id: nil)
+      @component_id = component_id
+      super(*args, implied_controller: implied_controller)
+    end
+
+    def to_s
+      @selector
+    end
+
+    def data_attribute_name
+      "#{@controller}-#{@outlet_name}-outlet"
+    end
+
+    def data_attribute_value
+      @selector
+    end
+
+    private
+
+    def parse_arguments(*args)
+      case args.size
+      when 1
+        parse_single_argument(args[0])
+      when 2
+        parse_two_arguments(args[0], args[1])
+      when 3
+        parse_three_arguments(args[0], args[1], args[2])
+      else
+        raise ArgumentError, "Invalid number of arguments: #{args.size}"
+      end
+    end
+
+    def parse_single_argument(arg)
+      @controller = implied_controller_name
+      if arg.is_a?(Symbol)
+        # Single symbol: outlet name on implied controller with auto-generated selector
+        outlet_identifier = arg.to_s.dasherize
+        @outlet_name = outlet_identifier
+        @selector = build_outlet_selector(outlet_identifier)
+      elsif arg.is_a?(String)
+        # Single string: outlet identifier with auto-generated selector
+        @outlet_name = arg.dasherize
+        @selector = build_outlet_selector(arg)
+      elsif arg.is_a?(Array) && arg.size == 2
+        # Array format: [outlet_identifier, css_selector]
+        @outlet_name = arg[0].to_s.dasherize
+        @selector = arg[1]
+      elsif arg.respond_to?(:stimulus_identifier)
+        # Component with stimulus_identifier
+        identifier = arg.stimulus_identifier
+        @outlet_name = identifier
+        @selector = build_outlet_selector(identifier)
+      elsif arg.respond_to?(:implied_controller_name)
+        # RootComponent with implied_controller_name
+        identifier = arg.implied_controller_name
+        @outlet_name = identifier
+        @selector = build_outlet_selector(identifier)
+      else
+        raise ArgumentError, "Invalid argument type: #{arg.class}"
+      end
+    end
+
+    def parse_two_arguments(arg1, arg2)
+      if arg1.is_a?(Symbol) && arg2.is_a?(String)
+        # outlet name on implied controller + custom selector
+        @controller = implied_controller_name
+        @outlet_name = arg1.to_s.dasherize
+        @selector = arg2
+      else
+        raise ArgumentError, "Invalid argument types: #{arg1.class}, #{arg2.class}"
+      end
+    end
+
+    def parse_three_arguments(controller, outlet_name, selector)
+      if controller.is_a?(String) && outlet_name.is_a?(Symbol) && selector.is_a?(String)
+        # controller path + outlet name + selector
+        @controller = stimulize_path(controller)
+        @outlet_name = outlet_name.to_s.dasherize
+        @selector = selector
+      else
+        raise ArgumentError, "Invalid argument types: #{controller.class}, #{outlet_name.class}, #{selector.class}"
+      end
+    end
+
+    # Build outlet selector following the same pattern as RootComponent
+    def build_outlet_selector(outlet_selector)
+      prefix = @component_id ? "##{@component_id} " : ""
+      "#{prefix}[data-controller~=#{outlet_selector}]"
+    end
+  end
+end

data/lib/vident/stimulus_outlet_collection.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Vident
+  class StimulusOutletCollection < StimulusCollectionBase
+    def to_h
+      return {} if items.empty?
+
+      merged = {}
+      items.each do |outlet|
+        merged.merge!(outlet.to_h)
+      end
+      merged
+    end
+  end
+end

data/lib/vident/stimulus_target.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Vident
+  class StimulusTarget < StimulusAttributeBase
+    attr_reader :controller, :name
+
+    def to_s
+      @name
+    end
+
+    # Returns the data attribute name for this target
+    def data_attribute_name
+      "#{@controller}-target"
+    end
+
+    # Returns the target name value for the data attribute
+    def data_attribute_value
+      @name
+    end
+
+    private
+
+    def parse_arguments(*args)
+      case args.size
+      when 1
+        parse_single_argument(args[0])
+      when 2
+        parse_two_arguments(args[0], args[1])
+      else
+        raise ArgumentError, "Invalid number of arguments: #{args.size}"
+      end
+    end
+
+    def parse_single_argument(arg)
+      @controller = implied_controller_name
+      if arg.is_a?(Symbol)
+        # 1 symbol arg, name of target on implied controller
+        @name = js_name(arg)
+      elsif arg.is_a?(String)
+        # 1 string arg, assume it's a target name on implied controller
+        @name = arg
+      else
+        raise ArgumentError, "Invalid argument type: #{arg.class}"
+      end
+    end
+
+    def parse_two_arguments(part1, part2)
+      if part1.is_a?(String) && part2.is_a?(Symbol)
+        # 1 string arg, 1 symbol = controller + target
+        @controller = stimulize_path(part1)
+        @name = js_name(part2)
+      else
+        raise ArgumentError, "Invalid argument types: #{part1.class}, #{part2.class}"
+      end
+    end
+  end
+end

data/lib/vident/stimulus_target_collection.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Vident
+  class StimulusTargetCollection < StimulusCollectionBase
+    def to_h
+      return {} if items.empty?
+
+      merged = {}
+      items.each do |target|
+        target.to_h.each do |key, value|
+          merged[key] = if merged.key?(key)
+            # Merge space-separated values for same target attribute
+            "#{merged[key]} #{value}"
+          else
+            value
+          end
+        end
+      end
+      merged
+    end
+  end
+end

data/lib/vident/stimulus_value.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vident
+  class StimulusValue < StimulusAttributeBase
+    attr_reader :controller, :value_name, :value
+
+    def to_s
+      @value.to_s
+    end
+
+    def data_attribute_name
+      "#{@controller}-#{@value_name}-value"
+    end
+
+    def data_attribute_value
+      @value
+    end
+
+    private
+
+    def parse_arguments(*args)
+      case args.size
+      when 2
+        parse_two_arguments(args[0], args[1])
+      when 3
+        parse_three_arguments(args[0], args[1], args[2])
+      else
+        raise ArgumentError, "Invalid number of arguments: #{args.size} (#{args.inspect}). Did you pass an array of hashes?"
+      end
+    end
+
+    def parse_two_arguments(value_name, value)
+      if value_name.is_a?(Symbol)
+        # value name on implied controller + value
+        @controller = implied_controller_name
+        @value_name = value_name.to_s.dasherize
+        @value = serialize_value(value)
+      else
+        raise ArgumentError, "Invalid argument types: #{value_name.class}, #{value.class}"
+      end
+    end
+
+    def parse_three_arguments(controller, value_name, value)
+      if controller.is_a?(String) && value_name.is_a?(Symbol)
+        # controller + value name + value
+        @controller = stimulize_path(controller)
+        @value_name = value_name.to_s.dasherize
+        @value = serialize_value(value)
+      else
+        raise ArgumentError, "Invalid argument types: #{controller.class}, #{value_name.class}, #{value.class}"
+      end
+    end
+
+    def serialize_value(value)
+      case value
+      when Array, Hash
+        value.to_json
+      when TrueClass, FalseClass
+        value.to_s
+      when Numeric
+        value.to_s
+      else
+        value.to_s
+      end
+    end
+  end
+end

data/lib/vident/stimulus_value_collection.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Vident
+  class StimulusValueCollection < StimulusCollectionBase
+    def to_h
+      return {} if items.empty?
+
+      merged = {}
+      items.each do |value|
+        merged.merge!(value.to_h)
+      end
+      merged
+    end
+  end
+end

data/lib/vident/tag_helper.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Vident
+  module TagHelper
+    # Generate a tag with the given name and options, including stimulus data attributes
+    def tag(
+      tag_name,
+      stimulus_controllers: nil,
+      stimulus_targets: nil,
+      stimulus_actions: nil,
+      stimulus_outlets: nil,
+      stimulus_values: nil,
+      stimulus_classes: nil,
+      stimulus_controller: nil,
+      stimulus_target: nil,
+      stimulus_action: nil,
+      stimulus_outlet: nil,
+      stimulus_value: nil,
+      stimulus_class: nil,
+      **options,
+      &block
+    )
+      # Ensure the plural attributes are actually enumerables
+      tag_attribute_must_be_collection!(stimulus_controllers, "stimulus_controllers")
+      tag_attribute_must_be_collection!(stimulus_targets, "stimulus_targets")
+      tag_attribute_must_be_collection!(stimulus_actions, "stimulus_actions")
+      tag_attribute_must_be_collection!(stimulus_outlets, "stimulus_outlets")
+      tag_attribute_must_be_collection!(stimulus_values, "stimulus_values")
+      tag_attribute_must_be_collection!(stimulus_classes, "stimulus_classes")
+
+      stimulus_controllers_collection = send(:stimulus_controllers, *tag_wrap_single_stimulus_attribute(stimulus_controllers, stimulus_controller))
+      stimulus_targets_collection = send(:stimulus_targets, *tag_wrap_single_stimulus_attribute(stimulus_targets, stimulus_target))
+      stimulus_actions_collection = send(:stimulus_actions, *tag_wrap_single_stimulus_attribute(stimulus_actions, stimulus_action))
+      stimulus_outlets_collection = send(:stimulus_outlets, *tag_wrap_single_stimulus_attribute(stimulus_outlets, stimulus_outlet))
+      stimulus_values_collection = send(:stimulus_values, stimulus_values || stimulus_value)
+      stimulus_classes_collection = send(:stimulus_classes, stimulus_classes || stimulus_class)
+
+      stimulus_data_attributes = StimulusDataAttributeBuilder.new(
+        controllers: stimulus_controllers_collection,
+        actions: stimulus_actions_collection,
+        targets: stimulus_targets_collection,
+        outlets: stimulus_outlets_collection,
+        values: stimulus_values_collection,
+        classes: stimulus_classes_collection
+      ).build
+      generate_tag(tag_name, stimulus_data_attributes, options, &block)
+    end
+
+    private
+
+    def tag_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 tag_wrap_single_stimulus_attribute(plural, singular)
+      plural || (singular ? Array.wrap(singular) : nil)
+    end
+
+    def generate_tag(tag_name, stimulus_data_attributes, options, &block)
+      raise NoMethodError, "Not implemented"
+    end
+  end
+end

data/lib/vident/tailwind.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Vident
+  # Adds Tailwind CSS class merging functionality to components
+  # This module provides methods to create and manage TailwindMerge::Merger instances
+  module Tailwind
+    # Get or create a thread-safe Tailwind merger instance
+    def tailwind_merger
+      return unless tailwind_merge_available?
+
+      return @tailwind_merger if defined?(@tailwind_merger)
+
+      @tailwind_merger = Thread.current[:vident_tailwind_merger] ||= ::TailwindMerge::Merger.new
+    end
+
+    # Check if TailwindMerge gem is available
+    def tailwind_merge_available?
+      defined?(::TailwindMerge::Merger) && ::TailwindMerge::Merger.respond_to?(:new)
+    rescue NameError
+      false
+    end
+  end
+end

data/lib/vident/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Vident
-  VERSION = "0.13.0"
+  VERSION = "1.0.0.alpha1"
 
   # Shared version for all vident gems
   def self.version

data/lib/vident.rb

@@ -1,12 +1,53 @@
 # frozen_string_literal: true
 
+if ENV["COVERAGE"]
+  require "simplecov"
+  SimpleCov.command_name "Vident"
+  SimpleCov.root File.expand_path("..", __dir__)
+  SimpleCov.start do
+    add_filter "/test/"
+    add_filter "/tmp/"
+    add_filter "/bin/"
+    add_filter "/lib/vident/engine.rb"
+  end
+end
+
 require "active_support"
 require "active_support/concern"
+require "literal"
+
 require "vident/version"
-require "vident/base"
+require "vident/tailwind"
+
+require "vident/stimulus_attribute_base"
+require "vident/stimulus_controller"
+require "vident/stimulus_action"
+require "vident/stimulus_target"
+require "vident/stimulus_outlet"
+require "vident/stimulus_value"
+require "vident/stimulus_class"
+
+require "vident/stimulus_collection_base"
+require "vident/stimulus_controller_collection"
+require "vident/stimulus_action_collection"
+require "vident/stimulus_target_collection"
+require "vident/stimulus_outlet_collection"
+require "vident/stimulus_value_collection"
+require "vident/stimulus_class_collection"
+
+require "vident/stimulus_attributes"
+require "vident/stimulus_data_attribute_builder"
+
+require "vident/tag_helper"
 require "vident/stable_id"
-require "vident/attributes/not_typed"
-require "vident/root_component"
+require "vident/class_list_builder"
+
+require "vident/stimulus_component"
+require "vident/component_class_lists"
+require "vident/component_attribute_resolver"
+require "vident/stimulus_builder"
+require "vident/stimulus_dsl"
+
 require "vident/component"
 
 require "vident/engine" if defined?(Rails)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: vident
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 1.0.0.alpha1
 platform: ruby
 authors:
 - Stephen Ierodiaconou
 bindir: bin
 cert_chain: []
-date: 2025-04-07 00:00:00.000000000 Z
+date: 2025-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -49,6 +49,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '9'
+- !ruby/object:Gem::Dependency
+  name: literal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
 description: Vident makes using Stimulus with your `ViewComponent` or `Phlex` view
   components as easy as writing Ruby. Vident is the base of your design system implementation,
   which provides helpers for working with Stimulus. For component libraries with ViewComponent
@@ -63,13 +83,34 @@ files:
 - LICENSE.txt
 - README.md
 - lib/vident.rb
-- lib/vident/attributes/not_typed.rb
-- lib/vident/base.rb
 - lib/vident/caching.rb
+- lib/vident/class_list_builder.rb
 - lib/vident/component.rb
+- lib/vident/component_attribute_resolver.rb
+- lib/vident/component_class_lists.rb
 - lib/vident/engine.rb
-- lib/vident/root_component.rb
 - lib/vident/stable_id.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_dsl.rb
+- lib/vident/stimulus_outlet.rb
+- lib/vident/stimulus_outlet_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/tag_helper.rb
+- lib/vident/tailwind.rb
 - lib/vident/version.rb
 homepage: https://github.com/stevegeek/vident
 licenses:
@@ -85,7 +126,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="