stimulus_plumbers 0.2.9 → 0.3.1

data/lib/stimulus_plumbers/form/fields/inputs/select.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    module Fields
+      module Inputs
+        module Select
+          def select(attribute, choices = nil, options = {}, html_options = {})
+            html_native = options.delete(:html_native) { false }
+            Field.new(@template, **options).render(
+              object,
+              attribute,
+              input_id: field_id(attribute)
+            ) do |html_opts, opts, error|
+              merged_html_opts = merge_html_options(html_options, html_opts, field_theme(:form_select, error: error))
+              if html_native
+                super(attribute, choices, opts, merged_html_opts)
+              else
+                render_select_dropdown(attribute, opts, merged_html_opts, err: error) { Array(choices) }
+              end
+            end
+          end
+
+          def collection_select(
+            attribute,
+            collection,
+            value_method,
+            text_method,
+            options = {},
+            html_options = {}
+          )
+            html_native = options.delete(:html_native) { false }
+            Field.new(@template, **options).render(
+              object,
+              attribute,
+              input_id: field_id(attribute)
+            ) do |html_opts, opts, error|
+              merged_html_opts = merge_html_options(html_options, html_opts, field_theme(:form_select, error: error))
+              if html_native
+                super(attribute, collection, value_method, text_method, opts, merged_html_opts)
+              else
+                render_select_dropdown(attribute, opts, merged_html_opts, err: error) do
+                  collection.map { |item| [item.public_send(text_method), item.public_send(value_method)] }
+                end
+              end
+            end
+          end
+
+          private
+
+          def render_select_dropdown(attribute, opts, html_opts, err:)
+            include_blank = opts.delete(:include_blank)
+            prompt        = opts.delete(:prompt)
+            current_value = opts.delete(:selected) { object.respond_to?(attribute) ? object.public_send(attribute) : nil }
+            choices       = build_select_dropdown_choices(yield(current_value), include_blank: include_blank, prompt: prompt)
+
+            combobox_opts = build_select_dropdown_opts(html_opts, current_value)
+            render_combobox(attribute, input_id: html_opts[:id], opts: combobox_opts, err: err) do
+              Components::Combobox::Dropdown.new(@template).render(
+                options:    choices,
+                value:      current_value,
+                labelledby: Field.label_id(html_opts[:id])
+              )
+            end
+          end
+
+          def build_select_dropdown_opts(html_opts, current_value)
+            Components::Combobox::Dropdown.default_opts.deep_merge(
+              input:   { value: current_value },
+              trigger: html_opts
+            )
+          end
+
+          def build_select_dropdown_choices(choices, include_blank:, prompt:)
+            return choices unless include_blank || prompt
+
+            choices = choices.dup
+            choices.unshift([include_blank.is_a?(String) ? include_blank : "", ""]) if include_blank
+            choices.unshift(build_select_dropdown_choice_prompt(prompt)) if prompt
+            choices
+          end
+
+          def build_select_dropdown_choice_prompt(prompt)
+            label = prompt.is_a?(String) ? prompt : I18n.t("helpers.select.prompt", default: "Please select")
+            [label, "", { disabled: true }]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/form/fields/inputs/submit.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    module Fields
+      module Inputs
+        module Submit
+          def submit(value = nil, options = {})
+            if value.is_a?(Hash)
+              options = value
+              value = nil
+            end
+            value   ||= submit_default_value
+            variant   = options.delete(:variant) { :default }
+            @template.tag.input(
+              type:  "submit",
+              value: value,
+              **merge_html_options(field_theme(:form_submit, variant: variant), options)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/form/fields/inputs/text.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    module Fields
+      module Inputs
+        module Text
+          FIELD_TYPES = %i[
+            color_field
+            datetime_local_field
+            email_field
+            month_field
+            number_field
+            range_field
+            telephone_field
+            text_field
+            url_field
+            week_field
+          ].freeze
+
+          FIELD_TYPES.each do |method_name|
+            define_method(method_name) do |attribute, options = {}|
+              Field.new(@template, **options).render(
+                object,
+                attribute,
+                input_id: field_id(attribute)
+              ) do |html_opts, opts, error|
+                html_options = merge_html_options(opts, html_opts, field_theme(:form_input, error: error))
+                super(attribute, html_options)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/form/fields/inputs/text_area.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    module Fields
+      module Inputs
+        module TextArea
+          def text_area(attribute, options = {})
+            Field.new(@template, **options).render(
+              object,
+              attribute,
+              input_id: field_id(attribute)
+            ) do |html_opts, opts, error|
+              html_options = merge_html_options(opts, html_opts, field_theme(:form_textarea, error: error))
+              super(attribute, html_options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/form/fields/label.rb

@@ -4,16 +4,20 @@ module StimulusPlumbers
   module Form
     module Fields
       class Label < Plumber::Base
-        def render(text:, for_id:, required: false, hidden: false)
-          klass = theme.resolve(:form_label, required: required, hidden: hidden).fetch(:classes, "")
-
-          inner = text.dup.html_safe
-          if required
-            mark_klass = theme.resolve(:form_required_mark).fetch(:classes, "")
-            inner += template.content_tag(:span, "*", "aria-hidden": "true", class: mark_klass.presence)
+        def render(text:, for_id: nil, id: nil, required: false, hidden: false, tag: :label)
+          mark_options = required && merge_html_options(
+            { aria: { hidden: true } },
+            theme.resolve(:form_required_mark)
+          )
+          html_options = merge_html_options(theme.resolve(:form_label, required: required, hidden: hidden))
+          template.content_tag(tag, for: for_id, id: id, **html_options) do
+            template.safe_join(
+              [
+                text,
+                mark_options ? template.content_tag(:span, "*", **mark_options) : nil
+              ]
+            )
           end
-
-          template.content_tag(:label, inner, for: for_id, class: klass.presence)
         end
       end
     end

data/lib/stimulus_plumbers/helpers/calendar_helper.rb

@@ -5,7 +5,7 @@ module StimulusPlumbers
     module CalendarHelper
       def sp_calendar_month(date: nil, **html_options, &block)
         if date
-          html_options.deep_merge!(
+          html_options = html_options.deep_merge(
             data: {
               "calendar-month-year-value":  date.year,
               "calendar-month-month-value": date.month - 1,

data/lib/stimulus_plumbers/helpers/combobox_helper.rb

@@ -4,70 +4,63 @@ 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 },
-          popover: { content: Components::Combobox::Date.new(self).render(value: value) }
+          trigger: { id: id, aria_label: label }.compact
         )
-        opts = opts.deep_merge(trigger: { aria_label: label }) if label
         Components::Combobox.new(self).render(
-          base_id: sp_dom_id,
-          options: opts,
-          data:    { input_format_type_value: "date" },
+          **opts,
+          data: { input_format_type_value: "date" },
           **html_options
-        )
+        ) do |popover_id|
+          Components::Combobox::Date.new(self).render(value: value, popover_id: popover_id)
+        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 },
-          popover: { content: Components::Combobox::Dropdown.new(self).render(options: options, value: value, label: label) }
-        )
-        opts = opts.deep_merge(trigger: { aria_label: label }) if label
-        Components::Combobox.new(self).render(
-          base_id: sp_dom_id,
-          options: opts,
-          **html_options
+          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)
+        end
       end
 
       def sp_combobox_autocomplete(label: nil, options: [], value: nil, url: nil, **html_options)
-        id         = sp_dom_id
-        popover_id = "#{id}_popover"
-        opts       = Components::Combobox::Autocomplete.default_opts.deep_merge(
+        id   = sp_dom_id
+        opts = Components::Combobox::Autocomplete.default_opts.deep_merge(
           input:   { value: value },
-          popover: {
-            content: Components::Combobox::Autocomplete.new(self).render(
-              options: options,
-              value:   value,
-              label:   label
-            ),
-            data:    url ? { combobox_dropdown_url_value: url } : {}
-          }
+          trigger: { id: id, aria_label: label }.compact,
+          popover: { data: url ? { combobox_dropdown_url_value: url } : {} }
         )
-        opts = opts.deep_merge(trigger: { aria_label: label }) if label
         Components::Combobox.new(self).render(
-          base_id: id,
-          options: opts,
-          data:    {
-            input_combobox_combobox_dropdown_outlet: "##{popover_id}",
+          **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)
+        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 },
-          popover: { content: Components::Combobox::Time.new(self).render(format: format, step: step, value: value) }
+          trigger: { id: id, aria_label: label }.compact
         )
-        opts = opts.deep_merge(trigger: { aria_label: label }) if label
         Components::Combobox.new(self).render(
-          base_id: sp_dom_id,
-          options: opts,
-          data:    { input_format_type_value: "time", input_format_options_value: { format: format }.to_json },
+          **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)
+        end
       end
     end
   end

data/lib/stimulus_plumbers/helpers/divider_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Helpers
+    module DividerHelper
+      def sp_divider(**html_options)
+        Components::Divider.new(self).render(**html_options)
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/helpers.rb

@@ -8,6 +8,7 @@ require_relative "helpers/calendar_helper"
 require_relative "helpers/calendar_turbo_helper"
 require_relative "helpers/card_helper"
 require_relative "helpers/combobox_helper"
+require_relative "helpers/divider_helper"
 require_relative "helpers/popover_helper"
 
 module StimulusPlumbers
@@ -20,6 +21,7 @@ module StimulusPlumbers
     include CalendarTurboHelper
     include CardHelper
     include ComboboxHelper
+    include DividerHelper
     include PopoverHelper
   end
 end

data/lib/stimulus_plumbers/plumber/base.rb

@@ -13,7 +13,7 @@ module StimulusPlumbers
       end
 
       def theme
-        StimulusPlumbers.config.theme
+        StimulusPlumbers.config.theme.current
       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

@@ -1,96 +1,13 @@
 # frozen_string_literal: true
 
-# :markup: markdown
+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
-      class MethodCall
-        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)
-          accepts_args = method_call.arity.negative? ? args : args.take(method_call.arity)
-          accepts_kwargs = method_call.parameters.any? { |type, _| %i[key keyreq keyrest].include?(type) }
-          accepts_kwargs ? method_call.call(*accepts_args, **kwargs) : method_call.call(*accepts_args)
-        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
-
-      class InstanceExec
-        attr_reader :block, :args, :kwargs
-
-        def initialize(block, *args, **kwargs)
-          @block = block
-          @args = args
-          @kwargs = kwargs
-          validate!
-        end
-
-        def call(target)
-          accepts_args = block.arity.negative? ? args : args.take(block.arity)
-          accepts_kwargs = block.parameters.any? { |type, _| %i[key keyreq keyrest].include?(type) }
-          if accepts_kwargs
-            target.instance_exec(
-              *accepts_args,
-              **kwargs,
-              &block
-            )
-          else
-            target.instance_exec(*accepts_args, &block)
-          end
-        end
-
-        private
-
-        def validate!
-          raise ArgumentError, "invalid block: #{block.inspect}" unless block.is_a?(Proc)
-        end
-      end
-
-      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
-
       def self.build(callable, *args, method_name: nil, init_args: [], init_kwargs: {}, **kwargs)
         case callable
         when Symbol

data/lib/stimulus_plumbers/plumber/html_options.rb

@@ -8,17 +8,18 @@ module StimulusPlumbers
       extend ActiveSupport::Concern
 
       def merge_html_options(*hashes)
-        classes     = hashes.flat_map { |h| [h[:class], h[:classes]] }
-        data_hashes = hashes.map { |h| h[:data] || {} }
+        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)
 
-        class_value = merge_string_option(*classes).presence
-        merged_data = merge_data_options(*data_hashes)
-
         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)

data/lib/stimulus_plumbers/plumber/renderer.rb

@@ -12,7 +12,7 @@ module StimulusPlumbers
       end
 
       module ClassMethods
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # 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?
@@ -26,7 +26,7 @@ module StimulusPlumbers
           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/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private