Phlexi::Field

gem 'phlexi-field'

# Create a root namespace for a user object
namespace = Phlexi::Field::Structure::Namespace.new(
  :user,                           # The key/name 
  parent: nil,                     # Root namespace has no parent
  builder_klass: Phlexi::Field::Builder,  # Field builder class
  object: @user                    # The data object
)

# Create a field within the namespace
email_field = namespace.field(:email)

# Access field properties
email_field.dom.id      # => "user_email"
email_field.dom.name    # => "user[email]"
email_field.value       # => The email value from @user

# For a has_one relationship
namespace.nest_one(:profile) do |profile|
  first_name = profile.field(:first_name)
  # DOM properties: id="user_profile_first_name", name="user[profile][first_name]"
end

# For a has_many relationship
namespace.nest_many(:addresses) do |address_builder|
  street = address_builder.field(:street)
  # DOM properties: id="user_addresses_street", name="user[addresses][][street]"
end

# Custom label
field = namespace.field(:email, label: "Email Address")

# Get the current label (automatically falls back to humanized attribute name)
field.label  # => "Email Address" or "Email" if not explicitly set

# Rails integration: Uses human_attribute_name if available
# user.class.human_attribute_name(:email) => "Email Address"

# Setting a hint for a field
field = namespace.field(:password, hint: "Must be at least 8 characters")
field.hint  # => "Must be at least 8 characters"
field.has_hint?  # => true

# Setting a description
field = namespace.field(:terms_accepted, 
                      description: "By accepting our terms, you agree to our privacy policy.")
field.description  # => "By accepting our terms, you agree to our privacy policy."
field.has_description?  # => true

field = namespace.field(:email, placeholder: "john@example.com")
field.placeholder  # => "john@example.com"

# Based on attribute/column type in ActiveRecord/ActiveModel
# email_field.inferred_field_type  # => :string, :integer, :boolean, etc.

# For string fields, it can also infer more specific types
# email_field.inferred_string_field_type  # => :email, :password, :url, etc. 

# Check if a field is required based on presence validators
field.required?  # => true/false based on presence validators

# Access the validation errors
field.errors  # => ["can't be blank", etc.]

field = namespace.field(:categories, multiple: true)
field.multiple?  # => true

class UserForm < Phlex::HTML
  def initialize(user)
    super()
    @user = user
  end
  
  def view_template
    namespace = Phlexi::Field::Structure::Namespace.new(
      :user, 
      parent: nil, 
      builder_klass: Phlexi::Field::Builder, 
      object: @user
    )
    
    form(action: "/users", method: "post") do
      # Create a name field
      name_field = namespace.field(:name)
      label(for: name_field.dom.id) { name_field.label }
      input(
        id: name_field.dom.id, 
        name: name_field.dom.name, 
        value: name_field.value, 
        type: "text"
      )
      
      # Create an email field
      email_field = namespace.field(:email)
      label(for: email_field.dom.id) { email_field.label }
      input(
        id: email_field.dom.id, 
        name: email_field.dom.name, 
        value: email_field.value, 
        type: "email"
      )
      
      # Submit button
      button(type: "submit") { "Submit" }
    end
  end
end

# Usage in a controller
def new
  user = User.new
  render UserForm.new(user)
end

# For a has_one relationship
namespace.nest_one(:profile) do |profile|
  profile.field(:first_name) # => Creates a field for user[profile][first_name]
end

# For a has_many relationship
namespace.nest_many(:addresses) do |address_builder|
  address_field = address_builder.field(:id)
  # Creates fields like user[addresses][][id]
end

# Custom label
field = namespace.field(:email, label: "Email Address")

# Required fields
field = namespace.field(:email, required: true)

# Placeholder text
field = namespace.field(:email, placeholder: "Enter your email")

# Description/hint text
field = namespace.field(:password, hint: "Must be at least 8 characters")

class MyInputComponent < Phlexi::Field::Components::Base
  def view_template
    input(
      id: field.dom.id,
      name: field.dom.name,
      value: field.value,
      type: "text",
      **attributes
    )
  end
end

# Usage
my_component = MyInputComponent.new(field, class: "custom-input")
render my_component

# In your Gemfile
gem 'phlexi-field'
gem 'phlex-rails'