stimulus_plumbers 0.3.3 → 0.4.2

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

@@ -1,90 +1,84 @@
 # frozen_string_literal: true
 
+require_relative "combobox"
+
 module StimulusPlumbers
   module Form
     module Fields
       module Inputs
         module Datetime
+          include Combobox
+
           def date_field(attribute, options = {})
-            html_native   = options.delete(:html_native) { false }
-            icon_leading  = options.delete(:icon_leading)
-            icon_trailing = options.delete(:icon_trailing) { "calendar" }
-            Field.new(@template, **options).render(
-              object,
-              attribute,
-              input_id: field_id(attribute)
-            ) do |html_opts, opts, error|
-              if html_native
-                html_options = merge_html_options(opts, html_opts, field_theme(:form_input, error: error))
-                super(attribute, html_options)
-              else
-                render_date_combobox(attribute, html_opts, error, icon_leading: icon_leading, icon_trailing: icon_trailing)
-              end
-            end
+            html_options = merge_html_options(theme.resolve(:form_field_input), options)
+            super(attribute, html_options)
           end
 
           def time_field(attribute, options = {})
-            html_native   = options.delete(:html_native) { false }
-            format        = options.delete(:format) { :h12 }
-            step          = options.delete(:step) { 1 }
-            icon_leading  = options.delete(:icon_leading)
-            icon_trailing = options.delete(:icon_trailing) { "clock" }
-            Field.new(@template, **options).render(
-              object,
-              attribute,
-              input_id: field_id(attribute)
-            ) do |html_opts, opts, error|
-              if html_native
-                html_options = merge_html_options(opts, html_opts, field_theme(:form_input, error: error))
-                super(attribute, html_options)
-              else
-                render_time_combobox(
-                  attribute,
-                  html_opts,
-                  error,
-                  format:        format,
-                  step:          step,
-                  icon_leading:  icon_leading,
-                  icon_trailing: icon_trailing
-                )
-              end
-            end
+            html_options = merge_html_options(theme.resolve(:form_field_input), options)
+            super(attribute, html_options)
           end
 
           private
 
-          def render_date_combobox(attribute, html_opts, error, icon_leading:, icon_trailing:)
+          def render_combobox_date(
+            attribute,
+            html_opts,
+            opts,
+            error,
+            floating: nil,
+            icon_leading: nil,
+            icon_trailing: nil,
+            **kwargs
+          )
             current_value = object.respond_to?(attribute) ? object.public_send(attribute) : nil
-            opts = Components::Combobox::Date.default_opts.deep_merge(
-              input:   { value: current_value, data: { combobox_date_date_value: current_value } },
+            labelledby    = Field.label_id(html_opts[:id])
+            combobox_opts = {
+              input:   { value: current_value },
               trigger: { aria: html_opts[:aria], icon_leading: icon_leading, icon_trailing: icon_trailing }.compact,
-              popover: { labelledby: Field.label_id(html_opts[:id]) }
-            )
+              **opts
+            }
             render_combobox(
               attribute,
               input_id: html_opts[:id],
-              opts:     opts,
-              err:      error,
-              data:     { input_formatter_format_value: "date" }
-            ) do |popover_id|
-              Components::Combobox::Date.new(@template).render(value: current_value, popover_id: popover_id)
+              opts:     combobox_opts,
+              error:    error,
+              floating: floating,
+              **kwargs
+            ) do |c|
+              c.date(value: current_value, labelledby: labelledby)
             end
           end
 
-          def render_time_combobox(attribute, html_opts, error, format:, step:, icon_leading:, icon_trailing:)
+          def render_combobox_time(
+            attribute,
+            html_opts,
+            opts,
+            error,
+            floating: nil,
+            format: :h12,
+            step: 1,
+            icon_leading: nil,
+            icon_trailing: nil,
+            **kwargs
+          )
             current_value = object.respond_to?(attribute) ? object.public_send(attribute) : nil
-            opts = Components::Combobox::Time.default_opts.deep_merge(
+            labelledby    = Field.label_id(html_opts[:id])
+            combobox_opts = {
               input:   { value: current_value },
               trigger: { aria: html_opts[:aria], icon_leading: icon_leading, icon_trailing: icon_trailing }.compact,
-              popover: { labelledby: Field.label_id(html_opts[:id]) }
-            )
+              **opts
+            }
             render_combobox(
               attribute,
               input_id: html_opts[:id],
-              opts:     opts,
-              err:      error,
-              data:     { input_formatter_format_value: "time", input_formatter_options_value: { format: format }.to_json }
-            ) { Components::Combobox::Time.new(@template).render(format: format, step: step, value: current_value) }
+              opts:     combobox_opts,
+              error:    error,
+              floating: floating,
+              **kwargs
+            ) do |c|
+              c.time(format: format, step: step, value: current_value, labelledby: labelledby)
+            end
           end
         end
       end

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

@@ -5,15 +5,21 @@ module StimulusPlumbers
     module Fields
       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
+          def file_field(attribute, floating: nil, **options)
+            html_options = merge_html_options(theme.resolve(:form_field_input_file, floating: floating), options)
+            super(attribute, html_options)
+          end
+
+          private
+
+          def render_file_input(attribute, html_opts, opts, error, floating: nil, **kwargs)
+            html_options = merge_html_options(
+              theme.resolve(:form_field_input_file, floating: floating, 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

@@ -5,52 +5,70 @@ module StimulusPlumbers
     module Fields
       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)
+          def password_field(attribute, floating: nil, revealable: false, **options)
+            html_options = merge_html_options(theme.resolve(:form_field_input, floating: floating), 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)
+          def render_password_input(attribute, html_opts, opts, error, floating: nil, revealable: false, **kwargs)
             html_options = merge_html_options(
+              theme.resolve(:form_field_input, floating: floating, error: error),
+              opts,
               html_opts,
-              field_theme(:form_input, error: error),
-              { data: { input_formatter_target: "input" } }
+              kwargs
             )
+            if revealable
+              render_revealable_password(error, floating: floating) do
+                revealable_html_options = merge_html_options(html_options, { data: { input_formatter_target: "input" } })
+                @template.password_field(@object_name, attribute, objectify_options(revealable_html_options))
+              end
+            else
+              @template.password_field(@object_name, attribute, objectify_options(html_options))
+            end
+          end
+
+          def render_revealable_password(error, floating: nil, &block)
             render_input_group(
               error:    error,
+              floating: floating,
               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),
-              {
-                type: "button",
-                aria: { label: "Show password", pressed: "false" },
-                data: { input_formatter_target: "toggle", action: "click->input-formatter#toggle" }
-              }
-            )
-            @template.content_tag(:button, "", **html_options)
+            build_reveal_button do
+              Components::Icon.new(@template).render(
+                name: "reveal",
+                aria: { hidden: "true" },
+                **theme.resolve(:button_icon)
+              )
+            end
+          end
+
+          def build_reveal_button(&block)
+            @template.content_tag(
+              :button,
+              **merge_html_options(
+                theme.resolve(:form_field_input_button_reveal),
+                {
+                  type: "button",
+                  aria: { label: I18n.t("stimulus_plumbers.form.password.show", default: "Show password"), pressed: "false" },
+                  data: { input_formatter_target: "toggle", action: "click->input-formatter#toggle" }
+                }
+              )
+            ) { @template.capture(&block) }
           end
         end
       end

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

@@ -0,0 +1,72 @@
+# 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), type)
+              end
+            end
+          end
+
+          def render_radio_button_label(builder, label_opts, type = :default)
+            html_options = merge_html_options(label_opts)
+            if %i[button card].include?(type)
+              group_options = merge_html_options(theme.resolve(:form_field_radio_item_group))
+              @template.content_tag(:div, **group_options) do
+                @template.safe_join(
+                  [
+                    builder.radio_button,
+                    builder.label(**html_options) { builder.text }
+                  ]
+                )
+              end
+            else
+              builder.label(**html_options) { @template.safe_join([builder.radio_button, builder.text]) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,99 +1,107 @@
 # 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
+          include Combobox
 
-          private
-
-          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)
-
-            return input_html unless clearable
-
+            html_options = merge_html_options(theme.resolve(:form_field_input), options, data)
             render_input_group(
-              trailing: method(:clear_button),
-              error:    !!error,
-              **merge_html_options(field_theme(:form_input_clearable), { data: { controller: "input-clearable" } })
-            ) { input_html }
+              trailing: clearable ? method(:clear_button) : nil,
+              error:    false,
+              **merge_html_options(
+                theme.resolve(:form_field_input_clearable),
+                clearable ? { data: { controller: "input-clearable" } } : {}
+              )
+            ) { super(attribute, html_options) }
           end
 
-          def render_search_combobox(attribute, html_opts, error, url:, clearable:, &block)
+          private
+
+          def render_combobox_typeahead(
+            attribute,
+            html_opts,
+            opts,
+            error,
+            floating: nil,
+            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(
+            labelledby    = Field.label_id(input_id)
+            combobox_opts = {
               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 = @template.capture(opts, input_id, current_value, &block)
-            return combobox_html unless clearable
+              trigger: {
+                data: clearable ? { input_clearable_target: "input" } : {},
+                aria: html_opts[:aria]
+              },
+              **opts
+            }
 
             render_input_group(
-              trailing: method(:clear_button),
-              error:    !!error,
-              **merge_html_options(field_theme(:form_input_clearable), { data: { controller: "input-clearable" } })
-            ) { combobox_html }
+              trailing: clearable ? method(:clear_button) : nil,
+              error:    error,
+              floating: floating,
+              **merge_html_options(theme.resolve(:form_field_input_clearable), { data: { controller: "input-clearable" } })
+            ) do
+              build_combobox_typeahead(
+                attribute,
+                combobox_opts,
+                input_id: input_id,
+                floating: floating,
+                error:    error,
+                **kwargs
+              ) do |c|
+                c.typeahead(options: choices, value: current_value, labelledby: labelledby, url: url)
+              end
+            end
           end
 
-          def render_search_typeahead(attribute, input_id, combobox_opts, error, choices, current_value)
+          def build_combobox_typeahead(attribute, opts, input_id:, floating:, error:, **kwargs, &block)
             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)) }
+              opts:     opts,
+              error:    error,
+              floating: floating,
+              **kwargs,
+              &block
+            )
           end
 
           def clear_button
-            Components::Button.new(@template).render(
-              icon_leading: "close",
+            build_clear_button do
+              Components::Icon.new(@template).render(
+                name: "close",
+                aria: { hidden: "true" },
+                **theme.resolve(:button_icon)
+              )
+            end
+          end
+
+          def build_clear_button(&block)
+            @template.content_tag(
+              :button,
               **merge_html_options(
-                field_theme(:form_button_clear),
+                theme.resolve(:form_field_input_button_clear),
                 {
-                  aria:   { label: "Clear search" },
+                  type:   "button",
                   hidden: true,
+                  aria:   { label: I18n.t("stimulus_plumbers.form.search.clear", default: "Clear search") },
                   data:   { input_clearable_target: "clear", action: "click->input-clearable#clear" }
                 }
               )
-            )
+            ) { @template.capture(&block) }
           end
         end
       end

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