treaty 0.7.0 → 0.9.0

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

@@ -53,10 +53,12 @@ module Treaty
             return if ALLOWED_TYPES.include?(@attribute_type)
 
             raise Treaty::Exceptions::Validation,
-                  I18n.t("treaty.attributes.validators.type.unknown_type",
-                         type: @attribute_type,
-                         attribute: @attribute_name,
-                         allowed: 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
@@ -86,18 +88,52 @@ module Treaty
 
           private
 
+          # Common type validation logic
+          # Checks if value matches expected type and raises exception with appropriate message
+          #
+          # @param value [Object] The value to validate
+          # @param expected_type [Symbol] The expected type symbol
+          # @yield Block that returns true if value is valid
+          # @raise [Treaty::Exceptions::Validation] If type validation fails
+          # @return [void]
+          def validate_type!(value, expected_type)
+            return if yield(value)
+
+            actual_type = value.class
+
+            attributes = {
+              attribute: @attribute_name,
+              value:,
+              expected_type:,
+              actual_type:
+            }
+
+            message = resolve_custom_message(**attributes) || default_message(**attributes)
+
+            raise Treaty::Exceptions::Validation, message
+          end
+
+          # Generates default error message for type mismatch using I18n
+          #
+          # @param attribute [Symbol] The attribute name
+          # @param expected_type [Symbol] The expected type
+          # @param actual_type [Class] The actual class of the value
+          # @return [String] Default error message
+          def default_message(attribute:, expected_type:, actual_type:, **)
+            I18n.t(
+              "treaty.attributes.validators.type.mismatch.#{expected_type}",
+              attribute:,
+              actual: actual_type
+            )
+          end
+
           # Validates that value is an Integer
           #
           # @param value [Object] The value to validate
           # @raise [Treaty::Exceptions::Validation] If value is not an Integer
           # @return [void]
           def validate_integer!(value)
-            return if value.is_a?(Integer)
-
-            raise Treaty::Exceptions::Validation,
-                  I18n.t("treaty.attributes.validators.type.mismatch.integer",
-                         attribute: @attribute_name,
-                         actual: value.class)
+            validate_type!(value, :integer) { |v| v.is_a?(Integer) }
           end
 
           # Validates that value is a String
@@ -106,12 +142,7 @@ module Treaty
           # @raise [Treaty::Exceptions::Validation] If value is not a String
           # @return [void]
           def validate_string!(value)
-            return if value.is_a?(String)
-
-            raise Treaty::Exceptions::Validation,
-                  I18n.t("treaty.attributes.validators.type.mismatch.string",
-                         attribute: @attribute_name,
-                         actual: value.class)
+            validate_type!(value, :string) { |v| v.is_a?(String) }
           end
 
           # Validates that value is a Boolean (TrueClass or FalseClass)
@@ -120,12 +151,7 @@ module Treaty
           # @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)
+            validate_type!(value, :boolean) { |v| v.is_a?(TrueClass) || v.is_a?(FalseClass) }
           end
 
           # Validates that value is a Hash (object type)
@@ -134,12 +160,7 @@ module Treaty
           # @raise [Treaty::Exceptions::Validation] If value is not a Hash
           # @return [void]
           def validate_object!(value)
-            return if value.is_a?(Hash)
-
-            raise Treaty::Exceptions::Validation,
-                  I18n.t("treaty.attributes.validators.type.mismatch.object",
-                         attribute: @attribute_name,
-                         actual: value.class)
+            validate_type!(value, :object) { |v| v.is_a?(Hash) }
           end
 
           # Validates that value is an Array
@@ -148,12 +169,7 @@ module Treaty
           # @raise [Treaty::Exceptions::Validation] If value is not an Array
           # @return [void]
           def validate_array!(value)
-            return if value.is_a?(Array)
-
-            raise Treaty::Exceptions::Validation,
-                  I18n.t("treaty.attributes.validators.type.mismatch.array",
-                         attribute: @attribute_name,
-                         actual: value.class)
+            validate_type!(value, :array) { |v| v.is_a?(Array) }
           end
 
           # Validates that value is a DateTime, Time, or Date
@@ -163,12 +179,7 @@ module Treaty
           # @return [void]
           def validate_datetime!(value)
             # 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)
-
-            raise Treaty::Exceptions::Validation,
-                  I18n.t("treaty.attributes.validators.type.mismatch.datetime",
-                         attribute: @attribute_name,
-                         actual: value.class)
+            validate_type!(value, :datetime) { |v| v.is_a?(DateTime) || v.is_a?(Time) || v.is_a?(Date) }
           end
         end
       end

data/lib/treaty/attribute/option_orchestrator.rb

@@ -146,7 +146,7 @@ module Treaty
         @attribute.options.each do |option_name, option_schema|
           processor_class = Option::Registry.processor_for(option_name)
 
-          next unless processor_class
+          next if processor_class.nil?
 
           processors_hash[option_name] = processor_class.new(
             attribute_name: @attribute.name,
@@ -177,10 +177,12 @@ module Treaty
         return if unknown_options.empty?
 
         raise Treaty::Exceptions::Validation,
-              I18n.t("treaty.attributes.options.unknown",
-                     attribute: @attribute.name,
-                     unknown: unknown_options.join(", "),
-                     known: 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/nested_array_validator.rb

@@ -115,10 +115,12 @@ module Treaty
           return if validated
 
           raise Treaty::Exceptions::Validation,
-                I18n.t("treaty.attributes.validators.nested.array.element_validation_error",
-                       attribute: @attribute.name,
-                       index:,
-                       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)
@@ -132,10 +134,12 @@ module Treaty
         def validate_regular_array_item!(array_item, index) # rubocop:disable Metrics/MethodLength
           unless array_item.is_a?(Hash)
             raise Treaty::Exceptions::Validation,
-                  I18n.t("treaty.attributes.validators.nested.array.element_type_error",
-                         attribute: @attribute.name,
-                         index:,
-                         actual: 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|
@@ -143,10 +147,12 @@ module Treaty
             validator.validate_value!(nested_value)
           rescue Treaty::Exceptions::Validation => e
             raise Treaty::Exceptions::Validation,
-                  I18n.t("treaty.attributes.validators.nested.array.attribute_error",
-                         attribute: @attribute.name,
-                         index:,
-                         message: 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,10 +171,12 @@ module Treaty
               validator.validate_value!(item)
             rescue Treaty::Exceptions::Validation => e
               raise Treaty::Exceptions::Validation,
-                    I18n.t("treaty.attributes.validators.nested.array.element_validation_error",
-                           attribute: attribute.name,
-                           index:,
-                           errors: e.message)
+                    I18n.t(
+                      "treaty.attributes.validators.nested.array.element_validation_error",
+                      attribute: attribute.name,
+                      index:,
+                      errors: e.message
+                    )
             end
           end
 
@@ -187,10 +189,12 @@ module Treaty
           def transform_array_item(item, index) # rubocop:disable Metrics/MethodLength
             unless item.is_a?(Hash)
               raise Treaty::Exceptions::Validation,
-                    I18n.t("treaty.attributes.validators.nested.array.element_type_error",
-                           attribute: attribute.name,
-                           index:,
-                           actual: item.class)
+                    I18n.t(
+                      "treaty.attributes.validators.nested.array.element_type_error",
+                      attribute: attribute.name,
+                      index:,
+                      actual: item.class
+                    )
             end
 
             transformed = {}
@@ -230,10 +234,12 @@ module Treaty
                                   end
             rescue Treaty::Exceptions::Validation => e
               raise Treaty::Exceptions::Validation,
-                    I18n.t("treaty.attributes.validators.nested.array.attribute_error",
-                           attribute: attribute.name,
-                           index:,
-                           message: e.message)
+                    I18n.t(
+                      "treaty.attributes.validators.nested.array.attribute_error",
+                      attribute: attribute.name,
+                      index:,
+                      message: e.message
+                    )
             end
 
             target_name = validator.target_name

data/lib/treaty/base.rb

@@ -2,7 +2,7 @@
 
 module Treaty
   class Base
-    include Info::DSL
+    include Info::Rest::DSL
     include Context::DSL
     include Versions::DSL
   end

data/lib/treaty/controller/dsl.rb

@@ -25,7 +25,10 @@ module Treaty
           treaty_class_name.constantize
         rescue NameError
           raise Treaty::Exceptions::ClassName,
-                I18n.t("treaty.controller.treaty_class_not_found", class_name: treaty_class_name)
+                I18n.t(
+                  "treaty.controller.treaty_class_not_found",
+                  class_name: treaty_class_name
+                )
         end
 
         def treaty_class_name

data/lib/treaty/entity.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Treaty
+  # Base class for defining DTO (Data Transfer Object) entities in Treaty.
+  #
+  # ## Purpose
+  #
+  # Treaty::Entity provides a base class for creating reusable DTO classes
+  # that can be used in both request and response definitions. This allows
+  # for better code organization and reusability of common data structures.
+  #
+  # ## Usage
+  #
+  # Create a DTO class by inheriting from Treaty::Entity:
+  #
+  # ```ruby
+  # class PostEntity < Treaty::Entity
+  #   string :id
+  #   string :title
+  #   string :content
+  #   datetime :created_at
+  # end
+  # ```
+  #
+  # Then use it in your treaty definitions:
+  #
+  # ```ruby
+  # class CreateTreaty < ApplicationTreaty
+  #   version 1 do
+  #     request PostEntity
+  #     response 201, PostEntity
+  #   end
+  # end
+  # ```
+  #
+  # ## Attribute Defaults
+  #
+  # Unlike request/response blocks, Entity attributes are required by default:
+  # - All attributes have `required: true` unless explicitly marked as `:optional`
+  # - Use `:optional` helper to make attributes optional:
+  #   ```ruby
+  #   string :title           # required by default
+  #   string :summary, :optional  # optional
+  #   ```
+  #
+  # ## Features
+  #
+  # - **Type Safety** - Enforce strict type checking for all attributes
+  # - **Nested Structures** - Support for nested objects and arrays
+  # - **Validation** - Built-in validation for all attribute types
+  # - **Reusability** - Define once, use in multiple treaties
+  # - **Options** - Full support for attribute options (required, default, as, etc.)
+  #
+  # ## Supported Types
+  #
+  # - `string` - String values
+  # - `integer` - Integer values
+  # - `boolean` - Boolean values (true/false)
+  # - `datetime` - DateTime values
+  # - `array` - Array values (with nested type definition)
+  # - `object` - Object values (with nested attributes)
+  class Entity
+    include Info::Entity::DSL
+    include Attribute::DSL
+
+    class << self
+      private
+
+      # Creates an Attribute::Entity::Attribute for this Entity class
+      #
+      # @return [Attribute::Entity::Attribute] Created attribute instance
+      def create_attribute(name, type, *helpers, nesting_level:, **options, &block)
+        Attribute::Entity::Attribute.new(
+          name,
+          type,
+          *helpers,
+          nesting_level:,
+          **options,
+          &block
+        )
+      end
+    end
+  end
+end

data/lib/treaty/info/entity/builder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Info
+    module Entity
+      class Builder
+        attr_reader :attributes
+
+        def self.build(...)
+          new.build(...)
+        end
+
+        def build(collection_of_attributes:)
+          build_all(
+            attributes: collection_of_attributes
+          )
+
+          self
+        end
+
+        private
+
+        def build_all(attributes:)
+          @attributes = build_versions_with(attributes)
+        end
+
+        ##########################################################################
+
+        def build_versions_with(collection, current_level = 0)
+          collection.to_h do |attribute|
+            [
+              attribute.name,
+              {
+                type: attribute.type,
+                options: attribute.options,
+                attributes: build_nested_attributes(attribute, current_level)
+              }
+            ]
+          end
+        end
+
+        def build_nested_attributes(attribute, current_level)
+          return {} unless attribute.nested?
+
+          build_versions_with(attribute.collection_of_attributes, current_level + 1)
+        end
+      end
+    end
+  end
+end

data/lib/treaty/info/entity/dsl.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Info
+    module Entity
+      module DSL
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def info
+            builder = Builder.build(
+              collection_of_attributes:
+            )
+
+            Result.new(builder)
+          end
+
+          # API: Treaty Web
+          def treaty?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/treaty/info/entity/result.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Info
+    module Entity
+      class Result
+        attr_reader :attributes
+
+        def initialize(builder)
+          @attributes = builder.attributes
+        end
+      end
+    end
+  end
+end

data/lib/treaty/info/rest/builder.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Info
+    module Rest
+      class Builder
+        attr_reader :versions
+
+        def self.build(...)
+          new.build(...)
+        end
+
+        def build(collection_of_versions:)
+          build_all(
+            versions: collection_of_versions
+          )
+
+          self
+        end
+
+        private
+
+        def build_all(versions:)
+          build_versions_with(
+            collection: versions
+          )
+        end
+
+        ##########################################################################
+
+        def build_versions_with(collection:) # rubocop:disable Metrics/MethodLength
+          @versions = collection.map do |version|
+            gem_version = version.version.version
+            {
+              version: gem_version.version,
+              segments: gem_version.segments,
+              default: version.default_result,
+              summary: version.summary_text,
+              strategy: version.strategy_instance.code,
+              deprecated: version.deprecated_result,
+              executor: build_executor_with(version),
+              request: build_request_with(version),
+              response: build_response_with(version)
+            }
+          end
+        end
+
+        ##########################################################################
+
+        def build_executor_with(version)
+          {
+            executor: version.executor.executor,
+            method: version.executor.method
+          }
+        end
+
+        ##########################################################################
+
+        def build_request_with(version)
+          build_attributes_structure(version.request_factory)
+        end
+
+        def build_response_with(version)
+          response_factory = version.response_factory
+          {
+            status: response_factory.status
+          }.merge(build_attributes_structure(response_factory))
+        end
+
+        ##########################################################################
+
+        def build_attributes_structure(factory)
+          {
+            attributes: build_attributes_hash(factory.collection_of_attributes)
+          }
+        end
+
+        def build_attributes_hash(collection, current_level = 0)
+          # validate_nesting_level!(current_level)
+
+          collection.to_h do |attribute|
+            [
+              attribute.name,
+              {
+                type: attribute.type,
+                options: attribute.options,
+                attributes: build_nested_attributes(attribute, current_level)
+              }
+            ]
+          end
+        end
+
+        def build_nested_attributes(attribute, current_level)
+          return {} unless attribute.nested?
+
+          build_attributes_hash(attribute.collection_of_attributes, current_level + 1)
+        end
+
+        # def validate_nesting_level!(level)
+        #   return unless level > Treaty::Engine.config.treaty.attribute_nesting_level
+        #
+        #   raise Treaty::Exceptions::NestedAttributes,
+        #         I18n.t("treaty.attributes.errors.nesting_level_exceeded",
+        #                level:,
+        #                max_level: Treaty::Engine.config.treaty.attribute_nesting_level)
+        # end
+      end
+    end
+  end
+end

data/lib/treaty/info/rest/dsl.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Info
+    module Rest
+      module DSL
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def info
+            builder = Builder.build(
+              collection_of_versions:
+            )
+
+            Result.new(builder)
+          end
+
+          # API: Treaty Web
+          def treaty?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/treaty/info/rest/result.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Info
+    module Rest
+      class Result
+        attr_reader :versions
+
+        def initialize(builder)
+          @versions = builder.versions
+        end
+      end
+    end
+  end
+end

data/lib/treaty/request/attribute/attribute.rb

@@ -3,6 +3,7 @@
 module Treaty
   module Request
     module Attribute
+      # Request-specific attribute that defaults to required: true
       class Attribute < Treaty::Attribute::Base
         private
 

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

@@ -3,6 +3,7 @@
 module Treaty
   module Request
     module Attribute
+      # Request-specific attribute builder
       class Builder < Treaty::Attribute::Builder::Base
         private
 

data/lib/treaty/request/entity.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Request
+    # Entity class for request definitions.
+    # Attributes are required by default.
+    #
+    # This class is used internally when defining request blocks.
+    # When you write a request block, Treaty creates an anonymous
+    # class based on Request::Entity.
+    class Entity
+      include Treaty::Attribute::DSL
+
+      class << self
+        private
+
+        # Creates a Request::Attribute::Attribute for this Request::Entity class
+        #
+        # @return [Request::Attribute::Attribute] Created attribute instance
+        def create_attribute(name, type, *helpers, nesting_level:, **options, &block)
+          Attribute::Attribute.new(
+            name,
+            type,
+            *helpers,
+            nesting_level:,
+            **options,
+            &block
+          )
+        end
+      end
+    end
+  end
+end