stimulus_plumbers 0.3.3 → 0.4.0

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

@@ -6,14 +6,15 @@ module StimulusPlumbers
       module Inputs
         module File
           def file_field(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_file, error: error))
-              super(attribute, html_options)
-            end
+            html_options = merge_html_options(theme.resolve(:form_field_input_file), options)
+            super(attribute, html_options)
+          end
+
+          private
+
+          def render_file_input(attribute, html_opts, opts, error, **kwargs)
+            html_options = merge_html_options(theme.resolve(:form_field_input_file, error: error), opts, html_opts, kwargs)
+            @template.file_field(@object_name, attribute, objectify_options(html_options))
           end
         end
       end

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

@@ -6,47 +6,54 @@ module StimulusPlumbers
       module Inputs
         module Password
           def password_field(attribute, options = {})
-            reveal = options.delete(:reveal) { false }
-            Field.new(@template, **options).render(
-              object,
-              attribute,
-              input_id: field_id(attribute)
-            ) do |html_opts, opts, error|
-              if reveal
-                render_reveal_password(merge_html_options(opts, html_opts), error) do |html_options|
-                  super(attribute, html_options)
-                end
-              else
-                html_options = merge_html_options(opts, html_opts, field_theme(:form_input, error: error))
-                super(attribute, html_options)
+            revealable = options.delete(:revealable) { false }
+            html_options = merge_html_options(theme.resolve(:form_field_input), options)
+            if revealable
+              render_revealable_password(false) do
+                super(attribute, merge_html_options(html_options, { data: { input_formatter_target: "input" } }))
               end
+            else
+              super(attribute, html_options)
             end
           end
 
           private
 
-          def render_reveal_password(html_opts, error, &block)
-            html_options = merge_html_options(
-              html_opts,
-              field_theme(:form_input, error: error),
-              { data: { input_formatter_target: "input" } }
-            )
+          def render_password_input(attribute, html_opts, opts, error, revealable: false, **kwargs)
+            if revealable
+              html_options = merge_html_options(
+                theme.resolve(:form_field_input, error: error),
+                opts,
+                html_opts,
+                kwargs,
+                { data: { input_formatter_target: "input" } }
+              )
+              render_revealable_password(error) do
+                @template.password_field(@object_name, attribute, objectify_options(html_options))
+              end
+            else
+              html_options = merge_html_options(theme.resolve(:form_field_input, error: error), opts, html_opts, kwargs)
+              @template.password_field(@object_name, attribute, objectify_options(html_options))
+            end
+          end
+
+          def render_revealable_password(error, &block)
             render_input_group(
               error:    error,
               trailing: method(:reveal_button),
               **merge_html_options(
-                field_theme(:form_input_reveal, error: error),
+                theme.resolve(:form_field_input_reveal, error: error),
                 { data: { controller: "input-formatter", input_formatter_format_value: "password" } }
               )
-            ) { @template.capture(html_options, &block) }
+            ) { @template.capture(&block) }
           end
 
           def reveal_button
             html_options = merge_html_options(
-              field_theme(:form_button_reveal),
+              theme.resolve(:form_field_input_button_reveal),
               {
                 type: "button",
-                aria: { label: "Show password", pressed: "false" },
+                aria: { label: I18n.t("stimulus_plumbers.form.password.show", default: "Show password"), pressed: "false" },
                 data: { input_formatter_target: "toggle", action: "click->input-formatter#toggle" }
               }
             )

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    module Fields
+      module Inputs
+        module Radio
+          def radio_button(attribute, tag_value, options = {})
+            html_options = merge_html_options(theme.resolve(:form_field_input_radio), options)
+            super(attribute, tag_value, html_options)
+          end
+
+          def collection_radio_buttons(
+            attribute,
+            collection,
+            value_method,
+            text_method,
+            options = {},
+            html_options = {},
+            &block
+          )
+            item_opts = merge_html_options(theme.resolve(:form_field_input_radio), html_options)
+            if block_given?
+              super(attribute, collection, value_method, text_method, options, item_opts, &block)
+            else
+              super(attribute, collection, value_method, text_method, options, item_opts) do |builder|
+                render_radio_button_label(builder, theme.resolve(:form_field_radio_label))
+              end
+            end
+          end
+
+          private
+
+          def render_collection_radio_button(attribute, collection, value_method, text_method, field_opts, **kwargs)
+            type    = kwargs.delete(:type)    { :default }
+            variant = kwargs.delete(:variant) { :default }
+            field = Field.new(@template, **{ layout: :inline }.deep_merge(field_opts))
+            render_fieldset(attribute, field) do |error|
+              item_opts = merge_html_options(
+                theme.resolve(:form_field_input_radio, error: error, type: type, variant: variant),
+                kwargs,
+                field.required ? { aria: { required: "true" } } : {}
+              )
+              @template.collection_radio_buttons(
+                @object_name, attribute, collection, value_method, text_method, {}, item_opts
+              ) do |builder|
+                render_radio_button_label(builder, theme.resolve(:form_field_radio_label, type: type, variant: variant))
+              end
+            end
+          end
+
+          def render_radio_button_label(builder, label_opts)
+            html_options = merge_html_options(label_opts)
+            builder.label(**html_options) { @template.safe_join([builder.radio_button, builder.text]) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,94 +1,71 @@
 # frozen_string_literal: true
 
+require_relative "combobox"
+
 module StimulusPlumbers
   module Form
     module Fields
       module Inputs
         module Search
-          def search_field(attribute, options = {})
-            html_native = options.delete(:html_native) { false }
-            clearable   = options.delete(:clearable) { false }
-            url         = options.delete(:url) { nil }
-            choices     = options.delete(:options) { [] }
-
-            Field.new(@template, **options).render(
-              object,
-              attribute,
-              input_id: field_id(attribute)
-            ) do |html_opts, opts, error|
-              if html_native
-                render_search_input(html_opts, opts, error, clearable: clearable) do |html_options|
-                  super(attribute, html_options)
-                end
-              else
-                render_search_combobox(
-                  attribute,
-                  html_opts,
-                  error,
-                  url:       url,
-                  clearable: clearable
-                ) do |combobox_opts, input_id, current_value|
-                  render_search_typeahead(attribute, input_id, combobox_opts, error, choices, current_value)
-                end
-              end
-            end
-          end
-
-          private
+          include Combobox
 
-          def render_search_input(html_opts, opts, error, clearable:, &block)
+          def search_field(attribute, options = {})
+            clearable    = options.delete(:clearable) { false }
             data         = clearable ? { data: { input_clearable_target: "input" } } : {}
-            html_options = merge_html_options(opts, html_opts, field_theme(:form_input, error: error), data)
-            input_html   = @template.capture(html_options, &block)
-
+            html_options = merge_html_options(theme.resolve(:form_field_input), options, data)
+            input_html   = super(attribute, html_options)
             return input_html unless clearable
 
             render_input_group(
               trailing: method(:clear_button),
-              error:    !!error,
-              **merge_html_options(field_theme(:form_input_clearable), { data: { controller: "input-clearable" } })
+              error:    false,
+              **merge_html_options(theme.resolve(:form_field_input_clearable), { data: { controller: "input-clearable" } })
             ) { input_html }
           end
 
-          def render_search_combobox(attribute, html_opts, error, url:, clearable:, &block)
+          private
+
+          def render_combobox_typeahead(attribute, html_opts, opts, error, url: nil, clearable: false, choices: [], **kwargs)
             current_value = object.respond_to?(attribute) ? object.public_send(attribute) : nil
-            input_id      = html_opts[:id]
-            opts          = Components::Combobox::Typeahead.default_opts.deep_merge(
-              input:   { value: current_value },
-              trigger: { data: clearable ? { input_clearable_target: "input" } : {}, aria: html_opts[:aria] },
-              popover: { data: url ? { combobox_dropdown_url_value: url } : {} }
+            combobox_html = render_typeahead_combobox(
+              attribute, html_opts, opts, error, current_value, clearable: clearable, choices: choices, url: url, **kwargs
             )
 
-            combobox_html = @template.capture(opts, input_id, current_value, &block)
             return combobox_html unless clearable
 
             render_input_group(
               trailing: method(:clear_button),
-              error:    !!error,
-              **merge_html_options(field_theme(:form_input_clearable), { data: { controller: "input-clearable" } })
+              error:    error,
+              **merge_html_options(theme.resolve(:form_field_input_clearable), { data: { controller: "input-clearable" } })
             ) { combobox_html }
           end
 
-          def render_search_typeahead(attribute, input_id, combobox_opts, error, choices, current_value)
+          def render_typeahead_combobox(attribute, html_opts, opts, error, current_value, clearable:, choices:, url:, **kwargs)
+            input_id      = html_opts[:id]
+            labelledby    = Field.label_id(input_id)
+            combobox_opts = {
+              input:   { value: current_value },
+              trigger: { data: clearable ? { input_clearable_target: "input" } : {}, aria: html_opts[:aria] },
+              **opts
+            }
             render_combobox(
               attribute,
               input_id: input_id,
               opts:     combobox_opts,
-              err:      error,
-              data:     {
-                input_combobox_combobox_dropdown_outlet: "##{Components::Combobox.popover_id_for(input_id)}",
-                action:                                  "input->input-combobox#onInput"
-              }
-            ) { Components::Combobox::Typeahead.new(@template).render(options: choices, value: current_value, labelledby: Field.label_id(input_id)) }
+              error:    error,
+              **kwargs
+            ) do |c|
+              c.typeahead(options: choices, value: current_value, labelledby: labelledby, url: url)
+            end
           end
 
           def clear_button
             Components::Button.new(@template).render(
               icon_leading: "close",
               **merge_html_options(
-                field_theme(:form_button_clear),
+                theme.resolve(:form_field_input_button_clear),
                 {
-                  aria:   { label: "Clear search" },
+                  aria:   { label: I18n.t("stimulus_plumbers.form.search.clear", default: "Clear search") },
                   hidden: true,
                   data:   { input_clearable_target: "clear", action: "click->input-clearable#clear" }
                 }

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

@@ -14,43 +14,32 @@ module StimulusPlumbers
               option_key_method,
               option_value_method,
               options = {},
-              html_options = {}
+              html_opts = {}
             )
-              html_native   = options.delete(:html_native) { false }
-              icon_leading  = options.delete(:icon_leading)
-              icon_trailing = options.delete(:icon_trailing) { "chevron-down" }
-              icons         = { icon_leading: icon_leading, icon_trailing: icon_trailing }
-              with_select_field(attribute, options, html_options) do |opts, merged, error|
-                if html_native
-                  super(
-                    attribute,
-                    collection,
-                    group_method,
-                    group_label_method,
-                    option_key_method,
-                    option_value_method,
-                    opts,
-                    merged
-                  )
-                else
-                  render_select_dropdown(attribute, opts, merged, err: error, **icons) do
-                    build_grouped_choices(collection, group_label_method, group_method, option_key_method, option_value_method)
-                  end
-                end
-              end
+              html_options = merge_html_options(theme.resolve(:form_select), html_opts)
+              super(
+                attribute,
+                collection,
+                group_method,
+                group_label_method,
+                option_key_method,
+                option_value_method,
+                options,
+                html_options
+              )
             end
-          end
 
-          private
+            private
 
-          def build_grouped_choices(collection, group_label_method, group_method, option_key_method, option_value_method)
-            collection.map do |group|
-              {
-                label:   group.public_send(group_label_method),
-                options: group.public_send(group_method).map do |item|
-                  [item.public_send(option_value_method), item.public_send(option_key_method)]
-                end
-              }
+            def build_grouped_choices(collection, group_label_method, group_method, option_key_method, option_value_method)
+              collection.map do |group|
+                {
+                  label:   group.public_send(group_label_method),
+                  options: group.public_send(group_method).map do |item|
+                    [item.public_send(option_value_method), item.public_send(option_key_method)]
+                  end
+                }
+              end
             end
           end
         end

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

@@ -6,52 +6,9 @@ module StimulusPlumbers
       module Inputs
         module Select
           module Timezone
-            def time_zone_select(attribute, priority_zones = nil, options = {}, html_options = {})
-              html_native   = options.delete(:html_native) { false }
-              icon_leading  = options.delete(:icon_leading)
-              icon_trailing = options.delete(:icon_trailing) { "chevron-down" }
-              icons         = { icon_leading: icon_leading, icon_trailing: icon_trailing }
-              with_select_field(attribute, options, html_options) do |opts, merged, error|
-                if html_native
-                  super(attribute, priority_zones, opts, merged)
-                else
-                  render_select_dropdown(attribute, opts, merged, err: error, **icons) do
-                    model = opts.delete(:model) { ActiveSupport::TimeZone }
-                    build_zone_choices(priority_zones, model.all)
-                  end
-                end
-              end
-            end
-
-            private
-
-            def build_zone_choices(priority_zones, all_zones)
-              return zone_options(all_zones) unless priority_zones
-
-              priority       = filter_priority_zones(priority_zones, all_zones)
-              priority_names = priority.to_set(&:name)
-              remaining      = all_zones.reject { |z| priority_names.include?(z.name) }
-              [
-                {
-                  label:   I18n.t("helpers.time_zone_select.priority_zones", default: "Suggested"),
-                  options: zone_options(priority)
-                },
-                {
-                  label:   I18n.t("helpers.time_zone_select.other_zones", default: "Other"),
-                  options: zone_options(remaining)
-                }
-              ]
-            end
-
-            def filter_priority_zones(priority_zones, all_zones)
-              case priority_zones
-              when Regexp then all_zones.select { |z| z.name.match?(priority_zones) }
-              else Array(priority_zones)
-              end
-            end
-
-            def zone_options(zones)
-              zones.map { |z| [z.to_s, z.name] }
+            def time_zone_select(attribute, priority_zones = nil, options = {}, html_opts = {})
+              html_options = merge_html_options(theme.resolve(:form_select), html_opts)
+              super(attribute, priority_zones, options, html_options)
             end
           end
         end

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

@@ -7,34 +7,11 @@ module StimulusPlumbers
         module Select
           module Weekday
             if ActionView.version >= Gem::Version.new("7.1")
-              def weekday_select(attribute, options = {}, html_options = {})
-                html_native   = options.delete(:html_native) { false }
-                icon_leading  = options.delete(:icon_leading)
-                icon_trailing = options.delete(:icon_trailing) { "chevron-down" }
-                icons         = { icon_leading: icon_leading, icon_trailing: icon_trailing }
-                with_select_field(attribute, options, html_options) do |opts, merged, error|
-                  if html_native
-                    super(attribute, opts, merged)
-                  else
-                    render_select_dropdown(attribute, opts, merged, err: error, **icons) do
-                      build_weekday_choices(opts)
-                    end
-                  end
-                end
+              def weekday_select(attribute, options = {}, html_opts = {})
+                html_options = merge_html_options(theme.resolve(:form_select), html_opts)
+                super(attribute, options, html_options)
               end
             end
-
-            private
-
-            def build_weekday_choices(opts)
-              index_as_value    = opts.delete(:index_as_value) { false }
-              day_format        = opts.delete(:day_format) { :day_names }
-              beginning_of_week = opts.delete(:beginning_of_week) { Date.beginning_of_week }
-
-              day_names = I18n.t("date.#{day_format}")
-              choices   = day_names.each_with_index.map { |name, i| index_as_value ? [name, i] : [name, name] }
-              choices.rotate(Date::DAYS_INTO_WEEK.fetch(beginning_of_week))
-            end
           end
         end
       end

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

@@ -1,86 +1,87 @@
 # frozen_string_literal: true
 
+require_relative "combobox"
+
 module StimulusPlumbers
   module Form
     module Fields
       module Inputs
         module Select
+          include Combobox
+
           def select(attribute, choices = nil, options = {}, html_options = {})
-            html_native   = options.delete(:html_native) { false }
-            icon_leading  = options.delete(:icon_leading)
-            icon_trailing = options.delete(:icon_trailing) { "chevron-down" }
-            icons         = { icon_leading: icon_leading, icon_trailing: icon_trailing }
-            with_select_field(attribute, options, html_options) do |opts, merged, error|
-              if html_native
-                super(attribute, choices, opts, merged)
-              else
-                render_select_dropdown(attribute, opts, merged, err: error, **icons) do
-                  Array(choices)
-                end
-              end
-            end
+            merged = merge_html_options(theme.resolve(:form_field_input_select), html_options)
+            super(attribute, choices, options, merged)
           end
 
-          def collection_select(
-            attribute,
-            collection,
-            value_method,
-            text_method,
-            options = {},
-            html_options = {}
-          )
-            html_native   = options.delete(:html_native) { false }
-            icon_leading  = options.delete(:icon_leading)
-            icon_trailing = options.delete(:icon_trailing) { "chevron-down" }
-            icons         = { icon_leading: icon_leading, icon_trailing: icon_trailing }
-            with_select_field(attribute, options, html_options) do |opts, merged, error|
-              if html_native
-                super(attribute, collection, value_method, text_method, opts, merged)
-              else
-                render_select_dropdown(attribute, opts, merged, err: error, **icons) do
-                  collection.map { |item| [item.public_send(text_method), item.public_send(value_method)] }
-                end
-              end
-            end
+          def collection_select(attribute, collection, value_method, text_method, options = {}, html_options = {})
+            merged = merge_html_options(theme.resolve(:form_field_input_select), html_options)
+            super(attribute, collection, value_method, text_method, options, merged)
           end
 
           private
 
-          def with_select_field(attribute, options, html_options)
-            Field.new(@template, **options).render(object, attribute, input_id: field_id(attribute)) do |html_opts, opts, error|
-              yield opts, merge_html_options(html_options, html_opts, field_theme(:form_select, error: error)), error
-            end
-          end
-
-          def render_select_dropdown(attribute, opts, html_opts, err:, icon_leading:, icon_trailing:)
-            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)
+          def render_combobox_dropdown(
+            attribute,
+            html_opts,
+            opts,
+            error,
+            icon_leading: nil,
+            icon_trailing: nil,
+            choices: [],
+            include_blank: nil,
+            prompt: nil,
+            selected: nil,
+            **kwargs
+          )
+            current_value = selected || (object.respond_to?(attribute) ? object.public_send(attribute) : nil)
+            all_choices   = build_select_dropdown_choices(Array(choices), include_blank: include_blank, prompt: prompt)
+            labelledby    = Field.label_id(html_opts[:id])
             combobox_opts = build_select_dropdown_opts(
-              html_opts,
-              current_value,
-              icon_leading:  icon_leading,
-              icon_trailing: icon_trailing
+              html_opts, current_value, opts: opts, icon_leading: icon_leading, icon_trailing: icon_trailing
             )
-            render_combobox(attribute, input_id: html_opts[:id], opts: combobox_opts, err: err) do
-              render_dropdown_component(choices, current_value, html_opts[:id])
+            render_combobox(
+              attribute,
+              input_id: html_opts[:id],
+              opts:     combobox_opts,
+              error:    error
+            ) do |c|
+              c.dropdown(options: all_choices, value: current_value, labelledby: labelledby, **kwargs)
             end
           end
 
-          def render_dropdown_component(choices, value, input_id)
-            Components::Combobox::Dropdown.new(@template).render(
-              options:    choices,
-              value:      value,
-              labelledby: Field.label_id(input_id)
-            )
+          def render_collection_combobox_dropdown(
+            attribute,
+            collection,
+            value_method,
+            text_method,
+            field_opts,
+            **kwargs
+          )
+            choices = collection.map { |item| [item.public_send(text_method), item.public_send(value_method)] }
+            render_field(:select, attribute, field_opts, { choices: choices, **kwargs })
+          end
+
+          def render_grouped_collection_combobox_dropdown(
+            attribute,
+            collection,
+            value_method,
+            text_method,
+            field_opts,
+            group_method:,
+            group_label_method:,
+            **kwargs
+          )
+            choices = build_grouped_choices(collection, group_label_method, group_method, value_method, text_method)
+            render_field(:select, attribute, field_opts, { choices: choices, **kwargs })
           end
 
-          def build_select_dropdown_opts(html_opts, current_value, icon_leading:, icon_trailing:)
-            Components::Combobox::Dropdown.default_opts.deep_merge(
+          def build_select_dropdown_opts(html_opts, current_value, opts:, icon_leading:, icon_trailing:)
+            {
               input:   { value: current_value },
-              trigger: html_opts.merge({ icon_leading: icon_leading, icon_trailing: icon_trailing }.compact)
-            )
+              trigger: { aria: html_opts[:aria], icon_leading: icon_leading, icon_trailing: icon_trailing }.compact,
+              **opts
+            }
           end
 
           def build_select_dropdown_choices(choices, include_blank:, prompt:)

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

@@ -10,13 +10,16 @@ module StimulusPlumbers
               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)
-            )
+            value ||= submit_default_value
+            type     = options.delete(:type)    { :default }
+            variant  = options.delete(:variant) { :primary }
+
+            Components::Button.new(@template).build(type: type, variant: variant) do |attrs|
+              @template.tag.button(
+                type: "submit",
+                **merge_html_options(attrs, options)
+              ) { value }
+            end
           end
         end
       end