stimulus_plumbers 0.3.3 → 0.4.2

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

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

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

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

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

@@ -10,13 +10,16 @@ module StimulusPlumbers
               options = value
               value = nil
             end
-            value   ||= submit_default_value
-            variant   = options.delete(:variant) { :default }
-            @template.tag.input(
-              type:  "submit",
-              value: value,
-              **merge_html_options(field_theme(:form_submit, variant: variant), options)
-            )
+            value ||= submit_default_value
+            type    = options.delete(:type)    { :default }
+            variant = options.delete(:variant) { :primary }
+
+            Components::Button.new(@template).build(type: type, variant: variant) do |attrs|
+              @template.tag.button(
+                type: "submit",
+                **merge_html_options(attrs, theme.resolve(:form_submit, type: type, variant: variant), options)
+              ) { @template.content_tag(:span, value) }
+            end
           end
         end
       end

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

@@ -5,31 +5,43 @@ module StimulusPlumbers
     module Fields
       module Inputs
         module Text
-          FIELD_TYPES = %i[
-            color_field
-            datetime_local_field
-            email_field
-            month_field
-            number_field
-            range_field
-            telephone_field
-            text_field
-            url_field
-            week_field
-          ].freeze
+          TEXT_FIELD_METHODS = {
+            text:           :text_field,
+            email:          :email_field,
+            number:         :number_field,
+            url:            :url_field,
+            tel:            :telephone_field,
+            color:          :color_field,
+            month:          :month_field,
+            week:           :week_field,
+            range:          :range_field,
+            datetime_local: :datetime_local_field
+          }.freeze
 
-          FIELD_TYPES.each do |method_name|
-            define_method(method_name) do |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_input, error: error))
-                super(attribute, html_options)
-              end
+          TEXT_FIELD_METHODS.each_value do |template_method|
+            define_method(template_method) do |attribute, floating: nil, **options|
+              html_options = merge_html_options(theme.resolve(:form_field_input, floating: floating), options)
+              super(attribute, html_options)
             end
           end
+
+          private
+
+          TEXT_FIELD_METHODS.each do |as_key, template_method|
+            define_method(:"render_#{as_key}_input") do |attribute, html_opts, opts, error, **kwargs|
+              render_text(attribute, html_opts, opts, error, template_method, **kwargs)
+            end
+          end
+
+          def render_text(attribute, html_opts, opts, error, template_method, floating: nil, **kwargs)
+            html_options = merge_html_options(
+              theme.resolve(:form_field_input, floating: floating, error: error),
+              opts,
+              html_opts,
+              kwargs
+            )
+            @template.public_send(template_method, @object_name, attribute, objectify_options(html_options))
+          end
         end
       end
     end

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

@@ -5,15 +5,21 @@ module StimulusPlumbers
     module Fields
       module Inputs
         module TextArea
-          def text_area(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_textarea, error: error))
-              super(attribute, html_options)
-            end
+          def text_area(attribute, floating: nil, **options)
+            html_options = merge_html_options(theme.resolve(:form_field_input_textarea, floating: floating), options)
+            super(attribute, html_options)
+          end
+
+          private
+
+          def render_text_area_input(attribute, html_opts, opts, error, floating: nil, **kwargs)
+            html_options = merge_html_options(
+              theme.resolve(:form_field_input_textarea, floating: floating, error: error),
+              opts,
+              html_opts,
+              kwargs
+            )
+            @template.text_area(@object_name, attribute, objectify_options(html_options))
           end
         end
       end

data/lib/stimulus_plumbers/form/fields/label/floating.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    module Fields
+      class Label
+        class Floating < Plumber::Base
+          def render(text:, for_id:, id:, floating:, required:, error:, &block)
+            html_options  = merge_html_options(theme.resolve(:form_field_input_group, floating: floating))
+            label_options = merge_html_options(theme.resolve(:form_field_label, floating: floating, error: error))
+            mark_options  = required && merge_html_options(
+              { aria: { hidden: true } },
+              theme.resolve(:form_field_required_mark)
+            )
+            template.content_tag(:div, **html_options) do
+              template.safe_join(
+                [
+                  template.capture(&block),
+                  render_label(text, mark_options, for: for_id, id: id, **label_options)
+                ]
+              )
+            end
+          end
+
+          private
+
+          def render_label(text, mark_options, **html_options)
+            template.content_tag(:label, **html_options) do
+              template.safe_join(
+                [
+                  text,
+                  mark_options ? template.content_tag(:span, "*", **mark_options) : nil
+                ]
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,10 +7,16 @@ module StimulusPlumbers
         def render(text:, for_id: nil, id: nil, required: false, hidden: false, tag: :label)
           mark_options = required && merge_html_options(
             { aria: { hidden: true } },
-            theme.resolve(:form_required_mark)
+            theme.resolve(:form_field_required_mark)
           )
-          html_options = merge_html_options(theme.resolve(:form_label, required: required, hidden: hidden))
-          template.content_tag(tag, for: for_id, id: id, **html_options) do
+          html_options = merge_html_options(theme.resolve(:form_field_label, required: required, hidden: hidden))
+          render_label(text, mark_options, tag, for: for_id, id: id, **html_options)
+        end
+
+        private
+
+        def render_label(text, mark_options, tag, **html_options)
+          template.content_tag(tag, **html_options) do
             template.safe_join(
               [
                 text,

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    module Fields
+      module Renderer
+        FIELD = {
+          text:           :render_text_input,
+          email:          :render_email_input,
+          number:         :render_number_input,
+          url:            :render_url_input,
+          tel:            :render_tel_input,
+          color:          :render_color_input,
+          month:          :render_month_input,
+          week:           :render_week_input,
+          range:          :render_range_input,
+          datetime_local: :render_datetime_local_input,
+          text_area:      :render_text_area_input,
+          file:           :render_file_input,
+          password:       :render_password_input,
+          date:           :render_combobox_date,
+          time:           :render_combobox_time,
+          select:         :render_combobox_dropdown,
+          search:         :render_combobox_typeahead
+        }.freeze
+
+        COLLECTION = {
+          collection_select:         :render_collection_combobox_dropdown,
+          grouped_collection_select: :render_grouped_collection_combobox_dropdown
+        }.freeze
+
+        CHOICE = {
+          radio:     :render_collection_radio_button,
+          check_box: :render_check_box
+        }.freeze
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/helpers/button_helper.rb

@@ -8,7 +8,7 @@ module StimulusPlumbers
       end
 
       def sp_button_group(...)
-        button_renderer.group(...)
+        Components::Button::Group.new(self).render(...)
       end
 
       private

data/lib/stimulus_plumbers/helpers/calendar_helper.rb

@@ -3,7 +3,7 @@
 module StimulusPlumbers
   module Helpers
     module CalendarHelper
-      def sp_calendar_month(**kwargs, &block)
+      def sp_calendar_month(**kwargs)
         date = kwargs.delete(:date)
         html_options = if date
                          kwargs.deep_merge(
@@ -16,7 +16,7 @@ module StimulusPlumbers
                        else
                          kwargs
                        end
-        calendar_renderer.month(**html_options, &block)
+        calendar_renderer.month(**html_options)
       end
 
       private

data/lib/stimulus_plumbers/helpers/calendar_turbo_helper.rb

@@ -3,14 +3,86 @@
 module StimulusPlumbers
   module Helpers
     module CalendarTurboHelper
-      def sp_calendar_month_turbo(**kwargs)
-        calendar_month_turbo_renderer.render(**kwargs)
+      def sp_calendar_turbo_month(**kwargs)
+        calendar_turbo_renderer.month(**kwargs)
+      end
+
+      def sp_calendar_turbo_year(**kwargs)
+        calendar_turbo_renderer.year(**kwargs)
+      end
+
+      def sp_calendar_turbo_decade(**kwargs)
+        calendar_turbo_renderer.decade(**kwargs)
+      end
+
+      def sp_calendar_turbo(
+        date: Date.today,
+        today: Date.today,
+        selectable: false,
+        selected_date: nil,
+        show_other_months: false,
+        since: nil,
+        till: nil,
+        disabled_months: [],
+        disabled_years: [],
+        **kwargs
+      )
+        safe_join(
+          [
+            content_tag(
+              :turbo_frame,
+              id:   "calendar-month-frame",
+              data: { "combobox-date-target": "monthView" }
+            ) do
+              calendar_turbo_renderer.month(
+                date:              date,
+                today:             today,
+                selectable:        selectable,
+                selected_date:     selected_date,
+                show_other_months: show_other_months,
+                since:             since,
+                till:              till,
+                **kwargs
+              )
+            end,
+            content_tag(
+              :turbo_frame,
+              id:     "calendar-year-frame",
+              hidden: true,
+              data:   { "combobox-date-target": "yearView" }
+            ) do
+              calendar_turbo_renderer.year(
+                date:            date,
+                today:           today,
+                selected_date:   selected_date,
+                since:           since,
+                till:            till,
+                disabled_months: disabled_months
+              )
+            end,
+            content_tag(
+              :turbo_frame,
+              id:     "calendar-decade-frame",
+              hidden: true,
+              data:   { "combobox-date-target": "decadeView" }
+            ) do
+              calendar_turbo_renderer.decade(
+                date:           date,
+                today:          today,
+                selected_date:  selected_date,
+                since:          since,
+                till:           till,
+                disabled_years: disabled_years
+              )
+            end
+          ]
+        )
       end
 
       private
 
-      def calendar_month_turbo_renderer
-        Components::Calendar::Month::Turbo.new(self)
+      def calendar_turbo_renderer
+        @calendar_turbo_renderer ||= Components::Calendar::Turbo.new(self)
       end
     end
   end

data/lib/stimulus_plumbers/helpers/card_helper.rb

@@ -4,17 +4,7 @@ module StimulusPlumbers
   module Helpers
     module CardHelper
       def sp_card(...)
-        card_renderer.render(...)
-      end
-
-      def sp_card_section(...)
-        card_renderer.section(...)
-      end
-
-      private
-
-      def card_renderer
-        Components::Card.new(self)
+        Components::Card.new(self).render(...)
       end
     end
   end

data/lib/stimulus_plumbers/helpers/combobox_helper.rb

@@ -3,76 +3,43 @@
 module StimulusPlumbers
   module Helpers
     module ComboboxHelper
-      def sp_combobox_date(**kwargs)
-        label = kwargs.delete(:label)
-        value = kwargs.delete(:value)
-        id    = sp_dom_id
-        opts  = Components::Combobox::Date.default_opts.deep_merge(
-          input:   { value: value },
-          trigger: { id: id, aria: ({ label: label } if label), icon_trailing: "calendar" }.compact
-        )
+      # Single entry point; panel type chosen by a block method (c.dropdown/date/...).
+      def sp_combobox(value: nil, label: nil, id: nil, close_on_select: nil, **kwargs, &block)
         Components::Combobox.new(self).render(
-          **opts,
-          data: { input_formatter_format_value: "date" },
-          **kwargs
-        ) do |popover_id|
-          Components::Combobox::Date.new(self).render(value: value, popover_id: popover_id)
+          id:              id || sp_dom_id,
+          label:           label,
+          input:           { value: value },
+          close_on_select: close_on_select,
+          **kwargs,
+          &block
+        )
+      end
+
+      def sp_combobox_date(value: nil, label: nil, **kwargs)
+        sp_combobox(value: value, label: label, **kwargs) do |c|
+          panel_opts = { value: value }
+          panel_opts[:label] = label if label
+          c.date(**panel_opts)
         end
       end
 
-      def sp_combobox_dropdown(**kwargs)
-        label   = kwargs.delete(:label)
-        value   = kwargs.delete(:value)
-        options = kwargs.delete(:options) { [] }
-        id      = sp_dom_id
-        opts    = Components::Combobox::Dropdown.default_opts.deep_merge(
-          input:   { value: value },
-          trigger: { id: id, aria: ({ label: label } if label), icon_trailing: "chevron-down" }.compact
-        )
-        Components::Combobox.new(self).render(**opts, **kwargs) do
-          Components::Combobox::Dropdown.new(self).render(options: options, value: value, label: label)
+      def sp_combobox_dropdown(options: [], value: nil, label: nil, **kwargs)
+        sp_combobox(value: value, label: label, **kwargs) do |c|
+          c.dropdown(options: options, value: value, label: label)
         end
       end
 
-      def sp_combobox_typeahead(**kwargs)
-        label   = kwargs.delete(:label)
-        value   = kwargs.delete(:value)
-        options = kwargs.delete(:options) { [] }
-        url     = kwargs.delete(:url)
-        id      = sp_dom_id
-        opts    = Components::Combobox::Typeahead.default_opts.deep_merge(
-          input:   { value: value },
-          trigger: { id: id, aria: ({ label: label } if label) }.compact,
-          popover: { data: url ? { combobox_dropdown_url_value: url } : {} }
-        )
-        Components::Combobox.new(self).render(
-          **opts,
-          data: {
-            input_combobox_combobox_dropdown_outlet: "##{Components::Combobox.popover_id_for(id)}",
-            action:                                  "input->input-combobox#onInput"
-          },
-          **kwargs
-        ) do
-          Components::Combobox::Typeahead.new(self).render(options: options, value: value, label: label)
+      def sp_combobox_typeahead(options: [], value: nil, label: nil, url: nil, **kwargs)
+        sp_combobox(value: value, label: label, **kwargs) do |c|
+          c.typeahead(options: options, value: value, label: label, url: url)
         end
       end
 
-      def sp_combobox_time(**kwargs)
-        format = kwargs.delete(:format) { :h12 }
-        label  = kwargs.delete(:label)
-        step   = kwargs.delete(:step) { 1 }
-        value  = kwargs.delete(:value)
-        id     = sp_dom_id
-        opts   = Components::Combobox::Time.default_opts.deep_merge(
-          input:   { value: value },
-          trigger: { id: id, aria: ({ label: label } if label), icon_trailing: "clock" }.compact
-        )
-        Components::Combobox.new(self).render(
-          **opts,
-          data: { input_formatter_format_value: "time", input_formatter_options_value: { format: format }.to_json },
-          **kwargs
-        ) do
-          Components::Combobox::Time.new(self).render(format: format, step: step, value: value)
+      def sp_combobox_time(format: :h12, step: 1, value: nil, label: nil, **kwargs)
+        sp_combobox(value: value, label: label, **kwargs) do |c|
+          panel_opts = { format: format, step: step, value: value }
+          panel_opts[:label] = label if label
+          c.time(**panel_opts)
         end
       end
     end