vident 0.6.3 → 0.8.0

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,49 +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
-
-        VALID_TAGS = Set[
-          *(Phlex::HTML::VoidElements::REGISTERED_ELEMENTS.keys + Phlex::HTML::StandardElements::REGISTERED_ELEMENTS.keys)
-        ].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/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

data/lib/vident/typed_component.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-if Gem.loaded_specs.has_key? "dry-struct"
-  require_relative "./attributes/typed"
-
-  module Vident
-    module TypedComponent
-      extend ActiveSupport::Concern
-
-      included do
-        include Vident::Base
-        include Vident::Attributes::Typed
-
-        attribute :id, String, delegates: false
-        attribute :html_options, Hash, delegates: false
-        attribute :element_tag, Symbol, delegates: false
-
-        # StimulusJS support
-        attribute :controllers, Array, default: [], delegates: false
-        attribute :actions, Array, default: [], delegates: false
-        attribute :targets, Array, default: [], delegates: false
-        attribute :data_maps, Array, default: [], delegates: false
-
-        # TODO normalise the syntax of defining actions, controllers, etc
-        attribute :named_classes, Hash, delegates: false
-      end
-
-      def initialize(attrs = {})
-        before_initialise(attrs)
-        prepare_attributes(attrs)
-        # The attributes need to also be set as ivars
-        attributes.each do |attr_name, attr_value|
-          instance_variable_set(self.class.attribute_ivar_names[attr_name], attr_value)
-        end
-        after_initialise
-        super()
-      end
-    end
-  end
-else
-  module Vident
-    module TypedComponent
-      def self.included(base)
-        raise "Vident::TypedComponent requires dry-struct to be installed"
-      end
-    end
-  end
-end

data/sig/vident.rbs

@@ -1,4 +0,0 @@
-module Vident
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end