phlex-forms 0.1.0 → 0.2.1

data/lib/forms/field.rb

@@ -4,13 +4,21 @@
 # error set. Builds the concrete leaf components (input/textarea/select/...) with
 # name/id/value/error wired in, and derives the label text and required flag.
 #
-# Not usually built directly — `Form#field(:name)` / the builder return one.
+# Not usually built directly — `Form#field_object(:name)` / the builder return one.
 module Forms
   class Field
+    # Data keys whose values are Stimulus token lists — merged by joining, not
+    # replacing, so validation controllers and live triggers coexist.
+    TOKEN_JOINED_DATA_KEYS = %i[controller action].freeze
+
     attr_reader :name, :model, :scope, :errors
 
-    def initialize(name:, model:, scope:, errors:, form:)
+    # error_name: where errors live when it differs from the input's name — an
+    # inferred belongs_to select is named :country_id but Rails attaches its
+    # errors to :country.
+    def initialize(name:, model:, scope:, errors:, form:, error_name: nil)
       @name = name
+      @error_name = error_name || name
       @model = model
       @scope = scope
       @errors = errors
@@ -18,46 +26,48 @@ module Forms
     end
 
     # --- leaf component builders (return component instances to render) ---
+    # Component classes resolve through the form's theme (see
+    # PhlexForms::Theme), so the same field renders daisy or plain.
 
     def input(*modifiers, type: :text, **)
-      Forms::Input.new(*modifiers, type:, **field_attributes, **)
+      theme[:input].new(*modifiers, type:, **field_attributes, **)
     end
 
     def textarea(*modifiers, **)
-      Forms::Textarea.new(*modifiers, **field_attributes, **)
+      theme[:textarea].new(*modifiers, **field_attributes, **)
     end
     alias text_area textarea
 
     def rich_textarea(*modifiers, **)
-      Forms::RichTextarea.new(*modifiers, name: field_name, id: field_id, value: field_value, **)
+      theme[:rich_textarea].new(*modifiers, name: field_name, id: field_id, value: field_value, **)
     end
     alias rich_text_area rich_textarea
 
     def hidden(**)
-      Forms::Input.new(type: :hidden, **field_attributes, **)
+      theme[:input].new(type: :hidden, **field_attributes, **)
     end
 
     # daisyui v5 "icon/text inside the field" wrapper. The block renders the
     # leading content (icon, prefix); the bare input is wired to this field.
     def wrapped_input(*modifiers, type: :text, **, &)
-      Forms::WrappedInput.new(*modifiers, type:, **field_attributes.except(:error), error: invalid?, **, &)
+      theme[:wrapped_input].new(*modifiers, type:, **field_attributes.except(:error), error: invalid?, **, &)
     end
 
     def file(*modifiers, **)
-      Forms::FileInput.new(*modifiers, **field_attributes.except(:value), **)
+      theme[:file].new(*modifiers, **field_attributes.except(:value), **)
     end
 
     def checkbox(*modifiers, **)
-      Forms::Checkbox.new(*modifiers, checked: field_value, **field_attributes.except(:value), **)
+      theme[:checkbox].new(*modifiers, checked: field_value, **field_attributes.except(:value), **)
     end
     alias check_box checkbox
 
     def toggle(*modifiers, **)
-      Forms::Toggle.new(*modifiers, checked: field_value, **field_attributes.except(:value), **)
+      theme[:toggle].new(*modifiers, checked: field_value, **field_attributes.except(:value), **)
     end
 
     def radio(value, *modifiers, **options)
-      Forms::Radio.new(
+      theme[:radio].new(
         *modifiers,
         value:,
         checked: field_value == value,
@@ -67,7 +77,7 @@ module Forms
     alias radio_button radio
 
     def select(choices = nil, **options)
-      Forms::Select.new(choices:, selected: field_value, **select_options(options))
+      theme[:select].new(choices:, selected: field_value, **select_options(options))
     end
 
     # Enhanced select: choices.js-backed when searchable, native otherwise.
@@ -75,18 +85,18 @@ module Forms
       searchable = options.delete(:searchable) { false }
       opts = select_options(options)
       if searchable
-        Forms::ChoicesSelect.new(*modifiers, choices:, selected: field_value, searchable: true, **opts)
+        theme[:choices_select].new(*modifiers, choices:, selected: field_value, searchable: true, **opts)
       else
-        Forms::Select.new(*modifiers, choices:, selected: field_value, **opts)
+        theme[:select].new(*modifiers, choices:, selected: field_value, **opts)
       end
     end
 
     def label(text = nil, *modifiers, **, &block)
-      Forms::Label.new(*modifiers, text: text || (block ? nil : field_label), for: field_id, **, &block)
+      theme[:label].new(*modifiers, text: text || (block ? nil : field_label), for: field_id, **, &block)
     end
 
     def control(label: nil, hint: nil, required: false, **, &)
-      Forms::FormControl.new(label:, hint:, error: field_error_message, for: field_id, required:, **, &)
+      theme[:control].new(label:, hint:, error: field_error_message, for: field_id, required:, **, &)
     end
 
     # --- derived metadata ---
@@ -113,7 +123,9 @@ module Forms
     end
 
     def invalid?
-      @errors&.include?(@name)
+      return false unless @errors
+
+      @errors.include?(@name) || @errors.include?(@error_name)
     end
 
     def field_name
@@ -160,6 +172,10 @@ module Forms
 
     private
 
+    def theme
+      @theme ||= @form.respond_to?(:theme) ? @form.theme : PhlexForms::Theme.resolve(nil)
+    end
+
     def consume_validate(options)
       return options unless options.key?(:validate)
 
@@ -189,10 +205,10 @@ module Forms
     def merge_data(existing, additions)
       existing = (existing || {}).dup
       additions.each do |key, value|
-        if key == :controller
-          existing[:controller] = [existing[:controller], value].compact.reject { |s| s.to_s.empty? }.join(" ")
+        existing[key] = if TOKEN_JOINED_DATA_KEYS.include?(key)
+          [existing[key], value].compact.reject { |s| s.to_s.empty? }.join(" ")
         else
-          existing[key] = value
+          value
         end
       end
       existing
@@ -207,7 +223,9 @@ module Forms
     end
 
     def field_error_message
-      @errors&.full_messages_for(@name)&.first if invalid?
+      return nil unless invalid?
+
+      @errors.full_messages_for(@name).first || @errors.full_messages_for(@error_name).first
     end
 
     def select_options(options)

data/lib/forms/fields_for_builder.rb

@@ -8,6 +8,7 @@ module Forms
     include PhlexForms::Builder
 
     attr_reader :model, :scope, :errors, :parent_form
+    alias object model # Rails form-builder compatibility (mirrors Forms::Form)
 
     def initialize(model:, scope:, errors:, parent_form:)
       @model = model
@@ -21,16 +22,27 @@ module Forms
       @parent_form.render(...)
     end
 
-    def field_object(name)
-      Forms::Field.new(name:, model: @model, scope: @scope, errors: @errors, form: @parent_form)
+    def field_object(name, error_name: nil)
+      Forms::Field.new(name:, model: @model, scope: @scope, errors: @errors, form: @parent_form, error_name:)
+    end
+    alias [] field_object # `item_form[:id].hidden` — Rails form-builder-style access
+
+    def default_field_variants
+      @parent_form.default_field_variants
+    end
+
+    def theme
+      @parent_form.theme
     end
 
     # Nested fields_for (single association or has_many collection).
-    def fields_for(association_name, model = nil, &)
+    # nested_attributes: false nests under the raw name (JSONB/hash columns).
+    def fields_for(association_name, model = nil, nested_attributes: true, &)
       return unless block_given?
 
       associated = model || (@model.public_send(association_name) if @model.respond_to?(association_name))
-      base_scope = "#{@scope}[#{association_name}_attributes]"
+      attributes_key = nested_attributes ? "#{association_name}_attributes" : association_name.to_s
+      base_scope = "#{@scope}[#{attributes_key}]"
 
       if associated.respond_to?(:each_with_index)
         associated.each_with_index do |item, index|
@@ -41,8 +53,9 @@ module Forms
       end
     end
 
-    def field_name(name) = "#{@scope}[#{name}]"
-    def field_id(name)   = "#{@scope.tr('[', '_').delete(']')}_#{name}"
+    def field_name(name)  = "#{@scope}[#{name}]"
+    def field_id(name)    = "#{@scope.tr('[', '_').delete(']')}_#{name}"
+    def field_value(name) = field_object(name).field_value
 
     private
 

data/lib/forms/form.rb

@@ -17,14 +17,32 @@ module Forms
     include Phlex::Rails::Helpers::FormAuthenticityToken if defined?(Phlex::Rails::Helpers::FormAuthenticityToken)
     include PhlexForms::Builder
 
-    attr_reader :model, :scope, :url, :method, :errors, :validate
+    attr_reader :model, :scope, :url, :method, :errors, :validate, :theme
+
+    # Rails form-builder compatibility: `f.object` / `f.object_name` mirror the
+    # ActionView FormBuilder API so call sites that introspect the bound record
+    # (`f.object.class.reflect_on_association(...)`) keep working.
+    alias object model
+    alias object_name scope
+
+    def initialize(*modifiers, model: nil, scope: nil, url: nil, method: nil, validate: false,
+                   field_variants: nil, theme: nil, live: nil, **options)
+      if live
+        raise ArgumentError,
+          "live validation requires a Forms::Base subclass — the endpoint rebuilds the " \
+          "form from its class, and an inline block cannot be serialized. Declare " \
+          "`live model: #{record_from(model)&.class&.name || 'YourModel'}` on the class instead."
+      end
 
-    def initialize(*modifiers, model: nil, scope: nil, url: nil, method: nil, validate: false, **options)
       super()
       @base_modifiers = modifiers
+      @field_variants = Array(field_variants)
+      @theme = PhlexForms::Theme.resolve(theme)
       @options = options
       @model = record_from(model)
-      @scope = scope&.to_s || derive_scope(@model)
+      # scope: false opts out of scoping entirely — bare field names for
+      # reactive row editors / <template>-cloned rows. nil means "derive".
+      @scope = scope == false ? nil : (scope&.to_s || derive_scope(@model))
       @url = url || derive_url(model)
       @method = method || derive_method(@model)
       @errors = (@model.errors if @model.respond_to?(:errors))
@@ -51,12 +69,13 @@ module Forms
     end
 
     # Return a Forms::Field for a name (used by the Builder mixin).
-    def field_object(name)
-      Forms::Field.new(name:, model: @model, scope: @scope, errors: @errors, form: self)
+    def field_object(name, error_name: nil)
+      Forms::Field.new(name:, model: @model, scope: @scope, errors: @errors, form: self, error_name:)
     end
+    alias [] field_object # `f[:email].hidden` — Rails form-builder-style access
 
     def submit(*, **, &)
-      render Forms::Submit.new(*, model: @model, **, &)
+      render theme[:submit].new(*, model: @model, **, &)
     end
 
     def rich_textarea(name, *modifiers, **)
@@ -76,11 +95,13 @@ module Forms
 
     # Nested attributes. Yields a FieldsForBuilder per association (single) or per
     # item (has_many), with the correctly-indexed nested scope.
-    def fields_for(association_name, model = nil, &)
+    # nested_attributes: false nests under the raw name (no `_attributes` suffix)
+    # for JSONB/hash columns that aren't Rails nested attributes.
+    def fields_for(association_name, model = nil, nested_attributes: true, &)
       return unless block_given?
 
       associated = model || (@model.public_send(association_name) if @model.respond_to?(association_name))
-      attributes_key = "#{association_name}_attributes"
+      attributes_key = nested_attributes ? "#{association_name}_attributes" : association_name.to_s
       base_scope = @scope ? "#{@scope}[#{attributes_key}]" : attributes_key
 
       if associated.respond_to?(:each_with_index)
@@ -122,9 +143,16 @@ module Forms
       render field_object(name).select(choices, **options.except(:prompt), **html_options)
     end
 
+    # Default variants prepended to every `field`'s inner input: global config
+    # first, then this form's field_variants: (call-site modifiers stack last).
+    def default_field_variants
+      PhlexForms.config.field_variants + @field_variants
+    end
+
     # Public name/id/value helpers for external components mirroring the Rails API.
-    def field_name(name) = @scope ? "#{@scope}[#{name}]" : name.to_s
-    def field_id(name)   = @scope ? "#{@scope}_#{name}" : name.to_s
+    def field_name(name)  = @scope ? "#{@scope}[#{name}]" : name.to_s
+    def field_id(name)    = @scope ? "#{@scope}_#{name}" : name.to_s
+    def field_value(name) = field_object(name).field_value
 
     private
 

data/lib/forms/group.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Forms
+  # A daisyui fieldset with an optional legend, for sectioning related fields.
+  # Exposed as `f.group` (not `section`/`fieldset` — those are Phlex::HTML
+  # element methods and defining them would shadow the elements inside forms).
+  #
+  #   f.group(legend: "Address") { f.field :street; f.field :city }
+  class Group < Phlex::HTML
+    def initialize(legend: nil, **options)
+      @legend = legend
+      @options = options
+      super()
+    end
+
+    def view_template
+      render DaisyUI::Fieldset.new(**@options) do |fs|
+        fs.legend { @legend } if @legend
+        yield if block_given?
+      end
+    end
+  end
+end

data/lib/forms/live/field.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Forms
+  module Live
+    # A Forms::Field that merges the blur-time validate trigger into every
+    # input's data attributes (via apply_validations, the seam every builder
+    # already routes options through).
+    class Field < Forms::Field
+      def initialize(live_trigger: nil, **)
+        super(**)
+        @live_trigger = live_trigger
+      end
+
+      def apply_validations(options)
+        merged = super
+        return merged unless @live_trigger
+
+        merged.merge(data: merge_data(merged[:data], @live_trigger[:data]))
+      end
+    end
+  end
+end

data/lib/forms/live.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Forms
+  # Server-truth live validation via phlex-reactive: the whole form is one
+  # reactive component. Each input's blur (and a debounced form-wide input
+  # trigger) POSTs every field to a single :validate action, which assigns a
+  # whitelisted slice to the model, runs the REAL ActiveModel validators —
+  # uniqueness, :if/:unless, confirmation, :on context all work — and replies
+  # with a focus-preserving morph. Nothing is ever persisted.
+  #
+  # Enabled through the Forms::Base macro (inline forms cannot be live — the
+  # endpoint rebuilds the component from its class, and a caller-supplied
+  # block cannot be serialized):
+  #
+  #   class UserForm < Forms::Base
+  #     live model: User, debounce: 300
+  #     def fields
+  #       field :email
+  #       field :password
+  #       field :password_confirmation
+  #     end
+  #   end
+  #
+  # Identity is STATE-backed (not reactive_record): the token signs the
+  # model's GlobalID when persisted (nil for new records — reactive_record
+  # cannot round-trip an unsaved draft) plus the `touched` field list, so
+  # error display state survives every round trip tamper-proof, with zero
+  # client-side bookkeeping.
+  module Live
+    extend ActiveSupport::Concern
+    include Phlex::Reactive::Component
+
+    # Registers the raw-hash param type the :validate schema is declared with.
+    # Called from the engine initializer (the registry freezes after boot);
+    # test suites call it from their spec helper.
+    def self.register_param_type!
+      return if Phlex::Reactive.param_type?(:form_attributes)
+
+      Phlex::Reactive.param_type(:form_attributes) do |value|
+        value.is_a?(Hash) ? value : Phlex::Reactive::ParamSchema::DROP
+      end
+    end
+
+    class_methods do
+      def setup_live(model_class:, scope:, debounce:)
+        @live_model_class = model_class
+        @live_scope = scope.to_s
+        @live_debounce = debounce
+        reactive_state :model_gid, :touched
+        action :validate, params: { scope.to_sym => :form_attributes, _touch: :string }
+        # phlex-reactive >= 0.11 defaults verify_authorized ON: an action that
+        # completes without an authorization call raises AuthorizationNotVerified
+        # and rolls back (#168). :validate is a deliberate no-persist, read-only
+        # pass — it assigns, validates, and discards; native submit stays
+        # authoritative — so it needs no authorization. Guarded so it's a no-op
+        # on older phlex-reactive that lacks the macro.
+        skip_verify_authorized :validate if respond_to?(:skip_verify_authorized)
+      end
+
+      def live_model_class = @live_model_class || inherited_live(:live_model_class)
+      def live_scope       = @live_scope || inherited_live(:live_scope)
+      def live_debounce    = @live_debounce || inherited_live(:live_debounce)
+
+      # Narrow (live_permit) or trim (live_deny) the attributes the :validate
+      # action may assign. Default: the model's column/attribute names plus
+      # every validated attribute (and its _confirmation twin).
+      def live_permit(*attrs) = @live_permit = attrs.map(&:to_s)
+      def live_deny(*attrs)   = @live_deny = attrs.map(&:to_s)
+
+      def live_permitted_attributes(model)
+        permitted = @live_permit || derived_live_attributes(model)
+        permitted - (@live_deny || [])
+      end
+
+      private
+
+      def inherited_live(reader)
+        superclass.respond_to?(reader) ? superclass.public_send(reader) : nil
+      end
+
+      def derived_live_attributes(model)
+        klass = model.class
+        names = []
+        names.concat(klass.attribute_names.map(&:to_s)) if klass.respond_to?(:attribute_names)
+        if klass.respond_to?(:validators)
+          klass.validators.each do |validator|
+            validator.attributes.each do |attr|
+              names << attr.to_s
+              names << "#{attr}_confirmation" if validator.is_a?(ActiveModel::Validations::ConfirmationValidator)
+            end
+          end
+        end
+        names.uniq
+      end
+    end
+
+    # Two construction modes: the app renders `new(model:)`; the endpoint
+    # rebuilds `new(model_gid:, touched:)` from the signed state (see
+    # Component::DSL.from_identity — only declared state keys round-trip).
+    def initialize(*modifiers, model: nil, model_gid: nil, touched: nil, **)
+      model ||= locate_live_model(model_gid)
+      @touched = Array(touched).map(&:to_s)
+      super(*modifiers, model:, **)
+      @model_gid = (@model.to_gid.to_s if signed_model_gid?)
+      # A form re-rendered after a failed submit (classic 422) arrives with
+      # errors already on the model — surface them without requiring touches.
+      @touched |= @errors.attribute_names.map(&:to_s) if @errors.respond_to?(:attribute_names)
+    end
+
+    # Streamable's #id contract: the reactive root's stable DOM id.
+    def id
+      @options[:id] || "#{@model.respond_to?(:persisted?) && @model.persisted? ? 'edit' : 'new'}_#{@scope}"
+    end
+
+    # Assign → validate → morph. The reply preserves the focused input and its
+    # caret (Idiomorph); the fresh token re-signs the updated touched set.
+    # `_touch` is the wire key (underscored so it can never collide with a
+    # model attribute) — the schema splats it back as this keyword.
+    def validate(_touch: nil, **posted) # rubocop:disable Lint/UnderscorePrefixedVariableName
+      @touched |= [_touch.to_s] if _touch
+      assign_live_attributes(posted[self.class.live_scope.to_sym])
+      @model.validate
+      reply.morph
+    end
+
+    # The <form> element is the reactive root: id + controller + signed token,
+    # plus the debounced whole-form input trigger (input events bubble; blur
+    # triggers live per-input via Live::Field because Stimulus params are
+    # per-element).
+    def form_attributes
+      attrs = super
+      mix(
+        attrs,
+        reactive_root(id: attrs[:id] || id),
+        on(:validate, event: "input", debounce: self.class.live_debounce)
+      )
+    end
+
+    # Untouched fields get no error set, so nothing flashes before the user
+    # leaves a field; each input carries its blur _touch trigger.
+    def field_object(name, error_name: nil)
+      show_errors = touched?(name) || touched?(error_name)
+      Forms::Live::Field.new(
+        name:, model: @model, scope: @scope, form: self, error_name:,
+        errors: (show_errors ? @errors : nil),
+        live_trigger: on(:validate, event: "blur", _touch: name.to_s)
+      )
+    end
+
+    def touched?(name)
+      name && @touched.include?(name.to_s)
+    end
+
+    def locate_live_model(model_gid)
+      return GlobalID::Locator.locate(model_gid) if model_gid.present?
+
+      self.class.live_model_class.new
+    end
+
+    def signed_model_gid?
+      @model.respond_to?(:to_gid) && @model.respond_to?(:persisted?) && @model.persisted?
+    end
+
+    # Whitelisted assignment through public writers. Values are validated and
+    # rendered, never saved; use live_permit/live_deny to adjust the surface.
+    def assign_live_attributes(attrs)
+      return if attrs.blank?
+
+      permitted = self.class.live_permitted_attributes(@model)
+      attrs.each do |key, value|
+        key = key.to_s
+        next unless permitted.include?(key)
+
+        setter = :"#{key}="
+        @model.public_send(setter, value) if @model.respond_to?(setter)
+      end
+    end
+  end
+end

data/lib/forms/plain/checkbox.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Forms
+  module Plain
+    # Bare checkbox, keeping the hidden unchecked-value field (that's binding
+    # logic, not styling). Also fills the :toggle theme role — a toggle is a
+    # styled checkbox.
+    class Checkbox < Forms::Checkbox
+      def view_template
+        input(type: "hidden", name: @name, value: @unchecked_value) if @unchecked_value && @name
+        attrs = unstyled_attributes
+        attrs[:checked] = true if @checked
+        input(type: "checkbox", value: @value, **attrs)
+      end
+    end
+  end
+end

data/lib/forms/plain/control.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Forms
+  module Plain
+    # The label + field + error/hint wrapper as a bare <div>, preserving
+    # FormControl's ordering contract.
+    class Control < Forms::FormControl
+      def view_template
+        div(**@options.except(:class), class: @options[:class]) do
+          render Label.new(text: @label, for: @field_id, required: @required) if @label
+
+          yield if block_given?
+
+          if @error
+            render FieldError.new(message: @error)
+          elsif @hint
+            render FieldHint.new(text: @hint)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forms/plain/field_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Forms
+  module Plain
+    # Inline validation error: no styling classes, stable hooks only
+    # (role="alert" + data-field-error).
+    class FieldError < Forms::FieldError
+      def view_template
+        return unless @message
+
+        p(role: "alert", data: { field_error: true }, **@options) { @message }
+      end
+    end
+  end
+end

data/lib/forms/plain/field_hint.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Forms
+  module Plain
+    # Inline hint text with a data-field-hint hook, no styling classes.
+    class FieldHint < Forms::FieldHint
+      def view_template
+        return unless @text
+
+        p(data: { field_hint: true }, **@options) { @text }
+      end
+    end
+  end
+end

data/lib/forms/plain/file_input.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Forms
+  module Plain
+    # Bare <input type="file">.
+    class FileInput < Forms::FileInput
+      def view_template
+        attrs = unstyled_attributes(accept: @accept)
+        attrs[:multiple] = true if @multiple
+        input(type: "file", **attrs)
+      end
+    end
+  end
+end

data/lib/forms/plain/group.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Forms
+  module Plain
+    # Semantic <fieldset>/<legend> without daisyui classes.
+    class Group < Forms::Group
+      def view_template
+        fieldset(**@options.except(:class), class: @options[:class]) do
+          legend { @legend } if @legend
+          yield if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/forms/plain/input.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Forms
+  module Plain
+    # Bare semantic <input>. Inherits the binding contract from Forms::Input;
+    # positional variants are accepted and ignored.
+    class Input < Forms::Input
+      def view_template
+        input(type: @type, value: @value.to_s, **unstyled_attributes)
+      end
+    end
+  end
+end

data/lib/forms/plain/label.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Forms
+  module Plain
+    # Bare <label>, with the required marker as a semantic <abbr>.
+    class Label < Forms::Label
+      def view_template(&block)
+        label(for: @for, **@attributes) do
+          if block
+            yield
+          elsif @text
+            plain @text
+            abbr(title: "required") { "*" } if @required
+          end
+        end
+      end
+    end
+  end
+end