stimulus_plumbers 0.3.2 → 0.4.0

data/lib/stimulus_plumbers/plumber/slots.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Plumber
+    class Slots
+      def self.slot(*names, by: nil)
+        names.each do |name|
+          by ? define_by_slot(name, by) : define_flat_slot(name)
+          define_reader(name)
+          define_predicate(name)
+        end
+      end
+
+      def initialize
+        @slots = {}
+      end
+
+      def resolve(name)
+        entry = @slots[name]
+        return unless entry
+
+        value = entry[:value]
+        value = value.call if value.is_a?(Proc)
+        block_given? ? yield(value) : value
+      end
+
+      def options_for(name)
+        (@slots[name] || {})[:options] || {}
+      end
+
+      def any?
+        @slots.any?
+      end
+
+      def none?
+        @slots.empty?
+      end
+
+      private
+
+      def set_slot(name, value, options = {})
+        @slots[name] = { value: value, options: options }
+      end
+
+      class << self
+        private
+
+        def define_flat_slot(name)
+          define_method(:"with_#{name}") do |value = nil, **opts, &block|
+            set_slot(name, block || value, opts)
+            nil
+          end
+        end
+
+        def define_by_slot(name, by)
+          define_method(:"with_#{name}") do |&block|
+            sub = by.new
+            block&.call(sub)
+            set_slot(name, sub)
+            nil
+          end
+        end
+
+        def define_reader(name)
+          define_method(name) { resolve(name) }
+        end
+
+        def define_predicate(name)
+          define_method(:"#{name}?") { @slots.key?(name) }
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/themes/base.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 require_relative "schema"
+require_relative "../plumber/dispatcher"
 
 module StimulusPlumbers
   module Themes
     class Base
       SCHEMA = {
-        **Schema::ACTION_LIST,
+        **Schema::LIST,
         **Schema::AVATAR,
         **Schema::BUTTON,
         **Schema::CALENDAR,
@@ -14,18 +15,20 @@ module StimulusPlumbers
         **Schema::COMBOBOX,
         **Schema::FORM,
         **Schema::ICON,
-        **Schema::LAYOUT
+        **Schema::INPUT_GROUP,
+        **Schema::LAYOUT,
+        **Schema::LINK
       }.freeze
 
       def name
         @name ||= self.class.name.demodulize.delete_suffix("Theme")
       end
 
-      def avatar_colors
+      def avatar_variants
         {}
       end
 
-      def avatar_color_range
+      def avatar_variant_range
         []
       end
 
@@ -33,17 +36,10 @@ module StimulusPlumbers
         {}
       end
 
-      def icon_range
-        icons.keys
-      end
-
       def attribute_names(component)
         SCHEMA.fetch(component, {}).keys
       end
 
-      # Resolves presentational classes for a component slot.
-      # Returns a Hash with :classes (String) and optionally :style (String).
-      # Returns {} when no mapping exists for the given component.
       def resolve(component, **args)
         method_name = :"#{component}_classes"
         unless respond_to?(method_name, true)
@@ -51,36 +47,37 @@ module StimulusPlumbers
           return {}
         end
 
-        send(method_name, **validate_args(component.to_sym, args))
+        send(method_name, **validate(component.to_sym, args))
       end
 
       private
 
-      def validate_args(component, args)
+      def validate(component, args)
         schema = SCHEMA.fetch(component, {})
         args.slice(*schema.keys).each_with_object({}) do |(key, value), result|
-          result[key] = coerce_arg(component, key, value, schema[key])
+          result[key] = cast(component, key, value, schema[key])
         end
       end
 
-      def coerce_arg(component, key, value, schema)
+      def cast(component, key, value, schema)
         return value unless schema
-
-        range = range_for(schema)
-        return value if range.empty? || range.include?(value)
+        return value if value.nil? || valid?(schema[:validate], value)
 
         StimulusPlumbers::Logger.warn(
           "#{component}##{key} received unknown value #{value.inspect}. " \
-          "Range: #{schema[:range].inspect}. Falling back to: #{schema[:default].inspect}"
+          "Validator: #{schema[:validate].inspect}. Falling back to: #{schema[:default].inspect}"
         )
         schema[:default]
       end
 
-      def range_for(schema)
-        if schema[:range].is_a?(Symbol)
-          respond_to?(schema[:range], true) ? send(schema[:range]) : []
+      def valid?(validator, value)
+        return true if validator.nil?
+
+        if validator.respond_to?(:include?)
+          validator.include?(value)
         else
-          schema[:range]
+          result = Plumber::Dispatcher.build(validator, value).call(self)
+          result.respond_to?(:include?) ? result.include?(value) : result
         end
       end
     end

data/lib/stimulus_plumbers/themes/icons/external.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "rexml/document"
+require "stimulus_plumbers/themes/schema/icon"
+
+module StimulusPlumbers
+  module Themes
+    module Icons
+      module External
+        SVG_RENAME     = Schema::Icon::SVG_ATTR_NAMES.invert.freeze
+        ELEMENT_RENAME = Schema::Icon::ELEMENT_ATTR_NAMES.invert.freeze
+
+        def include?(key)
+          File.exist?(svg_path(key))
+        end
+
+        def fetch(key)
+          file = svg_path(key)
+          parse_svg(key, File.read(file)) if File.exist?(file)
+        end
+
+        private
+
+        def svg_defaults(_key)
+          {}
+        end
+
+        def parse_svg(key, content)
+          doc  = REXML::Document.new(content)
+          root = doc.root
+
+          result = svg_defaults(key)
+          root.attributes.each_attribute do |attr|
+            result[SVG_RENAME.fetch(attr.name, attr.name.to_sym)] = attr.value
+          end
+
+          elements = parse_elements(root)
+          return if elements.empty?
+
+          result[:elements] = elements
+          result
+        end
+
+        def parse_elements(node)
+          node.elements.flat_map do |el|
+            el.name == "g" ? parse_elements(el) : [parse_element(el)].compact
+          end
+        end
+
+        def parse_element(node)
+          attrs = { tag: node.name.to_sym }
+          node.attributes.each_attribute do |attr|
+            attrs[ELEMENT_RENAME.fetch(attr.name, attr.name.tr("-", "_").to_sym)] = attr.value
+          end
+          attrs if attrs.size > 1
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/themes/icons/registry.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module StimulusPlumbers
+  module Themes
+    module Icons
+      class Registry < SimpleDelegator
+        attr_reader :aliases
+
+        def initialize(sources:, aliases: {})
+          @sources = sources
+          @aliases = aliases
+          super(
+            Hash.new do |h, key|
+              resolved = aliases.fetch(key, key)
+              value = nil
+              sources.each { |s| break if (value = s.fetch(resolved)) }
+              h[key] = value if value
+              value
+            end
+          )
+        end
+
+        def key?(name)
+          __getobj__.key?(name) ||
+            aliases.key?(name) ||
+            @sources.any? { |s| s.include?(aliases.fetch(name, name)) }
+        end
+        alias_method :include?, :key?
+        alias_method :has_key?, :key?
+        alias_method :member?, :key?
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/themes/schema/avatar/ranges.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Themes
+    module Schema
+      module Avatar
+        module Ranges
+          SIZE = %i[xs sm md lg xl].freeze
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/themes/schema/button/ranges.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Themes
+    module Schema
+      module Button
+        module Ranges
+          TYPE    = %i[default outline ghost fab fab_outline dashed card].freeze
+          SIZE    = %i[xs sm md lg xl].freeze
+          LAYOUT  = %i[stacked inline].freeze
+          VARIANT = %i[primary secondary tertiary success destructive warning info].freeze
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/themes/schema/card/ranges.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Themes
+    module Schema
+      module Card
+        module Ranges
+          VARIANT = %i[primary secondary tertiary success destructive warning info].freeze
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/themes/schema/form/checkbox/ranges.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Themes
+    module Schema
+      module Form
+        module Checkbox
+          module Ranges
+            TYPE    = %i[default button card].freeze
+            VARIANT = %i[primary secondary tertiary success destructive warning info].freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/themes/schema/form/radio/ranges.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Themes
+    module Schema
+      module Form
+        module Radio
+          module Ranges
+            TYPE    = %i[default button card].freeze
+            VARIANT = %i[primary secondary tertiary success destructive warning info].freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/themes/schema/form/ranges.rb

@@ -5,8 +5,7 @@ module StimulusPlumbers
     module Schema
       module Form
         module Ranges
-          LAYOUT         = %i[stacked inline].freeze
-          SUBMIT_VARIANT = %i[default button].freeze
+          LAYOUT = %i[stacked inline].freeze
         end
       end
     end

data/lib/stimulus_plumbers/themes/schema/icon.rb

@@ -4,27 +4,69 @@ module StimulusPlumbers
   module Themes
     module Schema
       module Icon
-        DEFAULTS = {
-          fill:            "none",
-          view_box:        "0 0 24 24",
-          width:           "24",
-          height:          "24",
-          stroke:          "currentColor",
-          stroke_width:    1.5,
-          stroke_linecap:  :round,
-          stroke_linejoin: :round
+        extend self
+
+        SVG_ATTR_DEFAULTS = {
+          xmlns:        "http://www.w3.org/2000/svg",
+          fill:         "none",
+          view_box:     "0 0 24 24",
+          width:        "24",
+          height:       "24",
+          stroke:       "currentColor",
+          stroke_width: 1.5
+        }.freeze
+
+        SVG_ATTR_NAMES = {
+          view_box:     "viewBox",
+          stroke_width: "stroke-width"
         }.freeze
 
-        ATTRS = ([:d] + DEFAULTS.keys).freeze
+        ELEMENT_ATTRS = {
+          path:     %i[d fill fill_rule clip_rule stroke_linecap stroke_linejoin opacity].freeze,
+          circle:   %i[cx cy r].freeze,
+          ellipse:  %i[cx cy rx ry].freeze,
+          rect:     %i[x y width height rx ry].freeze,
+          line:     %i[x1 y1 x2 y2].freeze,
+          polyline: %i[points].freeze,
+          polygon:  %i[points].freeze
+        }.freeze
+
+        ELEMENT_ATTR_NAMES = {
+          fill_rule:       "fill-rule",
+          clip_rule:       "clip-rule",
+          stroke_width:    "stroke-width",
+          stroke_linecap:  "stroke-linecap",
+          stroke_linejoin: "stroke-linejoin"
+        }.freeze
 
-        def self.resolve(icon_data)
+        def resolve(icon_data)
           return unless icon_data.is_a?(Hash)
 
-          merged = DEFAULTS.merge(icon_data.slice(*ATTRS)).transform_values(&:to_s)
-          return merged if merged[:d].present?
+          elements = Array(icon_data[:elements]).filter_map do |element|
+            next unless element.is_a?(Hash) && ELEMENT_ATTRS.key?(element[:tag])
+
+            { tag: element[:tag] }.merge(resolve_element_attrs(element))
+          end
+          return if elements.empty?
+
+          resolve_svg_attrs(icon_data).tap do |attrs|
+            attrs[:elements] = elements
+          end
+        end
+
+        private
+
+        def resolve_svg_attrs(svg_data)
+          SVG_ATTR_DEFAULTS
+            .merge(svg_data.slice(*SVG_ATTR_DEFAULTS.keys))
+            .transform_keys { |key| SVG_ATTR_NAMES.fetch(key, key.to_s) }
+            .transform_values(&:to_s)
+        end
 
-          StimulusPlumbers::Logger.warn("Icon missing required :d attribute")
-          nil
+        def resolve_element_attrs(element_data)
+          element_data.slice(*ELEMENT_ATTRS[element_data[:tag]])
+                      .transform_keys { |key| ELEMENT_ATTR_NAMES.fetch(key, key.to_s) }
+                      .transform_values(&:to_s)
         end
       end
     end

data/lib/stimulus_plumbers/themes/schema/link/ranges.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Themes
+    module Schema
+      module Link
+        module Ranges
+          TYPE    = %i[default button card].freeze
+          VARIANT = %i[default success destructive warning info].freeze
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/themes/schema/ranges.rb

@@ -4,11 +4,7 @@ module StimulusPlumbers
   module Themes
     module Schema
       module Ranges
-        BOOL           = [true, false].freeze
-        SIZE           = %i[sm md lg].freeze
-        FLEX_ALIGN     = %i[left center right top bottom].freeze
-        FLEX_DIRECTION = %i[row col].freeze
-        BUTTON_VARIANT = %i[primary secondary outline destructive ghost link].freeze
+        BOOL = [true, false].freeze
       end
     end
   end