stimulus_plumbers 0.3.2 → 0.4.0

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    module Fields
+      module Inputs
+        module Checkbox
+          def check_box(attribute, options = {}, checked_value = "1", unchecked_value = "0")
+            html_options = merge_html_options(theme.resolve(:form_field_input_checkbox), options)
+            super(attribute, html_options, checked_value, unchecked_value)
+          end
+
+          def collection_check_boxes(
+            attribute,
+            collection,
+            value_method,
+            text_method,
+            options = {},
+            html_options = {},
+            &block
+          )
+            item_opts = merge_html_options(theme.resolve(:form_field_input_checkbox), 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_check_box_label(builder, theme.resolve(:form_field_checkbox_label))
+              end
+            end
+          end
+
+          private
+
+          def render_check_box(attribute, collection, value_method, text_method, field_opts, **kwargs)
+            if collection
+              render_collection_check_box(attribute, collection, value_method, text_method, field_opts, **kwargs)
+            else
+              render_single_check_box(attribute, field_opts, **kwargs)
+            end
+          end
+
+          def render_collection_check_box(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_checkbox, error: error, type: type, variant: variant),
+                kwargs,
+                field.required ? { aria: { required: "true" } } : {}
+              )
+              @template.collection_check_boxes(
+                @object_name, attribute, collection, value_method, text_method, {}, item_opts
+              ) do |builder|
+                render_check_box_label(builder, theme.resolve(:form_field_checkbox_label, type: type, variant: variant), type)
+              end
+            end
+          end
+
+          def render_check_box_label(builder, label_opts, type = :default)
+            html_options = merge_html_options(label_opts)
+            case type
+            when :card
+              builder.label(**html_options) { @template.safe_join([builder.text, builder.check_box]) }
+            else
+              builder.label(**html_options) { @template.safe_join([builder.check_box, builder.text]) }
+            end
+          end
+
+          def render_single_check_box(attribute, field_opts, checked_value: "1", unchecked_value: "0", **kwargs)
+            field    = Field.new(@template, **field_opts)
+            input_id = field_id(attribute)
+            error    = field.error?(object, attribute)
+
+            Fields::Group.new(@template).render(layout: :stacked, error: error) do
+              check_box_html = build_check_box_input(field, attribute, input_id, error, checked_value, unchecked_value, **kwargs)
+              @template.safe_join(
+                [
+                  build_check_box_label(field, attribute, input_id, check_box_html),
+                  field.render_hint(input_id),
+                  field.render_errors(object, attribute, input_id)
+                ]
+              )
+            end
+          end
+
+          def build_check_box_input(field, attribute, input_id, error, checked_value, unchecked_value, **kwargs)
+            check_box_opts = merge_html_options(
+              theme.resolve(:form_checkbox, error: error),
+              kwargs,
+              {
+                id:   input_id,
+                aria: {
+                  describedby: field.described_by(object, attribute, input_id),
+                  invalid:     error ? "true" : nil,
+                  required:    field.required ? "true" : nil
+                }.compact
+              },
+              field.required ? { required: true } : {}
+            )
+            @template.check_box(@object_name, attribute, objectify_options(check_box_opts), checked_value, unchecked_value)
+          end
+
+          def build_check_box_label(field, attribute, input_id, check_box_html)
+            label_opts = merge_html_options(theme.resolve(:form_field_checkbox_label))
+            label_text = field.label || attribute.to_s.humanize
+            @template.content_tag(:label, for: input_id, **label_opts) do
+              @template.safe_join([check_box_html, label_text])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    module Fields
+      module Inputs
+        module Combobox
+          private
+
+          def render_combobox(attribute, input_id:, opts:, error:, **kwargs, &block)
+            combobox_opts = opts.deep_merge(input: { name: field_name(attribute) })
+
+            Components::Combobox.new(@template).render(
+              id: input_id,
+              **combobox_opts,
+              **merge_html_options(theme.resolve(:form_field_input_combobox, error: error), kwargs),
+              &block
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,78 +1,72 @@
 # 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 }
-            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)
-              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 }
-            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)
-              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)
+          def render_combobox_date(attribute, html_opts, opts, error, 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 } },
-              trigger: { aria: html_opts[:aria] },
-              popover: { labelledby: Field.label_id(html_opts[:id]) }
-            )
+            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,
+              **opts
+            }
             render_combobox(
               attribute,
               input_id: html_opts[:id],
-              opts:     opts,
-              err:      error,
-              data:     { input_format_type_value: "date" }
-            ) do |popover_id|
-              Components::Combobox::Date.new(@template).render(value: current_value, popover_id: popover_id)
+              opts:     combobox_opts,
+              error:    error,
+              **kwargs
+            ) do |c|
+              c.date(value: current_value, labelledby: labelledby)
             end
           end
 
-          def render_time_combobox(attribute, html_opts, error, format:, step:)
+          def render_combobox_time(
+            attribute,
+            html_opts,
+            opts,
+            error,
+            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] },
-              popover: { labelledby: Field.label_id(html_opts[:id]) }
-            )
+              trigger: { aria: html_opts[:aria], icon_leading: icon_leading, icon_trailing: icon_trailing }.compact,
+              **opts
+            }
             render_combobox(
               attribute,
               input_id: html_opts[:id],
-              opts:     opts,
-              err:      error,
-              data:     { input_format_type_value: "time", input_format_options_value: { format: format }.to_json }
-            ) { Components::Combobox::Time.new(@template).render(format: format, step: step, value: current_value) }
+              opts:     combobox_opts,
+              error:    error,
+              **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

@@ -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,48 +6,55 @@ 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_format_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),
-                { data: { controller: "input-format", input_format_type_value: "password" } }
+                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" },
-                data: { input_format_target: "toggle", action: "click->input-format#toggle" }
+                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.content_tag(:button, "", **html_options)

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,96 +1,73 @@
 # 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_autocomplete(attribute, input_id, combobox_opts, error, choices, current_value)
-                end
-              end
-            end
-          end
-
-          private
-
-          def render_search_input(html_opts, opts, error, clearable:, &block)
-            data         = clearable ? { data: { input_search_target: "input" } } : {}
-            html_options = merge_html_options(opts, html_opts, field_theme(:form_input, error: error), data)
-            input_html   = @template.capture(html_options, &block)
+          include Combobox
 
+          def search_field(attribute, options = {})
+            clearable    = options.delete(:clearable) { false }
+            data         = clearable ? { data: { input_clearable_target: "input" } } : {}
+            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_search), { data: { controller: "input-search" } })
+              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::Autocomplete.default_opts.deep_merge(
-              input:   { value: current_value },
-              trigger: { data: clearable ? { input_search_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_search), { data: { controller: "input-search" } })
+              error:    error,
+              **merge_html_options(theme.resolve(:form_field_input_clearable), { data: { controller: "input-clearable" } })
             ) { combobox_html }
           end
 
-          def render_search_autocomplete(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::Autocomplete.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_search_target: "clear", action: "click->input-search#clear" }
+                  data:   { input_clearable_target: "clear", action: "click->input-clearable#clear" }
                 }
               )
             )

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

@@ -14,38 +14,31 @@ module StimulusPlumbers
               option_key_method,
               option_value_method,
               options = {},
-              html_options = {}
+              html_opts = {}
             )
-              html_native = options.delete(:html_native) { false }
-              Field.new(@template, **options).render(
-                object,
+              html_options = merge_html_options(theme.resolve(:form_select), html_opts)
+              super(
                 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,
-                    group_method,
-                    group_label_method,
-                    option_key_method,
-                    option_value_method,
-                    opts,
-                    merged_html_opts
-                  )
-                else
-                  render_select_dropdown(attribute, opts, merged_html_opts, err: error) do
-                    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
+                collection,
+                group_method,
+                group_label_method,
+                option_key_method,
+                option_value_method,
+                options,
+                html_options
+              )
+            end
+
+            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
-                end
+                }
               end
             end
           end