stimulus_plumbers 0.3.2 → 0.4.0

data/lib/stimulus_plumbers/components/popover.rb

@@ -3,27 +3,57 @@
 module StimulusPlumbers
   module Components
     class Popover < Plumber::Base
-      def render(interactive: true, **kwargs, &block)
-        html_options = merge_html_options(
-          { classes: theme.resolve(:popover).fetch(:classes, "") },
-          kwargs
-        )
+      STIMULUS_CONTROLLER = "popover"
 
-        builder = Popover::Builder.new(template)
-        template.capture(builder, &block)
+      def self.panel_id_for(trigger_id)
+        [trigger_id, "popover"].compact.join("_")
+      end
 
-        template.content_tag(:div, **html_options) do
-          template.safe_join([builder.activator_html, wrap_content(interactive, builder)])
+      def render(...) = render_popover(...)
+
+      def build(panel_id: nil, &block)
+        @panel_id     = panel_id || self.class.panel_id_for(template.sp_dom_id)
+        @trigger_html = nil
+        @panel_html   = nil
+        yield self
+        template.safe_join([@trigger_html, @panel_html].compact)
+      end
+
+      def trigger(haspopup: "dialog", controls: @panel_id, **kwargs, &block)
+        if block_given? && block.arity == 1
+          attrs = {
+            panel_id: @panel_id,
+            aria:     { haspopup: haspopup, expanded: "false", controls: controls },
+            data:     { popover_target: "trigger", action: Popover::Trigger::STIMULUS_ACTION }
+          }
+          @trigger_html = template.capture(attrs, &block)
+        else
+          @trigger_html = Popover::Trigger.new(template).render(
+            panel_id: @panel_id, haspopup: haspopup, **kwargs, &block
+          )
         end
       end
 
+      def panel(**kwargs, &block)
+        @panel_html = Popover::Panel.new(template).render(panel_id: @panel_id, **kwargs, &block)
+      end
+
+      def build_panel(**kwargs, &block)
+        @panel_html = Popover::Panel.new(template).build(panel_id: @panel_id, **kwargs, &block)
+      end
+
       private
 
-      def wrap_content(interactive, builder)
-        if interactive
-          template.content_tag(:template, builder.content_html)
-        else
-          builder.content_html
+      def render_popover(panel_id: nil, close_on_select: nil, **kwargs, &block)
+        data = { controller: STIMULUS_CONTROLLER }
+        data[:popover_close_on_select_value] = close_on_select unless close_on_select.nil?
+        html_options = merge_html_options(
+          theme.resolve(:popover_wrapper),
+          kwargs,
+          { data: data }
+        )
+        template.content_tag(:div, **html_options) do
+          build(panel_id: panel_id, &block)
         end
       end
     end

data/lib/stimulus_plumbers/engine.rb

@@ -7,6 +7,7 @@ module StimulusPlumbers
     isolate_namespace StimulusPlumbers
 
     config.autoload_paths << File.expand_path("../stimulus-plumbers", __dir__)
+    config.i18n.load_path += Dir[File.expand_path("../../config/locales/*.{rb,yml}", __dir__)]
 
     initializer "stimulus_plumbers.assets", after: :set_default_precompile do |app|
       app.config.assets.precompile += %w[stimulus_plumbers/tokens.css] if app.config.respond_to?(:assets)

data/lib/stimulus_plumbers/form/base.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    class Base
+      OPTIONS = %i[label hint error required layout floating].freeze
+
+      attr_reader(*OPTIONS)
+
+      def initialize(
+        template,
+        label: nil,
+        hint: nil,
+        error: nil,
+        required: false,
+        layout: :stacked,
+        floating: nil,
+        **kwargs
+      )
+        @template = template
+        @label    = label
+        @hint     = hint
+        @error    = error
+        @required = required
+        @layout   = layout.to_sym
+        @floating = floating
+        @kwargs   = kwargs
+      end
+
+      def theme
+        StimulusPlumbers.config.theme.current
+      end
+
+      def error?(object, attribute)
+        build_errors(object, attribute).any?
+      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
+
+      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
+        )
+      end
+
+      private
+
+      def build_errors(object, attribute)
+        if error
+          Array(error)
+        elsif object.respond_to?(:errors)
+          object.errors[attribute]
+        else
+          []
+        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
+    end
+  end
+end

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)
-        Fields::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