stimulus_plumbers 0.3.2 → 0.4.0

data/lib/stimulus_plumbers/helpers/combobox_helper.rb

@@ -3,63 +3,43 @@
 module StimulusPlumbers
   module Helpers
     module ComboboxHelper
-      def sp_combobox_date(label: nil, value: nil, **html_options)
-        id   = sp_dom_id
-        opts = Components::Combobox::Date.default_opts.deep_merge(
-          input:   { value: value },
-          trigger: { id: id, aria_label: label }.compact
-        )
+      # Single entry point; panel type chosen by a block method (c.dropdown/date/...).
+      def sp_combobox(value: nil, label: nil, id: nil, close_on_select: nil, **kwargs, &block)
         Components::Combobox.new(self).render(
-          **opts,
-          data: { input_format_type_value: "date" },
-          **html_options
-        ) do |popover_id|
-          Components::Combobox::Date.new(self).render(value: value, popover_id: popover_id)
+          id:              id || sp_dom_id,
+          label:           label,
+          input:           { value: value },
+          close_on_select: close_on_select,
+          **kwargs,
+          &block
+        )
+      end
+
+      def sp_combobox_date(value: nil, label: nil, **kwargs)
+        sp_combobox(value: value, label: label, **kwargs) do |c|
+          panel_opts = { value: value }
+          panel_opts[:label] = label if label
+          c.date(**panel_opts)
         end
       end
 
-      def sp_combobox_dropdown(label: nil, options: [], value: nil, **html_options)
-        id   = sp_dom_id
-        opts = Components::Combobox::Dropdown.default_opts.deep_merge(
-          input:   { value: value },
-          trigger: { id: id, aria_label: label }.compact
-        )
-        Components::Combobox.new(self).render(**opts, **html_options) do
-          Components::Combobox::Dropdown.new(self).render(options: options, value: value, label: label)
+      def sp_combobox_dropdown(options: [], value: nil, label: nil, **kwargs)
+        sp_combobox(value: value, label: label, **kwargs) do |c|
+          c.dropdown(options: options, value: value, label: label)
         end
       end
 
-      def sp_combobox_autocomplete(label: nil, options: [], value: nil, url: nil, **html_options)
-        id   = sp_dom_id
-        opts = Components::Combobox::Autocomplete.default_opts.deep_merge(
-          input:   { value: value },
-          trigger: { id: id, aria_label: label }.compact,
-          popover: { data: url ? { combobox_dropdown_url_value: url } : {} }
-        )
-        Components::Combobox.new(self).render(
-          **opts,
-          data: {
-            input_combobox_combobox_dropdown_outlet: "##{Components::Combobox.popover_id_for(id)}",
-            action:                                  "input->input-combobox#onInput"
-          },
-          **html_options
-        ) do
-          Components::Combobox::Autocomplete.new(self).render(options: options, value: value, label: label)
+      def sp_combobox_typeahead(options: [], value: nil, label: nil, url: nil, **kwargs)
+        sp_combobox(value: value, label: label, **kwargs) do |c|
+          c.typeahead(options: options, value: value, label: label, url: url)
         end
       end
 
-      def sp_combobox_time(format: :h12, label: nil, step: 1, value: nil, **html_options)
-        id   = sp_dom_id
-        opts = Components::Combobox::Time.default_opts.deep_merge(
-          input:   { value: value },
-          trigger: { id: id, aria_label: label }.compact
-        )
-        Components::Combobox.new(self).render(
-          **opts,
-          data: { input_format_type_value: "time", input_format_options_value: { format: format }.to_json },
-          **html_options
-        ) do
-          Components::Combobox::Time.new(self).render(format: format, step: step, value: value)
+      def sp_combobox_time(format: :h12, step: 1, value: nil, label: nil, **kwargs)
+        sp_combobox(value: value, label: label, **kwargs) do |c|
+          panel_opts = { format: format, step: step, value: value }
+          panel_opts[:label] = label if label
+          c.time(**panel_opts)
         end
       end
     end

data/lib/stimulus_plumbers/helpers/divider_helper.rb

@@ -3,8 +3,8 @@
 module StimulusPlumbers
   module Helpers
     module DividerHelper
-      def sp_divider(**html_options)
-        Components::Divider.new(self).render(**html_options)
+      def sp_divider(label = nil, **kwargs)
+        Components::Divider.new(self).render(label, **kwargs)
       end
     end
   end

data/lib/stimulus_plumbers/helpers/icon_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Helpers
+    module IconHelper
+      def sp_icon(name:, **kwargs)
+        Components::Icon.new(self).render(name: name, **kwargs)
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/helpers/link_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Helpers
+    module LinkHelper
+      def sp_link(content = nil, **kwargs, &block)
+        Components::Link.new(self).render(content, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/helpers/list_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Helpers
+    module ListHelper
+      def sp_list(...)
+        Components::List.new(self).render(...)
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/helpers/plumber_helper.rb

@@ -3,12 +3,9 @@
 module StimulusPlumbers
   module Helpers
     module PlumberHelper
-      def sp_dom_id(record = nil, suffix = nil)
-        if record
-          dom_id(record, suffix)
-        else
-          "#{suffix}_#{SecureRandom.hex(8)}"
-        end
+      def sp_dom_id(record = nil, prefix: nil, suffix: nil)
+        base = record ? dom_id(record, prefix) : SecureRandom.hex(8)
+        ["sp", base, suffix].compact.join("_")
       end
     end
   end

data/lib/stimulus_plumbers/helpers/popover_helper.rb

@@ -3,8 +3,8 @@
 module StimulusPlumbers
   module Helpers
     module PopoverHelper
-      def sp_popover(interactive: true, **html_options, &block)
-        popover_renderer.render(interactive: interactive, **html_options, &block)
+      def sp_popover(...)
+        popover_renderer.render(...)
       end
 
       private

data/lib/stimulus_plumbers/helpers.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "helpers/plumber_helper"
-require_relative "helpers/action_list_helper"
+require_relative "helpers/icon_helper"
+require_relative "helpers/list_helper"
 require_relative "helpers/avatar_helper"
 require_relative "helpers/button_helper"
 require_relative "helpers/calendar_helper"
@@ -9,12 +10,14 @@ require_relative "helpers/calendar_turbo_helper"
 require_relative "helpers/card_helper"
 require_relative "helpers/combobox_helper"
 require_relative "helpers/divider_helper"
+require_relative "helpers/link_helper"
 require_relative "helpers/popover_helper"
 
 module StimulusPlumbers
   module Helpers
     include PlumberHelper
-    include ActionListHelper
+    include IconHelper
+    include ListHelper
     include AvatarHelper
     include ButtonHelper
     include CalendarHelper
@@ -22,6 +25,7 @@ module StimulusPlumbers
     include CardHelper
     include ComboboxHelper
     include DividerHelper
+    include LinkHelper
     include PopoverHelper
   end
 end

data/lib/stimulus_plumbers/logger.rb

@@ -4,17 +4,18 @@ module StimulusPlumbers
   module Logger
     LEVELS = %i[debug info warn error].freeze
 
-    module_function
-
     LEVELS.each do |level|
       define_method(level) do |message|
         tagged = StimulusPlumbers.config.log_formatter.call(message)
         if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
           Rails.logger.public_send(level, tagged)
         else
-          warn(tagged)
+          # Kernel.warn, not bare `warn` which would recurse into this module's own warn.
+          Kernel.warn(tagged)
         end
       end
     end
+
+    module_function(*LEVELS)
   end
 end

data/lib/stimulus_plumbers/plumber/base.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "options/html"
+require_relative "options/aria"
+require_relative "renderer"
+
 module StimulusPlumbers
   module Plumber
     class Base
-      include HtmlOptions
+      include Options::Html
+      include Options::Aria
       include Renderer
 
       attr_reader :template

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

@@ -4,20 +4,21 @@ module StimulusPlumbers
   module Plumber
     module Dispatcher
       class KlassProxy
-        attr_reader :klass, :method_name, :args, :kwargs, :init_args, :init_kwargs
+        attr_reader :klass, :method_name, :args, :kwargs, :init_args, :init_kwargs, :block
 
-        def initialize(klass, method_name, *args, init_args: [], init_kwargs: {}, **kwargs)
+        def initialize(klass, method_name, *args, init_args: [], init_kwargs: {}, **kwargs, &block)
           @klass       = klass
           @method_name = method_name
           @args        = args
           @kwargs      = kwargs
           @init_args   = init_args
           @init_kwargs = init_kwargs
+          @block       = block
           validate!
         end
 
         def call(_target)
-          klass.new(*init_args, **init_kwargs).public_send(method_name, *args, **kwargs)
+          klass.new(*init_args, **init_kwargs).public_send(method_name, *args, **kwargs, &@block)
         end
 
         private

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

@@ -6,12 +6,13 @@ module StimulusPlumbers
       class MethodCall
         include CallableInspector
 
-        attr_reader :method_name, :args, :kwargs
+        attr_reader :method_name, :args, :kwargs, :block
 
-        def initialize(method_name, *args, **kwargs)
+        def initialize(method_name, *args, **kwargs, &block)
           @method_name = method_name
           @args        = args
           @kwargs      = kwargs
+          @block       = block
           validate!
         end
 
@@ -20,7 +21,7 @@ module StimulusPlumbers
 
           method_call = target.method(method_name)
           dispatched  = args_for(method_call)
-          accepts_kwargs?(method_call) ? method_call.call(*dispatched, **kwargs) : method_call.call(*dispatched)
+          accepts_kwargs?(method_call) ? method_call.call(*dispatched, **kwargs, &@block) : method_call.call(*dispatched, &@block)
         end
 
         private

data/lib/stimulus_plumbers/plumber/dispatcher.rb

@@ -8,19 +8,19 @@ require_relative "dispatcher/klass_proxy"
 module StimulusPlumbers
   module Plumber
     module Dispatcher
-      def self.build(callable, *args, method_name: nil, init_args: [], init_kwargs: {}, **kwargs)
+      def self.build(callable, *args, method_name: nil, init_args: [], init_kwargs: {}, **kwargs, &block)
         case callable
         when Symbol
-          MethodCall.new(callable, *args, **kwargs)
+          MethodCall.new(callable, *args, **kwargs, &block)
         when Proc
           InstanceExec.new(callable, *args, **kwargs)
         when Module
-          KlassProxy.new(callable, method_name, *args, init_args: init_args, init_kwargs: init_kwargs, **kwargs)
+          KlassProxy.new(callable, method_name, *args, init_args: init_args, init_kwargs: init_kwargs, **kwargs, &block)
         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)
+          KlassProxy.new(klass, method_name, *args, init_args: init_args, init_kwargs: init_kwargs, **kwargs, &block)
         end
       end
     end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module StimulusPlumbers
+  module Plumber
+    module Options
+      module Aria
+        extend ActiveSupport::Concern
+
+        def labelled_aria(label, labelledby: nil)
+          { label: (label unless labelledby), labelledby: labelledby }.compact
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require_relative "theme"
+require_relative "stimulus"
+
+module StimulusPlumbers
+  module Plumber
+    module Options
+      module Html
+        extend ActiveSupport::Concern
+
+        included do
+          include Theme
+          include Stimulus
+        end
+
+        def merge_html_options(*hashes)
+          class_value = merge_theme_options(*hashes)
+          merged_data = merge_stimulus_data(*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
+      end
+    end
+  end
+end

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