treaty 0.12.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c10e0241b816115758a4383e524fc0f9cfb6738e95f4fddff5a1b32eb114c719
-  data.tar.gz: 4a5bfe17af7e6efb87975770aed1a3a67fb817aeee13cdbd05c88c187407efe0
+  metadata.gz: 1fe35b7cf209d578b34ee7d904bdd146db4a3ac61f022a1f5f02c80bfe21875e
+  data.tar.gz: 4be4a2f29fbfb30115e696baeaf618eaf59fe5c2fc309a0d1ced3eff61713671
 SHA512:
-  metadata.gz: 12b23780c22b9987d317323e723c81d5be07ff2099e74a6cf90c4eab5bb4d0d74a6f0c8b05f11f7800daf16c02d5dd7c317c2d7df770ad99c1638933e94b6297
-  data.tar.gz: 4074fa86260a0f9e79adeaf6b41a61f70f5e568e7cbd6592b4eb8c19c270c954753db941be3490ce40944d1edc8cf9445caf75ef1de0b18e65e7939ad6ffd191
+  metadata.gz: d256fd30a7553ebfc015c06049c4fc0edceddaa782b3b0bda807364568009465556e72867324bc4a707d61c52da579f5a40f4324922af4349f1a7553023a9443
+  data.tar.gz: 4d71a4831e946faf207b9c21947531f3bc6263941f07e3a627c2e504a8c471d6aec597fe167090c0d0d49979b3b4dbf2f8e0620cfe9cd12f492286f60b5a3e7a

data/README.md

@@ -13,7 +13,7 @@
 </div>
 
 > [!WARNING]
-> **Development Status**: Treaty is currently under active development in the 0.x version series. Breaking changes may occur between minor versions (0.x) as we refine the API and add new features. The library will stabilize with the 1.0 release. We recommend pinning to specific patch versions in your Gemfile (e.g., `gem "treaty", "~> 0.12.0"`) until the 1.0 release.
+> **Development Status**: Treaty is currently under active development in the 0.x version series. Breaking changes may occur between minor versions (0.x) as we refine the API and add new features. The library will stabilize with the 1.0 release. We recommend pinning to specific patch versions in your Gemfile (e.g., `gem "treaty", "~> 0.14.0"`) until the 1.0 release.
 
 ## 📚 Documentation
 
@@ -79,7 +79,7 @@ module Posts
           string :title
           string :content
           string :summary
-          datetime :created_at
+          time :created_at
         end
       end
 

data/config/locales/en.yml

@@ -17,7 +17,9 @@ en:
             boolean: "Attribute '%{attribute}' must be a Boolean (true or false), got %{actual}"
             object: "Attribute '%{attribute}' must be a Hash (object), got %{actual}"
             array: "Attribute '%{attribute}' must be an Array, got %{actual}"
-            datetime: "Attribute '%{attribute}' must be a DateTime/Time/Date, got %{actual}"
+            date: "Attribute '%{attribute}' must be a Date, got %{actual}"
+            time: "Attribute '%{attribute}' must be a Time, got %{actual}"
+            datetime: "Attribute '%{attribute}' must be a DateTime, got %{actual}"
 
         inclusion:
           invalid_schema: "Option 'inclusion' for attribute '%{attribute}' must have a non-empty array of allowed values"
@@ -49,6 +51,17 @@ en:
         as:
           invalid_type: "Option 'as' for attribute '%{attribute}' must be a Symbol. Got: %{type}"
 
+        transform:
+          invalid_type: "Option 'transform' for attribute '%{attribute}' must be a Proc or Lambda. Got: %{type}"
+          execution_error: "Transform failed for attribute '%{attribute}': %{error}"
+
+        cast:
+          invalid_type: "Option 'cast' for attribute '%{attribute}' must be a Symbol. Got: %{type}"
+          source_not_supported: "Option 'cast' for attribute '%{attribute}' cannot be used with type '%{source_type}'. Casting is only supported for: %{allowed}"
+          target_not_supported: "Option 'cast' for attribute '%{attribute}' cannot cast to '%{target_type}'. Supported target types: %{allowed}"
+          conversion_not_supported: "Option 'cast' for attribute '%{attribute}' does not support conversion from '%{from}' to '%{to}'"
+          conversion_error: "Cast failed for attribute '%{attribute}' from '%{from}' to '%{to}'. Value: '%{value}'. Error: %{error}"
+
       # Attribute builder DSL
       builder:
         not_implemented: "%{class} must implement #create_attribute"

data/lib/treaty/attribute/option/modifiers/cast_modifier.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Attribute
+    module Option
+      module Modifiers
+        # Converts attribute values between different types automatically.
+        #
+        # ## Usage Examples
+        #
+        # Simple mode:
+        #   string :created_at, cast: :datetime
+        #   datetime :timestamp, cast: :string
+        #   integer :active, cast: :boolean
+        #
+        # Advanced mode with custom error message:
+        #   string :created_at, cast: {
+        #     to: :datetime,
+        #     message: "Invalid date format"
+        #   }
+        #
+        # ## Use Cases
+        #
+        # 1. **Request type conversion**:
+        #    ```ruby
+        #    request do
+        #      string :created_at, cast: :datetime
+        #    end
+        #    # Input: { created_at: "2024-01-15T10:30:00Z" }
+        #    # Service receives: { created_at: DateTime object }
+        #    ```
+        #
+        # 2. **Response type conversion**:
+        #    ```ruby
+        #    response 200 do
+        #      datetime :created_at, cast: :string
+        #    end
+        #    # Service returns: { created_at: DateTime object }
+        #    # Output: { created_at: "2024-01-15T10:30:00Z" }
+        #    ```
+        #
+        # 3. **Unix timestamp conversion**:
+        #    ```ruby
+        #    integer :timestamp, cast: :datetime
+        #    datetime :created_at, cast: :integer
+        #    ```
+        #
+        # ## Supported Conversions
+        #
+        # ### From Integer
+        # - integer -> string: Converts to string representation
+        # - integer -> boolean: 0 = false, non-zero = true
+        # - integer -> date: Treats as Unix timestamp, converts to date
+        # - integer -> time: Treats as Unix timestamp
+        # - integer -> datetime: Treats as Unix timestamp, converts to datetime
+        #
+        # ### From String
+        # - string -> integer: Parses integer from string
+        # - string -> boolean: Parses truthy/falsy strings (true/false, yes/no, 1/0, on/off)
+        # - string -> date: Parses date string
+        # - string -> time: Parses time string
+        # - string -> datetime: Parses datetime string (ISO8601, RFC3339, etc.)
+        #
+        # ### From Boolean
+        # - boolean -> string: Converts to "true" or "false"
+        # - boolean -> integer: true = 1, false = 0
+        #
+        # ### From Date
+        # - date -> string: Converts to ISO8601 format
+        # - date -> integer: Converts to Unix timestamp
+        # - date -> time: Converts to Time at midnight
+        # - date -> datetime: Converts to DateTime at midnight
+        #
+        # ### From Time
+        # - time -> string: Converts to ISO8601 format
+        # - time -> integer: Converts to Unix timestamp
+        # - time -> date: Converts to Date
+        # - time -> datetime: Converts to DateTime
+        #
+        # ### From DateTime
+        # - datetime -> string: Converts to ISO8601 format
+        # - datetime -> integer: Converts to Unix timestamp
+        # - datetime -> date: Converts to Date
+        # - datetime -> time: Converts to Time
+        #
+        # ## Important Notes
+        #
+        # - Cast option only works with scalar types (integer, string, boolean, date, time, datetime)
+        # - Array and Object types are not supported for casting
+        # - Casting to the same type is allowed (no-op)
+        # - Nil values are not transformed (handled by RequiredValidator)
+        # - All conversion errors are caught and re-raised as Validation errors
+        #
+        # ## Error Handling
+        #
+        # If conversion fails (e.g., invalid date string, non-numeric string to integer),
+        # the error is caught and converted to a Treaty::Exceptions::Validation error.
+        #
+        # ## Advanced Mode
+        #
+        # Schema format: `{ to: :target_type, message: "Custom error" }`
+        # Note: Uses `:to` key instead of the default `:is` key.
+        class CastModifier < Treaty::Attribute::Option::Base # rubocop:disable Metrics/ClassLength
+          # Types that support casting (scalar types only)
+          ALLOWED_CAST_TYPES = %i[integer string boolean date time datetime].freeze
+
+          # Validates that cast option is correctly configured
+          #
+          # @raise [Treaty::Exceptions::Validation] If cast configuration is invalid
+          # @return [void]
+          def validate_schema! # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+            # If option_schema is nil, cast is not used for this attribute
+            return if @option_schema.nil?
+
+            target_type = option_value
+
+            # Validate that target type is a Symbol
+            unless target_type.is_a?(Symbol)
+              raise Treaty::Exceptions::Validation,
+                    I18n.t(
+                      "treaty.attributes.modifiers.cast.invalid_type",
+                      attribute: @attribute_name,
+                      type: target_type.class
+                    )
+            end
+
+            # Validate that source type supports casting
+            unless ALLOWED_CAST_TYPES.include?(@attribute_type)
+              raise Treaty::Exceptions::Validation,
+                    I18n.t(
+                      "treaty.attributes.modifiers.cast.source_not_supported",
+                      attribute: @attribute_name,
+                      source_type: @attribute_type,
+                      allowed: ALLOWED_CAST_TYPES.join(", ")
+                    )
+            end
+
+            # Validate that target type is allowed
+            unless ALLOWED_CAST_TYPES.include?(target_type)
+              raise Treaty::Exceptions::Validation,
+                    I18n.t(
+                      "treaty.attributes.modifiers.cast.target_not_supported",
+                      attribute: @attribute_name,
+                      target_type:,
+                      allowed: ALLOWED_CAST_TYPES.join(", ")
+                    )
+            end
+
+            # Validate that conversion from source to target is supported
+            return if conversion_supported?(@attribute_type, target_type)
+
+            raise Treaty::Exceptions::Validation,
+                  I18n.t(
+                    "treaty.attributes.modifiers.cast.conversion_not_supported",
+                    attribute: @attribute_name,
+                    from: @attribute_type,
+                    to: target_type
+                  )
+          end
+
+          # Applies type conversion to the value
+          # Skips conversion for nil values (handled by RequiredValidator)
+          #
+          # @param value [Object] The current value
+          # @return [Object] Converted value
+          def transform_value(value) # rubocop:disable Metrics/MethodLength
+            return value if value.nil? # Cast doesn't modify nil, required validator handles it.
+
+            target_type = option_value
+            conversion_lambda = conversion_matrix.dig(@attribute_type, target_type)
+
+            # Call conversion lambda
+            conversion_lambda.call(value:)
+          rescue StandardError => e
+            attributes = {
+              attribute: @attribute_name,
+              from: @attribute_type,
+              to: target_type,
+              value:,
+              error: e.message
+            }
+
+            # Catch all exceptions from conversion execution
+            error_message = resolve_custom_message(**attributes) || I18n.t(
+              "treaty.attributes.modifiers.cast.conversion_error",
+              **attributes
+            )
+
+            raise Treaty::Exceptions::Validation, error_message
+          end
+
+          protected
+
+          # Override value_key to use :to instead of :is
+          # This makes advanced mode syntax: cast: { to: :datetime }
+          #
+          # @return [Symbol] The key :to
+          def value_key
+            :to
+          end
+
+          private
+
+          # Checks if conversion from source type to target type is supported
+          #
+          # @param from_type [Symbol] Source type
+          # @param to_type [Symbol] Target type
+          # @return [Boolean] True if conversion is supported
+          def conversion_supported?(from_type, to_type)
+            conversion_matrix.dig(from_type, to_type).present?
+          end
+
+          # Matrix of all supported type conversions
+          # Maps from_type => to_type => conversion_lambda
+          #
+          # @return [Hash] Conversion matrix
+          def conversion_matrix # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+            @conversion_matrix ||= {
+              integer: {
+                integer: ->(value:) { value }, # No-op for same type
+                string: ->(value:) { value.to_s },
+                boolean: ->(value:) { value != 0 },
+                date: ->(value:) { Time.at(value).to_date },
+                time: ->(value:) { Time.at(value) },
+                datetime: ->(value:) { Time.at(value).to_datetime }
+              },
+              string: {
+                string: ->(value:) { value }, # No-op for same type
+                integer: ->(value:) { Integer(value) },
+                boolean: ->(value:) { parse_boolean(value) },
+                date: ->(value:) { Date.parse(value) },
+                time: ->(value:) { Time.parse(value) },
+                datetime: ->(value:) { DateTime.parse(value) }
+              },
+              boolean: {
+                boolean: ->(value:) { value }, # No-op for same type
+                string: ->(value:) { value.to_s },
+                integer: ->(value:) { value ? 1 : 0 }
+              },
+              date: {
+                date: ->(value:) { value }, # No-op for same type
+                string: ->(value:) { value.iso8601 },
+                integer: ->(value:) { value.to_time.to_i },
+                time: ->(value:) { value.to_time },
+                datetime: ->(value:) { value.to_datetime }
+              },
+              time: {
+                time: ->(value:) { value }, # No-op for same type
+                string: ->(value:) { value.iso8601 },
+                integer: ->(value:) { value.to_i },
+                date: ->(value:) { value.to_date },
+                datetime: ->(value:) { value.to_datetime }
+              },
+              datetime: {
+                datetime: ->(value:) { value }, # No-op for same type
+                string: ->(value:) { value.iso8601 },
+                integer: ->(value:) { value.to_i },
+                date: ->(value:) { value.to_date },
+                time: ->(value:) { value.to_time }
+              }
+            }
+          end
+
+          # Parses a string value into a boolean
+          # Recognizes: true/false, yes/no, 1/0, on/off (case-insensitive)
+          #
+          # @param value [String] The string value to parse
+          # @return [Boolean] Parsed boolean value
+          # @raise [ArgumentError] If string is not a recognized boolean value
+          def parse_boolean(value)
+            normalized = value.to_s.downcase.strip
+
+            return true if %w[true 1 yes on].include?(normalized)
+            return false if %w[false 0 no off].include?(normalized)
+
+            raise ArgumentError, "Cannot convert '#{value}' to boolean"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/treaty/attribute/option/modifiers/transform_modifier.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Attribute
+    module Option
+      module Modifiers
+        # Transforms attribute values using custom lambda functions.
+        #
+        # ## Usage Examples
+        #
+        # Simple mode:
+        #   integer :amount, transform: ->(value:) { value * 100 }
+        #   string :title, transform: ->(value:) { value.strip.upcase }
+        #
+        # Advanced mode with custom error message:
+        #   integer :amount, transform: {
+        #     is: ->(value:) { value * 100 },
+        #     message: "Failed to transform amount"
+        #   }
+        #
+        # ## Use Cases
+        #
+        # 1. **Request transformation**:
+        #    ```ruby
+        #    request do
+        #      integer :amount_cents, transform: ->(value:) { value * 100 }
+        #    end
+        #    # Input: { amount_cents: 10 }
+        #    # Service receives: { amount_cents: 1000 }
+        #    ```
+        #
+        # 2. **Response transformation**:
+        #    ```ruby
+        #    response 200 do
+        #      string :title, transform: ->(value:) { value.titleize }
+        #    end
+        #    # Service returns: { title: "hello world" }
+        #    # Output: { title: "Hello World" }
+        #    ```
+        #
+        # 3. **Complex transformations**:
+        #    ```ruby
+        #    string :email, transform: ->(value:) { value.downcase.strip }
+        #    datetime :timestamp, transform: ->(value:) { value.iso8601 }
+        #    ```
+        #
+        # ## Important Notes
+        #
+        # - Lambda must accept named argument `value:`
+        # - All exceptions raised in lambda are caught and re-raised as Validation errors
+        # - Transformation is applied during Phase 3 (after validation)
+        # - Can be combined with other options (required, default, as, etc.)
+        #
+        # ## Error Handling
+        #
+        # If the lambda raises any exception, it's caught and converted to a
+        # Treaty::Exceptions::Validation with appropriate error message.
+        #
+        # ## Advanced Mode
+        #
+        # Schema format: `{ is: lambda, message: nil }`
+        class TransformModifier < Treaty::Attribute::Option::Base
+          # Validates that transform value is a lambda
+          #
+          # @raise [Treaty::Exceptions::Validation] If transform is not a Proc/lambda
+          # @return [void]
+          def validate_schema!
+            transform_lambda = option_value
+
+            return if transform_lambda.respond_to?(:call)
+
+            raise Treaty::Exceptions::Validation,
+                  I18n.t(
+                    "treaty.attributes.modifiers.transform.invalid_type",
+                    attribute: @attribute_name,
+                    type: transform_lambda.class
+                  )
+          end
+
+          # Applies transformation to the value using the provided lambda
+          # Catches all exceptions and re-raises as Validation errors
+          # Skips transformation for nil values (handled by RequiredValidator)
+          #
+          # @param value [Object] The current value
+          # @return [Object] Transformed value
+          def transform_value(value) # rubocop:disable Metrics/MethodLength
+            return value if value.nil? # Transform doesn't modify nil, required validator handles it.
+
+            transform_lambda = option_value
+
+            # Call lambda with named argument
+            transform_lambda.call(value:)
+          rescue StandardError => e
+            attributes = {
+              attribute: @attribute_name,
+              error: e.message
+            }
+
+            # Catch all exceptions from lambda execution
+            error_message = resolve_custom_message(**attributes) || I18n.t(
+              "treaty.attributes.modifiers.transform.execution_error",
+              **attributes
+            )
+
+            raise Treaty::Exceptions::Validation, error_message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -27,6 +27,8 @@ module Treaty
       #
       # - `:as` → AsModifier - Renames attributes
       # - `:default` → DefaultModifier - Provides default values
+      # - `:transform` → TransformModifier - Transforms values using custom lambdas
+      # - `:cast` → CastModifier - Converts values between types automatically
       #
       # ## Auto-Registration
       #
@@ -81,6 +83,8 @@ module Treaty
           def register_modifiers!
             Registry.register(:as, Modifiers::AsModifier, category: :modifier)
             Registry.register(:default, Modifiers::DefaultModifier, category: :modifier)
+            Registry.register(:transform, Modifiers::TransformModifier, category: :modifier)
+            Registry.register(:cast, Modifiers::CastModifier, category: :modifier)
           end
         end
       end

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

@@ -13,7 +13,9 @@ module Treaty
         # - `:boolean` - Ruby TrueClass or FalseClass
         # - `:object` - Ruby Hash (for nested objects)
         # - `:array` - Ruby Array (for collections)
-        # - `:datetime` - Ruby DateTime, Time, or Date
+        # - `:date` - Ruby Date
+        # - `:time` - Ruby Time
+        # - `:datetime` - Ruby DateTime
         #
         # ## Usage Examples
         #
@@ -21,7 +23,9 @@ module Treaty
         #   integer :age
         #   string :name
         #   boolean :published
-        #   datetime :created_at
+        #   date :published_on
+        #   time :created_at
+        #   datetime :updated_at
         #
         # Nested structures:
         #   object :author do
@@ -36,14 +40,16 @@ module Treaty
         #
         # - Validates only non-nil values (nil handling is done by RequiredValidator)
         # - Type mismatch raises Treaty::Exceptions::Validation
-        # - Datetime accepts DateTime, Time, or Date objects
+        # - Date accepts only Date objects (not DateTime or Time)
+        # - Time accepts only Time objects (not Date or DateTime)
+        # - DateTime accepts only DateTime objects (not Date or Time)
         #
         # ## Note
         #
         # TypeValidator doesn't use option_schema - it validates based on attribute_type.
         # This validator is always active for all attributes.
         class TypeValidator < Treaty::Attribute::Option::Base
-          ALLOWED_TYPES = %i[integer string boolean object array datetime].freeze
+          ALLOWED_TYPES = %i[integer string boolean object array date time datetime].freeze
 
           # Validates that the attribute type is one of the allowed types
           #
@@ -81,6 +87,10 @@ module Treaty
               validate_object!(value)
             when :array
               validate_array!(value)
+            when :date
+              validate_date!(value)
+            when :time
+              validate_time!(value)
             when :datetime
               validate_datetime!(value)
             end
@@ -172,14 +182,33 @@ module Treaty
             validate_type!(value, :array) { |v| v.is_a?(Array) }
           end
 
-          # Validates that value is a DateTime, Time, or Date
+          # Validates that value is a Date (but not DateTime, since DateTime < Date)
           #
           # @param value [Object] The value to validate
-          # @raise [Treaty::Exceptions::Validation] If value is not a datetime type
+          # @raise [Treaty::Exceptions::Validation] If value is not a Date
+          # @return [void]
+          def validate_date!(value)
+            validate_type!(value, :date) { |v| v.is_a?(Date) && !v.is_a?(DateTime) }
+          end
+
+          # Validates that value is a Time or ActiveSupport::TimeWithZone
+          #
+          # @param value [Object] The value to validate
+          # @raise [Treaty::Exceptions::Validation] If value is not a Time
+          # @return [void]
+          def validate_time!(value)
+            validate_type!(value, :time) do |v|
+              v.is_a?(Time) || (defined?(ActiveSupport::TimeWithZone) && v.is_a?(ActiveSupport::TimeWithZone))
+            end
+          end
+
+          # Validates that value is a DateTime
+          #
+          # @param value [Object] The value to validate
+          # @raise [Treaty::Exceptions::Validation] If value is not a DateTime
           # @return [void]
           def validate_datetime!(value)
-            # TODO: It is better to divide it into different methods for each class.
-            validate_type!(value, :datetime) { |v| v.is_a?(DateTime) || v.is_a?(Time) || v.is_a?(Date) }
+            validate_type!(value, :datetime) { |v| v.is_a?(DateTime) }
           end
         end
       end

data/lib/treaty/attribute/option_normalizer.rb

@@ -70,7 +70,8 @@ module Treaty
       OPTION_KEY_MAPPING = {
         in: { advanced_key: :inclusion, value_key: :in },
         as: { advanced_key: :as, value_key: :is },
-        default: { advanced_key: :default, value_key: :is }
+        default: { advanced_key: :default, value_key: :is },
+        cast: { advanced_key: :cast, value_key: :to }
       }.freeze
       private_constant :OPTION_KEY_MAPPING
 

data/lib/treaty/attribute/validation/nested_transformer.rb

@@ -138,8 +138,7 @@ module Treaty
           def transform(value)
             value.each_with_index.map do |item, index|
               if simple_array?
-                validate_simple_element(item, index)
-                item
+                transform_simple_element(item, index)
               else
                 transform_array_item(item, index)
               end
@@ -156,19 +155,21 @@ module Treaty
               attribute.collection_of_attributes.first.name == SELF_OBJECT
           end
 
-          # Validates a simple array element (primitive value)
+          # Transforms a simple array element (primitive value)
+          # Validates and applies transformations to the element
           #
-          # @param item [Object] Array element to validate
+          # @param item [Object] Array element to transform
           # @param index [Integer] Element index for error messages
           # @raise [Treaty::Exceptions::Validation] If validation fails
-          # @return [void]
-          def validate_simple_element(item, index) # rubocop:disable Metrics/MethodLength
+          # @return [Object] Transformed element value
+          def transform_simple_element(item, index) # rubocop:disable Metrics/MethodLength
             self_attr = attribute.collection_of_attributes.first
             validator = AttributeValidator.new(self_attr)
             validator.validate_schema!
 
             begin
               validator.validate_value!(item)
+              validator.transform_value(item)
             rescue Treaty::Exceptions::Validation => e
               raise Treaty::Exceptions::Validation,
                     I18n.t(

data/lib/treaty/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: treaty
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Anton Sokolov
@@ -156,7 +156,9 @@ files:
 - lib/treaty/attribute/helper_mapper.rb
 - lib/treaty/attribute/option/base.rb
 - lib/treaty/attribute/option/modifiers/as_modifier.rb
+- lib/treaty/attribute/option/modifiers/cast_modifier.rb
 - lib/treaty/attribute/option/modifiers/default_modifier.rb
+- lib/treaty/attribute/option/modifiers/transform_modifier.rb
 - lib/treaty/attribute/option/registry.rb
 - lib/treaty/attribute/option/registry_initializer.rb
 - lib/treaty/attribute/option/validators/format_validator.rb