treaty 0.14.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fe35b7cf209d578b34ee7d904bdd146db4a3ac61f022a1f5f02c80bfe21875e
-  data.tar.gz: 4be4a2f29fbfb30115e696baeaf618eaf59fe5c2fc309a0d1ced3eff61713671
+  metadata.gz: cc42fa86dd5dc35d49f0a07a189d9ddc59f619e2341905c1ed62193e0d3069b7
+  data.tar.gz: ffc66f03e0ced6e666bb12db50f405117831b48c26475ab034ab4a16f4c431b1
 SHA512:
-  metadata.gz: d256fd30a7553ebfc015c06049c4fc0edceddaa782b3b0bda807364568009465556e72867324bc4a707d61c52da579f5a40f4324922af4349f1a7553023a9443
-  data.tar.gz: 4d71a4831e946faf207b9c21947531f3bc6263941f07e3a627c2e504a8c471d6aec597fe167090c0d0d49979b3b4dbf2f8e0620cfe9cd12f492286f60b5a3e7a
+  metadata.gz: 0b31ad204ddb19df8a296007f334d29e2e220fbb771f9c5a3851309e0a9ec1909dae0dbef3608633f6a5203da0b827fb90c75132e83f5ebb3fcc28f36fd33cc9
+  data.tar.gz: 0c6ec71d1be9155da662498264667a63072c5ce513d1ae0987a54091d76aa35a9fd21b3c722db38a8f4154919a2894f442736c44e23ff88961c9a1aadc841c49

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.14.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.16.0"`) until the 1.0 release.
 
 ## 📚 Documentation
 
@@ -133,4 +133,4 @@ Thank you to all [contributors](https://github.com/servactory/treaty/graphs/cont
 
 ## 📄 License
 
-Treaty is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+Treaty is available as open source under the terms of the [MIT License](./LICENSE).

data/config/locales/en.yml

@@ -45,6 +45,7 @@ en:
       # Attribute options
       options:
         unknown: "Unknown options for attribute '%{attribute}': %{unknown}. Known options: %{known}"
+        message_evaluation_error: "Custom message evaluation failed for attribute '%{attribute}': %{error}"
 
       # Attribute modifiers
       modifiers:
@@ -55,6 +56,10 @@ en:
           invalid_type: "Option 'transform' for attribute '%{attribute}' must be a Proc or Lambda. Got: %{type}"
           execution_error: "Transform failed for attribute '%{attribute}': %{error}"
 
+        computed:
+          invalid_type: "Option 'computed' for attribute '%{attribute}' must be a Proc or Lambda. Got: %{type}"
+          execution_error: "Computed 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}"
@@ -62,6 +67,18 @@ en:
           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 conditionals
+      conditionals:
+        if:
+          invalid_type: "Option 'if' for attribute '%{attribute}' must be a Proc or Lambda. Got: %{type}"
+          evaluation_error: "Conditional evaluation failed for attribute '%{attribute}': %{error}"
+
+        unless:
+          invalid_type: "Option 'unless' for attribute '%{attribute}' must be a Proc or Lambda. Got: %{type}"
+          evaluation_error: "Conditional evaluation failed for attribute '%{attribute}': %{error}"
+
+        mutual_exclusivity_error: "Attribute '%{attribute}' cannot have both 'if' and 'unless' options. Use only one conditional option."
+
       # Attribute builder DSL
       builder:
         not_implemented: "%{class} must implement #create_attribute"

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

@@ -76,8 +76,9 @@ module Treaty
         # Override in subclasses if transformation is needed
         #
         # @param value [Object] The value to transform
+        # @param _root_data [Hash] Full raw data from root level (used by computed modifier)
         # @return [Object] Transformed value
-        def transform_value(value)
+        def transform_value(value, _root_data = {})
           value
         end
 
@@ -143,10 +144,12 @@ module Treaty
 
         # Resolves custom message with lambda support
         # If message is a lambda, calls it with provided named arguments
+        # Catches all exceptions from lambda execution and re-raises as Validation errors
         #
         # @param attributes [Hash] Named arguments to pass to lambda
         # @return [String, nil] Resolved message string or nil
-        def resolve_custom_message(**attributes)
+        # @raise [Treaty::Exceptions::Validation] If custom message lambda raises an exception
+        def resolve_custom_message(**attributes) # rubocop:disable Metrics/MethodLength
           message = custom_message
           return nil if message.nil?
 
@@ -155,6 +158,15 @@ module Treaty
           else
             message
           end
+        rescue StandardError => e
+          # Catch all exceptions from custom message lambda execution
+          error_message = I18n.t(
+            "treaty.attributes.options.message_evaluation_error",
+            attribute: @attribute_name,
+            error: e.message
+          )
+
+          raise Treaty::Exceptions::Validation, error_message
         end
 
         # Checks if schema is in advanced mode

data/lib/treaty/attribute/option/conditionals/base.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Attribute
+    module Option
+      module Conditionals
+        # Base class for conditional option processors.
+        #
+        # ## Purpose
+        #
+        # Conditionals control whether an attribute should be processed at all.
+        # Unlike validators (which check data) and modifiers (which transform data),
+        # conditionals determine attribute visibility based on runtime conditions.
+        #
+        # ## Key Difference from Validators/Modifiers
+        #
+        # - **Validators**: Check if data is valid
+        # - **Modifiers**: Transform data values
+        # - **Conditionals**: Decide if attribute exists in output
+        #
+        # ## Processing
+        #
+        # Conditionals are evaluated BEFORE validators and modifiers:
+        # 1. If condition evaluates to `false` → attribute is skipped entirely
+        # 2. If condition evaluates to `true` → attribute is processed normally
+        #
+        # ## Mode Support
+        #
+        # Conditionals do NOT support simple/advanced modes.
+        # They only accept lambda/proc directly:
+        #
+        # ```ruby
+        # # Correct
+        # integer :rating, if: ->(**attributes) { attributes.dig(:post, :published_at).present? }
+        # array :tags, if: ->(post:) { post[:published_at].present? }
+        #
+        # # Incorrect - no simple/advanced mode
+        # integer :rating, if: true  # Not supported
+        # integer :rating, if: { is: ..., message: ... }  # Not supported
+        # ```
+        #
+        # ## Implementation
+        #
+        # Subclasses must implement:
+        # - `validate_schema!` - Validate the conditional schema at definition time
+        # - `evaluate_condition(data)` - Evaluate condition with runtime data
+        class Base < Treaty::Attribute::Option::Base
+          # Phase 1: Validates conditional schema
+          # Must be overridden in subclasses
+          #
+          # @raise [Treaty::Exceptions::Validation] If schema is invalid
+          # @return [void]
+          def validate_schema!
+            raise Treaty::Exceptions::NotImplemented,
+                  "#{self.class} must implement #validate_schema!"
+          end
+
+          # Evaluates the conditional with runtime data
+          # Must be overridden in subclasses
+          #
+          # @param _data [Hash] Raw data to evaluate condition against
+          # @raise [Treaty::Exceptions::Validation] If evaluation fails
+          # @return [Boolean] True if attribute should be processed, false otherwise
+          def evaluate_condition(_data)
+            raise Treaty::Exceptions::NotImplemented,
+                  "#{self.class} must implement #evaluate_condition"
+          end
+
+          # Conditionals do not validate values
+          # This is a no-op for conditionals
+          #
+          # @param _value [Object] The value (unused)
+          # @return [void]
+          def validate_value!(_value)
+            # No-op: conditionals don't validate values
+          end
+
+          # Conditionals do not transform values
+          # This is a no-op for conditionals
+          #
+          # @param value [Object] The value to pass through
+          # @return [Object] The unchanged value
+          def transform_value(value)
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/treaty/attribute/option/conditionals/if_conditional.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Attribute
+    module Option
+      module Conditionals
+        # Conditionally includes attributes based on runtime data evaluation.
+        #
+        # ## Usage Examples
+        #
+        # Basic usage with keyword arguments splat:
+        #   array :tags, if: ->(**attributes) { attributes.dig(:post, :published_at).present? }
+        #   integer :rating, if: ->(**attributes) { attributes.dig(:post, :published_at).present? }
+        #
+        # Named argument pattern:
+        #   array :tags, if: ->(post:) { post[:published_at].present? }
+        #   integer :views, if: ->(post:) { post[:published_at].present? }
+        #
+        # Complex conditions:
+        #   string :admin_note, if: ->(**attrs) {
+        #     attrs.dig(:user, :role) == "admin" && attrs.dig(:post, :flagged)
+        #   }
+        #
+        # ## Use Cases
+        #
+        # 1. **Show fields only when published**:
+        #    ```ruby
+        #    response 200 do
+        #      object :post do
+        #        string :id
+        #        string :title
+        #        datetime :published_at, :optional
+        #        integer :rating, if: ->(**attrs) { attrs.dig(:post, :published_at).present? }
+        #      end
+        #    end
+        #    # If published_at is nil → rating is excluded from response
+        #    # If published_at exists → rating is included
+        #    ```
+        #
+        # 2. **Role-based field visibility**:
+        #    ```ruby
+        #    response 200 do
+        #      object :user do
+        #        string :name
+        #        string :email, if: ->(user:) { user[:role] == "admin" }
+        #      end
+        #    end
+        #    ```
+        #
+        # 3. **Nested attribute conditionals**:
+        #    ```ruby
+        #    object :post do
+        #      string :title
+        #      array :tags, if: ->(post:) { post[:published_at].present? } do
+        #        string :_self
+        #      end
+        #    end
+        #    ```
+        #
+        # ## Important Notes
+        #
+        # - Lambda receives raw data as named arguments
+        # - Lambda MUST return truthy/falsy value
+        # - If condition is false → attribute is completely omitted
+        # - If condition is true → attribute is validated and transformed normally
+        # - All exceptions in lambda are caught and wrapped in Treaty::Exceptions::Validation
+        # - Does NOT support simple mode (if: true) or advanced mode (if: { is: ..., message: ... })
+        #
+        # ## Error Handling
+        #
+        # If the lambda raises any exception, it's caught and converted to a
+        # Treaty::Exceptions::Validation with detailed error message including:
+        # - Attribute name
+        # - Original exception message
+        #
+        # ## Data Access Pattern
+        #
+        # The lambda receives the same data structure that the orchestrator processes.
+        # For nested attributes, you can access parent data using dig:
+        #
+        # ```ruby
+        # # For response with { post: { title: "...", published_at: "..." } }
+        # integer :rating, if: ->(**attrs) { attrs.dig(:post, :published_at).present? }
+        #
+        # # Alternative: named argument pattern
+        # integer :rating, if: ->(post:) { post[:published_at].present? }
+        # ```
+        class IfConditional < Treaty::Attribute::Option::Conditionals::Base
+          # Validates that if option is a callable (Proc/Lambda)
+          #
+          # @raise [Treaty::Exceptions::Validation] If if is not a Proc/lambda
+          # @return [void]
+          def validate_schema!
+            conditional_lambda = @option_schema
+
+            return if conditional_lambda.respond_to?(:call)
+
+            raise Treaty::Exceptions::Validation,
+                  I18n.t(
+                    "treaty.attributes.conditionals.if.invalid_type",
+                    attribute: @attribute_name,
+                    type: conditional_lambda.class
+                  )
+          end
+
+          # Evaluates the conditional lambda with runtime data
+          # Returns boolean indicating if attribute should be processed
+          #
+          # @param data [Hash] Raw data from request/response/entity
+          # @raise [Treaty::Exceptions::Validation] If lambda execution fails
+          # @return [Boolean] True if attribute should be processed, false to skip it
+          def evaluate_condition(data)
+            conditional_lambda = @option_schema
+
+            # Call lambda with raw data as named arguments
+            # The lambda can use **attributes or specific named args like post:
+            result = conditional_lambda.call(**data)
+
+            # Convert result to boolean
+            !!result
+          rescue StandardError => e
+            # Catch all exceptions from lambda execution
+            raise Treaty::Exceptions::Validation,
+                  I18n.t(
+                    "treaty.attributes.conditionals.if.evaluation_error",
+                    attribute: @attribute_name,
+                    error: e.message
+                  )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/treaty/attribute/option/conditionals/unless_conditional.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Attribute
+    module Option
+      module Conditionals
+        # Conditionally excludes attributes based on runtime data evaluation.
+        #
+        # ## Usage Examples
+        #
+        # Basic usage with keyword arguments splat:
+        #   array :tags, unless: ->(**attributes) { attributes.dig(:post, :published_at).present? }
+        #   integer :draft_views, unless: ->(**attributes) { attributes.dig(:post, :published_at).present? }
+        #
+        # Named argument pattern:
+        #   array :draft_notes, unless: ->(post:) { post[:published_at].present? }
+        #   integer :edit_count, unless: ->(post:) { post[:published_at].present? }
+        #
+        # Complex conditions:
+        #   string :internal_note, unless: ->(**attrs) {
+        #     attrs.dig(:user, :role) == "admin" && attrs.dig(:post, :flagged)
+        #   }
+        #
+        # ## Use Cases
+        #
+        # 1. **Hide fields when published**:
+        #    ```ruby
+        #    response 200 do
+        #      object :post do
+        #        string :id
+        #        string :title
+        #        datetime :published_at, :optional
+        #        integer :draft_views, unless: ->(**attrs) { attrs.dig(:post, :published_at).present? }
+        #      end
+        #    end
+        #    # If published_at is nil → draft_views is included in response
+        #    # If published_at exists → draft_views is excluded
+        #    ```
+        #
+        # 2. **Role-based field exclusion**:
+        #    ```ruby
+        #    response 200 do
+        #      object :user do
+        #        string :name
+        #        string :internal_id, unless: ->(user:) { user[:role] == "public" }
+        #      end
+        #    end
+        #    ```
+        #
+        # 3. **Nested attribute conditionals**:
+        #    ```ruby
+        #    object :post do
+        #      string :title
+        #      array :draft_notes, unless: ->(post:) { post[:published_at].present? } do
+        #        string :_self
+        #      end
+        #    end
+        #    ```
+        #
+        # ## Important Notes
+        #
+        # - Lambda receives raw data as named arguments
+        # - Lambda MUST return truthy/falsy value
+        # - If condition is true → attribute is completely omitted (OPPOSITE of `if`)
+        # - If condition is false → attribute is validated and transformed normally
+        # - All exceptions in lambda are caught and wrapped in Treaty::Exceptions::Validation
+        # - Does NOT support simple mode (unless: true) or advanced mode (unless: { is: ..., message: ... })
+        #
+        # ## Difference from `if` Option
+        #
+        # `unless` is the logical opposite of `if`:
+        # - `if` includes attribute when condition is TRUE
+        # - `unless` includes attribute when condition is FALSE
+        #
+        # ```ruby
+        # # These are equivalent:
+        # integer :rating, if: ->(**attrs) { attrs.dig(:post, :published_at).present? }
+        # integer :rating, unless: ->(**attrs) { attrs.dig(:post, :published_at).blank? }
+        #
+        # # These are also equivalent:
+        # integer :draft_views, unless: ->(**attrs) { attrs.dig(:post, :published_at).present? }
+        # integer :draft_views, if: ->(**attrs) { attrs.dig(:post, :published_at).blank? }
+        # ```
+        #
+        # ## Error Handling
+        #
+        # If the lambda raises any exception, it's caught and converted to a
+        # Treaty::Exceptions::Validation with detailed error message including:
+        # - Attribute name
+        # - Original exception message
+        #
+        # ## Data Access Pattern
+        #
+        # The lambda receives the same data structure that the orchestrator processes.
+        # For nested attributes, you can access parent data using dig:
+        #
+        # ```ruby
+        # # For response with { post: { title: "...", published_at: "..." } }
+        # integer :draft_views, unless: ->(**attrs) { attrs.dig(:post, :published_at).present? }
+        #
+        # # Alternative: named argument pattern
+        # integer :draft_views, unless: ->(post:) { post[:published_at].present? }
+        # ```
+        class UnlessConditional < Treaty::Attribute::Option::Conditionals::Base
+          # Validates that unless option is a callable (Proc/Lambda)
+          #
+          # @raise [Treaty::Exceptions::Validation] If unless is not a Proc/lambda
+          # @return [void]
+          def validate_schema!
+            conditional_lambda = @option_schema
+
+            return if conditional_lambda.respond_to?(:call)
+
+            raise Treaty::Exceptions::Validation,
+                  I18n.t(
+                    "treaty.attributes.conditionals.unless.invalid_type",
+                    attribute: @attribute_name,
+                    type: conditional_lambda.class
+                  )
+          end
+
+          # Evaluates the conditional lambda with runtime data
+          # Returns boolean indicating if attribute should be processed
+          #
+          # @param data [Hash] Raw data from request/response/entity
+          # @raise [Treaty::Exceptions::Validation] If lambda execution fails
+          # @return [Boolean] True if attribute should be processed (when condition is FALSE), false to skip it
+          def evaluate_condition(data)
+            conditional_lambda = @option_schema
+
+            # Call lambda with raw data as named arguments
+            # The lambda can use **attributes or specific named args like post:
+            result = conditional_lambda.call(**data)
+
+            # Convert result to boolean and NEGATE it (opposite of if)
+            # unless includes attribute when condition is FALSE
+            !result
+          rescue StandardError => e
+            # Catch all exceptions from lambda execution
+            raise Treaty::Exceptions::Validation,
+                  I18n.t(
+                    "treaty.attributes.conditionals.unless.evaluation_error",
+                    attribute: @attribute_name,
+                    error: e.message
+                  )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -79,8 +79,9 @@ module Treaty
           # The renaming is handled by the orchestrator using target_name
           #
           # @param value [Object] The value to transform
+          # @param _root_data [Hash] Unused root data parameter
           # @return [Object] Unchanged value
-          def transform_value(value)
+          def transform_value(value, _root_data = {})
             value
           end
         end

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

@@ -162,8 +162,9 @@ module Treaty
           # Skips conversion for nil values (handled by RequiredValidator)
           #
           # @param value [Object] The current value
+          # @param _root_data [Hash] Unused root data parameter
           # @return [Object] Converted value
-          def transform_value(value) # rubocop:disable Metrics/MethodLength
+          def transform_value(value, _root_data = {}) # rubocop:disable Metrics/MethodLength
             return value if value.nil? # Cast doesn't modify nil, required validator handles it.
 
             target_type = option_value

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Attribute
+    module Option
+      module Modifiers
+        # Computes attribute values from all available raw data.
+        #
+        # ## Key Difference from Transform
+        #
+        # - `transform:` receives only `value:` (the current attribute's value)
+        # - `computed:` receives `**attributes` (ALL raw data from root level)
+        #
+        # ## Usage Examples
+        #
+        # Simple mode:
+        #   string :full_name, computed: ->(**attrs) {
+        #     "#{attrs.dig(:user, :first_name)} #{attrs.dig(:user, :last_name)}"
+        #   }
+        #
+        # Advanced mode with custom error message:
+        #   string :full_name, computed: {
+        #     is: ->(**attrs) { "#{attrs.dig(:user, :first_name)} #{attrs.dig(:user, :last_name)}" },
+        #     message: "Failed to compute full name"
+        #   }
+        #
+        # ## Use Cases
+        #
+        # 1. **Derived fields (full name from parts)**:
+        #    ```ruby
+        #    response 200 do
+        #      object :user do
+        #        string :first_name
+        #        string :last_name
+        #        string :full_name, computed: ->(**attrs) {
+        #          "#{attrs.dig(:user, :first_name)} #{attrs.dig(:user, :last_name)}"
+        #        }
+        #      end
+        #    end
+        #    ```
+        #
+        # 2. **Calculated values (word count)**:
+        #    ```ruby
+        #    response 200 do
+        #      object :post do
+        #        string :content
+        #        integer :word_count, computed: ->(**attrs) {
+        #          attrs.dig(:post, :content).to_s.split.size
+        #        }
+        #      end
+        #    end
+        #    ```
+        #
+        # 3. **Cross-object computations**:
+        #    ```ruby
+        #    response 200 do
+        #      object :order do
+        #        integer :quantity
+        #        integer :unit_price
+        #        integer :total, computed: ->(**attrs) {
+        #          attrs.dig(:order, :quantity).to_i * attrs.dig(:order, :unit_price).to_i
+        #        }
+        #      end
+        #    end
+        #    ```
+        #
+        # ## Important Notes
+        #
+        # - Lambda must accept `**attributes` (named argument splat)
+        # - Receives full raw data from root level (not just current object)
+        # - **Always computes** - ignores any existing value, result replaces everything
+        # - All exceptions raised in lambda are caught and re-raised as Validation errors
+        # - Computation is applied during Phase 3 (transformation phase)
+        # - Executes FIRST in modifier chain: computed -> transform -> cast -> default -> as
+        #
+        # ## Advanced Mode
+        #
+        # Schema format: `{ is: lambda, message: nil }`
+        class ComputedModifier < Treaty::Attribute::Option::Base
+          # Validates that computed value is a lambda
+          #
+          # @raise [Treaty::Exceptions::Validation] If computed is not a Proc/lambda
+          # @return [void]
+          def validate_schema!
+            computed_lambda = option_value
+
+            return if computed_lambda.respond_to?(:call)
+
+            raise Treaty::Exceptions::Validation,
+                  I18n.t(
+                    "treaty.attributes.modifiers.computed.invalid_type",
+                    attribute: @attribute_name,
+                    type: computed_lambda.class
+                  )
+          end
+
+          # Computes value using the provided lambda and full root data
+          # Always executes - ignores any existing value
+          #
+          # @param _value [Object] The current value (ignored - always computes)
+          # @param root_data [Hash] Full raw data from root level
+          # @return [Object] Computed value
+          def transform_value(_value, root_data = {}) # rubocop:disable Metrics/MethodLength
+            computed_lambda = option_value
+
+            # Call lambda with full root data as named arguments
+            computed_lambda.call(**root_data)
+          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.computed.execution_error",
+              **attributes
+            )
+
+            raise Treaty::Exceptions::Validation, error_message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -80,9 +80,9 @@ module Treaty
           # Empty strings, empty arrays, and false are NOT replaced
           #
           # @param value [Object] The current value
-          # @param _context [Hash] Unused context parameter
+          # @param _root_data [Hash] Unused root data parameter
           # @return [Object] Default value if original is nil, otherwise original value
-          def transform_value(value, _context = {})
+          def transform_value(value, _root_data = {})
             # Only apply default if value is nil
             # Empty strings, empty arrays, false are NOT replaced
             return value unless value.nil?

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

@@ -82,8 +82,9 @@ module Treaty
           # Skips transformation for nil values (handled by RequiredValidator)
           #
           # @param value [Object] The current value
+          # @param _root_data [Hash] Unused root data parameter
           # @return [Object] Transformed value
-          def transform_value(value) # rubocop:disable Metrics/MethodLength
+          def transform_value(value, _root_data = {}) # rubocop:disable Metrics/MethodLength
             return value if value.nil? # Transform doesn't modify nil, required validator handles it.
 
             transform_lambda = option_value