stimulus_plumbers 0.2.2

data/lib/stimulus_plumbers/components/date_picker/navigator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Components
+    module DatePicker
+      class Navigator < Plumber::Base
+        def render(icon_options: nil, **kwargs)
+          html_options = merge_html_options(
+            { classes: theme.resolve(:calendar_navigation_navigator).fetch(:classes, "") },
+            kwargs
+          )
+
+          if icon_options.nil?
+            template.content_tag(:button, nil, **html_options)
+          else
+            template.content_tag(:button, icon(icon_options), **html_options)
+          end
+        end
+
+        private
+
+        def icon(icon_options)
+          Icon::Renderer.new(template).icon(
+            classes: theme.resolve(:calendar_navigation_navigator_icon).fetch(:classes, ""),
+            **icon_options
+          )
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/components/date_picker/renderer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Components
+    module DatePicker
+      class Renderer < Plumber::Base
+        STIMULUS_CONTROLLER = "datepicker"
+        POPOVER_CONTROLLER  = "popover"
+        CALENDAR_CONTROLLER = Calendar::Renderer::OBSERVER_STIMULUS_CONTROLLER
+        CALENDAR_OUTLET     = "#{STIMULUS_CONTROLLER}_#{Calendar::Renderer::STIMULUS_CONTROLLER}_outlet".freeze
+        STIMULUS_DATA       = {
+          controller: "#{STIMULUS_CONTROLLER} #{POPOVER_CONTROLLER}",
+          action:     "#{CALENDAR_CONTROLLER}:selected->#{STIMULUS_CONTROLLER}#selected " \
+                      "#{CALENDAR_CONTROLLER}:selected->#{POPOVER_CONTROLLER}#hide"
+        }.freeze
+
+        def render(calendar_id: nil, calendar_dialog_id: nil, **kwargs)
+          data         = calendar_id ? STIMULUS_DATA.merge(CALENDAR_OUTLET => "##{calendar_id}") : STIMULUS_DATA
+          html_options = merge_html_options(
+            { classes: theme.resolve(:datepicker).fetch(:classes, ""), data: data },
+            kwargs
+          )
+
+          template.content_tag(:div, **html_options) do
+            template.safe_join([display_input(calendar_dialog_id), hidden_input, popover(calendar_id, calendar_dialog_id)])
+          end
+        end
+
+        private
+
+        def display_input(calendar_dialog_id)
+          template.tag.input(
+            type: "text",
+            role: "combobox",
+            aria: { label: "Date", haspopup: "dialog", controls: calendar_dialog_id },
+            data: {
+              "#{STIMULUS_CONTROLLER}_target": "display",
+              "#{POPOVER_CONTROLLER}_target":  "activator",
+              action:                          [
+                "focus->#{POPOVER_CONTROLLER}#show",
+                "click->#{POPOVER_CONTROLLER}#show"
+              ].join(" ")
+            }
+          )
+        end
+
+        def hidden_input
+          template.tag.input(
+            type: "hidden",
+            data: { "#{STIMULUS_CONTROLLER}_target": "input" }
+          )
+        end
+
+        def popover(calendar_id, calendar_dialog_id)
+          template.content_tag(
+            :div,
+            id:     calendar_dialog_id,
+            role:   "dialog",
+            aria:   { label: "Date picker" },
+            data:   { "#{POPOVER_CONTROLLER}_target": "content" },
+            hidden: ""
+          ) do
+            template.safe_join(
+              [
+                navigation(stimulus_controller: STIMULUS_CONTROLLER, step: "month"),
+                calendar_month(id: calendar_id)
+              ]
+            )
+          end
+        end
+
+        def navigation(**kwargs)
+          Navigation.new(template).render(stimulus_controller: STIMULUS_CONTROLLER, step: "month", **kwargs)
+        end
+
+        def calendar_month(**kwargs)
+          Calendar::Renderer.new(template).month(**kwargs)
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/components/icon/renderer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Components
+    module Icon
+      class Renderer < Plumber::Base
+        ICONS = {
+          "arrow-left"  => "M10.5 19.5 3 12m0 0 7.5-7.5M3 12h18",
+          "arrow-right" => "M13.5 4.5 21 12m0 0-7.5 7.5M21 12H3",
+          "arrow-up"    => "M4.5 10.5 12 3m0 0 7.5 7.5M12 3v18",
+          "arrow-down"  => "M19.5 13.5 12 21m0 0-7.5-7.5M12 21V3"
+        }.freeze
+
+        def icon(name:, **kwargs)
+          html_options = merge_html_options(
+            { classes: theme.resolve(:icon).fetch(:classes, "") },
+            kwargs
+          )
+
+          if ICONS[name]
+            svg_icon(ICONS[name], html_options)
+          else
+            template.content_tag(:span, nil, **html_options)
+          end
+        end
+
+        private
+
+        def svg_icon(path, html_options)
+          template.content_tag(
+            :svg,
+            xmlns:          "http://www.w3.org/2000/svg",
+            fill:           "none",
+            viewBox:        "0 0 24 24",
+            width:          "24",
+            height:         "24",
+            "stroke-width": "1.5",
+            stroke:         "currentColor",
+            **html_options
+          ) do
+            template.tag.path(
+              "stroke-linecap":  "round",
+              "stroke-linejoin": "round",
+              d:                 path
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/components/plumber/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Components
+    module Plumber
+      class Base
+        include HtmlOptions
+        include Renderer
+
+        attr_reader :template
+
+        def initialize(template)
+          @template = template
+        end
+
+        def theme
+          StimulusPlumbers.config.theme
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/components/plumber/dispatcher.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module StimulusPlumbers
+  module Components
+    module Plumber
+      module Dispatcher
+        class MethodCall
+          attr_reader :method_name, :args, :kwargs
+
+          def initialize(method_name, *args, **kwargs)
+            @method_name = method_name
+            @args = args
+            @kwargs = kwargs
+            validate!
+          end
+
+          def call(target)
+            raise NotImplementedError, "#{method_name.inspect} not implemented" unless target.respond_to?(method_name, true)
+
+            method_call = target.method(method_name)
+            accepts_args = method_call.arity.negative? ? args : args.take(method_call.arity)
+            accepts_kwargs = method_call.parameters.any? { |type, _| %i[key keyreq keyrest].include?(type) }
+            accepts_kwargs ? method_call.call(*accepts_args, **kwargs) : method_call.call(*accepts_args)
+          end
+
+          private
+
+          def validate!
+            return if method_name.is_a?(String) || method_name.is_a?(Symbol)
+
+            raise ArgumentError, "invalid method name: #{method_name.inspect}"
+          end
+        end
+
+        class InstanceExec
+          attr_reader :block, :args, :kwargs
+
+          def initialize(block, *args, **kwargs)
+            @block = block
+            @args = args
+            @kwargs = kwargs
+            validate!
+          end
+
+          def call(target)
+            accepts_args = block.arity.negative? ? args : args.take(block.arity)
+            accepts_kwargs = block.parameters.any? { |type, _| %i[key keyreq keyrest].include?(type) }
+            if accepts_kwargs
+              target.instance_exec(
+                *accepts_args,
+                **kwargs,
+                &block
+              )
+            else
+              target.instance_exec(*accepts_args, &block)
+            end
+          end
+
+          private
+
+          def validate!
+            raise ArgumentError, "invalid block: #{block.inspect}" unless block.is_a?(Proc)
+          end
+        end
+
+        class KlassProxy
+          attr_reader :klass, :method_name, :args, :kwargs, :init_args, :init_kwargs
+
+          def initialize(klass, method_name, *args, init_args: [], init_kwargs: {}, **kwargs)
+            @klass = klass
+            @method_name = method_name
+            @args = args
+            @kwargs = kwargs
+            @init_args = init_args
+            @init_kwargs = init_kwargs
+            validate!
+          end
+
+          def call(_target)
+            klass.new(*init_args, **init_kwargs).public_send(method_name, *args, **kwargs)
+          end
+
+          private
+
+          def validate!
+            raise ArgumentError, "invalid class: #{klass.inspect}" unless klass.is_a?(Module)
+            return if method_name.is_a?(String) || method_name.is_a?(Symbol)
+
+            raise ArgumentError, "invalid method name: #{method_name.inspect}"
+          end
+        end
+
+        def self.build(callable, *args, method_name: nil, init_args: [], init_kwargs: {}, **kwargs)
+          case callable
+          when Symbol
+            MethodCall.new(callable, *args, **kwargs)
+          when Proc
+            InstanceExec.new(callable, *args, **kwargs)
+          when Module
+            KlassProxy.new(callable, method_name, *args, init_args: init_args, init_kwargs: init_kwargs, **kwargs)
+          when String
+            klass = callable.safe_constantize
+            raise ArgumentError, "could not resolve class from: #{callable.inspect}" unless klass
+
+            KlassProxy.new(klass, method_name, *args, init_args: init_args, init_kwargs: init_kwargs, **kwargs)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/components/plumber/html_options.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module StimulusPlumbers
+  module Components
+    module Plumber
+      module HtmlOptions
+        extend ActiveSupport::Concern
+
+        def merge_html_options(*hashes)
+          classes = hashes.flat_map { |h| [h[:class], h[:classes]] }
+          rest    = hashes.map { |h| h.except(:class, :classes) }.reduce({}, :deep_merge)
+          class_value = merge_string_option(*classes).presence
+          class_value ? rest.merge(class: class_value) : rest
+        end
+
+        def merge_string_option(*parts, delimiter: " ")
+          tokens = parts.flat_map { |part| normalize_part(part, delimiter) }
+          tokens.compact.uniq.join(delimiter)
+        end
+
+        def normalize_part(value, delimiter)
+          case value
+          when String then value.present? ? value.split(delimiter) : []
+          when Hash then value.filter_map { |key, val| key if val }
+          when Array then [merge_string_option(*value).presence]
+          else []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/components/plumber/renderer.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module StimulusPlumbers
+  module Components
+    module Plumber
+      module Renderer
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :renderers, instance_writer: false, default: {}
+        end
+
+        module ClassMethods
+          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          def renders(method_name, with: nil, &block)
+            raise ArgumentError, "method_name must be Symbol" unless method_name.is_a?(Symbol)
+            raise ArgumentError, "provide either with: or a block" if !with.nil? && block_given?
+
+            with = block if block_given?
+
+            with_proc_or_symbol = with.is_a?(Proc) || with.is_a?(Symbol)
+            with_klazz = with.is_a?(Module) || with.is_a?(String)
+            raise ArgumentError, "with: must be a Symbol/Proc/Class" unless with_proc_or_symbol || with_klazz
+
+            self.renderers = renderers.merge(method_name => with)
+            ActiveSupport.version >= "7.2" ? generate_renderer_method(method_name) : eval_renderer_method(method_name)
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+          private
+
+          def generated_renderer_methods
+            @generated_renderer_methods ||= Module.new.tap { |mod| prepend mod }
+          end
+
+          def eval_renderer_method(method_name)
+            generated_renderer_methods.module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+              # def method_name(*args, **kwargs)
+              #   renderer = renderers.fetch(:method_name, {})
+              #
+              #   unless renderer.present?
+              #     raise ArgumentError, "#method_name not found in renderer" unless defined?(super)
+              #     super
+              #   end
+              #
+              #   dispatcher = StimulusPlumbers::Components::Plumber::Dispatcher.build(
+              #     renderer, *args, method_name: :#{method_name}, init_args: [template], **kwargs
+              #   )
+              #   raise ArgumentError, "invalid renderer, got: \#{renderer.inspect}" unless dispatcher
+              #
+              #   dispatcher.call(self)
+              # end
+              #{renderer_method_template(method_name)}
+            RUBY
+          end
+
+          def generate_renderer_method(method_name)
+            require "active_support/code_generator"
+            ActiveSupport::CodeGenerator.batch(generated_renderer_methods, __FILE__, __LINE__) do |owner|
+              owner.define_cached_method(method_name, namespace: :plumber_renderers) do |batch|
+                batch << renderer_method_template(method_name)
+              end
+            end
+          end
+
+          def renderer_method_template(method_name)
+            <<-RUBY
+            def #{method_name}(*args, **kwargs)
+              renderer = renderers.fetch(:#{method_name}, {})
+
+              unless renderer.present?
+                raise ArgumentError, "##{method_name} not found in renderer" unless defined?(super)
+                super
+              end
+
+              dispatcher = StimulusPlumbers::Components::Plumber::Dispatcher.build(
+                renderer, *args, method_name: :#{method_name}, init_args: [template], **kwargs
+              )
+              raise ArgumentError, "invalid renderer, got: \#{renderer.inspect}" unless dispatcher
+
+              dispatcher.call(self)
+            end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/components/popover/renderer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Components
+    module Popover
+      class Builder
+        attr_reader :activator_html, :content_html
+
+        def initialize(template)
+          @template = template
+          @activator_html = "".html_safe
+          @content_html   = "".html_safe
+        end
+
+        def activator(&block)
+          @activator_html = @template.capture(&block)
+        end
+
+        def content(&block)
+          @content_html = @template.capture(&block)
+        end
+      end
+
+      class Renderer < Plumber::Base
+        def popover(interactive: true, **kwargs, &block)
+          html_options = merge_html_options(
+            { classes: theme.resolve(:popover).fetch(:classes, "") },
+            kwargs
+          )
+
+          builder = Builder.new(template)
+          template.capture(builder, &block)
+
+          template.content_tag(:div, **html_options) do
+            wrapped_content = if interactive
+                                template.content_tag(:template, builder.content_html)
+                              else
+                                builder.content_html
+                              end
+            template.safe_join([builder.activator_html, wrapped_content])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/configuration.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "themes/base"
+require_relative "themes/tailwind_theme"
+
+module StimulusPlumbers
+  class Configuration
+    DEFAULT_LOG_FORMATTER  = ->(message) { "[StimulusPlumbers] #{message}" }
+    THEME_KLASS_FORMATTER  = ->(type) { "StimulusPlumbers::Themes::#{type.to_s.classify}Theme" }
+
+    def theme
+      @theme ||= build_theme(:tailwind)
+    end
+
+    def theme=(value)
+      @theme = build_theme(value)
+    end
+
+    def log_formatter
+      @log_formatter ||= DEFAULT_LOG_FORMATTER
+    end
+
+    def log_formatter=(callable)
+      raise ArgumentError, "log_formatter must respond to #call" unless callable.respond_to?(:call)
+
+      @log_formatter = callable
+    end
+
+    private
+
+    def build_theme(type)
+      return type if type.is_a?(Themes::Base)
+
+      klass_name = THEME_KLASS_FORMATTER.call(type)
+      klass_name.safe_constantize&.new or
+        raise ArgumentError, "Unknown theme #{type.inspect}: #{klass_name} is not defined."
+    end
+  end
+end

data/lib/stimulus_plumbers/engine.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+module StimulusPlumbers
+  class Engine < ::Rails::Engine
+    isolate_namespace StimulusPlumbers
+
+    config.autoload_paths << File.expand_path("../stimulus-plumbers", __dir__)
+
+    initializer "stimulus_plumbers.assets" do |app|
+      app.config.assets.paths << root.join("app/assets/javascripts")
+    end
+
+    initializer "stimulus_plumbers.helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include StimulusPlumbers::Helpers
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/form/builder.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "action_view/version"
+
+require_relative "field_component"
+require_relative "fields/renderer"
+require_relative "fields/text"
+require_relative "fields/text_area"
+require_relative "fields/file"
+require_relative "fields/select"
+require_relative "fields/choice"
+require_relative "../components/plumber/html_options"
+
+module StimulusPlumbers
+  module Form
+    class Builder < ActionView::Helpers::FormBuilder
+      include Components::Plumber::HtmlOptions
+      include Fields::Text
+      include Fields::TextArea
+      include Fields::File
+      include Fields::Select
+      include Fields::Choice
+
+      private
+
+      def build_field(attribute, form_field_opts, input_id: field_id(attribute))
+        FieldComponent.new(
+          object:           object,
+          attribute:        attribute,
+          input_id:         input_id,
+          label:            form_field_opts[:label],
+          details:          form_field_opts[:details],
+          error:            form_field_opts[:error],
+          required:         form_field_opts.fetch(:required, false),
+          label_visibility: form_field_opts.fetch(:label_visibility, :visible),
+          layout:           form_field_opts.fetch(:layout, :stacked)
+        )
+      end
+
+      def render_field(field, input_html)
+        Fields::Renderer.new(@template, theme, field).call(input_html)
+      end
+
+      def extract_options(options)
+        [options.except(*FieldComponent::OPTIONS), options.slice(*FieldComponent::OPTIONS)]
+      end
+
+      def field_theme(key, **variants)
+        { class: theme.resolve(key, **variants).fetch(:classes, "") }
+      end
+
+      def theme
+        StimulusPlumbers.config.theme
+      end
+
+      # field_id was added in Rails 7.0. Provide a compatible implementation for Rails 6.1.
+      if ActionView.version < "7.0"
+        def field_id(attribute, *suffixes, index: @index, namespace: @options[:namespace])
+          tokens = [namespace, @object_name, index, attribute, *suffixes]
+          tokens.select!(&:present?)
+          tokens.map! { |t| t.to_s.delete("]").tr("^-a-zA-Z0-9:.", "_") }
+          tokens.join("_")
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/form/field_component.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    class FieldComponent
+      OPTIONS = %i[label details error required label_visibility layout].freeze
+
+      attr_reader :object,
+                  :attribute,
+                  :input_id,
+                  :label_text,
+                  :details,
+                  :required,
+                  :label_visibility,
+                  :layout
+
+      def initialize(object:,
+                     attribute:,
+                     input_id:,
+                     label: nil,
+                     details: nil,
+                     error: nil,
+                     required: false,
+                     label_visibility: :visible,
+                     layout: :stacked)
+        @object           = object
+        @attribute        = attribute
+        @input_id         = input_id
+        @label_text       = label || attribute.to_s.humanize
+        @details          = details
+        @error_override   = error
+        @required         = required
+        @label_visibility = label_visibility.to_sym
+        @layout           = layout.to_sym
+      end
+
+      def errors
+        if @error_override
+          Array(@error_override)
+        elsif object.respond_to?(:errors)
+          object.errors[@attribute]
+        else
+          []
+        end
+      end
+
+      def error?
+        errors.any?
+      end
+
+      def html_opts
+        attrs = { id: input_id }
+        attrs[:"aria-describedby"] = described_by if described_by
+        attrs[:"aria-invalid"]     = "true"       if error?
+        attrs[:required]           = true         if required
+        attrs[:"aria-required"]    = "true"       if required
+        attrs
+      end
+
+      def hint_id
+        "#{input_id}_hint"
+      end
+
+      def error_id
+        "#{input_id}_error"
+      end
+
+      def described_by
+        ids = []
+        ids << hint_id  if details.present?
+        ids << error_id if errors.any?
+        ids.join(" ").presence
+      end
+
+      def label_hidden?
+        label_visibility == :exclusive
+      end
+    end
+  end
+end