treaty 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d99db2724f9dd4fd84a7f315d1acf070dcf70a7f3669dab9980334dc2c179076
-  data.tar.gz: d02611a96da26130b8504818fabd9adbc10fa72b8984fc8330e7b63aec79c7ea
+  metadata.gz: 34516da12bec1bd3df351363dacd13fc3e7e9c31806fef4a6aecf37be88754a8
+  data.tar.gz: 71bb387ce08aa6a3d42de04bef6e2c7e281089184e0815ad2679a9b87df30213
 SHA512:
-  metadata.gz: 492777e146c0042d9c78df8e9783a17d4aa705c629705425d7cd0db0ce2eaf5d8a2cf58b817c95fe1bc9025739044eb89959e91b04eb7e8dd205c6da9ab68251
-  data.tar.gz: 6133706b11654af81a88b32489d88d78f86a66df79a80a072c29fde23e2ea6130e0bee4ffe401def62f52a80ce293954228dd746bc57cf01d38e17833179f350
+  metadata.gz: '0398e7fa2f958bb24331f239cedd5db66880e2e08f402b82659b63a99941176e42ff64c867bdcd5c2aae054e4b35410f132d44f37724046c14b5c6967e9c6e6a'
+  data.tar.gz: 25433a8f90b4e6ee4528e3fa933be6ad7a6443ad593b12c99b9cc2fb3a110723b92690a2bbb2843e7de14fc27f5e7b806008fd361c31bbd4c74bd2a906e18b7f

data/README.md

@@ -1,32 +1,120 @@
-# Treaty
+<div align="center">
+  <h1>Treaty</h1>
+  <p>A Ruby library for defining and managing REST API contracts with versioning support.</p>
+</div>
 
-> [!WARNING]
-> This project is currently under development.
+<div align="center">
 
-## Quick Start
+[![Gem Version](https://img.shields.io/gem/v/treaty.svg)](https://rubygems.org/gems/treaty)
+[![Release Date](https://img.shields.io/github/release-date/servactory/treaty)](https://github.com/servactory/servactory/releases)
+[![Gem Downloads](https://img.shields.io/gem/dt/treaty.svg)](https://rubygems.org/gems/treaty)
+![Ruby Version](https://img.shields.io/badge/Ruby-3.2%2B-red)
+
+</div>
+
+## 📚 Documentation
+
+Explore comprehensive guides and documentation at [docs](./docs):
+
+- [Getting Started](./docs/getting-started.md) - installation and configuration
+- [Core Concepts](./docs/core-concepts.md) - understand fundamental concepts
+- [API Reference](./docs/api-reference.md) - complete API documentation
+- [Examples](./docs/examples.md) - practical real-world examples
+- [Internationalization](./docs/internationalization.md) - I18n and multilingual support
+- [Full Documentation Index](./docs/README.md) - all documentation topics
+
+## 💡 Why Treaty?
+
+Treaty provides a complete solution for building versioned APIs in Ruby on Rails:
+
+- **Type Safety** - Enforce strict type checking for request and response data
+- **API Versioning** - Manage multiple concurrent API versions effortlessly
+- **Built-in Validation** - Validate incoming requests and outgoing responses automatically
+- **Data Transformation** - Transform data seamlessly between different API versions
+- **Deprecation Management** - Mark versions as deprecated with flexible conditions
+- **Internationalization** - Full I18n support for multilingual error messages
+- **Well-documented** - Comprehensive guides and examples for every feature
+
+## 🚀 Quick Start
 
 ### Installation
 
+Add Treaty to your Gemfile:
+
 ```ruby
 gem "treaty"
 ```
 
-## Documentation
+Run:
 
-Complete documentation is available in the [docs](./docs) directory:
+```bash
+bundle install
+```
 
-- [Getting Started](./docs/getting-started.md) - installation and first steps
-- [Core Concepts](./docs/core-concepts.md) - fundamental concepts
-- [API Reference](./docs/api-reference.md) - complete API documentation
-- [Examples](./docs/examples.md) - practical examples
-- [Full Documentation Index](./docs/README.md) - all documentation topics
+### Define Treaty
+
+Create your first API contract in `app/treaties/posts/create_treaty.rb`:
+
+```ruby
+module Posts
+  class CreateTreaty < ApplicationTreaty
+    version 1, default: true do
+      strategy Treaty::Strategy::ADAPTER
+
+      request do
+        scope :post do
+          string :title, :required
+          string :content, :required
+          string :summary, :optional
+        end
+      end
+
+      response 201 do
+        scope :post do
+          string :id
+          string :title
+          string :content
+          string :summary
+          datetime :created_at
+        end
+      end
+
+      delegate_to Posts::CreateService
+    end
+  end
+end
+```
+
+### Use in Controller
+
+Define the treaty in your controller `app/controllers/posts_controller.rb`:
+
+```ruby
+class PostsController < ApplicationController
+  # Treaty automatically:
+  # 1. Validates incoming parameters according to request definition
+  # 2. Calls Posts::CreateService with validated data
+  # 3. Validates service response according to response definition
+  # 4. Returns transformed data to client
+  treaty :create
+end
+```
+
+## 🤝 Contributing
+
+We welcome contributions! You can help by:
+
+- Reporting bugs and suggesting features
+- Writing code and improving documentation
+- Reviewing pull requests
+- Sharing your experience with Treaty
+
+Please read our [Contributing Guide](./CONTRIBUTING.md) before submitting a pull request.
 
-## Contributing
+## 🙏 Acknowledgments
 
-This project is intended to be a safe, welcoming space for collaboration.
-Contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
-We recommend reading the [contributing guide](./CONTRIBUTING.md) as well.
+Thank you to all [contributors](https://github.com/servactory/treaty/graphs/contributors) who have helped make Treaty better!
 
-## License
+## 📄 License
 
 Treaty is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/config/locales/en.yml

@@ -0,0 +1,97 @@
+en:
+  treaty:
+    # ============================================================================
+    # Attributes: Definition, validation, and processing
+    # ============================================================================
+    attributes:
+      # Attribute value validators
+      validators:
+        required:
+          blank: "Attribute '%{attribute}' is required but was not provided or is empty"
+
+        type:
+          unknown_type: "Unknown type '%{type}' for attribute '%{attribute}'. Allowed types: %{allowed}"
+          mismatch:
+            integer: "Attribute '%{attribute}' must be an Integer, got %{actual}"
+            string: "Attribute '%{attribute}' must be a String, got %{actual}"
+            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}"
+
+        inclusion:
+          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}'"
+
+        # Nested structures validation
+        nested:
+          # Orchestrator errors
+          orchestrator:
+            collection_not_implemented: "Subclass must implement the collection_of_scopes method"
+            scope_data_not_implemented: "Subclass must implement the scope_data_for method"
+
+          # Array validation errors
+          array:
+            element_validation_error: "Error in array '%{attribute}' at index %{index}: Element must match one of the defined types. Errors: %{errors}"
+            element_type_error: "Error in array '%{attribute}' at index %{index}: Expected Hash but got %{actual}"
+            attribute_error: "Error in array '%{attribute}' at index %{index}: %{message}"
+
+      # Attribute options
+      options:
+        unknown: "Unknown options for attribute '%{attribute}': %{unknown}. Known options: %{known}"
+
+      # Attribute modifiers
+      modifiers:
+        as:
+          invalid_type: "Option 'as' for attribute '%{attribute}' must be a Symbol. Got: %{type}"
+
+      # Attribute builder DSL
+      builder:
+        not_implemented: "%{class} must implement #create_attribute"
+
+      # Attribute-level errors
+      errors:
+        nesting_level_exceeded: "Nesting level %{level} exceeds maximum allowed level of %{max_level}"
+        apply_defaults_not_implemented: "%{class} must implement #apply_defaults!"
+        process_nested_not_implemented: "%{class} must implement #process_nested_attributes"
+
+    # ============================================================================
+    # Versioning: API version management and resolution
+    # ============================================================================
+    versioning:
+      # Version resolver
+      resolver:
+        current_version_required: "Current version is required for validation"
+        version_not_found: "Version %{version} not found in treaty definition"
+        version_deprecated: "Version %{version} is deprecated and cannot be used"
+
+      # Version factory
+      factory:
+        invalid_default_option: "Default option for version must be true, false, or a Proc, got: %{type}"
+        unknown_method: "Unknown method: %{method}"
+
+      # Strategy validation
+      strategy:
+        unknown: "Unknown strategy: %{strategy}"
+
+    # ============================================================================
+    # Execution: Service and executor invocation
+    # ============================================================================
+    execution:
+      executor_missing: "Executor is not defined for version %{version}"
+      executor_empty: "Executor cannot be an empty string"
+      executor_not_found: "Executor class `%{class_name}` not found"
+      executor_invalid_type: "Invalid executor type: %{type}. Expected Proc, Class, String, or Symbol"
+      method_not_found: "Method '%{method}' not found in class '%{class_name}'"
+      proc_error: "%{message}"
+      servactory_input_error: "%{message}"
+      servactory_internal_error: "%{message}"
+      servactory_output_error: "%{message}"
+      servactory_failure_error: "%{message}"
+      regular_service_error: "%{message}"
+
+    # ============================================================================
+    # Controller DSL: Rails controller integration
+    # ============================================================================
+    controller:
+      treaty_class_not_found: "%{class_name}"

data/lib/treaty/attribute/base.rb

@@ -121,10 +121,10 @@ module Treaty
       def validate_nesting_level!
         return unless @nesting_level > Treaty::Engine.config.treaty.attribute_nesting_level
 
-        # TODO: It is necessary to implement a translation system (I18n).
         raise Treaty::Exceptions::NestedAttributes,
-              "Nesting level #{@nesting_level} exceeds maximum allowed level of " \
-              "#{Treaty::Engine.config.treaty.attribute_nesting_level}"
+              I18n.t("treaty.attributes.errors.nesting_level_exceeded",
+                     level: @nesting_level,
+                     max_level: Treaty::Engine.config.treaty.attribute_nesting_level)
       end
 
       # Extracts helper symbols from arguments
@@ -150,22 +150,24 @@ module Treaty
       # Applies default values for options based on context (request/response)
       # Must be implemented in subclasses
       #
-      # @raise [NotImplementedError] If subclass doesn't implement
+      # @raise [Treaty::Exceptions::NotImplemented] If subclass doesn't implement
       # @return [void]
       def apply_defaults!
         # Must be implemented in subclasses
-        raise NotImplementedError, "#{self.class} must implement #apply_defaults!"
+        raise Treaty::Exceptions::NotImplemented,
+              I18n.t("treaty.attributes.errors.apply_defaults_not_implemented", class: self.class)
       end
 
       # Processes nested attributes block for object/array types
       # Must be implemented in subclasses
       #
       # @param block [Proc] Block containing nested attribute definitions
-      # @raise [NotImplementedError] If subclass doesn't implement
+      # @raise [Treaty::Exceptions::NotImplemented] If subclass doesn't implement
       # @return [void]
-      def process_nested_attributes(&block)
+      def process_nested_attributes
         # Must be implemented in subclasses
-        raise NotImplementedError, "#{self.class} must implement #process_nested_attributes"
+        raise Treaty::Exceptions::NotImplemented,
+              I18n.t("treaty.attributes.errors.process_nested_not_implemented", class: self.class)
       end
     end
   end

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

@@ -130,11 +130,12 @@ module Treaty
 
         # Creates an attribute instance (must be implemented in subclasses)
         #
-        # @raise [NotImplementedError] If subclass doesn't implement
+        # @raise [Treaty::Exceptions::NotImplemented] If subclass doesn't implement
         # @return [Attribute::Base] Created attribute instance
         def create_attribute(*)
           # Must be implemented in subclasses
-          raise NotImplementedError, "#{self.class} must implement #create_attribute"
+          raise Treaty::Exceptions::NotImplemented,
+                I18n.t("treaty.attributes.builder.not_implemented", class: self.class)
         end
       end
     end

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

@@ -132,6 +132,7 @@ module Treaty
         end
 
         # Gets custom error message from advanced mode schema
+        # Returns nil if no custom message, which triggers I18n default message
         #
         # @return [String, nil] Custom error message or nil for default message
         def custom_message

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

@@ -53,9 +53,10 @@ module Treaty
 
             return if target.is_a?(Symbol)
 
-            # TODO: It is necessary to implement a translation system (I18n).
             raise Treaty::Exceptions::Validation,
-                  "Option 'as' for attribute '#{@attribute_name}' must be a Symbol. Got: #{target.class}"
+                  I18n.t("treaty.attributes.modifiers.as.invalid_type",
+                         attribute: @attribute_name,
+                         type: target.class)
           end
 
           # Indicates that AsModifier transforms attribute names

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

@@ -28,9 +28,8 @@ module Treaty
 
             return if allowed_values.is_a?(Array) && !allowed_values.empty?
 
-            # TODO: It is necessary to implement a translation system (I18n).
             raise Treaty::Exceptions::Validation,
-                  "Option 'inclusion' for attribute '#{@attribute_name}' must have a non-empty array of allowed values"
+                  I18n.t("treaty.attributes.validators.inclusion.invalid_schema", attribute: @attribute_name)
           end
 
           # Validates that value is included in allowed set
@@ -48,7 +47,6 @@ module Treaty
 
             message = custom_message || default_message(allowed_values, value)
 
-            # TODO: It is necessary to implement a translation system (I18n).
             raise Treaty::Exceptions::Validation, message
           end
 
@@ -64,14 +62,16 @@ module Treaty
 
           private
 
-          # Generates default error message with allowed values
+          # Generates default error message with allowed values using I18n
           #
           # @param allowed_values [Array] Array of allowed values
           # @param value [Object] The actual value that failed validation
           # @return [String] Default error message
           def default_message(allowed_values, value)
-            # TODO: It is necessary to implement a translation system (I18n).
-            "Attribute '#{@attribute_name}' must be one of: #{allowed_values.join(', ')}. Got: '#{value}'"
+            I18n.t("treaty.attributes.validators.inclusion.not_included",
+                   attribute: @attribute_name,
+                   allowed: allowed_values.join(", "),
+                   value:)
           end
         end
       end

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

@@ -53,7 +53,6 @@ module Treaty
 
             message = custom_message || default_message
 
-            # TODO: It is necessary to implement a translation system (I18n).
             raise Treaty::Exceptions::Validation, message
           end
 
@@ -80,12 +79,11 @@ module Treaty
             true
           end
 
-          # Generates default error message
+          # Generates default error message using I18n
           #
           # @return [String] Default error message
           def default_message
-            # TODO: It is necessary to implement a translation system (I18n).
-            "Attribute '#{@attribute_name}' is required but was not provided or is empty"
+            I18n.t("treaty.attributes.validators.required.blank", attribute: @attribute_name)
           end
         end
       end

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

@@ -10,6 +10,7 @@ module Treaty
         #
         # - `:integer` - Ruby Integer
         # - `:string` - Ruby String
+        # - `:boolean` - Ruby TrueClass or FalseClass
         # - `:object` - Ruby Hash (for nested objects)
         # - `:array` - Ruby Array (for collections)
         # - `:datetime` - Ruby DateTime, Time, or Date
@@ -19,6 +20,7 @@ module Treaty
         # Simple types:
         #   integer :age
         #   string :name
+        #   boolean :published
         #   datetime :created_at
         #
         # Nested structures:
@@ -41,7 +43,7 @@ module Treaty
         # 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 object array datetime].freeze
+          ALLOWED_TYPES = %i[integer string boolean object array datetime].freeze
 
           # Validates that the attribute type is one of the allowed types
           #
@@ -50,10 +52,11 @@ module Treaty
           def validate_schema!
             return if ALLOWED_TYPES.include?(@attribute_type)
 
-            # TODO: It is necessary to implement a translation system (I18n).
             raise Treaty::Exceptions::Validation,
-                  "Unknown type '#{@attribute_type}' for attribute '#{@attribute_name}'. " \
-                  "Allowed types: #{ALLOWED_TYPES.join(', ')}"
+                  I18n.t("treaty.attributes.validators.type.unknown_type",
+                         type: @attribute_type,
+                         attribute: @attribute_name,
+                         allowed: ALLOWED_TYPES.join(", "))
           end
 
           # Validates that the value matches the declared type
@@ -62,7 +65,7 @@ module Treaty
           # @param value [Object] The value to validate
           # @raise [Treaty::Exceptions::Validation] If value type doesn't match
           # @return [void]
-          def validate_value!(value) # rubocop:disable Metrics/MethodLength
+          def validate_value!(value) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
             return if value.nil? # Type validation doesn't check for nil, required does.
 
             case @attribute_type
@@ -70,6 +73,8 @@ module Treaty
               validate_integer!(value)
             when :string
               validate_string!(value)
+            when :boolean
+              validate_boolean!(value)
             when :object
               validate_object!(value)
             when :array
@@ -89,9 +94,10 @@ module Treaty
           def validate_integer!(value)
             return if value.is_a?(Integer)
 
-            # TODO: It is necessary to implement a translation system (I18n).
             raise Treaty::Exceptions::Validation,
-                  "Attribute '#{@attribute_name}' must be an Integer, got #{value.class}"
+                  I18n.t("treaty.attributes.validators.type.mismatch.integer",
+                         attribute: @attribute_name,
+                         actual: value.class)
           end
 
           # Validates that value is a String
@@ -102,9 +108,24 @@ module Treaty
           def validate_string!(value)
             return if value.is_a?(String)
 
-            # TODO: It is necessary to implement a translation system (I18n).
             raise Treaty::Exceptions::Validation,
-                  "Attribute '#{@attribute_name}' must be a String, got #{value.class}"
+                  I18n.t("treaty.attributes.validators.type.mismatch.string",
+                         attribute: @attribute_name,
+                         actual: value.class)
+          end
+
+          # Validates that value is a Boolean (TrueClass or FalseClass)
+          #
+          # @param value [Object] The value to validate
+          # @raise [Treaty::Exceptions::Validation] If value is not a Boolean
+          # @return [void]
+          def validate_boolean!(value)
+            return if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+            raise Treaty::Exceptions::Validation,
+                  I18n.t("treaty.attributes.validators.type.mismatch.boolean",
+                         attribute: @attribute_name,
+                         actual: value.class)
           end
 
           # Validates that value is a Hash (object type)
@@ -115,9 +136,10 @@ module Treaty
           def validate_object!(value)
             return if value.is_a?(Hash)
 
-            # TODO: It is necessary to implement a translation system (I18n).
             raise Treaty::Exceptions::Validation,
-                  "Attribute '#{@attribute_name}' must be a Hash (object), got #{value.class}"
+                  I18n.t("treaty.attributes.validators.type.mismatch.object",
+                         attribute: @attribute_name,
+                         actual: value.class)
           end
 
           # Validates that value is an Array
@@ -128,9 +150,10 @@ module Treaty
           def validate_array!(value)
             return if value.is_a?(Array)
 
-            # TODO: It is necessary to implement a translation system (I18n).
             raise Treaty::Exceptions::Validation,
-                  "Attribute '#{@attribute_name}' must be an Array, got #{value.class}"
+                  I18n.t("treaty.attributes.validators.type.mismatch.array",
+                         attribute: @attribute_name,
+                         actual: value.class)
           end
 
           # Validates that value is a DateTime, Time, or Date
@@ -142,9 +165,10 @@ module Treaty
             # TODO: It is better to divide it into different methods for each class.
             return if value.is_a?(DateTime) || value.is_a?(Time) || value.is_a?(Date)
 
-            # TODO: It is necessary to implement a translation system (I18n).
             raise Treaty::Exceptions::Validation,
-                  "Attribute '#{@attribute_name}' must be a DateTime/Time/Date, got #{value.class}"
+                  I18n.t("treaty.attributes.validators.type.mismatch.datetime",
+                         attribute: @attribute_name,
+                         actual: value.class)
           end
         end
       end

data/lib/treaty/attribute/option_normalizer.rb

@@ -128,10 +128,11 @@ module Treaty
         def normalize_value(value, value_key)
           if advanced_mode?(value, value_key)
             # Already in advanced mode, ensure it has both keys.
+            # message: nil means use I18n default message from validators
             { value_key => value.fetch(value_key), message: value.fetch(:message, nil) }
           else
             # Simple mode, convert to advanced.
-            # TODO: It is necessary to implement a translation system (I18n).
+            # message: nil means use I18n default message from validators
             { value_key => value, message: nil }
           end
         end

data/lib/treaty/attribute/option_orchestrator.rb

@@ -176,10 +176,11 @@ module Treaty
 
         return if unknown_options.empty?
 
-        # TODO: It is necessary to implement a translation system (I18n).
         raise Treaty::Exceptions::Validation,
-              "Unknown options for attribute '#{@attribute.name}': #{unknown_options.join(', ')}. " \
-              "Known options: #{Option::Registry.all_options.join(', ')}"
+              I18n.t("treaty.attributes.options.unknown",
+                     attribute: @attribute.name,
+                     unknown: unknown_options.join(", "),
+                     known: Option::Registry.all_options.join(", "))
       end
     end
   end

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

@@ -71,12 +71,11 @@ module Treaty
         # Performs validation and transformation
         # Must be implemented in subclasses
         #
-        # @raise [NotImplementedError] If subclass doesn't implement
+        # @raise [Treaty::Exceptions::NotImplemented] If subclass doesn't implement
         # @return [Hash] Validated and transformed data
         def validate!
-          # TODO: It is necessary to implement a translation system (I18n).
           raise Treaty::Exceptions::Validation,
-                "Subclass must implement the validate! method"
+                I18n.t("treaty.attributes.validators.nested.orchestrator.collection_not_implemented")
         end
 
         private

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

@@ -114,10 +114,11 @@ module Treaty
 
           return if validated
 
-          # TODO: It is necessary to implement a translation system (I18n).
           raise Treaty::Exceptions::Validation,
-                "Error in array '#{@attribute.name}' at index #{index}: " \
-                "Item must match one of the defined types. Errors: #{errors.join('; ')}"
+                I18n.t("treaty.attributes.validators.nested.array.element_validation_error",
+                       attribute: @attribute.name,
+                       index:,
+                       errors: errors.join("; "))
         end
 
         # Validates array item for complex arrays (with regular attributes)
@@ -130,18 +131,22 @@ module Treaty
         # @return [void]
         def validate_regular_array_item!(array_item, index) # rubocop:disable Metrics/MethodLength
           unless array_item.is_a?(Hash)
-            # TODO: It is necessary to implement a translation system (I18n).
             raise Treaty::Exceptions::Validation,
-                  "Error in array '#{@attribute.name}' at index #{index}: Expected Hash but got #{array_item.class}"
+                  I18n.t("treaty.attributes.validators.nested.array.element_type_error",
+                         attribute: @attribute.name,
+                         index:,
+                         actual: array_item.class)
           end
 
           regular_validators.each do |nested_attribute, validator|
             nested_value = array_item.fetch(nested_attribute.name, nil)
             validator.validate_value!(nested_value)
           rescue Treaty::Exceptions::Validation => e
-            # TODO: It is necessary to implement a translation system (I18n).
             raise Treaty::Exceptions::Validation,
-                  "Error in array '#{@attribute.name}' at index #{index}: #{e.message}"
+                  I18n.t("treaty.attributes.validators.nested.array.attribute_error",
+                         attribute: @attribute.name,
+                         index:,
+                         message: e.message)
           end
         end
 

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

@@ -171,9 +171,10 @@ module Treaty
               validator.validate_value!(item)
             rescue Treaty::Exceptions::Validation => e
               raise Treaty::Exceptions::Validation,
-                    "Error in array '#{attribute.name}' at index #{index}: " \
-                    "Element must match one of the defined types. " \
-                    "Errors: #{e.message}"
+                    I18n.t("treaty.attributes.validators.nested.array.element_validation_error",
+                           attribute: attribute.name,
+                           index:,
+                           errors: e.message)
             end
           end
 
@@ -183,11 +184,13 @@ module Treaty
           # @param index [Integer] Element index for error messages
           # @raise [Treaty::Exceptions::Validation] If item is not a Hash
           # @return [Hash] Transformed hash
-          def transform_array_item(item, index)
+          def transform_array_item(item, index) # rubocop:disable Metrics/MethodLength
             unless item.is_a?(Hash)
               raise Treaty::Exceptions::Validation,
-                    "Error in array '#{attribute.name}' at index #{index}: " \
-                    "Expected Hash but got #{item.class}"
+                    I18n.t("treaty.attributes.validators.nested.array.element_type_error",
+                           attribute: attribute.name,
+                           index:,
+                           actual: item.class)
             end
 
             transformed = {}
@@ -227,7 +230,10 @@ module Treaty
                                   end
             rescue Treaty::Exceptions::Validation => e
               raise Treaty::Exceptions::Validation,
-                    "Error in array '#{attribute.name}' at index #{index}: #{e.message}"
+                    I18n.t("treaty.attributes.validators.nested.array.attribute_error",
+                           attribute: attribute.name,
+                           index:,
+                           message: e.message)
             end
 
             target_name = validator.target_name