vident 0.7.0 → 0.9.0

data/lib/vident/attributes/not_typed.rb

@@ -15,6 +15,7 @@ module Vident
           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
@@ -41,6 +42,8 @@ module Vident
       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
 

data/lib/vident/base.rb

@@ -33,15 +33,7 @@ module Vident
       end
 
       def identifier_name_path
-        if phlex_component?
-          name.remove("Views::").underscore
-        else
-          name.underscore
-        end
-      end
-
-      def phlex_component?
-        @phlex_component ||= ancestors.map(&:name).include?("Phlex::HTML")
+        name.underscore
       end
 
       private
@@ -52,7 +44,7 @@ module Vident
           def #{attr_name}
             #{@attribute_ivar_names[attr_name]}
           end
-
+  
           def #{attr_name}?
             #{@attribute_ivar_names[attr_name]}.present?
           end
@@ -95,25 +87,6 @@ module Vident
 
     # HTML and attribute definition and creation
 
-    # Helper to create the main element
-    def parent_element(**options)
-      @parent_element ||= begin
-        # Note: we cant mix phlex and view_component render contexts
-        klass = if self.class.phlex_component?
-          RootComponent::UsingPhlexHTML
-        else
-          RootComponent::UsingViewComponent
-        end
-        element_attrs = options
-          .except(:id, :element_tag, :html_options, :controller, :controllers, :actions, :targets, :named_classes, :data_maps)
-          .merge(
-            stimulus_options_for_component(options)
-          )
-        klass.new(**element_attrs)
-      end
-    end
-    alias_method :root, :parent_element
-
     # FIXME: if we call them before `root` we will setup the root element before we intended
     # The separation between component and root element is a bit messy. Might need rethinking.
     delegate :action, :target, :named_classes, to: :root
@@ -155,6 +128,12 @@ module Vident
 
     private
 
+    def parent_element_attributes(options)
+      options
+        .except(:id, :element_tag, :html_options, :controller, :controllers, :actions, :targets, :named_classes, :data_maps)
+        .merge(stimulus_options_for_component(options))
+    end
+
     # Prepare the stimulus attributes for a StimulusComponent
     def stimulus_options_for_component(options)
       {

data/lib/vident/caching.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Vident
+  # 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.
+  module Caching
+    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)
+        # Add view file to cache key
+        attrs << :component_modified_time
+        attrs << :attributes
+        named_cache_key_includes(name, *attrs.uniq)
+      end
+
+      attr_reader :named_cache_key_attributes
+
+      # Components 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
+
+        raise StandardError, "Must implement current_component_modified_time" unless respond_to?(:current_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 + current_component_modified_time
+      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

data/lib/vident/component.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "./attributes/not_typed"
-
 module Vident
   module Component
     extend ActiveSupport::Concern

data/lib/vident/engine.rb

@@ -0,0 +1,15 @@
+module Vident
+  class Engine < ::Rails::Engine
+    lib_path = File.expand_path("../../../lib/", __FILE__)
+    config.autoload_paths << lib_path
+    config.eager_load_paths << lib_path
+
+    config.before_initialize do
+      Rails.autoloaders.each do |autoloader|
+        autoloader.inflector.inflect(
+          "version" => "VERSION"
+        )
+      end
+    end
+  end
+end

data/lib/vident/root_component.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Vident
+  module RootComponent
+    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

data/lib/vident/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Vident
-  VERSION = "0.7.0"
+  VERSION = "0.9.0"
 end

data/lib/vident.rb

@@ -1,41 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "vident/version"
-require_relative "vident/railtie"
+require "vident/version"
+require "vident/engine"
 
 module Vident
-  class << self
-    def configuration
-      @configuration ||= Configuration.new
-    end
-
-    def configure
-      yield(configuration) if block_given?
-      configuration
-    end
-  end
-
-  class Configuration
-    attr_accessor :include_i18n_helpers
-
-    def initialize
-      @include_i18n_helpers = true
-    end
-  end
+  # Your code goes here...
 end
-
-require_relative "vident/stable_id"
-require_relative "vident/root_component/base"
-require_relative "vident/root_component/using_better_html"
-require_relative "vident/root_component/using_phlex_html"
-require_relative "vident/root_component/using_view_component"
-require_relative "vident/base"
-require_relative "vident/component"
-require_relative "vident/typed_component"
-require_relative "vident/caching/cache_key"
-require_relative "vident/tailwind" if Gem.loaded_specs.has_key? "tailwind_merge"
-require_relative "vident/testing/attributes_tester"
-require_relative "vident/testing/auto_test"
-
-# TODO: what if not using view_component?
-require_relative "vident/test_case"

metadata

@@ -1,22 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: vident
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Stephen Ierodiaconou
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2023-03-08 00:00:00.000000000 Z
+date: 2023-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '7'
     - - "<"
       - !ruby/object:Gem::Version
         version: '8'
@@ -40,43 +40,25 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".standard.yml"
-- CHANGELOG.md
-- CODE_OF_CONDUCT.md
-- Gemfile
-- LICENSE.txt
 - README.md
 - Rakefile
-- examples/avatar.png
-- examples/ex1.gif
-- lib/tasks/vident.rake
+- lib/tasks/vident_tasks.rake
 - lib/vident.rb
 - lib/vident/attributes/not_typed.rb
-- lib/vident/attributes/typed.rb
-- lib/vident/attributes/typed_niling_struct.rb
-- lib/vident/attributes/types.rb
 - lib/vident/base.rb
-- lib/vident/caching/cache_key.rb
+- lib/vident/caching.rb
 - lib/vident/component.rb
-- lib/vident/railtie.rb
-- lib/vident/root_component/base.rb
-- lib/vident/root_component/using_better_html.rb
-- lib/vident/root_component/using_phlex_html.rb
-- lib/vident/root_component/using_view_component.rb
+- lib/vident/engine.rb
+- lib/vident/root_component.rb
 - lib/vident/stable_id.rb
-- lib/vident/tailwind.rb
-- lib/vident/test_case.rb
-- lib/vident/testing/attributes_tester.rb
-- lib/vident/testing/auto_test.rb
-- lib/vident/typed_component.rb
 - lib/vident/version.rb
-- sig/vident.rbs
 homepage: https://github.com/stevegeek/vident
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/stevegeek/vident
   source_code_uri: https://github.com/stevegeek/vident
+  changelog_uri: https://github.com/stevegeek/vident/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -92,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Vident is the base of your design system implementation, which provides helpers

data/.standard.yml

@@ -1,3 +0,0 @@
-# For available configuration options, see:
-#   https://github.com/testdouble/standard
-ruby_version: 3.0

data/CHANGELOG.md

@@ -1,79 +0,0 @@
-
-# Change Log
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](http://keepachangelog.com/)
-and this project adheres to [Semantic Versioning](http://semver.org/).
-
-## [Unreleased]
-
-### Added
-
-### Changed
-
-### Fixed
-
-## [0.7.0] - 2023-03-08  
-
-### Added
-
-- new `Vident::Tailwind` module which uses [tailwind_merge](https://github.com/gjtorikian/tailwind_merge) to merge TailwindCSS classes
-
-### Changed
-
-- Removed a dependency on intenal constants from `phlex`
-
-## [0.6.3] - 2023-03-03
-
-### Fixed
-
-- Fix for changes to HTML tag collection in Phlex
-
-
-## [0.6.2] - 2023-02-23
-
-### Fixed
-
-- Element tag options are not set when no ID is provided
-
-
-## [0.6.1] - 2023-02-20
-
-### Fixed
-
-- `better_html` support fix for aliased dsl methods
-
-
-## [0.6.0] - 2023-02-20
-
-### Added
-
-- Experimental support for `better_html` in the root components (the stimulus attributes are generated with `html_attributes`)
-
-
-
-## [0.5.1] - 2023-02-17
-
-### Added
-
-- N/A
-
-### Changed
-
-- N/A
-
-### Fixed
-
-- Typed attributes was not always using custom coercion methods if they were defined 
-
-### Removed
-
-- N/A
-
-### Deprecated
-
-- N/A
-
-### Security
-
-- N/A