stimulus_plumbers 0.4.13 → 0.4.15

data/lib/stimulus_plumbers/components/progress_ring.rb

@@ -3,40 +3,25 @@
 module StimulusPlumbers
   module Components
     class ProgressRing < Plumber::Base
+      include Progress::Shared
+
       def render(...)
         render_ring(...)
       end
 
       private
 
-      def render_ring(value:, max: 100, min: 0, indeterminate: false, **kwargs)
+      def render_ring(value:, max: 100, min: 0, indeterminate: false, size: nil, **kwargs)
         icon_options = merge_html_options(
-          theme.resolve(:progress_ring),
+          theme.resolve(:progress_ring, size: size),
           kwargs,
-          stimulus_data(value: value, min: min, max: max, indeterminate: indeterminate),
+          progress_stimulus_data(
+            value: value, min: min, max: max, variant: "ring", "progress-indeterminate-value": indeterminate
+          ),
           { role: "progressbar", aria: progress_aria(value: value, min: min, max: max, indeterminate: indeterminate) }
         )
         Components::Icon.new(template).render("progress-ring", **icon_options)
       end
-
-      def progress_aria(value:, min:, max:, indeterminate:)
-        aria = { valuemin: min, valuemax: max }
-        aria[:valuenow] = value unless indeterminate
-        aria
-      end
-
-      def stimulus_data(value:, min:, max:, indeterminate:)
-        {
-          data: {
-            controller:                     "progress",
-            "progress-variant-value":       "ring",
-            "progress-current-value":       value,
-            "progress-min-value":           min,
-            "progress-max-value":           max,
-            "progress-indeterminate-value": indeterminate
-          }
-        }
-      end
     end
   end
 end

data/lib/stimulus_plumbers/components/timeline/event/slots.rb

@@ -9,7 +9,6 @@ module StimulusPlumbers
 
           def with_indicator(icon: nil)
             set_slot(:indicator, icon, { type: icon ? :icon : :dot, icon: icon })
-            nil
           end
         end
       end

data/lib/stimulus_plumbers/form/builder.rb

@@ -31,6 +31,7 @@ module StimulusPlumbers
     class Builder < ActionView::Helpers::FormBuilder
       include Plumber::Options::Html
       include Plumber::Options::Aria
+      include Plumber::Dispatcher::CallableInspector
       include Fields::Inputs::Checkbox
       include Fields::Inputs::Code
       include Fields::Inputs::CreditCard
@@ -47,10 +48,10 @@ module StimulusPlumbers
       include Fields::Inputs::Text
       include Fields::Inputs::TextArea
 
-      def field(attribute, as:, **options)
+      def field(attribute, as:, **options, &block)
         field_opts = options.slice(*Field::OPTIONS)
         input_opts = options.except(*Field::OPTIONS)
-        render_field(as, attribute, field_opts, input_opts)
+        render_field(as, attribute, field_opts, input_opts, &block)
       end
 
       def collection_field(attribute, as:, collection:, value_method:, text_method:, **options)
@@ -71,9 +72,11 @@ module StimulusPlumbers
         StimulusPlumbers.config.theme.current
       end
 
-      def render_field(as, attribute, field_opts, input_opts)
+      def render_field(as, attribute, field_opts, input_opts, &block)
         raise ArgumentError, "unknown field type: #{as.inspect}" unless Fields::Renderer::FIELD.key?(as)
 
+        validate_field_block!(as, block)
+
         field = Field.new(@template, **field_opts)
         field.render(object, attribute, input_id: field_id(attribute)) do |html_opts, opts, error|
           Plumber::Dispatcher.build(
@@ -83,11 +86,19 @@ module StimulusPlumbers
             opts,
             error,
             floating: field.floating,
-            **input_opts
+            **input_opts,
+            &block
           ).call(self)
         end
       end
 
+      def validate_field_block!(as, block)
+        return unless block
+        return if accepts_block?(method(Fields::Renderer::FIELD.fetch(as)))
+
+        raise ArgumentError, "field type #{as.inspect} does not accept a block"
+      end
+
       def render_collection_field(as, attribute, field_opts, collection, value_method, text_method, input_opts)
         raise ArgumentError, "unknown collection field type: #{as.inspect}" unless Fields::Renderer::COLLECTION.key?(as)
 

data/lib/stimulus_plumbers/form/fields/inputs/password/revealable.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    module Fields
+      module Inputs
+        module Password
+          # Reveal toggle: input group wrapper, toggle button, and its icon pair.
+          module Revealable
+            STIMULUS_CONTROLLER = "input-revealable"
+            STIMULUS_ACTION     = "click->#{STIMULUS_CONTROLLER}#toggle".freeze
+
+            private
+
+            def render_revealable_password(error, floating: nil, &block)
+              render_input_group(
+                error:    error,
+                floating: floating,
+                trailing: method(:reveal_button),
+                **merge_html_options(
+                  theme.resolve(:form_field_input_reveal, error: error),
+                  data: reveal_data
+                )
+              ) { @template.capture(&block) }
+            end
+
+            def reveal_button
+              build_reveal_button do
+                @template.safe_join(
+                  [password_icon("reveal", "revealIcon"), password_icon("conceal", "concealIcon", hidden: true)]
+                )
+              end
+            end
+
+            def reveal_data
+              {
+                controller:                           STIMULUS_CONTROLLER,
+                input_revealable_reveal_label_value:  I18n.t("stimulus_plumbers.form.password.show", default: "Show password"),
+                input_revealable_conceal_label_value: I18n.t("stimulus_plumbers.form.password.hide", default: "Hide password")
+              }
+            end
+
+            def password_icon(name, target, hidden: false)
+              Components::Icon.new(@template).render(
+                name,
+                size:   :sm,
+                aria:   { hidden: "true" },
+                data:   { input_revealable_target: target },
+                hidden: hidden,
+                **theme.resolve(:button_icon)
+              )
+            end
+
+            def build_reveal_button(&block)
+              @template.content_tag(
+                :button,
+                **merge_html_options(
+                  theme.resolve(:form_field_input_button_reveal),
+                  {
+                    type: "button",
+                    aria: { label: I18n.t("stimulus_plumbers.form.password.show", default: "Show password") },
+                    data: { input_revealable_target: "toggle", action: STIMULUS_ACTION }
+                  }
+                )
+              ) { @template.capture(&block) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/form/fields/inputs/password/strength.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Form
+    module Fields
+      module Inputs
+        module Password
+          module Strength
+            private
+
+            def apply_strength_wiring(html_options, input_id)
+              described = [html_options.dig(:aria, :describedby), Components::PasswordStrength.rules_id_for(input_id)]
+                          .compact.join(" ")
+              merge_html_options(
+                html_options,
+                aria: { describedby: described },
+                data: {
+                  password_strength_target: "input", action: "input->password-strength#score"
+                }
+              )
+            end
+
+            def wrap_with_strength(input, input_id)
+              Components::PasswordStrength.new(@template).render(input: input, input_id: input_id, config: @password_requirements)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
+require_relative "password/revealable"
+require_relative "password/strength"
+
 module StimulusPlumbers
   module Form
     module Fields
       module Inputs
         module Password
-          STIMULUS_CONTROLLER = "input-revealable"
-          STIMULUS_ACTION     = "click->#{STIMULUS_CONTROLLER}#toggle".freeze
+          include Revealable
+          include Strength
+
           DEFAULT_AUTOCOMPLETE = "current-password"
 
           def password_field(attribute, floating: nil, revealable: false, **options)
@@ -24,78 +28,43 @@ module StimulusPlumbers
             end
           end
 
-          private
+          # Requirements collected from a `field` block, held for the renderer.
+          attr_reader :password_requirements
 
-          def render_password_input(attribute, html_opts, opts, error, floating: nil, revealable: false, **kwargs)
-            html_options = merge_html_options(
-              theme.resolve(:form_field_input, floating: floating, error: error),
-              opts,
-              html_opts,
-              kwargs,
-              { autocomplete: kwargs.delete(:autocomplete) || DEFAULT_AUTOCOMPLETE }
-            )
-            if revealable
-              render_revealable_password(error, floating: floating) do
-                revealable_html_options = merge_html_options(html_options, { data: { input_revealable_target: "input" } })
-                @template.password_field(@object_name, attribute, objectify_options(revealable_html_options))
-              end
-            else
-              @template.password_field(@object_name, attribute, objectify_options(html_options))
-            end
-          end
+          private
 
-          def render_revealable_password(error, floating: nil, &block)
-            render_input_group(
-              error:    error,
-              floating: floating,
-              trailing: method(:reveal_button),
-              **merge_html_options(
-                theme.resolve(:form_field_input_reveal, error: error),
-                data: reveal_data
-              )
-            ) { @template.capture(&block) }
-          end
+          def render_password_input(attribute, html_opts, opts, error, floating: nil, revealable: false, **kwargs, &block)
+            # A shared `requirements:` object (spec Section C) takes precedence over a field block.
+            @password_requirements = kwargs.delete(:requirements) || build_password_requirements(&block)
+            input_id = html_opts[:id]
+            html_options = password_html_options(html_opts, opts, error, floating, kwargs)
+            html_options = apply_strength_wiring(html_options, input_id) if @password_requirements.active?
+            input = if revealable
+                      render_revealable_password(error, floating: floating) do
+                        revealable_html_options = merge_html_options(html_options, { data: { input_revealable_target: "input" } })
+                        @template.password_field(@object_name, attribute, objectify_options(revealable_html_options))
+                      end
+                    else
+                      @template.password_field(@object_name, attribute, objectify_options(html_options))
+                    end
+            return input unless @password_requirements.active?
 
-          def reveal_button
-            build_reveal_button do
-              @template.safe_join(
-                [password_icon("reveal", "revealIcon"), password_icon("conceal", "concealIcon", hidden: true)]
-              )
-            end
+            wrap_with_strength(input, input_id)
           end
 
-          def reveal_data
-            {
-              controller:                           STIMULUS_CONTROLLER,
-              input_revealable_reveal_label_value:  I18n.t("stimulus_plumbers.form.password.show", default: "Show password"),
-              input_revealable_conceal_label_value: I18n.t("stimulus_plumbers.form.password.hide", default: "Hide password")
-            }
+          def build_password_requirements(&block)
+            StimulusPlumbers::Password::Requirements.build(&block)
           end
 
-          def password_icon(name, target, hidden: false)
-            Components::Icon.new(@template).render(
-              name,
-              size:   :sm,
-              aria:   { hidden: "true" },
-              data:   { input_revealable_target: target },
-              hidden: hidden,
-              **theme.resolve(:button_icon)
+          def password_html_options(html_opts, opts, error, floating, kwargs)
+            merge_html_options(
+              theme.resolve(:form_field_input, floating: floating, error: error),
+              opts,
+              html_opts,
+              kwargs,
+              { autocomplete: kwargs.delete(:autocomplete) || DEFAULT_AUTOCOMPLETE }
             )
           end
-
-          def build_reveal_button(&block)
-            @template.content_tag(
-              :button,
-              **merge_html_options(
-                theme.resolve(:form_field_input_button_reveal),
-                {
-                  type: "button",
-                  aria: { label: I18n.t("stimulus_plumbers.form.password.show", default: "Show password") },
-                  data: { input_revealable_target: "toggle", action: STIMULUS_ACTION }
-                }
-              )
-            ) { @template.capture(&block) }
-          end
         end
       end
     end

data/lib/stimulus_plumbers/helpers/progress_helper.rb

@@ -7,8 +7,16 @@ module StimulusPlumbers
         Components::ProgressBar.new(self).render(value: value, min: min, max: max, indeterminate: indeterminate, **kwargs)
       end
 
-      def sp_progress_ring(value:, min: 0, max: 100, indeterminate: false, **kwargs)
-        Components::ProgressRing.new(self).render(value: value, min: min, max: max, indeterminate: indeterminate, **kwargs)
+      def sp_progress_segmented(value:, segments:, min: 0, max: 100, mode: :discrete, indeterminate: false, ramp: nil, **kwargs)
+        Components::ProgressBar.new(self).render_segmented(
+          value: value, segments: segments, min: min, max: max, mode: mode, indeterminate: indeterminate, ramp: ramp, **kwargs
+        )
+      end
+
+      def sp_progress_ring(value:, min: 0, max: 100, indeterminate: false, size: nil, **kwargs)
+        Components::ProgressRing.new(self).render(
+          value: value, min: min, max: max, indeterminate: indeterminate, size: size, **kwargs
+        )
       end
 
       def sp_progress_meter(value:, min: 0, max: 100, low: nil, high: nil, optimum: nil, **kwargs)

data/lib/stimulus_plumbers/password/requirements.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Password
+    # Declarative password rule set: DSL + evaluation + serialization. Consumed by
+    # the form renderer, PasswordStrengthValidator, and the JS controller (via to_stimulus).
+    class Requirements
+      LEVEL_KEYS = %i[weak fine strong].freeze
+      BUILTIN_KEYS = %i[length uppercase lowercase digit symbol].freeze
+      DEFAULT_THRESHOLDS = { low: 34, high: 100, optimum: 100 }.freeze
+
+      BUILTIN_PATTERNS = {
+        uppercase: "[A-Z]",
+        lowercase: "[a-z]",
+        digit:     "\\d",
+        symbol:    "[^A-Za-z0-9]"
+      }.freeze
+
+      class << self
+        def build
+          new.tap { |req| yield req if block_given? }
+        end
+      end
+
+      def initialize
+        @enforced_options = nil
+        @custom = {}
+        @overrides = {}
+      end
+
+      def enforce(**options)
+        @enforced_options = options
+        nil
+      end
+
+      def rule(key, label = nil, pattern: nil, min: nil, max: nil, negate: false)
+        key = key.to_sym
+        if pattern
+          if negate
+            min = 0
+            max = 0
+          end
+          @custom[key] = { pattern: source_of(pattern), min: min.nil? ? 1 : min, max: max, label: label }
+        else
+          raise ArgumentError, unknown_rule_message(key) unless BUILTIN_KEYS.include?(key)
+
+          @overrides[key] = label
+        end
+        nil
+      end
+
+      def enforced?
+        !@enforced_options.nil?
+      end
+
+      # Any rule present — built-ins (only when enforced?) or a custom rule. Drives whether
+      # the form renders the strength UI; enforced? alone misses custom-only rule sets.
+      def active?
+        descriptors.any?
+      end
+
+      def rules
+        descriptors.to_h { |descriptor| [descriptor[:key], descriptor[:label]] }
+      end
+
+      def thresholds
+        DEFAULT_THRESHOLDS.merge((@enforced_options || {}).slice(*DEFAULT_THRESHOLDS.keys))
+      end
+
+      def evaluate(password)
+        password = password.to_s
+        results = descriptors.to_h { |descriptor| [descriptor[:key], satisfies?(descriptor, password)] }
+        satisfied = results.values.count(true)
+        { rules: results, value: score(satisfied, results.size), level: level_for(satisfied, results.size) }
+      end
+
+      def valid?(password)
+        result = evaluate(password)
+        result[:rules].any? && result[:rules].values.all?
+      end
+
+      def to_stimulus
+        { rules: descriptors.map { |descriptor| serialize(descriptor) }, options: stimulus_options, labels: level_labels }
+      end
+
+      private
+
+      def descriptors
+        list = enforced? ? BUILTIN_KEYS.filter_map { |key| builtin_descriptor(key) } : []
+        @custom.each do |key, spec|
+          list << { key: key, pattern: spec[:pattern], min: spec[:min], max: spec[:max], label: spec[:label] }
+        end
+        apply_overrides(list)
+      end
+
+      def builtin_descriptor(key)
+        options = @enforced_options
+        return length_descriptor(options) if key == :length && (options.key?(:min_length) || options.key?(:max_length))
+
+        bounds = parse_count(options[key])
+        return unless bounds
+
+        label = builtin_label(key, bounds[:min])
+        { key: key, pattern: BUILTIN_PATTERNS[key], min: bounds[:min], max: bounds[:max], label: label }
+      end
+
+      def length_descriptor(options)
+        unless options.key?(:min_length) && options.key?(:max_length)
+          raise ArgumentError, "length rule requires both min_length and max_length"
+        end
+
+        label = builtin_label(:length, options[:min_length])
+        { key: :length, min: options[:min_length], max: options[:max_length], label: label }
+      end
+
+      def parse_count(value)
+        case value
+        when nil, false then nil
+        when true then { min: 1, max: nil }
+        when Integer then { min: value, max: nil }
+        when Range then { min: value.begin, max: value.end }
+        else raise ArgumentError, "invalid occurrence count #{value.inspect}"
+        end
+      end
+
+      def satisfies?(descriptor, password)
+        n = descriptor[:pattern] ? password.scan(Regexp.new(descriptor[:pattern])).size : password.length
+        min = descriptor[:min] || 0
+        max = descriptor[:max] || Float::INFINITY
+        n.between?(min, max)
+      end
+
+      def score(satisfied, total)
+        total.zero? ? 0 : (satisfied.to_f / total * 100).round
+      end
+
+      def level_for(satisfied, total)
+        return "strong" if total.positive? && satisfied == total
+
+        score(satisfied, total) < thresholds[:low] ? "weak" : "fine"
+      end
+
+      def serialize(descriptor)
+        data = { key: descriptor[:key].to_s, label: descriptor[:label], min: descriptor[:min] }
+        data[:max] = descriptor[:max] unless descriptor[:max].nil?
+        data[:pattern] = descriptor[:pattern] if descriptor[:pattern]
+        data
+      end
+
+      def stimulus_options
+        { "low" => thresholds[:low] }
+      end
+
+      def level_labels
+        LEVEL_KEYS.index_with { |key| I18n.t("stimulus_plumbers.password.levels.#{key}") }.transform_keys(&:to_s)
+      end
+
+      def apply_overrides(list)
+        return list if @overrides.empty?
+
+        list.map do |descriptor|
+          next descriptor unless @overrides.key?(descriptor[:key])
+
+          descriptor.merge(label: @overrides[descriptor[:key]])
+        end
+      end
+
+      def builtin_label(key, count)
+        I18n.t("stimulus_plumbers.password.rules.#{key}", count: count)
+      end
+
+      def source_of(pattern)
+        pattern.is_a?(Regexp) ? pattern.source : pattern.to_s
+      end
+
+      def unknown_rule_message(key)
+        known = BUILTIN_KEYS.map(&:inspect).join(", ")
+        "unknown rule key: #{key.inspect} (known keys: #{known}), or pass pattern: for a custom rule"
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/password_strength_validator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "password/requirements"
+
+# Top-level so `validates :attr, password_strength: {...}` resolves via Rails' symbol lookup.
+class PasswordStrengthValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    requirements = options[:with] || build_requirements
+    result = requirements.evaluate(value.to_s)
+    return if result[:rules].any? && result[:rules].values.all?
+
+    unmet_messages(requirements, result).each { |message| record.errors.add(attribute, message) }
+  end
+
+  private
+
+  def build_requirements
+    StimulusPlumbers::Password::Requirements.build do |req|
+      req.enforce(**options.except(:with, :message, :on, :if, :unless, :allow_nil, :allow_blank))
+    end
+  end
+
+  def unmet_messages(requirements, result)
+    return [options[:message]] if options[:message]
+
+    labels = requirements.rules
+    result[:rules].reject { |_key, ok| ok }.keys.map { |key| labels[key] }
+  end
+end

data/lib/stimulus_plumbers/plumber/config.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Plumber
+    # Sibling of Slots for block DSLs whose payload is configuration, not content.
+    # Slots captures blocks through the view; Config only stores values, and holds
+    # the template to pass on to renderers.
+    #
+    # The store is private. Slots publishes `resolve` because its payload is uniform
+    # content a renderer reads generically; a Config's settings are typed, so each
+    # subclass exposes its own named readers instead.
+    class Config
+      attr_reader :template
+
+      def initialize(template = nil)
+        @template = template
+        @config = {}
+      end
+
+      private
+
+      # Returns nil so a subclass's DSL method reads as a command, not a value.
+      def configure(name, value)
+        @config[name] = value
+        nil
+      end
+
+      def config(name)
+        @config[name]
+      end
+
+      def configured?(name)
+        @config.key?(name)
+      end
+    end
+  end
+end

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

@@ -13,6 +13,10 @@ module StimulusPlumbers
         def accepts_kwargs?(callable)
           callable.parameters.any? { |type, _| %i[key keyreq keyrest].include?(type) }
         end
+
+        def accepts_block?(callable)
+          callable.parameters.any? { |type, _| type == :block }
+        end
       end
     end
   end

data/lib/stimulus_plumbers/plumber/slots.rb

@@ -37,8 +37,10 @@ module StimulusPlumbers
         @template ? @template.capture(&block) : block.call
       end
 
+      # Returns nil so a subclass's `with_*` method reads as a command, not a value.
       def set_slot(name, value, options = {})
         @slots[name] = { value: value, options: options }
+        nil
       end
 
       class << self
@@ -55,7 +57,6 @@ module StimulusPlumbers
         def define_flat_slot(name)
           define_method(:"with_#{name}") do |value = nil, **opts, &block|
             set_slot(name, block || value, opts)
-            nil
           end
         end
 
@@ -64,7 +65,6 @@ module StimulusPlumbers
             sub = by.new(@template)
             block&.call(sub)
             set_slot(name, sub)
-            nil
           end
         end
 

data/lib/stimulus_plumbers/themes/icons/external.rb

@@ -31,7 +31,7 @@ module StimulusPlumbers
 
           result = svg_defaults(key)
           root.attributes.each_attribute do |attr|
-            result[SVG_RENAME.fetch(attr.name, attr.name.to_sym)] = attr.value
+            result[SVG_RENAME.fetch(attr.name, attr.name.tr("-", "_").to_sym)] = attr.value
           end
 
           elements = parse_elements(root)