treaty 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44bc6d4e290eabdc45efdc7d1e73003f2bb1077e4eee99ad2e9912852d87ecb4
-  data.tar.gz: 72d4767ab3b9e69ec5eec87429cfabd54e6e82783ac4ea321b99eeb04eb85c07
+  metadata.gz: 8fd8fd4a097f7ff97cdb53e0d7825d79da5562d0bb6347e8e40794c158f8cb41
+  data.tar.gz: b0e119a2ba1018b4eeeb49c753b2949fb4c320ca89be29d633e7e6367cbd7360
 SHA512:
-  metadata.gz: c5d922b7116ebb82cf7d9c60d8bca8c9f45594744cc10e19319f0b3e22d631f8310a1695861f7979f8bf472b87b8bf5687248faae8ca93f90bec04e6fcfa7fd1
-  data.tar.gz: 2fbebe3ceaeeaf1bd743f36fbd40678bda0f9c8dbdbd284610f2de4a0101c6e8d865fa11f555b1fa195fd37e06eae519f82aa08fae8fb29694296ad65fa42be7
+  metadata.gz: 10514553e41066a04e066e6561744f69ca779bc4a87594bab7dce48b7e6217a5d5a6f2b7e28f1770876a9d3ff82d2f715cf4d167ef683dc36723b65a1549dc62
+  data.tar.gz: e262a6a4b2dbe068c53ced57ddcd7d9687a8e0be7d13f90ab8c2b9176015a3099829af702f59d22d28588a8c929e7178746d79356c35d4d0e899cc46991ce439

data/config/locales/en.yml

@@ -23,6 +23,11 @@ en:
           invalid_schema: "Option 'inclusion' for attribute '%{attribute}' must have a non-empty array of allowed values"
           not_included: "Attribute '%{attribute}' must be one of: %{allowed}. Got: '%{value}'"
 
+        format:
+          type_mismatch: "Option 'format' for attribute '%{attribute}' can only be used with String type. Current type: %{type}"
+          unknown_format: "Unknown format '%{format_name}' for attribute '%{attribute}'. Allowed formats: %{allowed}"
+          mismatch: "Attribute '%{attribute}' has invalid %{format_name} format: '%{value}'"
+
         # Nested structures validation
         nested:
           # Orchestrator errors

data/lib/treaty/attribute/option/registry_initializer.rb

@@ -21,6 +21,7 @@ module Treaty
       # - `:required` → RequiredValidator - Validates required/optional attributes
       # - `:type` → TypeValidator - Validates value types
       # - `:inclusion` → InclusionValidator - Validates value is in allowed set
+      # - `:format` → FormatValidator - Validates string values match specific formats
       #
       # ## Built-in Modifiers
       #
@@ -71,6 +72,7 @@ module Treaty
             Registry.register(:required, Validators::RequiredValidator, category: :validator)
             Registry.register(:type, Validators::TypeValidator, category: :validator)
             Registry.register(:inclusion, Validators::InclusionValidator, category: :validator)
+            Registry.register(:format, Validators::FormatValidator, category: :validator)
           end
 
           # Registers all built-in modifiers

data/lib/treaty/attribute/option/validators/format_validator.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Attribute
+    module Option
+      module Validators
+        # 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 }
+        #   }
+        class FormatValidator < Treaty::Attribute::Option::Base # rubocop:disable Metrics/ClassLength
+          # UUID format regex (8-4-4-4-12 hexadecimal pattern)
+          UUID_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 format regex (8-16 chars, at least one digit, lowercase, and uppercase)
+          PASSWORD_PATTERN = /\A(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z]).{8,16}\z/
+
+          # Boolean string format regex (accepts "true", "false", "0", "1" case-insensitive)
+          BOOLEAN_PATTERN = /\A(true|false|0|1)\z/i
+
+          # Default format definitions with patterns and validators
+          # Each format can have:
+          # - pattern: Regex for pattern matching
+          # - validator: Lambda for custom validation logic
+          DEFAULT_FORMATS = {
+            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
+
+          # Validates that format is only used with string type attributes
+          # and that the format name is valid
+          #
+          # @raise [Treaty::Exceptions::Validation] If format is used with non-string type
+          # @raise [Treaty::Exceptions::Validation] If format name is unknown
+          # @return [void]
+          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
+
+          # Validates that the value matches the specified format
+          # Skips validation for nil values (handled by RequiredValidator)
+          #
+          # @param value [String] The value to validate
+          # @raise [Treaty::Exceptions::Validation] If value doesn't match format
+          # @return [void]
+          def validate_value!(value) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+            return if value.nil? # Format validation doesn't check for nil, required does.
+
+            format_name = option_value
+            format_definition = formats[format_name]
+
+            # Allow blank values (empty strings should be caught by required validator)
+            return if value.to_s.strip.empty?
+
+            # Apply pattern matching if defined
+            if format_definition.fetch(:pattern)
+              return if value.match?(format_definition.fetch(:pattern))
+
+              # Pattern failed, and no validator - raise error
+              unless format_definition.fetch(:validator)
+                attributes = {
+                  attribute: @attribute_name,
+                  value:,
+                  format_name:
+                }
+
+                message = resolve_custom_message(**attributes) || default_message(**attributes)
+
+                raise Treaty::Exceptions::Validation, message
+              end
+            end
+
+            # Apply validator if defined
+            return unless format_definition.fetch(:validator)
+            return if format_definition.fetch(:validator).call(value)
+
+            attributes = {
+              attribute: @attribute_name,
+              value:,
+              format_name:
+            }
+
+            message = resolve_custom_message(**attributes) || default_message(**attributes)
+
+            raise Treaty::Exceptions::Validation, message
+          end
+
+          private
+
+          # Returns the available formats (allows for extension)
+          #
+          # @return [Hash] Hash of available formats with their definitions
+          def formats
+            DEFAULT_FORMATS
+          end
+
+          # Generates default error message for format validation failure using I18n
+          #
+          # @param attribute [Symbol] The attribute name
+          # @param value [Object] The actual value that failed validation
+          # @param format_name [Symbol] The format name
+          # @return [String] Default error message
+          def default_message(attribute:, value:, format_name:)
+            I18n.t(
+              "treaty.attributes.validators.format.mismatch",
+              attribute:,
+              value:,
+              format_name:
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/treaty/version.rb

@@ -3,7 +3,7 @@
 module Treaty
   module VERSION
     MAJOR = 0
-    MINOR = 8
+    MINOR = 9
     PATCH = 0
     PRE = nil
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: treaty
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Anton Sokolov
@@ -159,6 +159,7 @@ files:
 - lib/treaty/attribute/option/modifiers/default_modifier.rb
 - lib/treaty/attribute/option/registry.rb
 - lib/treaty/attribute/option/registry_initializer.rb
+- lib/treaty/attribute/option/validators/format_validator.rb
 - lib/treaty/attribute/option/validators/inclusion_validator.rb
 - lib/treaty/attribute/option/validators/required_validator.rb
 - lib/treaty/attribute/option/validators/type_validator.rb