stimulus_plumbers 0.3.2 → 0.4.0

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

@@ -6,50 +6,9 @@ module StimulusPlumbers
       module Inputs
         module Select
           module Timezone
-            def time_zone_select(attribute, priority_zones = nil, options = {}, html_options = {})
-              html_native = options.delete(:html_native) { false }
-              Field.new(@template, **options).render(object, 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, priority_zones, opts, merged_html_opts)
-                else
-                  render_select_dropdown(attribute, opts, merged_html_opts, err: error) do
-                    model = opts.delete(:model) { ActiveSupport::TimeZone }
-                    build_zone_choices(priority_zones, model.all)
-                  end
-                end
-              end
-            end
-
-            private
-
-            def build_zone_choices(priority_zones, all_zones)
-              return zone_options(all_zones) unless priority_zones
-
-              priority       = filter_priority_zones(priority_zones, all_zones)
-              priority_names = priority.to_set(&:name)
-              remaining      = all_zones.reject { |z| priority_names.include?(z.name) }
-              [
-                {
-                  label:   I18n.t("helpers.time_zone_select.priority_zones", default: "Suggested"),
-                  options: zone_options(priority)
-                },
-                {
-                  label:   I18n.t("helpers.time_zone_select.other_zones", default: "Other"),
-                  options: zone_options(remaining)
-                }
-              ]
-            end
-
-            def filter_priority_zones(priority_zones, all_zones)
-              case priority_zones
-              when Regexp then all_zones.select { |z| z.name.match?(priority_zones) }
-              else Array(priority_zones)
-              end
-            end
-
-            def zone_options(zones)
-              zones.map { |z| [z.to_s, z.name] }
+            def time_zone_select(attribute, priority_zones = nil, options = {}, html_opts = {})
+              html_options = merge_html_options(theme.resolve(:form_select), html_opts)
+              super(attribute, priority_zones, options, html_options)
             end
           end
         end

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

@@ -7,36 +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 }
-                Field.new(@template, **options).render(
-                  object,
-                  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, opts, merged_html_opts)
-                  else
-                    render_select_dropdown(attribute, opts, merged_html_opts, err: error) 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,74 +1,87 @@
 # 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 }
-            Field.new(@template, **options).render(
-              object,
+            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 = {})
+            merged = merge_html_options(theme.resolve(:form_field_input_select), html_options)
+            super(attribute, collection, value_method, text_method, options, merged)
+          end
+
+          private
+
+          def render_combobox_dropdown(
+            attribute,
+            html_opts,
+            opts,
+            error,
+            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, opts: opts, icon_leading: icon_leading, icon_trailing: icon_trailing
+            )
+            render_combobox(
               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, choices, opts, merged_html_opts)
-              else
-                render_select_dropdown(attribute, opts, merged_html_opts, err: error) { Array(choices) }
-              end
+              input_id: html_opts[:id],
+              opts:     combobox_opts,
+              error:    error
+            ) do |c|
+              c.dropdown(options: all_choices, value: current_value, labelledby: labelledby, **kwargs)
             end
           end
 
-          def collection_select(
+          def render_collection_combobox_dropdown(
             attribute,
             collection,
             value_method,
             text_method,
-            options = {},
-            html_options = {}
+            field_opts,
+            **kwargs
           )
-            html_native = options.delete(:html_native) { false }
-            Field.new(@template, **options).render(
-              object,
-              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, value_method, text_method, opts, merged_html_opts)
-              else
-                render_select_dropdown(attribute, opts, merged_html_opts, err: error) do
-                  collection.map { |item| [item.public_send(text_method), item.public_send(value_method)] }
-                end
-              end
-            end
+            choices = collection.map { |item| [item.public_send(text_method), item.public_send(value_method)] }
+            render_field(:select, attribute, field_opts, { choices: choices, **kwargs })
           end
 
-          private
-
-          def render_select_dropdown(attribute, opts, html_opts, err:)
-            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)
-
-            combobox_opts = build_select_dropdown_opts(html_opts, current_value)
-            render_combobox(attribute, input_id: html_opts[:id], opts: combobox_opts, err: err) do
-              Components::Combobox::Dropdown.new(@template).render(
-                options:    choices,
-                value:      current_value,
-                labelledby: Field.label_id(html_opts[:id])
-              )
-            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)
-            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
-            )
+              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, options)
+              ) { value }
+            end
           end
         end
       end

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

@@ -5,31 +5,38 @@ 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, options = {}|
+              html_options = merge_html_options(theme.resolve(:form_field_input), 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, **kwargs)
+            html_options = merge_html_options(theme.resolve(:form_field_input, 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

@@ -6,14 +6,15 @@ module StimulusPlumbers
       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
+            html_options = merge_html_options(theme.resolve(:form_field_input_textarea), options)
+            super(attribute, html_options)
+          end
+
+          private
+
+          def render_text_area_input(attribute, html_opts, opts, error, **kwargs)
+            html_options = merge_html_options(theme.resolve(:form_field_input_textarea, 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:, type:, required:, error:, &block)
+            html_options  = merge_html_options(theme.resolve(:form_field_floating_group, type: type))
+            label_options = merge_html_options(theme.resolve(:form_field_floating_label, type: type, 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/avatar_helper.rb

@@ -3,8 +3,8 @@
 module StimulusPlumbers
   module Helpers
     module AvatarHelper
-      def sp_avatar(name: nil, initials: nil, url: nil, color: nil, size: :md, **html_options, &block)
-        avatar_renderer.render(name: name, initials: initials, url: url, color: color, size: size, **html_options, &block)
+      def sp_avatar(...)
+        avatar_renderer.render(...)
       end
 
       private

data/lib/stimulus_plumbers/helpers/button_helper.rb

@@ -3,16 +3,12 @@
 module StimulusPlumbers
   module Helpers
     module ButtonHelper
-      def sp_button(content = nil, url: nil, external: false, variant: :primary, size: :md, **html_options, &block)
-        button_renderer.render(
-          content,
-          url: url, external: external, variant: variant, size: size, **html_options,
-          &block
-        )
+      def sp_button(content = nil, **kwargs, &block)
+        button_renderer.render(content, **kwargs, &block)
       end
 
-      def sp_button_group(alignment: :left, direction: :row, **html_options, &block)
-        button_renderer.group(alignment: alignment, direction: direction, **html_options, &block)
+      def sp_button_group(...)
+        Components::Button::Group.new(self).render(...)
       end
 
       private

data/lib/stimulus_plumbers/helpers/calendar_helper.rb

@@ -3,17 +3,20 @@
 module StimulusPlumbers
   module Helpers
     module CalendarHelper
-      def sp_calendar_month(date: nil, **html_options, &block)
-        if date
-          html_options = html_options.deep_merge(
-            data: {
-              "calendar-month-year-value":  date.year,
-              "calendar-month-month-value": date.month - 1,
-              "calendar-month-day-value":   date.day
-            }
-          )
-        end
-        calendar_renderer.month(**html_options, &block)
+      def sp_calendar_month(**kwargs)
+        date = kwargs.delete(:date)
+        html_options = if date
+                         kwargs.deep_merge(
+                           data: {
+                             "calendar-month-year-value":  date.year,
+                             "calendar-month-month-value": date.month - 1,
+                             "calendar-month-day-value":   date.day
+                           }
+                         )
+                       else
+                         kwargs
+                       end
+        calendar_renderer.render(**html_options)
       end
 
       private

data/lib/stimulus_plumbers/helpers/calendar_turbo_helper.rb

@@ -3,28 +3,66 @@
 module StimulusPlumbers
   module Helpers
     module CalendarTurboHelper
-      def sp_calendar_month_turbo(
+      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,
-        **html_options
+        **kwargs
       )
-        calendar_month_turbo_renderer.render(
-          date:              date,
-          today:             today,
-          selectable:        selectable,
-          selected_date:     selected_date,
-          show_other_months: show_other_months,
-          **html_options
+        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,
+                **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)
+            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)
+            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

@@ -3,18 +3,8 @@
 module StimulusPlumbers
   module Helpers
     module CardHelper
-      def sp_card(title: nil, **html_options, &block)
-        card_renderer.render(title: title, **html_options, &block)
-      end
-
-      def sp_card_section(title: nil, **html_options, &block)
-        card_renderer.section(title: title, **html_options, &block)
-      end
-
-      private
-
-      def card_renderer
-        Components::Card.new(self)
+      def sp_card(...)
+        Components::Card.new(self).render(...)
       end
     end
   end