stimulus_plumbers 0.2.8 → 0.2.9

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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module StimulusPlumbers
-  module Components
-    module Avatar
-      class Renderer < Plumber::Base
-        def avatar(name: nil, initials: nil, url: nil, color: nil, size: :md, **kwargs, &block)
-          color_css = resolve_color(color, name, initials) unless url || block_given?
-
-          html_options = merge_html_options(
-            {
-              classes:      [theme.resolve(:avatar, size: size).fetch(:classes, ""), color_css],
-              "aria-label": name,
-              role:         "img"
-            },
-            kwargs
-          )
-
-          template.content_tag(:span, inner(name, initials, url, &block), **html_options)
-        end
-
-        private
-
-        def inner(name, initials, url, &block)
-          if block_given?
-            template.capture(&block)
-          elsif url
-            template.tag.img(src: url, alt: name.present? ? "#{name}'s avatar" : "", onerror: "this.src=''")
-          elsif initials
-            initials_svg(initials)
-          else
-            fallback_svg
-          end
-        end
-
-        def resolve_color(color, name, initials)
-          if color
-            theme.avatar_colors.fetch(color, nil)
-          elsif (seed = name || initials)
-            theme.avatar_color_range[seed.bytes.reduce(:^) % theme.avatar_color_range.length]
-          else
-            theme.avatar_color_range.first
-          end
-        end
-
-        def initials_svg(initials)
-          template.content_tag(:svg, viewBox: "0 0 40 40") do
-            template.content_tag(
-              :text,
-              initials.upcase,
-              x:             "50%",
-              y:             "50%",
-              dy:            "0.35em",
-              fill:          "currentColor",
-              "font-size":   "20",
-              "text-anchor": "middle"
-            )
-          end
-        end
-
-        def fallback_svg
-          template.content_tag(:svg, viewBox: "0 0 40 40") do
-            template.tag.path(
-              fill: "currentColor",
-              d:    "M8.28 27.5A14.95 14.95 0 0120 21.8c4.76 0 8.97 2.24 11.72 5.7a14.02 " \
-                    "14.02 0 01-8.25 5.91 14.82 14.82 0 01-6.94 0 14.02 14.02 0 01-8.25-5.9z" \
-                    "M13.99 12.78a6.02 6.02 0 1112.03 0 6.02 6.02 0 01-12.03 0z"
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module StimulusPlumbers
-  module Components
-    module Button
-      class Renderer < Plumber::Base
-        def button(content = nil, url: nil, external: false, variant: :primary, size: :md, **kwargs, &block)
-          content      = template.capture(&block) if block_given?
-          html_options = merge_html_options(
-            { classes: theme.resolve(:button, variant: variant, size: size).fetch(:classes, "") },
-            kwargs
-          )
-
-          if url
-            html_options[:target] = "_blank" if external
-            template.content_tag(:a, content, href: url, **html_options)
-          else
-            html_options[:type] ||= "button"
-            template.content_tag(:button, content, **html_options)
-          end
-        end
-
-        def group(alignment: :left, direction: :row, **kwargs, &block)
-          html_options = merge_html_options(
-            { classes: theme.resolve(:button_group, alignment: alignment, direction: direction).fetch(:classes, "") },
-            kwargs
-          )
-          template.content_tag(:div, template.capture(&block), **html_options)
-        end
-      end
-    end
-  end
-end

data/lib/stimulus_plumbers/components/calendar/month/turbo/renderer.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module StimulusPlumbers
-  module Components
-    module Calendar
-      module Month
-        module Turbo
-          class Renderer < Plumber::Base
-            STIMULUS_CONTROLLER = "calendar-month-observer"
-
-            def render(
-              date: Date.today,
-              today: Date.today,
-              selectable: false,
-              selected_date: nil,
-              show_other_months: false,
-              **kwargs
-            )
-              html_options = merge_html_options(
-                {
-                  classes: theme.resolve(:calendar).fetch(:classes, ""),
-                  data:    { controller: STIMULUS_CONTROLLER, action: "click->#{STIMULUS_CONTROLLER}#select" }
-                },
-                kwargs
-              )
-
-              template.content_tag(:div, role: "grid", **html_options) do
-                template.safe_join(
-                  [
-                    days_of_week,
-                    days_of_month(
-                      date:              date,
-                      today:             today,
-                      selectable:        selectable,
-                      selected_date:     selected_date,
-                      show_other_months: show_other_months
-                    )
-                  ]
-                )
-              end
-            end
-
-            private
-
-            def days_of_week(**kwargs)
-              DaysOfWeek.new(template).render(**kwargs)
-            end
-
-            def days_of_month(**kwargs)
-              DaysOfMonth.new(template, **kwargs).render
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module StimulusPlumbers
-  module Components
-    module Calendar
-      class Renderer < Plumber::Base
-        STIMULUS_CONTROLLER          = "calendar-month"
-        OBSERVER_STIMULUS_CONTROLLER = "calendar-month-observer"
-        STIMULUS_DATA                = {
-          controller: "#{STIMULUS_CONTROLLER} #{OBSERVER_STIMULUS_CONTROLLER}",
-          action:     "click->#{OBSERVER_STIMULUS_CONTROLLER}#select"
-        }.freeze
-
-        def month(**kwargs)
-          html_options = merge_html_options(
-            { classes: theme.resolve(:calendar).fetch(:classes, ""), data: STIMULUS_DATA },
-            kwargs
-          )
-
-          template.content_tag(:div, role: "grid", **html_options) do
-            template.safe_join(
-              [
-                template.tag.div(data: { "#{STIMULUS_CONTROLLER}-target" => "daysOfWeek" }),
-                template.tag.div(
-                  role: "rowgroup",
-                  data: { "#{STIMULUS_CONTROLLER}-target" => "daysOfMonth" }
-                )
-              ]
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module StimulusPlumbers
-  module Components
-    module Card
-      class Renderer < Plumber::Base
-        def card(title: nil, **kwargs, &block)
-          html_options = merge_html_options(
-            { classes: theme.resolve(:card).fetch(:classes, "") },
-            kwargs
-          )
-
-          template.content_tag(:div, **html_options) do
-            template.safe_join(
-              [
-                (template.content_tag(:h2, title) if title.present?),
-                template.capture(&block)
-              ].compact
-            )
-          end
-        end
-
-        def section(title: nil, **kwargs, &block)
-          html_options = merge_html_options(
-            { classes: theme.resolve(:card_section).fetch(:classes, "") },
-            kwargs
-          )
-
-          template.content_tag(:div, **html_options) do
-            template.safe_join(
-              [
-                (template.content_tag(:h3, title) if title.present?),
-                template.capture(&block)
-              ].compact
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/stimulus_plumbers/components/combobox/option.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module StimulusPlumbers
-  module Components
-    module Combobox
-      class Option < Plumber::Base
-        def render(label:, value:, description: nil, disabled: false, selected: false)
-          aria = { selected: selected ? "true" : "false" }
-          aria[:disabled] = "true" if disabled
-
-          template.content_tag(:li, role: "option", aria: aria, data: { value: value }) do
-            if description
-              template.safe_join(
-                [
-                  template.content_tag(:span, label),
-                  template.content_tag(:span, description)
-                ]
-              )
-            else
-              label
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/stimulus_plumbers/components/combobox/option_group.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module StimulusPlumbers
-  module Components
-    module Combobox
-      module OptionGroup
-        private
-
-        def render_items(items, value: nil)
-          @selected_value = value.to_s
-          template.safe_join(items.map { |item| render_item(item) })
-        end
-
-        def render_item(item)
-          case item
-          when Hash
-            item.key?(:options) ? render_group(item[:label], item[:options]) : render_option_hash(item)
-          else
-            render_option(item[0], item[1].to_s, item[2] || {})
-          end
-        end
-
-        def render_option_hash(item)
-          render_option(item[:label], item[:value].to_s, item.except(:label, :value))
-        end
-
-        def render_option(label, value, attrs = {})
-          Option.new(template).render(
-            label:       label,
-            value:       value,
-            selected:    @selected_value == value,
-            disabled:    attrs[:disabled] || false,
-            description: attrs[:description]
-          )
-        end
-
-        def render_group(label, options)
-          template.content_tag(:li, role: "group", aria: { label: label }) do
-            template.safe_join(
-              [
-                template.content_tag(:span, label, aria: { hidden: "true" }),
-                template.content_tag(:ul) do
-                  template.safe_join(options.map { |opt| render_item(opt) })
-                end
-              ]
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module StimulusPlumbers
-  module Components
-    module Combobox
-      class Renderer < Plumber::Base
-        STIMULUS_CONTROLLER = "input-combobox"
-        FORMAT_CONTROLLER   = "input-format"
-        FORMAT_ACTION       = "input-combobox:changed->input-format#format"
-
-        def render(base_id:, options: {}, **kwargs)
-          popover_id    = "#{base_id}_popover"
-          initial_value = options.dig(:input, :value)
-
-          base_data = {
-            controller: "#{STIMULUS_CONTROLLER} #{FORMAT_CONTROLLER}",
-            action:     FORMAT_ACTION
-          }
-          base_data[:input_combobox_value_value] = initial_value if initial_value.present?
-
-          html_options = merge_html_options({ data: base_data }, kwargs)
-
-          template.content_tag(:div, **html_options) do
-            template.safe_join(
-              [
-                trigger_input(
-                  popover_id,
-                  options.dig(:popover, :haspopup) || options.dig(:popover, :role) || "dialog",
-                  options.fetch(:trigger, {})
-                ),
-                hidden_input(options.fetch(:input, {})),
-                popover_element(popover_id, options.fetch(:popover, {}))
-              ]
-            )
-          end
-        end
-
-        private
-
-        def trigger_input(popover_id, haspopup, opts)
-          base_data = {
-            "#{STIMULUS_CONTROLLER}_target": "trigger",
-            input_format_target:             "input",
-            action:                          "focus->#{STIMULUS_CONTROLLER}#open keydown.esc->#{STIMULUS_CONTROLLER}#close"
-          }
-          data = merge_data_options(base_data, opts.fetch(:data, {}).symbolize_keys)
-
-          aria = { haspopup: haspopup, expanded: "false", controls: popover_id }
-          aria[:autocomplete] = opts[:aria_autocomplete] if opts[:aria_autocomplete]
-          aria[:label]        = opts[:aria_label]        if opts[:aria_label]
-
-          template.tag.input(
-            type:     "text",
-            readonly: (opts.fetch(:readonly, true) ? true : nil),
-            role:     "combobox",
-            aria:     aria,
-            data:     data
-          )
-        end
-
-        def hidden_input(opts)
-          data = { "#{STIMULUS_CONTROLLER}_target": "value" }.merge(opts.fetch(:data, {}))
-          template.tag.input(type: "hidden", name: opts[:name], value: opts[:value], data: data)
-        end
-
-        def popover_element(popover_id, opts)
-          base_data = { "#{STIMULUS_CONTROLLER}_target": "popover" }
-          data = merge_data_options(base_data, (opts[:data] || {}).symbolize_keys)
-
-          attrs = { id: popover_id, hidden: "", data: data }
-          attrs[:role] = opts[:role] if opts[:role]
-          attrs[:aria] = { label: opts[:label] } if opts[:label]
-          template.content_tag(opts.fetch(:tag, :div), **attrs) { opts[:content] }
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-# 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

@@ -1,113 +0,0 @@
-# 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

@@ -1,53 +0,0 @@
-# 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]] }
-          data_hashes = hashes.map { |h| h[:data] || {} }
-          rest        = hashes.map { |h| h.except(:class, :classes, :data) }.reduce({}, :deep_merge)
-
-          class_value = merge_string_option(*classes).presence
-          merged_data = merge_data_options(*data_hashes)
-
-          result = class_value ? rest.merge(class: class_value) : rest
-          merged_data.present? ? result.merge(data: merged_data) : result
-        end
-
-        STIMULUS_SPACEJOIN_KEYS = %i[controller action].freeze
-
-        def merge_data_options(*hashes, spacejoin: STIMULUS_SPACEJOIN_KEYS)
-          hashes.reduce({}) do |acc, d|
-            acc.merge(d) do |key, old_val, new_val|
-              if spacejoin.include?(key.to_sym)
-                merge_string_option(old_val, new_val).presence || new_val
-              else
-                new_val
-              end
-            end
-          end
-        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