vident 0.13.1 → 1.0.0.alpha1

data/lib/vident/attributes/not_typed.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  module Attributes
-    module NotTyped
-      extend ActiveSupport::Concern
-
-      def attributes
-        @__attributes ||= {}
-      end
-
-      def prepare_attributes(attributes)
-        @__attributes ||= {}
-        attribute_names.each do |attr_name|
-          options = self.class.attribute_options
-          default = options&.dig(attr_name, :default)
-          allow_nil = options[attr_name] ? options[attr_name].fetch(:allow_nil, true) : true
-
-          if attributes&.include? attr_name
-            value = attributes[attr_name]
-            @__attributes[attr_name] = (value.nil? && default) ? default : value
-          else
-            @__attributes[attr_name] = default
-          end
-          raise ArgumentError, "Attribute #{attr_name} cannot be nil" if @__attributes[attr_name].nil? && !allow_nil
-          instance_variable_set(self.class.attribute_ivar_names[attr_name], @__attributes[attr_name])
-        end
-      end
-
-      def attribute_names
-        self.class.attribute_names
-      end
-
-      def attribute(key)
-        attributes[key]
-      end
-
-      def to_hash
-        attributes.dup
-      end
-
-      class_methods do
-        def inherited(subclass)
-          subclass.instance_variable_set(:@attribute_ivar_names, @attribute_ivar_names.clone)
-          subclass.instance_variable_set(:@attribute_names, @attribute_names.clone)
-          subclass.instance_variable_set(:@attribute_options, @attribute_options.clone)
-          super
-        end
-
-        attr_reader :attribute_ivar_names, :attribute_names, :attribute_options
-
-        def attribute(name, **options)
-          @attribute_names ||= []
-          @attribute_names << name
-          @attribute_ivar_names ||= {}
-          @attribute_ivar_names[name] = :"@#{name}"
-          @attribute_options ||= {}
-          @attribute_options[name] = options
-          define_attribute_delegate(name) if delegates?(options)
-        end
-
-        def delegates?(options)
-          options[:delegates] != false
-        end
-
-        def define_attribute_delegate(attr_name)
-          # Define reader & presence check method
-          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def #{attr_name}
-            @#{attr_name}
-          end
-
-          def #{attr_name}?
-            send(:#{attr_name}).present?
-          end
-          RUBY
-        end
-      end
-    end
-  end
-end

data/lib/vident/base.rb

@@ -1,247 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  module Base
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def no_stimulus_controller
-        @no_stimulus_controller = true
-      end
-
-      def stimulus_controller?
-        !@no_stimulus_controller
-      end
-
-      # The "name" of the component from its class name and namespace. This is used to generate a HTML class name
-      # that can helps identify the component type in the DOM or for styling purposes.
-      def component_name
-        @component_name ||= stimulus_identifier
-      end
-
-      def slots?
-        registered_slots.present?
-      end
-
-      # Dont check collection params, we use kwargs
-      def validate_collection_parameter!(validate_default: false)
-      end
-
-      # stimulus controller identifier
-      def stimulus_identifier
-        ::Vident::Base.stimulus_identifier_from_path(identifier_name_path)
-      end
-
-      def identifier_name_path
-        name.underscore
-      end
-
-      private
-
-      # Define reader & presence check method, for performance use ivar directly
-      def define_attribute_delegate(attr_name)
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def #{attr_name}
-            #{@attribute_ivar_names[attr_name]}
-          end
-  
-          def #{attr_name}?
-            #{@attribute_ivar_names[attr_name]}.present?
-          end
-        RUBY
-      end
-    end
-
-    def prepare_attributes(attributes)
-      raise NotImplementedError
-    end
-
-    # Override this method to perform any initialisation before attributes are set
-    def before_initialize(_attrs)
-    end
-
-    # Override this method to perform any initialisation after attributes are set
-    def after_initialize
-    end
-
-    def clone(overrides = {})
-      new_set = to_hash.merge(**overrides)
-      self.class.new(**new_set)
-    end
-
-    def inspect(klass_name = "Component")
-      attr_text = attributes.map { |k, v| "#{k}=#{v.inspect}" }.join(", ")
-      "#<#{self.class.name}<Vident::#{klass_name}> #{attr_text}>"
-    end
-
-    # Generate a unique ID for a component, can be overridden as required. Makes it easier to setup things like ARIA
-    # attributes which require elements to reference by ID. Note this overrides the `id` accessor
-    def id
-      @id.presence || random_id
-    end
-
-    # If connecting an outlet to this specific component instance, use this ID
-    def outlet_id
-      @outlet_id ||= [stimulus_identifier, "##{id}"]
-    end
-
-    # Methods to use in component views
-    # ---------------------------------
-
-    delegate :params, to: :helpers
-
-    # HTML and attribute definition and creation
-
-    # Generate action/target/etc Stimulus attribute string that can be used externally to this component
-    delegate :action, :target, :named_classes, to: :root
-
-    # This can be overridden to return an array of extra class names
-    def element_classes
-    end
-
-    # A HTML class name that can helps identify the component type in the DOM or for styling purposes.
-    def component_class_name
-      self.class.component_name
-    end
-    alias_method :js_event_name_prefix, :component_class_name
-
-    # Generates the full list of HTML classes for the component
-    def render_classes(erb_defined_classes = nil)
-      # TODO: avoid pointless creation of arrays
-      base_classes = [component_class_name] + Array.wrap(element_classes)
-      base_classes += Array.wrap(erb_defined_classes) if erb_defined_classes
-      classes_on_component = attribute(:html_options)&.fetch(:class, nil)
-      base_classes += Array.wrap(classes_on_component) if classes_on_component
-      produce_style_classes(base_classes)
-    end
-
-    def stimulus_identifier
-      self.class.stimulus_identifier
-    end
-
-    # The `component` class name is used to create the controller name.
-    # The path of the Stimulus controller when none is explicitly set
-    def default_controller_path
-      self.class.identifier_name_path
-    end
-
-    def stimulus_identifier_from_path(path)
-      path.split("/").map { |p| p.to_s.dasherize }.join("--")
-    end
-    module_function :stimulus_identifier_from_path
-
-    private
-
-    def root_element_attributes
-      {}
-    end
-
-    def merge_element_attributes!(element_attributes, attributes)
-      attributes.each_with_object(element_attributes) do |(k, v), h|
-        if h[k].is_a?(Hash)
-          h[k].merge!(v)
-        elsif h[k].is_a?(Array)
-          h[k] << v
-        else
-          h[k] = v
-        end
-      end
-    end
-
-    def root_component_attributes(**attributes)
-      @root_component_attributes ||= {}
-      merge_element_attributes!(@root_component_attributes, attributes)
-    end
-
-    def stimulus_options_for_root_component
-      attributes = root_element_attributes
-      merge_element_attributes!(attributes, @root_component_attributes) if @root_component_attributes.present?
-      stimulus_options_for_component(attributes)
-    end
-
-    # Prepare the stimulus attributes for a StimulusComponent
-    def stimulus_options_for_component(options)
-      # Add pending actions
-      all_actions = attribute(:actions) + Array.wrap(options[:actions])
-      all_actions += @pending_actions if @pending_actions&.any?
-
-      # Add pending targets
-      all_targets = attribute(:targets) + Array.wrap(options[:targets])
-      all_targets += @pending_targets if @pending_targets&.any?
-
-      # Merge pending named classes
-      named_classes_option = merge_stimulus_option(options, :named_classes)
-      if @pending_named_classes&.any?
-        named_classes_option = named_classes_option.merge(@pending_named_classes)
-      end
-
-      {
-        id: respond_to?(:id) ? id : (attribute(:id) || options[:id]),
-        element_tag: attribute(:element_tag) || options[:element_tag] || :div,
-        html_options: prepare_html_options(options[:html_options]),
-        controllers: (
-          self.class.stimulus_controller? ? [default_controller_path] : []
-        ) + Array.wrap(options[:controllers]) + attribute(:controllers),
-        actions: all_actions,
-        targets: all_targets,
-        outlets: attribute(:outlets) + Array.wrap(options[:outlets]),
-        outlet_host: attribute(:outlet_host),
-        named_classes: named_classes_option,
-        values: prepare_stimulus_option(options, :values)
-      }
-    end
-
-    def prepare_html_options(erb_options)
-      # Options should override in this order:
-      # - defined on component class methods (lowest priority)
-      # - defined by passing to component erb
-      # - defined by passing to component constructor (highest priority)
-      options = erb_options&.except(:class) || {}
-      classes_from_view = Array.wrap(erb_options[:class]) if erb_options&.key?(:class)
-      options[:class] = render_classes(classes_from_view)
-      options.merge!(attribute(:html_options).except(:class)) if attribute(:html_options)
-      options
-    end
-
-    # TODO: deprecate the ability to set via method on class (responds_to?) and just use component attributes
-    # or attributes passed to parent_element
-    def prepare_stimulus_option(options, name)
-      resolved = respond_to?(name) ? Array.wrap(send(name)) : []
-      resolved.concat(Array.wrap(attribute(name)))
-      resolved.concat(Array.wrap(options[name]))
-      resolved
-    end
-
-    def merge_stimulus_option(options, name)
-      (attribute(name) || {}).merge(options[name] || {})
-    end
-
-    def produce_style_classes(class_names)
-      dedupe_view_component_classes(class_names)
-    end
-
-    def template_path
-      self.class.template_path
-    end
-
-    def random_id
-      @random_id ||= "#{component_class_name}-#{StableId.next_id_in_sequence}"
-    end
-
-    CLASSNAME_SEPARATOR = " "
-
-    # Join all the various class definisions possible and dedupe
-    def dedupe_view_component_classes(html_classes)
-      html_classes.reject!(&:blank?)
-
-      # Join, then dedupe.
-      # This ensures that entries from the classes array such as "a b", "a", "b" are correctly deduped.
-      # Note we are trying to do this with less allocations to avoid GC churn
-      # classes = classes.join(" ").split(" ").uniq
-      html_classes.map! { |x| x.include?(CLASSNAME_SEPARATOR) ? x.split(CLASSNAME_SEPARATOR) : x }
-        .flatten!
-      html_classes.uniq!
-      html_classes.present? ? html_classes.join(CLASSNAME_SEPARATOR) : nil
-    end
-  end
-end

data/lib/vident/root_component.rb

@@ -1,309 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  module RootComponent
-    def initialize(
-      controllers: nil,
-      actions: nil,
-      targets: nil,
-      outlets: nil,
-      outlet_host: nil,
-      named_classes: nil, # https://stimulus.hotwired.dev/reference/css-classes
-      values: nil,
-      element_tag: nil,
-      id: nil,
-      html_options: nil
-    )
-      @element_tag = element_tag
-      @html_options = html_options
-      @id = id
-      @controllers = Array.wrap(controllers)
-      @actions = actions
-      @targets = targets
-      @outlets = outlets
-      @named_classes = named_classes
-      @values = values
-
-      outlet_host.connect_outlet(self) if outlet_host.respond_to?(:connect_outlet)
-    end
-
-    def connect_outlet(outlet)
-      @outlets ||= []
-      @outlets << outlet
-    end
-
-    # The view component's helpers for setting stimulus data-* attributes on this component.
-
-    # TODO: rename
-    # Create a Stimulus action string, and returns it
-    #   examples:
-    #   action(:my_thing) => "current_controller#myThing"
-    #   action(:click, :my_thing) => "click->current_controller#myThing"
-    #   action("click->current_controller#myThing") => "click->current_controller#myThing"
-    #   action("path/to/current", :my_thing) => "path--to--current_controller#myThing"
-    #   action(:click, "path/to/current", :my_thing) => "click->path--to--current_controller#myThing"
-    def action(*args)
-      part1, part2, part3 = args
-      (args.size == 1) ? parse_action_arg(part1) : parse_multiple_action_args(part1, part2, part3)
-    end
-
-    def action_data_attribute(*actions)
-      {action: parse_actions(actions).join(" ")}
-    end
-
-    # TODO: rename & make stimulus Target class instance and returns it, which can convert to String
-    # Create a Stimulus Target and returns it
-    #   examples:
-    #   target(:my_target) => {controller: 'current_controller' name: 'myTarget'}
-    #   target("path/to/current", :my_target) => {controller: 'path--to--current_controller', name: 'myTarget'}
-    def target(name, part2 = nil)
-      if part2.nil?
-        {controller: implied_controller_name, name: js_name(name)}
-      else
-        {controller: stimulize_path(name), name: js_name(part2)}
-      end
-    end
-
-    def target_data_attribute(name)
-      build_target_data_attributes([target(name)])
-    end
-
-    def build_outlet_selector(outlet_selector)
-      prefix = @id ? "##{@id} " : ""
-      "#{prefix}[data-controller~=#{outlet_selector}]"
-    end
-
-    def outlet(css_selector: nil)
-      controller = implied_controller_name
-      if css_selector.nil?
-        [controller, build_outlet_selector(controller)]
-      else
-        [controller, css_selector]
-      end
-    end
-
-    # Getter for a named 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 named_classes(*names)
-      names.map { |name| convert_classes_list_to_string(@named_classes[name]) }.join(" ")
-    end
-
-    # Helpers for generating the Stimulus data-* attributes directly
-
-    # Return the HTML `data-controller` attribute for the given controllers
-    def with_controllers(*controllers_to_set)
-      "data-controller=\"#{controller_list(controllers_to_set)}\"".html_safe
-    end
-
-    # Return the HTML `data-target` attribute for the given targets
-    def as_targets(*targets)
-      attrs = build_target_data_attributes(parse_targets(targets))
-      attrs.map { |dt, n| "data-#{dt}=\"#{n}\"" }.join(" ").html_safe
-    end
-    alias_method :as_target, :as_targets
-
-    # Return the HTML `data-action` attribute for the given actions
-    def with_actions(*actions_to_set)
-      "data-action='#{parse_actions(actions_to_set).join(" ")}'".html_safe
-    end
-    alias_method :with_action, :with_actions
-
-    # Return the HTML `data-` attribute for the given outlets
-    def with_outlets(*outlets)
-      attrs = build_outlet_data_attributes(outlets)
-      attrs.map { |dt, n| "data-#{dt}=\"#{n}\"" }.join(" ").html_safe
-    end
-    alias_method :with_outlet, :with_outlets
-
-    private
-
-    # An implicit Stimulus controller name is built from the implicit controller path
-    def implied_controller_name
-      stimulize_path(implied_controller_path)
-    end
-
-    # When using the DSL if you dont specify, the first controller is implied
-    def implied_controller_path
-      @controllers&.first || raise(StandardError, "No controllers have been specified")
-    end
-
-    # A complete list of Stimulus controllers for this component
-    def controller_list(controllers_to_set)
-      controllers_to_set&.map { |c| stimulize_path(c) }&.join(" ")
-    end
-
-    # Complete list of actions ready to be use in the data-action attribute
-    def action_list(actions_to_parse)
-      return nil unless actions_to_parse&.size&.positive?
-      parse_actions(actions_to_parse).join(" ")
-    end
-
-    # Complete list of targets ready to be use in the data attributes
-    def target_list
-      return {} unless @targets&.size&.positive?
-      build_target_data_attributes(parse_targets(@targets))
-    end
-
-    def named_classes_list
-      return {} unless @named_classes&.size&.positive?
-      build_named_classes_data_attributes(@named_classes)
-    end
-
-    def values_list
-      return {} unless @values&.size&.positive?
-      build_values_attributes
-    end
-
-    # stimulus "data-*" attributes map for this component
-    def tag_data_attributes
-      {controller: controller_list(@controllers), action: action_list(@actions)}
-        .merge!(target_list)
-        .merge!(outlet_list)
-        .merge!(named_classes_list)
-        .merge!(values_list)
-        .compact_blank!
-    end
-
-    def outlet_list
-      return {} unless @outlets&.size&.positive?
-      build_outlet_data_attributes(@outlets)
-    end
-
-    def parse_outlet(outlet_config)
-      if outlet_config.is_a?(String)
-        [outlet_config, build_outlet_selector(outlet_config)]
-      elsif outlet_config.is_a?(Symbol)
-        outlet_config = outlet_config.to_s.tr("_", "-")
-        [outlet_config, build_outlet_selector(outlet_config)]
-      elsif outlet_config.is_a?(Array)
-        outlet_config[..1]
-      elsif outlet_config.respond_to?(:stimulus_identifier) # Is a Component
-        [outlet_config.stimulus_identifier, build_outlet_selector(outlet_config.stimulus_identifier)]
-      elsif outlet_config.send(:implied_controller_name) # Is a RootComponent ?
-        [outlet_config.send(:implied_controller_name), build_outlet_selector(outlet_config.send(:implied_controller_name))]
-      else
-        raise ArgumentError, "Invalid outlet config: #{outlet_config}"
-      end
-    end
-
-    def build_outlet_data_attributes(outlets)
-      outlets.each_with_object({}) do |outlet_config, obj|
-        identifier, css_selector = parse_outlet(outlet_config)
-        obj[:"#{implied_controller_name}-#{identifier}-outlet"] = css_selector
-      end
-    end
-
-    # Actions can be specified as a symbol, in which case they imply an action on the primary
-    # controller, or as a string in which case it implies an action that is already fully qualified
-    # stimulus action.
-    # 1 Symbol: :my_action => "my_controller#myAction"
-    # 1 String: "my_controller#myAction"
-    # 2 Symbols: [:click, :my_action] => "click->my_controller#myAction"
-    # 1 String, 1 Symbol: ["path/to/controller", :my_action] => "path--to--controller#myAction"
-    # 1 Symbol, 1 String, 1 Symbol: [:hover, "path/to/controller", :my_action] => "hover->path--to--controller#myAction"
-
-    def parse_action_arg(part1)
-      if part1.is_a?(Symbol)
-        # 1 symbol arg, name of method on this controller
-        "#{implied_controller_name}##{js_name(part1)}"
-      elsif part1.is_a?(String)
-        # 1 string arg, fully qualified action
-        part1
-      end
-    end
-
-    def parse_multiple_action_args(part1, part2, part3)
-      if part3.nil? && part1.is_a?(Symbol)
-        # 2 symbol args = event + action
-        "#{part1}->#{implied_controller_name}##{js_name(part2)}"
-      elsif part3.nil?
-        # 1 string arg, 1 symbol = controller + action
-        "#{stimulize_path(part1)}##{js_name(part2)}"
-      else
-        # 1 symbol, 1 string, 1 symbol = as above but with event
-        "#{part1}->#{stimulize_path(part2)}##{js_name(part3)}"
-      end
-    end
-
-    # Parse actions, targets and attributes that are passed in as symbols or strings
-
-    def parse_targets(targets)
-      targets.map { |n| parse_target(n) }
-    end
-
-    def parse_target(raw_target)
-      return raw_target if raw_target.is_a?(String)
-      if raw_target.is_a?(Hash)
-        raw_target[:name] = js_name(raw_target[:name]) if raw_target[:name].is_a?(Symbol)
-        return raw_target
-      end
-      return target(*raw_target) if raw_target.is_a?(Array)
-      target(raw_target)
-    end
-
-    def build_target_data_attributes(targets)
-      targets.map { |t| [:"#{t[:controller]}-target", t[:name]] }.to_h
-    end
-
-    def parse_actions(actions)
-      actions.map! { |a| a.is_a?(String) ? a : action(*a) }
-    end
-
-    def parse_value_attributes(attrs, controller: nil)
-      attrs.transform_keys do |value_name|
-        :"#{controller || implied_controller_name}-#{value_name.to_s.dasherize}-value"
-      end
-    end
-
-    def build_values_attributes
-      @values.each_with_object({}) do |m, obj|
-        if m.is_a?(Hash)
-          obj.merge!(parse_value_attributes(m))
-        elsif m.is_a?(Array)
-          controller_path = m.first
-          data = m.last
-          obj.merge!(parse_value_attributes(data, controller: stimulize_path(controller_path)))
-        end
-      end
-    end
-
-    def build_values_data_attributes(values)
-      values.map { |name, value| [:"#{name}-value", value] }.to_h
-    end
-
-    def parse_named_classes_hash(named_classes)
-      named_classes.map do |name, classes|
-        logical_name = name.to_s.dasherize
-        classes_str = convert_classes_list_to_string(classes)
-        if classes.is_a?(Hash)
-          {controller: stimulize_path(classes[:controller_path]), name: logical_name, classes: classes_str}
-        else
-          {controller: implied_controller_name, name: logical_name, classes: classes_str}
-        end
-      end
-    end
-
-    def build_named_classes_data_attributes(named_classes)
-      parse_named_classes_hash(named_classes)
-        .map { |c| [:"#{c[:controller]}-#{c[:name]}-class", c[:classes]] }
-        .to_h
-    end
-
-    def convert_classes_list_to_string(classes)
-      return "" if classes.nil?
-      return classes if classes.is_a?(String)
-      return classes.join(" ") if classes.is_a?(Array)
-      classes[:classes].is_a?(Array) ? classes[:classes].join(" ") : classes[:classes]
-    end
-
-    # Convert a file path to a stimulus controller name
-    def stimulize_path(path)
-      path.split("/").map { |p| p.to_s.dasherize }.join("--")
-    end
-
-    # Convert a Ruby 'snake case' string to a JavaScript camel case strings
-    def js_name(name)
-      name.to_s.camelize(:lower)
-    end
-  end
-end