stimulus_plumbers 0.3.3 → 0.4.0

data/lib/stimulus_plumbers/plumber/options/stimulus.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require_relative "token_list"
+
+module StimulusPlumbers
+  module Plumber
+    module Options
+      module Stimulus
+        extend ActiveSupport::Concern
+        include TokenList
+
+        STIMULUS_SPACEJOIN_KEYS = %i[controller action].freeze
+
+        def merge_stimulus_data(*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_token_list(old_val, new_val).presence || new_val
+              else
+                new_val
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/plumber/options/theme.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require_relative "token_list"
+
+module StimulusPlumbers
+  module Plumber
+    module Options
+      module Theme
+        extend ActiveSupport::Concern
+        include TokenList
+
+        def merge_theme_options(*hashes)
+          merge_token_list(*hashes.flat_map { |h| [h[:class], h[:classes]] }).presence
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/plumber/options/token_list.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module StimulusPlumbers
+  module Plumber
+    module Options
+      module TokenList
+        extend ActiveSupport::Concern
+
+        def merge_token_list(*parts, delimiter: " ")
+          tokens = parts.flat_map { |part| normalize_part(part, delimiter) }
+          tokens.compact.uniq.join(delimiter)
+        end
+
+        private
+
+        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_token_list(*value).presence]
+          else []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/plumber/renderer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/concern"
+require_relative "dispatcher"
 
 module StimulusPlumbers
   module Plumber
@@ -11,78 +12,172 @@ module StimulusPlumbers
         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?
+      def set_slots
+        @set_slots ||= {}
+      end
+
+      def slot_renderable?(name)
+        slots = set_slots[name]
+        return false if slots.nil?
+        return false if slots.is_a?(StimulusPlumbers::Plumber::Slots) && slots.none?
+        return false if slots.is_a?(Array) && slots.empty?
+
+        true
+      end
+
+      def slot_kwargs_for(name)
+        case set_slots[name]
+        when StimulusPlumbers::Plumber::Slots then { slot: set_slots[name] }
+        when Array
+          values = set_slots[name]
+          { value: values.one? ? values.first : values }
+        else {}
+        end
+      end
+
+      def slot_block_for(name)
+        slots = set_slots[name]
+        slots if slots.is_a?(Proc)
+      end
 
+      module ClassMethods
+        def renders(method_name, with: nil, slots: nil, by: nil, &block)
+          validate!(method_name, with, slots, by, 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
+          if slots.present?
+            by = Class.new(StimulusPlumbers::Plumber::Slots)
+            by.slot(*slots)
+          end
+          self.renderers = renderers.merge(method_name => { with: with, by: by })
 
-          self.renderers = renderers.merge(method_name => with)
-          ActiveSupport.version >= "7.2" ? generate_renderer_method(method_name) : eval_renderer_method(method_name)
+          generate_renderer_method(method_name)
+          generate_slot_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 }
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def validate!(method_name, with, slots, by, has_block)
+          raise ArgumentError, "method_name must be a Symbol" unless method_name.is_a?(Symbol)
+          raise ArgumentError, "provide either with: or a block, not both" if with && has_block
+          raise ArgumentError, "slots: requires with:" if slots && with.nil? && !has_block
+          raise ArgumentError, "by: requires with:" if by && with.nil?
+          raise ArgumentError, "slots: and by: are mutually exclusive" if slots && by
+          raise ArgumentError, "by: must be a Class" if by && !by.is_a?(Class)
+
+          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 || has_block
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        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
+        def generated_renderer_methods
+          @generated_renderer_methods ||= Module.new.tap { |mod| prepend mod }
         end
 
         def generate_renderer_method(method_name)
+          return eval_renderer_method(method_name) if ActiveSupport.version < "7.2"
+
           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|
+            owner.define_cached_method(:"render_#{method_name}", namespace: :plumber_renderers) do |batch|
               batch << renderer_method_template(method_name)
             end
           end
         end
 
+        def eval_renderer_method(method_name)
+          generated_renderer_methods.module_eval(renderer_method_template(method_name), __FILE__, __LINE__)
+        end
+
         def renderer_method_template(method_name)
           <<-RUBY
-          def #{method_name}(*args, **kwargs)
-            renderer = renderers.fetch(:#{method_name}, {})
+          def render_#{method_name}(*args, **kwargs)
+            return nil unless slot_renderable?(:#{method_name})
 
-            unless renderer.present?
-              raise ArgumentError, "##{method_name} not found in renderer" unless defined?(super)
-              super
+            renderer = renderers.fetch(:#{method_name}, {})
+            target   = renderer[:with]
+            unless target
+              raise ArgumentError, "#render_#{method_name} not found" unless defined?(super)
+              return super
             end
 
             dispatcher = StimulusPlumbers::Plumber::Dispatcher.build(
-              renderer, *args, method_name: :#{method_name}, init_args: [template], **kwargs
+              target, *args,
+              init_args: [template],
+              init_kwargs: {},
+              method_name: :render,
+              **kwargs,
+              **slot_kwargs_for(:#{method_name}),
+              &slot_block_for(:#{method_name})
             )
-            raise ArgumentError, "invalid renderer, got: \#{renderer.inspect}" unless dispatcher
-
+            raise ArgumentError, "invalid renderer for :#{method_name}" unless dispatcher
             dispatcher.call(self)
           end
           RUBY
         end
+
+        def generated_slot_methods
+          @generated_slot_methods ||= Module.new.tap { |mod| prepend mod }
+        end
+
+        def generate_slot_method(method_name)
+          return eval_slot_method(method_name) if ActiveSupport.version < "7.2"
+
+          require "active_support/code_generator"
+          ActiveSupport::CodeGenerator.batch(generated_slot_methods, __FILE__, __LINE__) do |owner|
+            owner.define_cached_method(:"with_#{method_name}", namespace: :plumber_renderers) do |batch|
+              batch << slot_setter_template(method_name)
+            end
+            owner.define_cached_method(:"#{method_name}", namespace: :plumber_renderers) do |batch|
+              batch << slot_getter_template(method_name)
+            end
+            owner.define_cached_method(:"#{method_name}?", namespace: :plumber_renderers) do |batch|
+              batch << slot_predicate_template(method_name)
+            end
+          end
+        end
+
+        def eval_slot_method(method_name)
+          generated_slot_methods.module_eval(slot_setter_template(method_name), __FILE__, __LINE__)
+          generated_slot_methods.module_eval(slot_getter_template(method_name), __FILE__, __LINE__)
+          generated_slot_methods.module_eval(slot_predicate_template(method_name), __FILE__, __LINE__)
+        end
+
+        def slot_setter_template(method_name)
+          <<-RUBY
+          def with_#{method_name}(*values, &block)
+            klass = renderers.dig(:#{method_name}, :by)
+            if klass && block_given? && !block.arity.zero?
+              builder = klass.new
+              block.call(builder)
+              set_slots[:#{method_name}] = builder
+            elsif block_given?
+              set_slots[:#{method_name}] = block
+            else
+              set_slots[:#{method_name}] = values
+            end
+            nil
+          end
+          RUBY
+        end
+
+        def slot_getter_template(method_name)
+          <<-RUBY
+          def #{method_name}
+            set_slots[:#{method_name}]
+          end
+          RUBY
+        end
+
+        def slot_predicate_template(method_name)
+          <<-RUBY
+          def #{method_name}?
+            slot_renderable?(:#{method_name})
+          end
+          RUBY
+        end
       end
     end
   end

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

@@ -7,7 +7,7 @@ module StimulusPlumbers
   module Themes
     class Base
       SCHEMA = {
-        **Schema::ACTION_LIST,
+        **Schema::LIST,
         **Schema::AVATAR,
         **Schema::BUTTON,
         **Schema::CALENDAR,
@@ -16,18 +16,19 @@ module StimulusPlumbers
         **Schema::FORM,
         **Schema::ICON,
         **Schema::INPUT_GROUP,
-        **Schema::LAYOUT
+        **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
 
@@ -39,9 +40,6 @@ module StimulusPlumbers
         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)

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/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[xs sm md lg xl].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 fab dashed].freeze
+        BOOL = [true, false].freeze
       end
     end
   end