stimulus_plumbers 0.3.3 → 0.4.0

data/lib/stimulus_plumbers/form/builder.rb

@@ -2,10 +2,17 @@
 
 require "action_view/version"
 
+require_relative "../plumber/options/aria"
+require_relative "../plumber/options/html"
+
+require_relative "base"
 require_relative "field"
+require_relative "fields/renderer"
 require_relative "fields/fieldset"
-require_relative "fields/inputs/choice"
+require_relative "fields/inputs/checkbox"
+require_relative "fields/inputs/combobox"
 require_relative "fields/inputs/datetime"
+require_relative "fields/inputs/radio"
 require_relative "fields/inputs/file"
 require_relative "fields/inputs/password"
 require_relative "fields/inputs/search"
@@ -16,14 +23,15 @@ require_relative "fields/inputs/select/weekday"
 require_relative "fields/inputs/submit"
 require_relative "fields/inputs/text"
 require_relative "fields/inputs/text_area"
-require_relative "../plumber/html_options"
 
 module StimulusPlumbers
   module Form
     class Builder < ActionView::Helpers::FormBuilder
-      include Plumber::HtmlOptions
-      include Fields::Inputs::Choice
+      include Plumber::Options::Html
+      include Plumber::Options::Aria
+      include Fields::Inputs::Checkbox
       include Fields::Inputs::Datetime
+      include Fields::Inputs::Radio
       include Fields::Inputs::File
       include Fields::Inputs::Password
       include Fields::Inputs::Search
@@ -35,35 +43,75 @@ module StimulusPlumbers
       include Fields::Inputs::Text
       include Fields::Inputs::TextArea
 
+      def field(attribute, as:, **options)
+        field_opts = options.slice(*Field::OPTIONS)
+        input_opts = options.except(*Field::OPTIONS)
+        render_field(as, attribute, field_opts, input_opts)
+      end
+
+      def collection_field(attribute, as:, collection:, value_method:, text_method:, **options)
+        field_opts = options.slice(*Field::OPTIONS)
+        input_opts = options.except(*Field::OPTIONS)
+        render_collection_field(as, attribute, field_opts, collection, value_method, text_method, input_opts)
+      end
+
+      def choice(attribute, as:, collection: nil, value_method: nil, text_method: nil, **options)
+        field_opts = options.slice(*Field::OPTIONS)
+        input_opts = options.except(*Field::OPTIONS)
+        render_choice_field(as, attribute, field_opts, collection, value_method, text_method, input_opts)
+      end
+
       private
 
-      def render_fieldset(attribute, field, &block)
-        Fields::Fieldset.new(@template).render(object, attribute, field_id(attribute), field, &block)
+      def theme
+        StimulusPlumbers.config.theme.current
       end
 
-      def render_input_group(error:, leading: nil, trailing: nil, **wrapper_opts, &block)
-        Components::InputGroup.new(@template).render(leading: leading, trailing: trailing, error: error, **wrapper_opts, &block)
+      def render_field(as, attribute, field_opts, input_opts)
+        raise ArgumentError, "unknown field type: #{as.inspect}" unless Fields::Renderer::FIELD.key?(as)
+
+        field = Field.new(@template, **field_opts)
+        field.render(object, attribute, input_id: field_id(attribute)) do |html_opts, opts, error|
+          Plumber::Dispatcher.build(
+            Fields::Renderer::FIELD.fetch(as), attribute, html_opts, opts, error, **input_opts
+          ).call(self)
+        end
       end
 
-      def render_combobox(attribute, input_id:, opts:, err:, **wrapper_opts, &block)
-        combobox_opts = opts.deep_merge(
-          input:   { name: field_name(attribute) },
-          trigger: { id: input_id }
-        )
-
-        Components::Combobox.new(@template).render(
-          **combobox_opts,
-          **merge_html_options(wrapper_opts, field_theme(:form_combobox, error: err)),
-          &block
-        )
+      def render_collection_field(as, attribute, field_opts, collection, value_method, text_method, input_opts)
+        raise ArgumentError, "unknown collection field type: #{as.inspect}" unless Fields::Renderer::COLLECTION.key?(as)
+
+        Plumber::Dispatcher.build(
+          Fields::Renderer::COLLECTION.fetch(as),
+          attribute,
+          collection,
+          value_method,
+          text_method,
+          field_opts,
+          **input_opts
+        ).call(self)
       end
 
-      def field_theme(key, **variants)
-        { class: theme.resolve(key, **variants).fetch(:classes, "") }
+      def render_choice_field(as, attribute, field_opts, collection, value_method, text_method, input_opts)
+        raise ArgumentError, "unknown choice type: #{as.inspect}" unless Fields::Renderer::CHOICE.key?(as)
+
+        Plumber::Dispatcher.build(
+          Fields::Renderer::CHOICE.fetch(as),
+          attribute,
+          collection,
+          value_method,
+          text_method,
+          field_opts,
+          **input_opts
+        ).call(self)
       end
 
-      def theme
-        StimulusPlumbers.config.theme.current
+      def render_fieldset(attribute, field, &block)
+        Fields::Fieldset.new(@template).render(object, attribute, field_id(attribute), field, &block)
+      end
+
+      def render_input_group(error:, leading: nil, trailing: nil, **wrapper_opts, &block)
+        Components::InputGroup.new(@template).render(leading: leading, trailing: trailing, error: error, **wrapper_opts, &block)
       end
 
       # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
@@ -94,7 +142,6 @@ module StimulusPlumbers
 
           names = method_names.map! { |name| "[#{name}]" }.join
 
-          # a little duplication to construct fewer strings
           if object_name.blank?
             "#{method_name}#{names}#{"[]" if multiple}"
           elsif index

data/lib/stimulus_plumbers/form/field.rb

@@ -1,56 +1,51 @@
 # frozen_string_literal: true
 
+require_relative "base"
+
 module StimulusPlumbers
   module Form
-    class Field
-      attr_reader :label, :required, :layout
+    class Field < Base
+      TYPES = %i[
+        text email number url tel color month week range datetime_local
+        text_area file password date time select search
+      ].freeze
+      COLLECTION_TYPES = %i[radio check_box collection_select grouped_collection_select].freeze
+      FLOATING_TYPES   = %i[standard filled outlined].freeze
+      OPTIONS          = (Base::OPTIONS + %i[hide_label]).freeze
+
+      attr_reader :hide_label
 
       def self.label_id(input_id)
         [input_id, "label"].compact.join("_")
       end
 
-      def initialize(
-        template,
-        label: nil,
-        hint: nil,
-        error: nil,
-        required: false,
-        hide_label: false,
-        layout: :stacked,
-        **kwargs
-      )
-        @template       = template
-        @label          = label
-        @hint           = hint
-        @error_override = error
-        @required       = required
-        @hide_label     = hide_label
-        @layout         = layout.to_sym
-        @kwargs         = kwargs
+      def initialize(template, hide_label: false, **kwargs)
+        super(template, **kwargs)
+        @hide_label = hide_label
       end
 
       def label_hidden?
         @hide_label
       end
 
-      def error?(object, attribute)
-        build_errors(object, attribute).any?
+      def render(object, attribute, input_id:, &block)
+        @label ||= attribute.to_s.humanize
+        case @floating
+        when *FLOATING_TYPES
+          render_floating_field(object, attribute, input_id, &block)
+        else
+          render_default_field(object, attribute, input_id, &block)
+        end
       end
 
-      def described_by(object, attribute, input_id)
-        ids = []
-        ids << hint_id(input_id) if @hint.present?
-        ids.concat(build_error_ids(object, attribute, input_id))
-        ids.join(" ").presence
-      end
+      private
 
-      def render(object, attribute, input_id:, &block)
-        @label ||= attribute.to_s.humanize
-        error          = error?(object, attribute)
+      def render_default_field(object, attribute, input_id, &block)
+        error_override = error?(object, attribute)
         aria           = build_aria(object, attribute, input_id)
-        generated_opts = build_html_options(input_id, aria)
-        field_html     = @template.capture(generated_opts, @kwargs, error, &block)
-        Fields::Group.new(@template).render(layout: @layout, error: error) do
+        field_opts = build_html_options(input_id, aria)
+        field_html = @template.capture(field_opts, @kwargs, error_override, &block)
+        Fields::Group.new(@template).render(layout: @layout, error: error_override) do
           @template.safe_join(
             [
               field_label(input_id),
@@ -62,70 +57,43 @@ module StimulusPlumbers
         end
       end
 
-      def render_hint(input_id)
-        Fields::Hint.new(@template).render(text: @hint, id: hint_id(input_id)) if @hint.present?
-      end
-
-      def render_errors(object, attribute, input_id)
-        errs = build_errors(object, attribute)
-        return if errs.none?
-
-        @template.safe_join(
-          errs.map.with_index do |message, i|
-            Fields::Error.new(@template).render(message: message, id: build_error_ids(object, attribute, input_id)[i])
-          end
+      def field_label(input_id)
+        Fields::Label.new(@template).render(
+          text:     @label,
+          for_id:   input_id,
+          id:       self.class.label_id(input_id),
+          required: @required,
+          hidden:   @hide_label
         )
       end
 
-      private
-
-      def build_errors(object, attribute)
-        if @error_override
-          Array(@error_override)
-        elsif object.respond_to?(:errors)
-          object.errors[attribute]
-        else
-          []
+      def render_floating_field(object, attribute, input_id, &block)
+        error_override = error?(object, attribute)
+        aria           = build_aria(object, attribute, input_id)
+        input_classes  = theme.resolve(:form_field_floating, type: @floating, error: error_override)[:classes]
+        field_opts     = build_html_options(input_id, aria).merge(class: input_classes, placeholder: " ")
+        Fields::Group.new(@template).render(layout: @layout, error: error_override) do
+          @template.safe_join(
+            [
+              floating_field_label(input_id, error: error_override) do
+                @template.capture(field_opts, @kwargs, error_override, &block)
+              end,
+              render_hint(input_id),
+              render_errors(object, attribute, input_id)
+            ]
+          )
         end
       end
 
-      def build_aria(object, attribute, input_id)
-        aria = {}
-        aria[:describedby] = described_by(object, attribute, input_id)
-        aria[:invalid]     = "true" if error?(object, attribute)
-        aria[:required]    = "true" if @required
-        aria.compact
-      end
-
-      def build_html_options(input_id, aria)
-        attrs = { id: input_id, aria: aria }
-        attrs[:required] = true if @required
-        attrs
-      end
-
-      def hint_id(input_id)
-        [input_id, "hint"].compact.join("_")
-      end
-
-      def error_id(input_id)
-        [input_id, "error"].compact.join("_")
-      end
-
-      def build_error_ids(object, attribute, input_id)
-        errs = build_errors(object, attribute)
-        return [] if errs.none?
-        return [error_id(input_id)] if errs.one?
-
-        errs.each_index.map { |i| [error_id(input_id), i + 1].compact.join("_") }
-      end
-
-      def field_label(input_id)
-        Fields::Label.new(@template).render(
+      def floating_field_label(input_id, error:, &block)
+        Fields::Label::Floating.new(@template).render(
           text:     @label,
           for_id:   input_id,
           id:       self.class.label_id(input_id),
+          type:     @floating,
           required: @required,
-          hidden:   @hide_label
+          error:    error,
+          &block
         )
       end
     end

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

@@ -5,7 +5,7 @@ module StimulusPlumbers
     module Fields
       class Error < Plumber::Base
         def render(message:, id:)
-          html_options = merge_html_options(theme.resolve(:form_error))
+          html_options = merge_html_options(theme.resolve(:form_field_error))
           template.content_tag(:p, message, id: id, role: "alert", **html_options)
         end
       end

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

@@ -7,7 +7,7 @@ module StimulusPlumbers
         def render(object, attribute, input_id, field, &block)
           error         = field.error?(object, attribute)
           fieldset_opts = build_fieldset_aria(field, object, attribute, input_id, error)
-          Group.new(template).render(layout: field.layout, error: error) do
+          Group.new(template).render(layout: :stacked, error: error) do
             template.safe_join(
               [
                 build_fieldset(fieldset_opts, field, attribute, error, &block),
@@ -25,12 +25,17 @@ module StimulusPlumbers
             template.safe_join(
               [
                 legend(field, attribute),
-                template.capture(error, &block)
+                fields_wrapper(field.layout) { template.capture(error, &block) }
               ]
             )
           end
         end
 
+        def fields_wrapper(layout, &block)
+          html_options = merge_html_options(theme.resolve(:form_field_choice_items, layout: layout))
+          template.content_tag(:div, **html_options, &block)
+        end
+
         def legend(field, attribute)
           Label.new(template).render(
             text:     field.label || attribute.to_s.humanize,
@@ -41,12 +46,10 @@ module StimulusPlumbers
         end
 
         def build_fieldset_aria(field, object, attribute, input_id, error)
-          opts = {}
-          db = field.described_by(object, attribute, input_id)
-          opts[:"aria-describedby"] = db      if db
-          opts[:"aria-invalid"]     = "true"  if error
-          opts[:"aria-required"]    = "true"  if field.required
-          opts
+          aria = {}
+          aria[:describedby] = field.described_by(object, attribute, input_id)
+          aria[:invalid]     = "true" if error
+          { aria: aria.compact }
         end
       end
     end

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

@@ -5,7 +5,7 @@ module StimulusPlumbers
     module Fields
       class Hint < Plumber::Base
         def render(text:, id:)
-          html_options = merge_html_options(theme.resolve(:form_details))
+          html_options = merge_html_options(theme.resolve(:form_field_hint))
           template.content_tag(:p, text, id: id, **html_options)
         end
       end

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,90 +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 }
-            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, 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,
+              **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,
+            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,
+              **kwargs
+            ) do |c|
+              c.time(format: format, step: step, value: current_value, labelledby: labelledby)
+            end
           end
         end
       end