treaty 0.0.1 → 0.1.0

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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Attribute
+    module Validation
+      module Orchestrator
+        # Base orchestrator for validating and transforming data according to treaty definitions.
+        #
+        # ## Purpose
+        #
+        # Coordinates the validation and transformation of request/response data for a specific
+        # API version. Processes all scopes and their attributes, applying validations and
+        # transformations defined in the treaty DSL.
+        #
+        # ## Responsibilities
+        #
+        # 1. **Scope Processing** - Iterates through all defined scopes
+        # 2. **Attribute Validation** - Validates each attribute's value
+        # 3. **Data Transformation** - Transforms values (defaults, renaming)
+        # 4. **Nested Handling** - Delegates nested structures to NestedTransformer
+        # 5. **Result Assembly** - Builds final transformed data structure
+        #
+        # ## Usage
+        #
+        # Subclasses must implement:
+        # - `collection_of_scopes` - Returns scopes for this context (request/response)
+        # - `scope_data_for(name)` - Extracts data for a specific scope
+        #
+        # Example:
+        #   orchestrator = Request::Orchestrator.new(version_factory: factory, data: params)
+        #   validated_data = orchestrator.validate!
+        #
+        # ## Special Scopes
+        #
+        # - Normal scope: `{ scope_name: { ... } }`
+        # - Self scope (`:_self`): Attributes merged directly into parent
+        #
+        # ## Architecture
+        #
+        # Uses:
+        # - `AttributeValidator` - Validates individual attributes
+        # - `NestedTransformer` - Handles nested objects and arrays
+        #
+        # The refactored design separates concerns:
+        # - Orchestrator: High-level flow and scope iteration
+        # - Validator: Individual attribute validation
+        # - Transformer: Nested structure transformation
+        class Base
+          SELF_SCOPE = :_self
+          private_constant :SELF_SCOPE
+
+          attr_reader :version_factory, :data
+
+          # Class-level factory method for validation
+          # Creates instance and calls validate!
+          #
+          # @param args [Hash] Arguments passed to initialize
+          # @return [Hash] Validated and transformed data
+          def self.validate!(...)
+            new(...).validate!
+          end
+
+          # Creates a new orchestrator instance
+          #
+          # @param version_factory [VersionFactory] Factory containing version info
+          # @param data [Hash] Data to validate and transform (default: {})
+          def initialize(version_factory:, data: {})
+            @version_factory = version_factory
+            @data = data
+          end
+
+          # Validates and transforms all scopes
+          # Iterates through scopes, processes attributes, handles :_self scope
+          #
+          # @return [Hash] Transformed data with all scopes processed
+          def validate!
+            transformed_data = {}
+
+            collection_of_scopes.each do |scope_factory|
+              transformed_scope_data = validate_and_transform_scope!(scope_factory)
+              transformed_data[scope_factory.name] = transformed_scope_data if scope_factory.name != SELF_SCOPE
+              transformed_data.merge!(transformed_scope_data) if scope_factory.name == SELF_SCOPE
+            end
+
+            transformed_data
+          end
+
+          private
+
+          # Returns collection of scopes for this context
+          # Must be implemented in subclasses
+          #
+          # @raise [Treaty::Exceptions::Validation] If not implemented
+          # @return [Array<ScopeFactory>] Collection of scope factories
+          def collection_of_scopes
+            # TODO: It is necessary to implement a translation system (I18n).
+            raise Treaty::Exceptions::Validation,
+                  "Subclass must implement the collection_of_scopes method"
+          end
+
+          # Validates all attributes in a scope (deprecated, not used)
+          #
+          # @param scope_factory [ScopeFactory] The scope to validate
+          # @return [void]
+          def validate_scope!(scope_factory)
+            scope_data = scope_data_for(scope_factory.name)
+
+            validators_for_scope(scope_factory).each do |attribute, validator|
+              value = scope_data.fetch(attribute.name, nil)
+              validator.validate_value!(value)
+            end
+          end
+
+          # Gets cached validators for scope or builds them
+          #
+          # @param scope_factory [ScopeFactory] The scope factory
+          # @return [Hash] Hash of attribute => validator
+          def validators_for_scope(scope_factory)
+            @validators_cache ||= {}
+            @validators_cache[scope_factory] ||= build_validators_for_scope(scope_factory)
+          end
+
+          # Builds validators for all attributes in a scope
+          #
+          # @param scope_factory [ScopeFactory] The scope factory
+          # @return [Hash] Hash of attribute => validator
+          def build_validators_for_scope(scope_factory)
+            scope_factory.collection_of_attributes.each_with_object({}) do |attribute, cache|
+              validator = AttributeValidator.new(attribute)
+              validator.validate_schema!
+              cache[attribute] = validator
+            end
+          end
+
+          # Extracts data for a specific scope
+          # Must be implemented in subclasses
+          #
+          # @param _name [Symbol] The scope name
+          # @raise [Treaty::Exceptions::Validation] If not implemented
+          # @return [Hash] Scope data
+          def scope_data_for(_name)
+            # TODO: It is necessary to implement a translation system (I18n).
+            raise Treaty::Exceptions::Validation,
+                  "Subclass must implement the scope_data_for method"
+          end
+
+          # Validates and transforms all attributes in a scope
+          # Handles both nested and regular attributes
+          #
+          # @param scope_factory [ScopeFactory] The scope to process
+          # @return [Hash] Transformed scope data
+          def validate_and_transform_scope!(scope_factory) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+            scope_data = scope_data_for(scope_factory.name)
+
+            return scope_data if scope_factory.collection_of_attributes.empty?
+
+            transformed_scope_data = {}
+
+            validators_for_scope(scope_factory).each do |attribute, validator|
+              source_name = attribute.name
+              value = scope_data.fetch(source_name, nil)
+
+              if attribute.nested?
+                transformed_value = validate_and_transform_nested(attribute, value, validator)
+              else
+                validator.validate_value!(value)
+                transformed_value = validator.transform_value(value)
+              end
+
+              target_name = validator.target_name
+
+              transformed_scope_data[target_name] = transformed_value
+            end
+
+            transformed_scope_data
+          end
+
+          # Validates and transforms nested attribute (object/array)
+          # Delegates transformation to NestedTransformer
+          #
+          # @param attribute [Attribute::Base] The nested attribute
+          # @param value [Object] The value to validate and transform
+          # @param validator [AttributeValidator] The validator instance
+          # @return [Object] Transformed nested value
+          def validate_and_transform_nested(attribute, value, validator)
+            validator.validate_type!(value) unless value.nil?
+            validator.validate_required!(value)
+
+            transformer = NestedTransformer.new(attribute)
+            transformer.transform(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/treaty/base.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Treaty
+  class Base
+    include Info::DSL
+    include Context::DSL
+    include Versions::DSL
+  end
+end

data/lib/treaty/configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Treaty
+  class Configuration
+    include ::ActiveModel::Validations
+
+    attr_accessor :version
+
+    attr_reader :attribute_nesting_level
+
+    def initialize
+      @version = ->(context) { context }
+
+      @attribute_nesting_level = 5
+    end
+  end
+end

data/lib/treaty/context/callable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Context
+    module Callable
+      def call!(controller:, params:)
+        context = send(:new)
+
+        _call!(context, controller:, params:)
+      end
+
+      private
+
+      def _call!(context, controller:, params:)
+        context.send(
+          :_call!,
+          controller:,
+          params:,
+          collection_of_versions:
+        )
+      end
+    end
+  end
+end

data/lib/treaty/context/dsl.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Context
+    module DSL
+      def self.included(base)
+        base.extend(Callable)
+        base.include(Workspace)
+      end
+    end
+  end
+end

data/lib/treaty/context/workspace.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Context
+    module Workspace
+      private
+
+      def _call!(
+        controller:,
+        params:,
+        collection_of_versions:
+      )
+        call!(
+          controller:,
+          params:,
+          collection_of_versions:
+        )
+      end
+
+      def call!(
+        collection_of_versions:,
+        **
+      )
+        @collection_of_versions = collection_of_versions
+      end
+    end
+  end
+end

data/lib/treaty/controller/dsl.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Controller
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.include(InstanceMethods)
+      end
+
+      module ClassMethods
+        private
+
+        def treaty(action_name)
+          define_method(action_name) do
+            treaty = treaty_class.call!(controller: self, params:)
+
+            render json: treaty.data, status: treaty.status
+          end
+        end
+      end
+
+      module InstanceMethods
+        def treaty_class
+          treaty_class_name.constantize
+        rescue NameError
+          # TODO: It is necessary to implement a translation system (I18n).
+          raise Treaty::Exceptions::ClassName, treaty_class_name
+        end
+
+        def treaty_class_name
+          # TODO: Need to move `Treaty` to configuration.
+          self.class.name.sub(/Controller$/, "::#{action_name.to_s.classify}Treaty")
+        end
+      end
+    end
+  end
+end

data/lib/treaty/engine.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Treaty
+  class Engine < ::Rails::Engine
+    isolate_namespace Treaty
+
+    config.treaty = Treaty::Configuration.new
+
+    def self.configure
+      yield(config.treaty) if block_given?
+    end
+
+    initializer "treaty.register_option_processors", before: :load_config_initializers do
+      # Register all option processors (validators and modifiers)
+      require "treaty/attribute/option/registry_initializer"
+    end
+
+    initializer "treaty.validate_configuration" do
+      config.after_initialize do
+        unless config.treaty.valid?
+          errors = config.treaty.errors.full_messages
+          raise "Invalid Treaty configuration: #{errors.join(', ')}"
+        end
+      end
+    end
+
+    initializer "treaty.controller_methods" do
+      ActiveSupport.on_load(:action_controller_base) do
+        include Treaty::Controller::DSL
+      end
+
+      ActiveSupport.on_load(:action_controller_api) do
+        include Treaty::Controller::DSL
+      end
+    end
+  end
+end

data/lib/treaty/exceptions/base.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    class Base < StandardError
+    end
+  end
+end

data/lib/treaty/exceptions/class_name.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    class ClassName < Base
+      def initialize(class_name)
+        super("Invalid class name: #{class_name}")
+      end
+    end
+  end
+end

data/lib/treaty/exceptions/deprecated.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    class Deprecated < Base
+    end
+  end
+end

data/lib/treaty/exceptions/execution.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    class Execution < Base
+    end
+  end
+end

data/lib/treaty/exceptions/method_name.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    class MethodName < Base
+    end
+  end
+end

data/lib/treaty/exceptions/nested_attributes.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    class NestedAttributes < Base
+    end
+  end
+end

data/lib/treaty/exceptions/strategy.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    class Strategy < Base
+    end
+  end
+end

data/lib/treaty/exceptions/unexpected.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    class Unexpected < Base
+    end
+  end
+end

data/lib/treaty/exceptions/validation.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    class Validation < Base
+    end
+  end
+end

data/lib/treaty/info/builder.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Info
+    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)
+        {
+          scopes: build_scopes_with(version.request_factory)
+        }
+      end
+
+      def build_response_with(version)
+        response_factory = version.response_factory
+        {
+          status: response_factory.status,
+          scopes: build_scopes_with(response_factory)
+        }
+      end
+
+      ##########################################################################
+
+      def build_scopes_with(request_factory)
+        request_factory.collection_of_scopes.to_h do |scope|
+          [
+            scope.name,
+            build_attributes_with(scope.collection_of_attributes)
+          ]
+        end
+      end
+
+      ##########################################################################
+
+      def build_attributes_with(collection, current_level = 0)
+        # validate_nesting_level!(current_level)
+
+        {
+          attributes: build_attributes_hash(collection, current_level)
+        }
+      end
+
+      def build_attributes_hash(collection, 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
+      #
+      #   # TODO: It is necessary to implement a translation system (I18n).
+      #   raise Treaty::Exceptions::NestedAttributes,
+      #         "Nesting level #{level} exceeds maximum allowed level of " \
+      #         "#{Treaty::Engine.config.treaty.attribute_nesting_level}"
+      # end
+    end
+  end
+end

data/lib/treaty/info/dsl.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Info
+    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

data/lib/treaty/info/result.rb

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

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Request
+    module Attribute
+      class Attribute < Treaty::Attribute::Base
+        private
+
+        def apply_defaults!
+          # For request: required by default (true).
+          # TODO: It is necessary to implement a translation system (I18n).
+          @options[:required] ||= { is: true, message: nil }
+        end
+
+        def process_nested_attributes(&block)
+          return unless object_or_array?
+
+          builder = Builder.new(collection_of_attributes, @nesting_level + 1)
+          builder.instance_eval(&block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Request
+    module Attribute
+      class Builder < Treaty::Attribute::Builder::Base
+        private
+
+        def create_attribute(name, type, *helpers, nesting_level:, **options, &block)
+          Attribute.new(
+            name,
+            type,
+            *helpers,
+            nesting_level:,
+            **options,
+            &block
+          )
+        end
+      end
+    end
+  end
+end