Class: Treaty::Attribute::Option::Validators::FormatValidator

Inherits:

Base

Object
Base
Treaty::Attribute::Option::Validators::FormatValidator

show all

Defined in:: lib/treaty/attribute/option/validators/format_validator.rb

Overview

Validates that string attribute value matches a specific format.

## Supported Formats

‘:uuid` - Universally unique identifier
‘:email` - Email address (RFC 2822 compliant)
‘:password` - Password (8-16 chars, must contain digit, lowercase, and uppercase)
‘:duration` - ActiveSupport::Duration compatible string (e.g., “1 day”, “2 hours”)
‘:date` - ISO 8601 date string (e.g., “2025-01-15”)
‘:datetime` - ISO 8601 datetime string (e.g., “2025-01-15T10:30:00Z”)
‘:time` - Time string (e.g., “10:30:00”, “10:30 AM”)
‘:boolean` - Boolean string (“true”, “false”, “0”, “1”)

## Usage Examples

Simple mode:

string :email, format: :email
string :started_on, format: :date

Advanced mode:

string :email, format: { is: :email }
string :started_on, format: { is: :date, message: "Invalid date format" }
string :started_on, format: { is: :date, message: ->(attribute:, value:, **) { "#{attribute} has invalid date: #{value}" } } # rubocop:disable Layout/LineLength

## Validation Rules

Only works with ‘:string` type attributes
Raises Treaty::Exceptions::Validation if used with non-string types
Skips validation for nil values (handled by RequiredValidator)
Each format has a pattern and/or validator for flexible validation

## Extensibility

To add new formats, extend DEFAULT_FORMATS hash with format definition:

DEFAULT_FORMATS[:custom_format] = {
  pattern: /regex/,
  validator: ->(value) { custom_validation_logic }
}

Constant Summary collapse

UUID_PATTERN = UUID format regex (8-4-4-4-12 hexadecimal pattern)

/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i

PASSWORD_PATTERN = Password format regex (8-16 chars, at least one digit, lowercase, and uppercase)

/\A(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z]).{8,16}\z/

BOOLEAN_PATTERN = Boolean string format regex (accepts “true”, “false”, “0”, “1” case-insensitive)

/\A(true|false|0|1)\z/i

DEFAULT_FORMATS = Default format definitions with patterns and validators Each format can have: pattern: Regex for pattern matching validator: Lambda for custom validation logic

{
  uuid: {
    pattern: UUID_PATTERN,
    validator: nil
  },
  email: {
    pattern: URI::MailTo::EMAIL_REGEXP,
    validator: nil
  },
  password: {
    pattern: PASSWORD_PATTERN,
    validator: nil
  },
  duration: {
    pattern: nil,
    validator: lambda do |value|
      ActiveSupport::Duration.parse(value)
      true
    rescue StandardError
      false
    end
  },
  date: {
    pattern: nil,
    validator: lambda do |value|
      Date.parse(value)
      true
    rescue ArgumentError, TypeError
      false
    end
  },
  datetime: {
    pattern: nil,
    validator: lambda do |value|
      DateTime.parse(value)
      true
    rescue ArgumentError, TypeError
      false
    end
  },
  time: {
    pattern: nil,
    validator: lambda do |value|
      Time.parse(value)
      true
    rescue ArgumentError, TypeError
      false
    end
  },
  boolean: {
    pattern: BOOLEAN_PATTERN,
    validator: nil
  }
}.freeze

Instance Method Summary collapse

#validate_schema! ⇒ void

Validates that format is only used with string type attributes and that the format name is valid.
#validate_value!(value) ⇒ void

Validates that the value matches the specified format Skips validation for nil values (handled by RequiredValidator).

Methods inherited from Base

#initialize, #target_name, #transform_value, #transforms_name?

Constructor Details

This class inherits a constructor from Treaty::Attribute::Option::Base

Instance Method Details

#validate_schema! ⇒ `void`

This method returns an undefined value.

Validates that format is only used with string type attributes and that the format name is valid

Raises:

(Treaty::Exceptions::Validation) —

If format is used with non-string type
(Treaty::Exceptions::Validation) —

If format name is unknown

# File 'lib/treaty/attribute/option/validators/format_validator.rb', line 120

def validate_schema! # rubocop:disable Metrics/MethodLength
  # Format option only works with string types
  unless @attribute_type == :string
    raise Treaty::Exceptions::Validation,
          I18n.t(
            "treaty.attributes.validators.format.type_mismatch",
            attribute: @attribute_name,
            type: @attribute_type
          )
  end

  format_name = option_value

  # Validate that format name exists
  return if formats.key?(format_name)

  raise Treaty::Exceptions::Validation,
        I18n.t(
          "treaty.attributes.validators.format.unknown_format",
          attribute: @attribute_name,
          format_name:,
          allowed: formats.keys.join(", ")
        )
end

#validate_value!(value) ⇒ `void`