vident 0.7.0 → 0.9.0

data/lib/vident/root_component/base.rb

@@ -1,237 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  module RootComponent
-    module Base
-      def initialize(
-        controllers: nil,
-        actions: nil,
-        targets: nil,
-        named_classes: nil, # https://stimulus.hotwired.dev/reference/css-classes
-        data_maps: 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
-        @named_classes = named_classes
-        @data_map_kvs = {}
-        @data_maps = data_maps
-      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
-
-      # 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
-
-      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
-
-      # stimulus "data-*" attributes map for this component
-      def tag_data_attributes
-        {controller: controller_list(@controllers), action: action_list(@actions)}
-          .merge!(target_list)
-          .merge!(named_classes_list)
-          .merge!(data_map_attributes)
-          .compact_blank!
-      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)
-        return raw_target if raw_target.is_a?(Hash)
-        target(raw_target)
-      end
-
-      def build_target_data_attributes(targets)
-        targets.map { |t| ["#{t[:controller]}-target".to_sym, t[:name]] }.to_h
-      end
-
-      def parse_actions(actions)
-        actions.map! { |a| a.is_a?(String) ? a : action(*a) }
-      end
-
-      def parse_attributes(attrs, controller = nil)
-        attrs.transform_keys { |k| "#{controller || implied_controller_name}-#{k}" }
-      end
-
-      def data_map_attributes
-        return {} unless @data_maps
-        @data_maps.each_with_object({}) do |m, obj|
-          if m.is_a?(Hash)
-            obj.merge!(parse_attributes(m))
-          elsif m.is_a?(Array)
-            controller_path = m.first
-            data = m.last
-            obj.merge!(parse_attributes(data, stimulize_path(controller_path)))
-          end
-        end
-      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
-end

data/lib/vident/root_component/using_better_html.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-if Gem.loaded_specs.has_key? "better_html"
-  require "better_html"
-  require "cgi/util"
-
-  module Vident
-    module RootComponent
-      module UsingBetterHTML
-        # Return the HTML `data-controller` attribute for the given controllers
-        def with_controllers(*controllers_to_set)
-          helpers.html_attributes("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))
-          helpers.html_attributes(attrs.transform_keys! { |k| "data-#{k}" })
-        end
-        alias_method :as_target, :as_targets
-
-        # Return the HTML `data-action` attribute for the given actions
-        def with_actions(*actions_to_set)
-          actions_str = action_list(actions_to_set)
-          actions_str.present? ? helpers.html_attributes("data-action" => actions_str) : nil
-        end
-        alias_method :with_action, :with_actions
-
-        private
-
-        # 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?
-          # `html_attributes` will escape '->' thus breaking the stimulus action, so we need to do our own escaping
-          actions_str_raw = parse_actions(actions_to_parse).join(" ")
-          CGI.escapeHTML(actions_str_raw).gsub("->", "->").html_safe
-        end
-      end
-    end
-  end
-end

data/lib/vident/root_component/using_phlex_html.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-if Gem.loaded_specs.has_key? "phlex"
-  require "phlex"
-
-  module Vident
-    module RootComponent
-      class UsingPhlexHTML < Phlex::HTML
-        include Base
-        if Gem.loaded_specs.has_key? "better_html"
-          include UsingBetterHTML
-        end
-
-        STANDARD_ELEMENTS = [:a, :abbr, :address, :article, :aside, :b, :bdi, :bdo, :blockquote, :body, :button, :caption, :cite, :code, :colgroup, :data, :datalist, :dd, :del, :details, :dfn, :dialog, :div, :dl, :dt, :em, :fieldset, :figcaption, :figure, :footer, :form, :g, :h1, :h2, :h3, :h4, :h5, :h6, :head, :header, :hgroup, :html, :i, :iframe, :ins, :kbd, :label, :legend, :li, :main, :map, :mark, :menuitem, :meter, :nav, :noscript, :object, :ol, :optgroup, :option, :output, :p, :path, :picture, :pre, :progress, :q, :rp, :rt, :ruby, :s, :samp, :script, :section, :select, :slot, :small, :span, :strong, :style, :sub, :summary, :sup, :svg, :table, :tbody, :td, :template_tag, :textarea, :tfoot, :th, :thead, :time, :title, :tr, :u, :ul, :video, :wbr].freeze
-        VOID_ELEMENTS = [:area, :br, :embed, :hr, :img, :input, :link, :meta, :param, :source, :track, :col].freeze
-
-        VALID_TAGS = Set[*(STANDARD_ELEMENTS + VOID_ELEMENTS)].freeze
-
-        # Create a tag for a target with a block containing content
-        def target_tag(tag_name, targets, **options, &block)
-          parsed = parse_targets(Array.wrap(targets))
-          options[:data] ||= {}
-          options[:data].merge!(build_target_data_attributes(parsed))
-          generate_tag(tag_name, **options, &block)
-        end
-
-        # Build a tag with the attributes determined by this components properties and stimulus
-        # data attributes.
-        def template(&block)
-          # Generate tag options and render
-          tag_type = @element_tag.presence&.to_sym || :div
-          raise ArgumentError, "Unsupported HTML tag name #{tag_type}" unless VALID_TAGS.include?(tag_type)
-          options = @html_options&.dup || {}
-          data_attrs = tag_data_attributes
-          data_attrs = options[:data].present? ? data_attrs.merge(options[:data]) : data_attrs
-          options = options.merge(id: @id) if @id
-          options.except!(:data)
-          options.merge!(data_attrs.transform_keys { |k| "data-#{k}" })
-          generate_tag(tag_type, **options, &block)
-        end
-
-        private
-
-        def generate_tag(tag_type, **options, &block)
-          send((tag_type == :template) ? :template_tag : tag_type, **options, &block)
-        end
-      end
-    end
-  end
-end

data/lib/vident/root_component/using_view_component.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-if Gem.loaded_specs.has_key? "view_component"
-  require "view_component"
-
-  module Vident
-    module RootComponent
-      class UsingViewComponent < ::ViewComponent::Base
-        include Base
-        if Gem.loaded_specs.has_key? "better_html"
-          include UsingBetterHTML
-        end
-
-        SELF_CLOSING_TAGS = Set[:area, :base, :br, :col, :embed, :hr, :img, :input, :link, :meta, :param, :source, :track, :wbr].freeze
-
-        def target_tag(tag_name, targets, **options, &block)
-          parsed = parse_targets(Array.wrap(targets))
-          options[:data] ||= {}
-          options[:data].merge!(build_target_data_attributes(parsed))
-          content = view_context.capture(&block) if block
-          view_context.content_tag(tag_name, content, options)
-        end
-
-        def call
-          # Generate outer tag options and render
-          tag_type = content_tag_type
-          options = content_tag_options
-          if SELF_CLOSING_TAGS.include?(tag_type)
-            view_context.tag(tag_type, options)
-          else
-            view_context.content_tag(tag_type, content, options)
-          end
-        end
-
-        private
-
-        def content_tag_options
-          options = @html_options&.dup || {}
-          data_attrs = tag_data_attributes
-          options[:data] = options[:data].present? ? data_attrs.merge(options[:data]) : data_attrs
-          return options unless @id
-          options.merge(id: @id)
-        end
-
-        def content_tag_type
-          @element_tag.presence || :div
-        end
-      end
-    end
-  end
-end

data/lib/vident/tailwind.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-
-module Vident
-  module Tailwind
-    # Adds a utility class merge specifically for Tailwind, allowing you to more easily specify class overrides
-    # without having to worry about the specificity of the classes.
-    def produce_style_classes(class_names)
-      ::TailwindMerge::Merger.new.merge(dedupe_view_component_classes(class_names))
-    end
-  end
-end

data/lib/vident/test_case.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-# TODO: what about when used with Phlex?
-module Vident
-  class TestCase < ::ViewComponent::TestCase
-    include Vident::Testing::AutoTest
-  end
-end

data/lib/vident/testing/attributes_tester.rb

@@ -1,176 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  module Testing
-    class AttributesTester
-      def initialize(test_configurations)
-        @test_configurations = test_configurations
-      end
-
-      # Generates attribute hashes for all permutations of the given valid values.
-      def valid_configurations
-        # Expands any auto generated values and returns all attributes and their values
-        test_attrs = prepare_attributes_to_test
-
-        # The first permutation is the initial state
-        initial_state = prepare_initial_test_state(test_attrs)
-
-        # Create remaining permutations
-        test_attrs.flat_map do |attr_name, values|
-          values.map { |v| initial_state.merge(attr_name => v) }
-        end
-      end
-
-      # Generates attribute hashes for all permutations of the given invalid values.
-      def invalid_configurations
-        return [] unless invalid_configured?
-
-        # prepare a valid initial state, then add any attrs that have :invalid
-        initial_state = prepare_initial_test_state(prepare_attributes_to_test)
-
-        # Merge in the invalid permutations
-        test_configurations.inject([]) do |memo, attr|
-          key, opts = attr
-          next memo += nil if opts == :strict_boolean
-          if opts.is_a?(Hash)
-            values = if opts[:invalid].nil? && opts[:valid].is_a?(Hash)
-              # If no invalid key specified we generate based on whats valid
-              config = invalid_attribute_test_values_for(opts[:valid][:type], opts[:valid])
-              (config&.fetch(:invalid, []) || []) + (config&.fetch(:converts, []) || [])
-            elsif opts[:invalid].is_a?(Array)
-              opts[:invalid]
-            end
-
-            memo += values.map { |i| initial_state.merge(key => i) } if values
-          end
-          memo
-        end
-      end
-
-      private
-
-      attr_reader :test_configurations
-
-      def invalid_configured?
-        test_configurations.values.any? { |v| v.respond_to?(:key?) && v.key?(:invalid) }
-      end
-
-      def prepare_attributes_to_test
-        test_configurations.transform_values do |attr_config|
-          next [true, false, nil] if attr_config == :boolean
-          next [true, false] if attr_config == :strict_boolean
-          valid = attr_config[:valid]
-          raise "Ensure :valid attributes configuration is provided" unless valid
-          next valid if valid.is_a?(Array)
-          attribute_test_values_for(valid)
-        end
-      end
-
-      def prepare_initial_test_state(test_attrs)
-        initial_state = {}
-        test_attrs.each { |attr_name, values| initial_state[attr_name] = values.first }
-        initial_state
-      end
-
-      def attribute_test_values_for(options)
-        type = parse_type(options[:type])
-        return options[:in] if options[:in]
-        values =
-          case type
-          when :string, "String"
-            s = (1..8).map { |l| ::Faker::String.random(length: l) }
-            s.prepend "test string"
-            s = s.select(&:present?)
-            s << "" if options[:allow_blank]
-            s
-          when :boolean
-            [false, true]
-          when :float, "Float"
-            (1..3).map { Faker::Number.positive } + (1..3).map { Faker::Number.negative }
-          when :numeric, "Numeric"
-            (1..3).map { Faker::Number.positive } + [1, 5]
-          when :integer, "Integer"
-            min = options[:min] || -10_000
-            max = options[:max] || 10_000
-            (1..3).map { Kernel.rand(min..max) }
-          when :array, "Array"
-            a =
-              if options[:sub_type] == Numeric
-                [[1, 2, 3], [0.3, 2, 0.002]]
-              elsif options[:sub_type]
-                [[options[:sub_type].new]]
-              else
-                [%i[a b c], [1, 2, 3], %w[a b]]
-              end
-            a << [] if options[:allow_blank]
-            a
-          when :any
-            [false, 1245, {}, :df, "hi"]
-          when :hash, "Hash"
-            a = [{a: 1}]
-            a << {} if options[:allow_blank]
-            a
-          when :symbol, "Symbol"
-            %i[a b c]
-          else
-            raise StandardError, "Attribute type not understood (#{type})"
-          end
-
-        if options[:allow_nil] || !options[:default].nil? || (options[:allow_blank] && options[:allow_nil].nil?)
-          values << nil
-        end
-        values
-      end
-
-      def invalid_attribute_test_values_for(type, options)
-        values = case parse_type(type)
-        when :string, "String"
-          # All values are also convertable to string
-          a = {converts: [false, 1245, 1.0, {}, :df, []], invalid: []}
-          a[:invalid] << "" if options[:allow_blank] == false
-          a
-        when :boolean
-          # All values are also convertable to boolean with !!
-          {converts: ["sdf", 234, 3.5, {}, :sdf, []], invalid: []}
-        when :float, "Float"
-          # Not all values are convertable to float
-          {converts: [234, "12.2"], invalid: ["sdf", 234, {}, :sdf, [], false]}
-        when :numeric, "Numeric"
-          {converts: ["12.2"], invalid: ["sdf", {}, :sdf, [], false]}
-        when :integer, "Integer"
-          # Not all values are convertable to integer
-          {converts: [234.0, "123", "sdf"], invalid: [{}, :sdf, [], false]}
-        when :array, "Array"
-          # Not all values are convertable to array
-          a = if options[:sub_type]
-            {converts: [{}, [{}]], invalid: ["sdf", [123], [Class.new]]}
-          else
-            {converts: [{}], invalid: ["sdf", 234, 3.5, :sdf, false]}
-          end
-          a[:invalid] << [] if options[:allow_blank] == false
-          a
-        when :any
-          # There are no invalid values
-          {converts: [], invalid: []}
-        when :hash, "Hash"
-          a = {converts: [[], [[:a, 1], [:b, 2]]], invalid: [:sdf, false, "boo", 123]}
-          a[:invalid] << {} if options[:allow_blank] == false
-          a
-        when :symbol, "Symbol"
-          {converts: ["foo"], invalid: [{}, false, [], 123]}
-        else
-          raise StandardError, "Attribute type not understood (#{type})"
-        end
-
-        if options[:default].nil? && (!options[:allow_nil] || (!options[:allow_blank] && options[:allow_nil] != true))
-          values[:invalid] << nil
-        end
-        values
-      end
-
-      def parse_type(type)
-        type.is_a?(Symbol) ? type : type.name
-      end
-    end
-  end
-end

data/lib/vident/testing/auto_test.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "minitest/hooks"
-
-module Vident
-  module Testing
-    module AutoTest
-      extend ActiveSupport::Concern
-
-      included do
-        include Minitest::Hooks
-
-        def before_all
-          @results_content = []
-          ::Vident::StableId.set_current_sequence_generator
-        end
-
-        def after_all
-          html = <<~HTML
-            <!doctype html>
-            <html lang="en">
-            <head>
-            <meta charset="UTF-8">
-            <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
-            <meta http-equiv="X-UA-Compatible" content="ie=edge">
-            <title>Test run output</title>
-            </head>
-            <body>
-              #{@results_content.map(&:to_s).join("<hr>\n").html_safe}
-            </body>
-            </html>
-          HTML
-
-          # TODO: configurable layout
-          filename = self.class.name.gsub("::", "_")
-          File.write("render_results_#{filename}.html", html) # TODO: path for outputs (eg default tmp/)
-        end
-      end
-
-      class_methods do
-        def auto_test(class_under_test, **param_config)
-          attribute_tester = Vident::Testing::AttributesTester.new(param_config)
-          attribute_tester.valid_configurations.each_with_index do |test, index|
-            class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-              def test_renders_with_valid_attrs_#{index}
-                test_attrs = #{test}
-                begin 
-                  @results_content << render_inline(#{class_under_test}.new(**test_attrs))
-                rescue => error
-                  assert(false, "Should not raise with #{test.to_s.tr("\"", "'")} but did raise \#{error}")
-                end
-              end
-            RUBY
-          end
-
-          attribute_tester.invalid_configurations.each_with_index do |test, index|
-            class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-              def test_raises_with_invalid_attrs_#{index}
-                test_attrs = #{test}
-                assert_raises(StandardError, "Should raise with #{test.to_s.tr("\"", "'")}") do
-                  @results_content << render_inline(#{class_under_test}.new(**test_attrs))
-                end
-              end
-            RUBY
-          end
-        end
-      end
-    end
-  end
-end