stimulus_plumbers 0.2.8 → 0.3.0

data/lib/stimulus_plumbers/plumber/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Plumber
+    class Base
+      include HtmlOptions
+      include Renderer
+
+      attr_reader :template
+
+      def initialize(template)
+        @template = template
+      end
+
+      def theme
+        StimulusPlumbers.config.theme.current
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/plumber/dispatcher/callable_inspector.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Plumber
+    module Dispatcher
+      module CallableInspector
+        private
+
+        def args_for(callable)
+          callable.arity.negative? ? args : args.take(callable.arity)
+        end
+
+        def accepts_kwargs?(callable)
+          callable.parameters.any? { |type, _| %i[key keyreq keyrest].include?(type) }
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/plumber/dispatcher/instance_exec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Plumber
+    module Dispatcher
+      class InstanceExec
+        include CallableInspector
+
+        attr_reader :block, :args, :kwargs
+
+        def initialize(block, *args, **kwargs)
+          @block  = block
+          @args   = args
+          @kwargs = kwargs
+          validate!
+        end
+
+        def call(target)
+          dispatched = args_for(block)
+          if accepts_kwargs?(block)
+            target.instance_exec(*dispatched, **kwargs, &block)
+          else
+            target.instance_exec(*dispatched, &block)
+          end
+        end
+
+        private
+
+        def validate!
+          raise ArgumentError, "invalid block: #{block.inspect}" unless block.is_a?(Proc)
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/plumber/dispatcher/klass_proxy.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Plumber
+    module Dispatcher
+      class KlassProxy
+        attr_reader :klass, :method_name, :args, :kwargs, :init_args, :init_kwargs
+
+        def initialize(klass, method_name, *args, init_args: [], init_kwargs: {}, **kwargs)
+          @klass       = klass
+          @method_name = method_name
+          @args        = args
+          @kwargs      = kwargs
+          @init_args   = init_args
+          @init_kwargs = init_kwargs
+          validate!
+        end
+
+        def call(_target)
+          klass.new(*init_args, **init_kwargs).public_send(method_name, *args, **kwargs)
+        end
+
+        private
+
+        def validate!
+          raise ArgumentError, "invalid class: #{klass.inspect}" unless klass.is_a?(Module)
+          return if method_name.is_a?(String) || method_name.is_a?(Symbol)
+
+          raise ArgumentError, "invalid method name: #{method_name.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/plumber/dispatcher/method_call.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Plumber
+    module Dispatcher
+      class MethodCall
+        include CallableInspector
+
+        attr_reader :method_name, :args, :kwargs
+
+        def initialize(method_name, *args, **kwargs)
+          @method_name = method_name
+          @args        = args
+          @kwargs      = kwargs
+          validate!
+        end
+
+        def call(target)
+          raise NotImplementedError, "#{method_name.inspect} not implemented" unless target.respond_to?(method_name, true)
+
+          method_call = target.method(method_name)
+          dispatched  = args_for(method_call)
+          accepts_kwargs?(method_call) ? method_call.call(*dispatched, **kwargs) : method_call.call(*dispatched)
+        end
+
+        private
+
+        def validate!
+          return if method_name.is_a?(String) || method_name.is_a?(Symbol)
+
+          raise ArgumentError, "invalid method name: #{method_name.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/plumber/dispatcher.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "dispatcher/callable_inspector"
+require_relative "dispatcher/method_call"
+require_relative "dispatcher/instance_exec"
+require_relative "dispatcher/klass_proxy"
+
+module StimulusPlumbers
+  module Plumber
+    module Dispatcher
+      def self.build(callable, *args, method_name: nil, init_args: [], init_kwargs: {}, **kwargs)
+        case callable
+        when Symbol
+          MethodCall.new(callable, *args, **kwargs)
+        when Proc
+          InstanceExec.new(callable, *args, **kwargs)
+        when Module
+          KlassProxy.new(callable, method_name, *args, init_args: init_args, init_kwargs: init_kwargs, **kwargs)
+        when String
+          klass = callable.safe_constantize
+          raise ArgumentError, "could not resolve class from: #{callable.inspect}" unless klass
+
+          KlassProxy.new(klass, method_name, *args, init_args: init_args, init_kwargs: init_kwargs, **kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/plumber/html_options.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module StimulusPlumbers
+  module Plumber
+    module HtmlOptions
+      extend ActiveSupport::Concern
+
+      def merge_html_options(*hashes)
+        class_value = merge_string_option(*extract_classes(*hashes)).presence
+        merged_data = merge_data_options(*hashes.map { |h| h[:data] || {} })
+        rest        = hashes.map { |h| h.except(:class, :classes, :data) }.reduce({}, :deep_merge)
+
+        result = class_value ? rest.merge(class: class_value) : rest
+        merged_data.present? ? result.merge(data: merged_data) : result
+      end
+
+      def extract_classes(*hashes)
+        hashes.flat_map { |h| [h[:class], h[:classes]] }
+      end
+
+      STIMULUS_SPACEJOIN_KEYS = %i[controller action].freeze
+
+      def merge_data_options(*hashes, spacejoin: STIMULUS_SPACEJOIN_KEYS)
+        hashes.reduce({}) do |acc, d|
+          acc.merge(d) do |key, old_val, new_val|
+            if spacejoin.include?(key.to_sym)
+              merge_string_option(old_val, new_val).presence || new_val
+            else
+              new_val
+            end
+          end
+        end
+      end
+
+      def merge_string_option(*parts, delimiter: " ")
+        tokens = parts.flat_map { |part| normalize_part(part, delimiter) }
+        tokens.compact.uniq.join(delimiter)
+      end
+
+      def normalize_part(value, delimiter)
+        case value
+        when String then value.present? ? value.split(delimiter) : []
+        when Hash then value.filter_map { |key, val| key if val }
+        when Array then [merge_string_option(*value).presence]
+        else []
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/plumber/renderer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module StimulusPlumbers
+  module Plumber
+    module Renderer
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :renderers, instance_writer: false, default: {}
+      end
+
+      module ClassMethods
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def renders(method_name, with: nil, &block)
+          raise ArgumentError, "method_name must be Symbol" unless method_name.is_a?(Symbol)
+          raise ArgumentError, "provide either with: or a block" if !with.nil? && block_given?
+
+          with = block if block_given?
+
+          with_proc_or_symbol = with.is_a?(Proc) || with.is_a?(Symbol)
+          with_klazz = with.is_a?(Module) || with.is_a?(String)
+          raise ArgumentError, "with: must be a Symbol/Proc/Class" unless with_proc_or_symbol || with_klazz
+
+          self.renderers = renderers.merge(method_name => with)
+          ActiveSupport.version >= "7.2" ? generate_renderer_method(method_name) : eval_renderer_method(method_name)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        private
+
+        def generated_renderer_methods
+          @generated_renderer_methods ||= Module.new.tap { |mod| prepend mod }
+        end
+
+        def eval_renderer_method(method_name)
+          generated_renderer_methods.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            # def method_name(*args, **kwargs)
+            #   renderer = renderers.fetch(:method_name, {})
+            #
+            #   unless renderer.present?
+            #     raise ArgumentError, "#method_name not found in renderer" unless defined?(super)
+            #     super
+            #   end
+            #
+            #   dispatcher = StimulusPlumbers::Plumber::Dispatcher.build(
+            #     renderer, *args, method_name: :#{method_name}, init_args: [template], **kwargs
+            #   )
+            #   raise ArgumentError, "invalid renderer, got: \#{renderer.inspect}" unless dispatcher
+            #
+            #   dispatcher.call(self)
+            # end
+            #{renderer_method_template(method_name)}
+          RUBY
+        end
+
+        def generate_renderer_method(method_name)
+          require "active_support/code_generator"
+          ActiveSupport::CodeGenerator.batch(generated_renderer_methods, __FILE__, __LINE__) do |owner|
+            owner.define_cached_method(method_name, namespace: :plumber_renderers) do |batch|
+              batch << renderer_method_template(method_name)
+            end
+          end
+        end
+
+        def renderer_method_template(method_name)
+          <<-RUBY
+          def #{method_name}(*args, **kwargs)
+            renderer = renderers.fetch(:#{method_name}, {})
+
+            unless renderer.present?
+              raise ArgumentError, "##{method_name} not found in renderer" unless defined?(super)
+              super
+            end
+
+            dispatcher = StimulusPlumbers::Plumber::Dispatcher.build(
+              renderer, *args, method_name: :#{method_name}, init_args: [template], **kwargs
+            )
+            raise ArgumentError, "invalid renderer, got: \#{renderer.inspect}" unless dispatcher
+
+            dispatcher.call(self)
+          end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/themes/base.rb

@@ -1,31 +1,41 @@
 # frozen_string_literal: true
 
-require_relative "schema/ranges"
-require_relative "base/action_list"
-require_relative "base/avatar"
-require_relative "base/button"
-require_relative "base/calendar"
-require_relative "base/card"
-require_relative "base/form"
-require_relative "base/layout"
+require_relative "schema"
 
 module StimulusPlumbers
   module Themes
     class Base
       SCHEMA = {
-        **ActionList::SCHEMA,
-        **Avatar::SCHEMA,
-        **Button::SCHEMA,
-        **Calendar::SCHEMA,
-        **Card::SCHEMA,
-        **Form::SCHEMA,
-        **Layout::SCHEMA
+        **Schema::ACTION_LIST,
+        **Schema::AVATAR,
+        **Schema::BUTTON,
+        **Schema::CALENDAR,
+        **Schema::CARD,
+        **Schema::COMBOBOX,
+        **Schema::FORM,
+        **Schema::LAYOUT
       }.freeze
 
       def name
         @name ||= self.class.name.demodulize.delete_suffix("Theme")
       end
 
+      def avatar_colors
+        {}
+      end
+
+      def avatar_color_range
+        []
+      end
+
+      def icons
+        {}
+      end
+
+      def icon_range
+        icons.keys
+      end
+
       def attribute_names(component)
         SCHEMA.fetch(component, {}).keys
       end
@@ -55,11 +65,7 @@ module StimulusPlumbers
       def coerce_arg(component, key, value, schema)
         return value unless schema
 
-        range = if schema[:range].is_a?(Symbol)
-                  respond_to?(schema[:range], true) ? send(schema[:range]) : []
-                else
-                  schema[:range]
-                end
+        range = range_for(schema)
         return value if range.empty? || range.include?(value)
 
         StimulusPlumbers::Logger.warn(
@@ -68,6 +74,14 @@ module StimulusPlumbers
         )
         schema[:default]
       end
+
+      def range_for(schema)
+        if schema[:range].is_a?(Symbol)
+          respond_to?(schema[:range], true) ? send(schema[:range]) : []
+        else
+          schema[:range]
+        end
+      end
     end
   end
 end

data/lib/stimulus_plumbers/themes/configuration.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Themes
+    class Configuration
+      def register(name, klass)
+        raise ArgumentError, "#{klass} must be a subclass of Themes::Base" unless klass <= Base
+
+        registry[name.to_sym] = klass
+        self
+      end
+
+      def use(name_or_instance)
+        @current = resolve(name_or_instance)
+        self
+      end
+
+      def current
+        @current ||= Base.new
+      end
+
+      def registry
+        @registry ||= {}
+      end
+
+      private
+
+      def resolve(value)
+        return value if value.is_a?(Base)
+
+        klass = registry[value.to_sym]
+        raise ArgumentError, "Unknown theme #{value.inspect}. Registered: #{registry.keys.inspect}" unless klass
+
+        klass.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Themes
+    module Schema
+      module Form
+        module Ranges
+          LAYOUT         = %i[stacked inline].freeze
+          SUBMIT_VARIANT = %i[default button].freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+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
+        }.freeze
+
+        ATTRS = ([:d] + DEFAULTS.keys).freeze
+
+        def self.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?
+
+          StimulusPlumbers::Logger.warn("Icon missing required :d attribute")
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -4,11 +4,11 @@ module StimulusPlumbers
   module Themes
     module Schema
       module Ranges
-        BOOL_RANGE   = [true, false].freeze
-        SIZE_RANGE   = %i[sm md lg].freeze
-        ALIGN_RANGE  = %i[left center right top bottom].freeze
-        DIR_RANGE    = %i[row col].freeze
-        LAYOUT_RANGE = %i[stacked inline].freeze
+        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
       end
     end
   end

data/lib/stimulus_plumbers/themes/schema.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "schema/ranges"
+require_relative "schema/form/ranges"
+require_relative "schema/icon"
+
+module StimulusPlumbers
+  module Themes
+    module Schema
+      ACTION_LIST = {
+        action_list_item: {
+          active: { default: false, range: Ranges::BOOL }
+        }.freeze,
+        action_list:      {}.freeze
+      }.freeze
+
+      AVATAR = {
+        avatar: {
+          size:  { default: :md, range: Ranges::SIZE },
+          color: { default: nil, range: :avatar_color_range }
+        }.freeze
+      }.freeze
+
+      BUTTON = {
+        button:       {
+          variant: { default: :primary, range: Ranges::BUTTON_VARIANT },
+          size:    { default: :md,      range: Ranges::SIZE }
+        }.freeze,
+        button_group: {
+          alignment: { default: :left, range: Ranges::FLEX_ALIGN },
+          direction: { default: :row,  range: Ranges::FLEX_DIRECTION }
+        }.freeze
+      }.freeze
+
+      CALENDAR = {
+        calendar:                           {}.freeze,
+        calendar_days_of_week:              {}.freeze,
+        calendar_week:                      {}.freeze,
+        calendar_days_of_month:             {}.freeze,
+        calendar_day:                       {
+          today:    { default: false, range: Ranges::BOOL },
+          selected: { default: false, range: Ranges::BOOL },
+          outside:  { default: false, range: Ranges::BOOL }
+        }.freeze,
+        calendar_navigation:                {}.freeze,
+        calendar_navigation_navigator:      {}.freeze,
+        calendar_navigation_navigator_icon: {
+          name: { default: "arrow-left", range: :icon_range }
+        }.freeze
+      }.freeze
+
+      CARD = {
+        card:         {}.freeze,
+        card_section: {}.freeze
+      }.freeze
+
+      COMBOBOX = {
+        combobox_trigger:              {}.freeze,
+        combobox_option:               {
+          selected: { default: false, range: Ranges::BOOL },
+          disabled: { default: false, range: Ranges::BOOL }
+        }.freeze,
+        combobox_option_group:         {}.freeze,
+        combobox_listbox:              {}.freeze,
+        combobox_autocomplete_loading: {}.freeze,
+        combobox_autocomplete_empty:   {}.freeze,
+        combobox_time:                 {}.freeze
+      }.freeze
+
+      FORM = {
+        form_group:         {
+          layout: { default: :stacked, range: Form::Ranges::LAYOUT },
+          error:  { default: false,    range: Ranges::BOOL }
+        }.freeze,
+        form_label:         {
+          required: { default: false, range: Ranges::BOOL },
+          hidden:   { default: false, range: Ranges::BOOL }
+        }.freeze,
+        form_required_mark: {}.freeze,
+        form_details:       {}.freeze,
+        form_error:         {}.freeze,
+        form_input:         { error: { default: false, range: Ranges::BOOL } }.freeze,
+        form_textarea:      { error: { default: false, range: Ranges::BOOL } }.freeze,
+        form_file:          { error: { default: false, range: Ranges::BOOL } }.freeze,
+        form_select:        { error: { default: false, range: Ranges::BOOL } }.freeze,
+        form_checkbox:      { error: { default: false, range: Ranges::BOOL } }.freeze,
+        form_radio:         { error: { default: false, range: Ranges::BOOL } }.freeze,
+        form_input_group:   { error: { default: false, range: Ranges::BOOL } }.freeze,
+        form_combobox:      { error: { default: false, range: Ranges::BOOL } }.freeze,
+        form_input_reveal:  {}.freeze,
+        form_button_reveal: {}.freeze,
+        form_submit:        {
+          variant: { default: :default, range: Form::Ranges::SUBMIT_VARIANT }
+        }.freeze
+      }.freeze
+
+      LAYOUT = {
+        divider: {}.freeze,
+        popover: {}.freeze
+      }.freeze
+    end
+  end
+end

data/lib/stimulus_plumbers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StimulusPlumbers
-  VERSION = "0.2.8"
+  VERSION = "0.3.0"
 end