vident 0.6.3 → 0.8.0

data/lib/vident/attributes/typed.rb

@@ -1,229 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-
-if Gem.loaded_specs.has_key? "dry-struct"
-  require_relative "./types"
-  require_relative "./typed_niling_struct"
-
-  module Vident
-    # Adapts Dry Types to confinus Typed Attributes. We use dry-struct (see ::Core::NilingStruct) but
-    # we could probably also use dry-initializer directly, saving us from maintaining the schema.
-    module Attributes
-      module Typed
-        extend ActiveSupport::Concern
-
-        # TODO: better handling of when either class.schema is undefined (as no attributes configured) or when
-        # other methods ar called before prepare_attributes is called
-        def prepare_attributes(attributes)
-          @__attributes = self.class.schema.new(**attributes)
-        end
-
-        def attributes
-          @__attributes.attributes
-        end
-
-        def attribute_names
-          @attribute_names ||= self.class.attribute_names
-        end
-
-        def attribute(key)
-          if Rails.env.development? && !key?(key)
-            raise StandardError, "Attribute #{key} not found in #{self.class.name}"
-          end
-          @__attributes.attributes[key]
-        end
-        alias_method :[], :attribute
-
-        def key?(key)
-          self.class.schema.attribute_names.include?(key)
-        end
-
-        def to_hash
-          @__attributes.to_h
-        end
-
-        class_methods do
-          def inherited(subclass)
-            subclass.instance_variable_set(:@schema, @schema.clone)
-            subclass.instance_variable_set(:@attribute_ivar_names, @attribute_ivar_names.clone)
-            super
-          end
-
-          def attribute_names
-            schema.attribute_names
-          end
-
-          def attribute_metadata(key)
-            schema.schema.key(key).meta
-          end
-
-          attr_reader :schema, :attribute_ivar_names
-
-          def attribute(name, signature = :any, **options, &converter)
-            strict = !options[:convert]
-            signatures = extract_member_type_and_subclass(signature, options)
-            type_info = map_primitive_to_dry_type(signatures, strict, converter)
-            type_info = set_constraints(type_info, options)
-            type_info = set_metadata(type_info, signatures, options)
-            define_on_schema(name, type_info, options)
-          end
-
-          private
-
-          def set_constraints(type_info, options)
-            if allows_nil?(options)
-              type_info = type_info.optional.meta(required: false)
-            end
-            unless allows_blank?(options)
-              type_info = type_info.constrained(filled: true)
-            end
-            if options[:default]&.is_a?(Proc)
-              type_info = type_info.default(options[:default].freeze)
-            elsif !options[:default].nil?
-              type_info = type_info.default(->(_) { options[:default] }.freeze)
-            end
-            if options[:in]
-              type_info.constrained(included_in: options[:in].freeze)
-            end
-            type_info
-          end
-
-          def set_metadata(type_info, signatures, options)
-            metadata = {typed_attribute_type: signatures, typed_attribute_options: options}
-            type_info.meta(**metadata)
-          end
-
-          def delegates?(options)
-            options[:delegates] != false
-          end
-
-          def define_on_schema(attribute_name, type_info, options)
-            @attribute_ivar_names ||= {}
-            @attribute_ivar_names[attribute_name] = :"@#{attribute_name}"
-            define_attribute_delegate(attribute_name) if delegates?(options)
-            @schema ||= const_set(:TypedSchema, Class.new(Vident::Attributes::TypedNilingStruct))
-            @schema.attribute attribute_name, type_info
-          end
-
-          def define_attribute_delegate(attr_name)
-            # Define reader & presence check method
-            class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          def #{attr_name}
-            @__attributes.attributes[:#{attr_name}]
-          end
-
-          def #{attr_name}?
-            send(:#{attr_name}).present?
-          end
-            RUBY
-          end
-
-          def allows_nil?(options)
-            return true unless options
-            allow_nil = options[:allow_nil]
-            return false if allow_nil == false
-            allow_nil || allows_blank?(options)
-          end
-
-          def allows_blank?(options)
-            return true unless options
-            allow_blank = options[:allow_blank]
-            allow_blank.nil? ? true : allow_blank
-          end
-
-          def map_primitive_to_dry_type(signatures, strict, converter)
-            types = signatures.map do |type, subtype|
-              dry_type = dry_type_from_primary_type(type, strict, converter)
-              if subtype && dry_type.respond_to?(:of)
-                subtype_info = dry_type_from_primary_type(subtype, strict, converter)
-                # Sub types of collections currently can be nil - this should be an option
-                dry_type.of(subtype_info.optional.meta(required: false))
-              else
-                dry_type
-              end
-            end
-            types.reduce(:|)
-          end
-
-          def extract_member_type_and_subclass(signature, options)
-            case signature
-            when Set
-              signature.flat_map { |s| extract_member_type_and_subclass(s, options) }
-            when Array
-              [[Array, signature.first]]
-            else
-              [[signature, options[:type] || options[:sub_type]]]
-            end
-          end
-
-          def dry_type_from_primary_type(type, strict, converter)
-            # If a converter is provided, we should use it to coerce the value
-            if converter && !strict && !type.is_a?(Symbol)
-              return Types.Constructor(type) do |value|
-                next value if value.is_a?(type)
-
-                converter.call(value).tap do |new_value|
-                  unless new_value.is_a?(type)
-                    raise ArgumentError, "Type conversion proc did not convert #{value} to #{type}"
-                  end
-                end
-              end
-            end
-
-            if type == :any
-              Types::Nominal::Any
-            elsif type == Integer
-              strict ? Types::Strict::Integer : Types::Params::Integer
-            elsif type == BigDecimal
-              strict ? Types::Strict::Decimal : Types::Params::Decimal
-            elsif type == Float
-              strict ? Types::Strict::Float : Types::Params::Float
-            elsif type == Numeric
-              if strict
-                Types::Strict::Float | Types::Strict::Integer | Types::Strict::Decimal
-              else
-                Types::Params::Float | Types::Params::Integer | Types::Params::Decimal
-              end
-            elsif type == Symbol
-              strict ? Types::Strict::Symbol : Types::Coercible::Symbol
-            elsif type == String
-              strict ? Types::Strict::String : Types::Coercible::String
-            elsif type == Time
-              strict ? Types::Strict::Time : Types::Params::Time
-            elsif type == Date
-              strict ? Types::Strict::Date : Types::Params::Date
-            elsif type == Array
-              strict ? Types::Strict::Array : Types::Params::Array
-            elsif type == Hash
-              strict ? Types::Strict::Hash : Types::Coercible::Hash
-            elsif type == :boolean
-              strict ? Types::Strict::Bool : Types::Params::Bool
-            elsif strict
-              # when strict create a Nominal type with a is_a? constraint, otherwise create a Nominal type which constructs
-              # values using the default constructor, `new`.
-              Types.Instance(type)
-            else
-              # dry calls this when initialising the Type. Check if type of input is correct or create new instance
-              Types.Constructor(type) do |value|
-                next value if value.is_a?(type)
-
-                type.new(**value)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-else
-  module Vident
-    module Attributes
-      module Typed
-        def self.included(base)
-          raise "Vident::Attributes::Typed requires dry-struct to be installed"
-        end
-      end
-    end
-  end
-end

data/lib/vident/attributes/typed_niling_struct.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  module Attributes
-    # A dry struct that is loose about keys provided on initialization. It sets them to nil if not provided.
-    # It is strict about types but not about provided keys
-    class TypedNilingStruct < ::Dry::Struct
-      # convert string keys to symbols
-      transform_keys(&:to_sym)
-
-      # resolve default types on nil
-      transform_types do |type|
-        if type.default?
-          type.constructor { |value| value.nil? ? ::Dry::Types::Undefined : value }
-        else
-          type
-        end
-      end
-
-      class << self
-        def check_schema_duplication(new_keys)
-          # allow overriding keys
-        end
-      end
-    end
-  end
-end

data/lib/vident/attributes/types.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "dry-struct"
-
-module Vident
-  module Attributes
-    module Types
-      include ::Dry.Types
-
-      StrippedString = Types::String.constructor(&:strip)
-      BooleanDefaultFalse = Types::Bool.default(false)
-      BooleanDefaultTrue = Types::Bool.default(true)
-      HashDefaultEmpty = Types::Hash.default({}.freeze)
-    end
-  end
-end

data/lib/vident/caching/cache_key.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-# Rails fragment caching works by either expecting the cached key object to respond to `cache_key` or for that object
-# to be an array or hash. In our case the object maybe an instance of Core::Presenter so here we add a default
-# `cache_key` implementation.
-module Vident
-  module Caching
-    module CacheKey
-      extend ActiveSupport::Concern
-
-      class_methods do
-        def inherited(subclass)
-          subclass.instance_variable_set(
-            :@named_cache_key_attributes,
-            @named_cache_key_attributes.clone
-          )
-          super
-        end
-
-        def with_cache_key(*attrs, name: :_collection)
-          raise StandardError, "with_cache_key can only be used on components *without* slots as there is no eary way to track their content changes so too risky" if respond_to?(:slots?) && slots?
-          # Add view file to cache key
-          attrs << :component_modified_time
-          named_cache_key_includes(name, *attrs)
-        end
-
-        attr_reader :named_cache_key_attributes
-
-        # TypedComponents can be used with fragment caching, but you need to be careful! Read on...
-        #
-        #     <% cache component do %>
-        #      <%= render component %>
-        #    <% end %>
-        #
-        # The most important point is that Rails cannot track dependencies on the component itself, so you need to
-        # be careful to be explicit on the attributes, and manually specify any sub Viewcomponent dependencies that the
-        # component has. The assumption is that the subcomponent takes any attributes from the parent, so the cache key
-        # depends on the parent component attributes. Otherwise changes to the parent or sub component views/Ruby class
-        # will result in different cache keys too. Of course if you invalidate all cache keys with a modifier on deploy
-        # then no need to worry about changing the cache key on component changes, only on attribute/data changes.
-        #
-        # A big caveat is that the cache key cannot depend on anything related to the view_context of the component (such
-        # as `helpers` as the key is created before the rending pipline is invoked (which is when the view_context is set).
-        def depends_on(*klasses)
-          @component_dependencies ||= []
-          @component_dependencies += klasses
-        end
-
-        attr_reader :component_dependencies
-
-        def component_modified_time
-          return @component_modified_time if Rails.env.production? && @component_modified_time
-          # FIXME: This could stack overflow if there are circular dependencies
-          deps = component_dependencies&.map(&:component_modified_time)&.join("-") || ""
-          @component_modified_time = deps + sidecar_view_modified_time + rb_component_modified_time
-        end
-
-        def sidecar_view_modified_time
-          return @sidecar_view_modified_time if Rails.env.production? && defined?(@sidecar_view_modified_time)
-          @sidecar_view_modified_time = ::File.exist?(template_path) ? ::File.mtime(template_path).to_i.to_s : ""
-        end
-
-        def rb_component_modified_time
-          return @rb_component_modified_time if Rails.env.production? && defined?(@rb_component_modified_time)
-          @rb_component_modified_time = ::File.exist?(component_path) ? ::File.mtime(component_path).to_i.to_s : ""
-        end
-
-        def template_path
-          File.join components_base_path, "#{virtual_path}.html.erb"
-        end
-
-        def component_path
-          File.join components_base_path, "#{virtual_path}.rb"
-        end
-
-        def components_base_path
-          ::Rails.configuration.view_component.view_component_path || "app/components"
-        end
-
-        private
-
-        def named_cache_key_includes(name, *attrs)
-          define_cache_key_method unless @named_cache_key_attributes
-          @named_cache_key_attributes ||= {}
-          @named_cache_key_attributes[name] = attrs
-        end
-
-        def define_cache_key_method
-          # If the presenter defines cache key setup then define the method. Otherwise Rails assumes this
-          # will return a valid key if the class will respond to this
-          define_method :cache_key do |n = :_collection|
-            if defined?(@cache_key)
-              return @cache_key[n] if @cache_key.key?(n)
-            else
-              @cache_key ||= {}
-            end
-            generate_cache_key(n)
-            @cache_key[n]
-          end
-        end
-      end
-
-      # Component modified time which is combined with other cache key attributes to generate cache key for an instance
-      def component_modified_time
-        self.class.component_modified_time
-      end
-
-      def cacheable?
-        respond_to? :cache_key
-      end
-
-      def cache_key_modifier
-        ENV["RAILS_CACHE_ID"]
-      end
-
-      def cache_keys_for_sources(key_attributes)
-        sources = key_attributes.flat_map { |n| n.is_a?(Proc) ? instance_eval(&n) : send(n) }
-        sources.compact.map do |item|
-          next if item == self
-          generate_item_cache_key_from(item)
-        end
-      end
-
-      def generate_item_cache_key_from(item)
-        if item.respond_to? :cache_key_with_version
-          item.cache_key_with_version
-        elsif item.respond_to? :cache_key
-          item.cache_key
-        elsif item.is_a?(String)
-          Digest::SHA1.hexdigest(item)
-        else
-          Digest::SHA1.hexdigest(Marshal.dump(item))
-        end
-      end
-
-      def generate_cache_key(index)
-        key_attributes = self.class.named_cache_key_attributes[index]
-        return nil unless key_attributes
-        key = "#{self.class.name}/#{cache_keys_for_sources(key_attributes).join("/")}"
-        raise StandardError, "Cache key for key #{key} is blank!" if key.blank?
-        @cache_key[index] = cache_key_modifier.present? ? "#{key}/#{cache_key_modifier}" : key
-      end
-    end
-  end
-end

data/lib/vident/railtie.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Vident
-  # Include rake tasks
-  class Railtie < ::Rails::Railtie
-    rake_tasks do
-      load "tasks/vident.rake"
-    end
-  end
-end

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