phlex-forms 0.1.0

data/lib/forms/password_field.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Forms
+  # Convenience: an Input pre-typed as password.
+  #   PasswordField(:primary, name: "user[password]")
+  class PasswordField < Input
+    def initialize(*, placeholder: "••••••••", autocomplete: "current-password", **)
+      super(*, type: "password", placeholder:, autocomplete:, **)
+    end
+  end
+end

data/lib/forms/radio.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Forms
+  # A model-bound radio input, delegating to DaisyUI::Radio.
+  class Radio < Phlex::HTML
+    include PhlexForms::DelegatedField
+
+    def initialize(*modifiers, name: nil, id: nil, value: nil, checked: false,
+                   error: false, disabled: false, required: false, **attributes)
+      @modifiers = normalize_modifiers(modifiers)
+      @name = name
+      @id = id
+      @value = value
+      @checked = checked
+      @error = error
+      @disabled = disabled
+      @required = required
+      @full_width = false
+      @attributes = attributes
+      super()
+    end
+
+    def view_template
+      attrs = binding_attributes
+      attrs[:checked] = true if @checked
+      render DaisyUI::Radio.new(*daisy_modifiers, value: @value, **attrs)
+    end
+  end
+end

data/lib/forms/range.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Forms
+  # A model-bound range slider, delegating to DaisyUI::Range.
+  class Range < Phlex::HTML
+    include PhlexForms::DelegatedField
+
+    def initialize(*modifiers, name: nil, id: nil, value: nil, min: 0, max: 100,
+                   step: 1, error: false, disabled: false, full_width: true, **attributes)
+      @modifiers = normalize_modifiers(modifiers)
+      @name = name
+      @id = id
+      @value = value
+      @min = min
+      @max = max
+      @step = step
+      @error = error
+      @disabled = disabled
+      @required = false
+      @full_width = full_width
+      @attributes = attributes
+      super()
+    end
+
+    def view_template
+      render DaisyUI::Range.new(
+        *daisy_modifiers,
+        value: @value, min: @min, max: @max, step: @step,
+        **binding_attributes
+      )
+    end
+  end
+end

data/lib/forms/rich_textarea.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Forms
+  # A rich-text editor backed by the Lexxy `<lexxy-editor>` custom element for
+  # ActionText. Optional feature: requires ActionText/Lexxy in the host app.
+  # Renders an editor bound to the field; when the value is an ActionText::RichText
+  # its HTML body is used as the initial content.
+  class RichTextarea < Phlex::HTML
+    register_element :lexxy_editor
+
+    def initialize(*modifiers, name:, id: nil, value: nil, **options)
+      @modifiers = modifiers
+      @name = name
+      @id = id || name.to_s.gsub(/[\[\]]/, "_").gsub(/_+$/, "")
+      @value = value
+      @options = options
+      super()
+    end
+
+    def view_template
+      lexxy_editor(
+        name: @name,
+        id: @id,
+        value: formatted_value,
+        class: editor_classes,
+        **@options.except(:class, :error)
+      )
+    end
+
+    private
+
+    def formatted_value
+      return nil if @value.nil? || (@value.respond_to?(:blank?) && @value.blank?)
+
+      content = @value.respond_to?(:body) ? @value.body&.to_html : @value.to_s
+      content.to_s.empty? ? nil : "<div>#{content}</div>"
+    end
+
+    def editor_classes
+      [@options[:class], "lexxy-content"].compact.join(" ")
+    end
+  end
+end

data/lib/forms/select.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Forms
+  # A model-bound native `<select>`. Delegates the element + variants to
+  # DaisyUI::Select (daisyui v5 puts the `select` class on the element itself)
+  # and renders the options from `choices` inside its block.
+  class Select < Phlex::HTML
+    include PhlexForms::DelegatedField
+
+    def initialize(*modifiers, name: nil, id: nil, choices: [], selected: nil,
+                   include_blank: false, prompt: nil, error: false, disabled: false,
+                   required: false, full_width: true, **attributes)
+      @modifiers = normalize_modifiers(modifiers)
+      @name = name
+      @id = id
+      @choices = choices
+      @selected = selected
+      @include_blank = include_blank
+      @prompt = prompt
+      @error = error
+      @disabled = disabled
+      @required = required
+      @full_width = full_width
+      @attributes = attributes
+      super()
+    end
+
+    def view_template
+      render DaisyUI::Select.new(*daisy_modifiers, **binding_attributes) do |el|
+        render_prompt(el) if @prompt || @include_blank
+        render_choices(el)
+      end
+    end
+
+    private
+
+    # The options are rendered inside DaisyUI::Select's block, so option/optgroup
+    # resolve to the daisyui component's Phlex methods (yielded as `s`).
+    def render_prompt(el)
+      text = @prompt || (@include_blank.is_a?(String) ? @include_blank : "")
+      el.option(value: "", selected: @selected.blank?) { text }
+    end
+
+    def render_choices(el)
+      case @choices
+      when Hash then render_hash_choices(el, @choices)
+      else render_array_choices(el, Array(@choices))
+      end
+    end
+
+    def render_array_choices(el, choices)
+      choices.each do |choice|
+        if choice.is_a?(Array)
+          el.option(value: choice.last.to_s, selected: @selected.to_s == choice.last.to_s) { choice.first.to_s }
+        else
+          el.option(value: choice.to_s, selected: @selected.to_s == choice.to_s) { choice.to_s }
+        end
+      end
+    end
+
+    def render_hash_choices(el, choices)
+      choices.each do |label, value|
+        if value.is_a?(Array) || value.is_a?(Hash)
+          el.optgroup(label:) do
+            value.is_a?(Array) ? render_array_choices(el, value) : render_hash_choices(el, value)
+          end
+        else
+          el.option(value: value.to_s, selected: @selected.to_s == value.to_s) { label.to_s }
+        end
+      end
+    end
+  end
+end

data/lib/forms/submit.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Forms
+  # Submit button, delegating markup and variants to DaisyUI::Button. Defaults its
+  # label from the model's persistence state (Create/Update <Model>) via i18n, or
+  # takes explicit text.
+  #
+  #   Submit()                 # "Create User" / "Update User"
+  #   Submit(:primary, :lg)    # default text, modifiers
+  #   Submit("Save")           # custom text
+  #   Submit("Save", :primary) # custom text + modifiers
+  class Submit < Phlex::HTML
+    def initialize(*args, model: nil, disabled: false, **attributes)
+      if args.first.is_a?(String) || args.first.nil?
+        @text = args.first
+        @modifiers = args.drop(1)
+      else
+        @text = nil
+        @modifiers = args
+      end
+      @model = model
+      @disabled = disabled
+      @attributes = attributes
+      super()
+    end
+
+    def view_template(&block)
+      attrs = { type: "submit", **@attributes }
+      attrs[:disabled] = true if @disabled
+      render DaisyUI::Button.new(*@modifiers, **attrs) do
+        block ? yield : button_text
+      end
+    end
+
+    private
+
+    def button_text
+      @text || default_text
+    end
+
+    def default_text
+      action = persisted? ? "update" : "create"
+      if (name = model_name)
+        I18n.t("cmd.#{action}_model", model: name, default: I18n.t("cmd.#{action}"))
+      else
+        I18n.t("cmd.#{action}")
+      end
+    end
+
+    def persisted?
+      @model.respond_to?(:persisted?) && @model.persisted?
+    end
+
+    def model_name
+      if @model.respond_to?(:model_name)
+        @model.model_name.human
+      elsif @model.respond_to?(:class) && @model.class.respond_to?(:model_name)
+        @model.class.model_name.human
+      end
+    end
+  end
+end

data/lib/forms/textarea.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Forms
+  # A model-bound textarea. Thin form-binding layer over DaisyUI::Textarea.
+  class Textarea < Phlex::HTML
+    include PhlexForms::DelegatedField
+
+    def initialize(*modifiers, name: nil, id: nil, value: nil, error: false,
+                   disabled: false, required: false, rows: 4, full_width: true, **attributes)
+      @modifiers = normalize_modifiers(modifiers)
+      @name = name
+      @id = id
+      @value = value
+      @error = error
+      @disabled = disabled
+      @required = required
+      @rows = rows
+      @full_width = full_width
+      @attributes = attributes
+      super()
+    end
+
+    def view_template
+      render DaisyUI::Textarea.new(*daisy_modifiers, rows: @rows, **binding_attributes) { @value }
+    end
+  end
+end

data/lib/forms/time_zone_select.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Forms
+  # A time-zone `<select>` populated by Rails' time_zone_options_for_select,
+  # delegating the styling to DaisyUI::Select and wiring the `tz` Stimulus
+  # controller (which auto-selects the browser's zone when none is set).
+  #
+  # Requires phlex-rails' TimeZoneOptionsForSelect helper (a Rails host); outside
+  # Rails, pass explicit `choices` to a plain Forms::Select instead.
+  class TimeZoneSelect < Phlex::HTML
+    include PhlexForms::DelegatedField
+
+    include Phlex::Rails::Helpers::TimeZoneOptionsForSelect if defined?(Phlex::Rails::Helpers::TimeZoneOptionsForSelect)
+
+    def initialize(*modifiers, name: nil, id: nil, selected: nil, priority_zones: nil,
+                   model: ActiveSupport::TimeZone, placeholder: nil, include_blank: false,
+                   error: false, disabled: false, required: false, full_width: true, **attributes)
+      @modifiers = normalize_modifiers(modifiers)
+      @name = name
+      @id = id
+      @selected = selected
+      @priority_zones = priority_zones
+      @zone_model = model
+      @placeholder = placeholder
+      @include_blank = include_blank
+      @error = error
+      @disabled = disabled
+      @required = required
+      @full_width = full_width
+      @attributes = attributes
+      super()
+    end
+
+    def view_template
+      render DaisyUI::Select.new(*daisy_modifiers, **select_attributes) do |el|
+        render_placeholder(el) if @placeholder || @include_blank
+        el.raw(el.safe(time_zone_options_for_select(@selected, @priority_zones, @zone_model)))
+      end
+    end
+
+    private
+
+    def select_attributes
+      data = { controller: "tz" }.merge(@attributes[:data] || {})
+      binding_attributes(data:).except(:value)
+    end
+
+    def render_placeholder(el)
+      el.option(value: "", disabled: true, selected: @selected.blank?) { @placeholder.to_s }
+    end
+  end
+end

data/lib/forms/toggle.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Forms
+  # A model-bound toggle switch, delegating to DaisyUI::Toggle. Emits a hidden
+  # field carrying the unchecked value so an unchecked box still submits (the
+  # Rails checkbox convention).
+  class Toggle < Phlex::HTML
+    include PhlexForms::DelegatedField
+
+    def initialize(*modifiers, name: nil, id: nil, value: "1", unchecked_value: "0",
+                   checked: false, error: false, disabled: false, required: false, **attributes)
+      @modifiers = normalize_modifiers(modifiers)
+      @name = name
+      @id = id
+      @value = value
+      @unchecked_value = unchecked_value
+      @checked = checked
+      @error = error
+      @disabled = disabled
+      @required = required
+      @full_width = false
+      @attributes = attributes
+      super()
+    end
+
+    def view_template
+      input(type: "hidden", name: @name, value: @unchecked_value) if @unchecked_value && @name
+      render DaisyUI::Toggle.new(*daisy_modifiers, value: @value, **checkbox_attributes)
+    end
+
+    private
+
+    def checkbox_attributes
+      attrs = binding_attributes
+      attrs[:checked] = true if @checked
+      attrs
+    end
+  end
+end

data/lib/forms/validations/introspector.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Forms
+  module Validations
+    # Introspects an ActiveModel class (or instance) and translates
+    # each attribute's validators into a `data:` hash ready to merge
+    # into a Phlex element. Phlex handles the `data-` prefixing and
+    # underscore-to-hyphen conversion at render time.
+    #
+    # Sticks to validators whose semantics are reproducible client
+    # side. Skips anything with `:if` / `:unless` / `:on` because
+    # those need server context the browser doesn't have. Server
+    # validation remains authoritative — the client side just
+    # shortens the loop for the common cases.
+    class Introspector
+      CONTROLLER_PREFIX = "forms--validations"
+
+      # Validators we know how to mirror. Keys are the short class
+      # name (without namespace), values are the controller suffix
+      # appended to CONTROLLER_PREFIX. Matching on the short name
+      # picks up both `ActiveModel::Validations::*` (form objects)
+      # and `ActiveRecord::Validations::*` (AR models inherit a
+      # parallel set of subclasses for uniqueness/etc.) without
+      # listing both namespaces.
+      SUPPORTED = {
+        "PresenceValidator" => "presence",
+        "LengthValidator" => "length",
+        "FormatValidator" => "format",
+        "NumericalityValidator" => "numericality",
+        "InclusionValidator" => "inclusion",
+        "ExclusionValidator" => "exclusion",
+        "ConfirmationValidator" => "confirmation",
+        "AcceptanceValidator" => "acceptance"
+      }.freeze
+
+      LENGTH_KEYS = %i[maximum minimum is].freeze
+
+      NUMERICALITY_KEYS = %i[
+        greater_than greater_than_or_equal_to
+        less_than less_than_or_equal_to
+        equal_to other_than
+        only_integer odd even
+      ].freeze
+
+      # Convenience: returns a null introspector for nil models so
+      # callers don't need to guard.
+      def self.for(model_or_class)
+        return Null.new if model_or_class.nil?
+
+        klass = model_or_class.is_a?(Class) ? model_or_class : model_or_class.class
+        return Null.new unless klass.respond_to?(:validators_on)
+
+        new(klass)
+      end
+
+      def initialize(model_class)
+        @model_class = model_class
+      end
+
+      # Returns a hash of the shape:
+      #   {
+      #     controller: "forms--validations--presence forms--validations--length",
+      #     forms__validations__presence_required_value: "true",
+      #     forms__validations__length_maximum_value: "60",
+      #   }
+      #
+      # Returns {} when no supported validators are present.
+      # The double-underscore key encoding survives Phlex/Rails'
+      # underscore-to-hyphen rewrite: `__` → `-` (deliberate).
+      def data_attributes_for(attribute)
+        validators = applicable_validators(attribute)
+        return {} if validators.empty?
+
+        controllers = []
+        attrs = {}
+
+        validators.each do |validator|
+          suffix = SUPPORTED[validator.class.name.split("::").last]
+          next unless suffix
+
+          controllers << "#{CONTROLLER_PREFIX}--#{suffix}"
+          value_attributes(suffix, validator, attribute).each do |key, value|
+            attrs[data_key(suffix, key)] = value
+          end
+        end
+
+        return {} if controllers.empty?
+
+        { controller: controllers.uniq.join(" ") }.merge(attrs)
+      end
+
+      private
+
+      attr_reader :model_class
+
+      # Phlex turns underscores in `data:` hash keys into hyphens
+      # in the rendered HTML. To produce a key like
+      # `data-forms--validations--length-maximum-value` from a
+      # Ruby symbol we need every "-" represented as "__" in the
+      # symbol. That's what this method builds.
+      def data_key(suffix, key)
+        prefix = CONTROLLER_PREFIX.tr("-", "_")
+        :"#{prefix}__#{suffix}_#{key}_value"
+      end
+
+      def applicable_validators(attribute)
+        return [] unless model_class.respond_to?(:validators_on)
+
+        model_class.validators_on(attribute).reject { |v| conditional?(v) }
+      end
+
+      def conditional?(validator)
+        opts = validator.options
+        opts[:if].present? || opts[:unless].present? || opts[:on].present?
+      end
+
+      def value_attributes(suffix, validator, attribute)
+        case suffix
+        when "presence" then presence_attrs
+        when "length" then length_attrs(validator)
+        when "format" then format_attrs(validator)
+        when "numericality" then numericality_attrs(validator)
+        when "inclusion", "exclusion" then collection_attrs(validator)
+        when "confirmation" then confirmation_attrs(attribute)
+        when "acceptance" then acceptance_attrs(validator)
+        else {}
+        end
+      end
+
+      def presence_attrs
+        { required: "true" }
+      end
+
+      def length_attrs(validator)
+        opts = validator.options
+        attrs = {}
+
+        LENGTH_KEYS.each do |key|
+          attrs[key] = opts[key].to_s if opts.key?(key)
+        end
+
+        if opts.key?(:in) || opts.key?(:within)
+          range = opts[:in] || opts[:within]
+          attrs[:minimum] = range.min.to_s
+          attrs[:maximum] = range.max.to_s
+        end
+
+        attrs[:allow_blank] = "true" if opts[:allow_blank]
+        attrs[:allow_nil] = "true" if opts[:allow_nil]
+        attrs
+      end
+
+      def format_attrs(validator)
+        opts = validator.options
+        regex = opts[:with]
+        return {} unless regex.is_a?(Regexp)
+
+        attrs = { pattern: js_regex_source(regex) }
+        flags = js_regex_flags(regex)
+        attrs[:flags] = flags unless flags.empty?
+        attrs[:allow_blank] = "true" if opts[:allow_blank]
+        attrs
+      end
+
+      # JS regex syntax is mostly compatible with Ruby's, but two
+      # gotchas matter for the validators we'll be wiring up:
+      #   - Ruby `\A` / `\z` anchors → JS `^` / `$`
+      #   - Inline modifiers like `(?-mix:...)` need stripping
+      def js_regex_source(regex)
+        src = regex.source
+        src = src.gsub(/\A\(\?[-mix]+:(.+)\)\z/, '\1') # strip wrapper modifiers
+        src.gsub("\\A", "^").gsub("\\z", "$").gsub("\\Z", "$")
+      end
+
+      def js_regex_flags(regex)
+        flags = []
+        flags << "i" if regex.options.anybits?(Regexp::IGNORECASE)
+        flags << "m" if regex.options.anybits?(Regexp::MULTILINE)
+        flags.join
+      end
+
+      def numericality_attrs(validator)
+        opts = validator.options
+        attrs = {}
+
+        NUMERICALITY_KEYS.each do |key|
+          next unless opts.key?(key)
+
+          value = opts[key]
+          attrs[key] = value.is_a?(TrueClass) ? "true" : value.to_s
+        end
+
+        attrs[:allow_nil] = "true" if opts[:allow_nil]
+        attrs[:allow_blank] = "true" if opts[:allow_blank]
+        attrs
+      end
+
+      def collection_attrs(validator)
+        list = validator.options[:in]
+        return {} unless list.respond_to?(:to_a)
+
+        attrs = { in: list.to_a.to_json }
+        attrs[:allow_blank] = "true" if validator.options[:allow_blank]
+        attrs
+      end
+
+      def confirmation_attrs(attribute)
+        { match: "#{attribute}_confirmation" }
+      end
+
+      def acceptance_attrs(validator)
+        accept = validator.options[:accept] || %w[1 true]
+        { accept: Array(accept).map(&:to_s).to_json }
+      end
+
+      # No-op introspector returned for nil / non-AR models.
+      class Null
+        def data_attributes_for(_attribute)
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/forms/validations/manual_rules.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Forms
+  module Validations
+    # Accepts an inline rules hash and produces the same data-* hash
+    # shape that `Introspector#data_attributes_for` returns. Used when
+    # a caller wants client-side validation on a form not backed by
+    # an ActiveModel object (e.g. plain form objects, marketplace
+    # submissions that bypass the model in test setup, etc.).
+    #
+    # Supported shape:
+    #
+    #   ManualRules.new(
+    #     length: { maximum: 60, minimum: 3 },
+    #     presence: true,
+    #     format: { with: /\A[a-z]+\z/i },
+    #     numericality: { greater_than_or_equal_to: 0 },
+    #     inclusion: { in: %w[a b c] },
+    #     exclusion: { in: %w[admin] },
+    #     confirmation: true,
+    #     acceptance: true,
+    #   )
+    class ManualRules
+      def initialize(rules)
+        @rules = rules
+      end
+
+      def data_attributes
+        # Build a tiny ad-hoc model whose validators reproduce the
+        # rules, then delegate to the Introspector. Saves us
+        # reimplementing the per-validator → data-attr conversion in
+        # two places.
+        klass = build_adhoc_model
+        Introspector.new(klass).data_attributes_for(:value)
+      end
+
+      private
+
+      attr_reader :rules
+
+      def build_adhoc_model
+        captured_rules = rules
+        Class.new do
+          include ActiveModel::Model
+          include ActiveModel::Validations
+
+          attr_accessor :value, :value_confirmation
+
+          captured_rules.each do |key, opts|
+            case key
+            when :presence
+              validates :value, presence: true if opts
+            when :length
+              validates :value, length: opts
+            when :format
+              validates :value, format: opts
+            when :numericality
+              validates :value, numericality: opts
+            when :inclusion
+              validates :value, inclusion: opts
+            when :exclusion
+              validates :value, exclusion: opts
+            when :confirmation
+              validates :value, confirmation: true if opts
+            when :acceptance
+              validates :value, acceptance: opts.is_a?(Hash) ? opts : { accept: %w[1 true] }
+            end
+          end
+
+          def self.name
+            "Forms::Validations::ManualRules::Adhoc"
+          end
+        end
+      end
+    end
+  end
+end