treaty 0.18.0 → 0.20.0

data/lib/treaty/response/attribute/attribute.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Response
-    module Attribute
-      # Response-specific attribute that defaults to required: false
-      class Attribute < Treaty::Attribute::Base
-        private
-
-        def apply_defaults!
-          # For response: optional by default (false).
-          # message: nil means use I18n default message from validators
-          @options[:required] ||= { is: false, 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/response/attribute/builder.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Response
-    module Attribute
-      # Response-specific attribute builder
-      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
-
-        # Deep copies an attribute with adjusted nesting level for Response context.
-        #
-        # @param source_attribute [Treaty::Attribute::Base] Attribute to copy
-        # @param new_nesting_level [Integer] New nesting level
-        # @return [Response::Attribute::Attribute] Copied attribute
-        def deep_copy_attribute(source_attribute, new_nesting_level) # rubocop:disable Metrics/MethodLength
-          copied = Attribute.new(
-            source_attribute.name,
-            source_attribute.type,
-            nesting_level: new_nesting_level,
-            **deep_copy_options(source_attribute.options)
-          )
-
-          return copied unless source_attribute.nested?
-
-          source_attribute.collection_of_attributes.each do |nested_source|
-            nested_copied = deep_copy_attribute(nested_source, new_nesting_level + 1)
-            copied.collection_of_attributes << nested_copied
-          end
-
-          copied
-        end
-      end
-    end
-  end
-end

data/lib/treaty/response/entity.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Response
-    # Entity class for response definitions.
-    # Attributes are optional by default.
-    #
-    # This class is used internally when defining response blocks.
-    # When you write a response block, Treaty creates an anonymous
-    # class based on Response::Entity.
-    class Entity
-      include Treaty::Attribute::DSL
-
-      class << self
-        private
-
-        # Creates a Response::Attribute::Attribute for this Response::Entity class
-        #
-        # @return [Response::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

data/lib/treaty/response/factory.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Response
-    # Factory for creating response definitions.
-    #
-    # Supports two modes:
-    # 1. Block mode: Creates an anonymous Response::Entity class with the block
-    # 2. Entity mode: Uses a provided Entity class directly
-    #
-    # ## Block Mode
-    #
-    # ```ruby
-    # response 200 do
-    #   object :post do
-    #     string :id
-    #   end
-    # end
-    # ```
-    #
-    # ## Entity Mode
-    #
-    # ```ruby
-    # response 200, Posts::Create::ResponseEntity
-    # ```
-    class Factory
-      attr_reader :status
-
-      def initialize(status)
-        @status = status
-      end
-
-      # Uses a provided Entity class
-      #
-      # @param entity_class [Class] Entity class to use
-      # @return [void]
-      # @raise [Treaty::Exceptions::Validation] if entity_class is not a valid Treaty::Entity subclass
-      def use_entity(entity_class)
-        validate_entity_class!(entity_class)
-        @entity_class = entity_class
-      end
-
-      # Returns collection of attributes from the entity class
-      #
-      # @return [Collection] Collection of attributes
-      def collection_of_attributes
-        return Treaty::Attribute::Collection.new if @entity_class.nil?
-
-        @entity_class.collection_of_attributes
-      end
-
-      # Handles DSL methods for defining attributes
-      #
-      # This allows the factory to be used with method_missing
-      # for backwards compatibility with direct method calls.
-      # Creates an anonymous Response::Entity class on first use.
-      def method_missing(type, *helpers, **options, &block)
-        # If no entity class yet, create one
-        @entity_class ||= Class.new(Entity)
-
-        # Call the method on the entity class
-        @entity_class.public_send(type, *helpers, **options, &block)
-      end
-
-      def respond_to_missing?(name, *)
-        super
-      end
-
-      private
-
-      # Validates that the provided entity_class is a valid Treaty::Entity subclass
-      #
-      # @param entity_class [Class] Entity class to validate
-      # @raise [Treaty::Exceptions::Validation] if entity_class is not a valid Treaty::Entity subclass
-      def validate_entity_class!(entity_class)
-        return if entity_class.is_a?(Class) && entity_class < Treaty::Entity
-
-        raise Treaty::Exceptions::Validation,
-              I18n.t(
-                "treaty.response.factory.invalid_entity_class",
-                type: entity_class.class,
-                value: entity_class
-              )
-      end
-    end
-  end
-end

data/lib/treaty/response/validator.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Response
-    # Validator for response data
-    class Validator
-      class << self
-        # Validates response data against the response definition
-        #
-        # @param response_data [Hash] Response data to validate
-        # @param version_factory [Versions::Factory] Version factory with response definition
-        # @return [Hash] Validated and transformed response data
-        def validate!(version_factory:, response_data: {})
-          new(version_factory:, response_data:).validate!
-        end
-      end
-
-      def initialize(version_factory:, response_data: {})
-        @version_factory = version_factory
-        @response_data = response_data
-      end
-
-      def validate!
-        validate_response_attributes!
-      end
-
-      private
-
-      def validate_response_attributes!
-        return @response_data unless response_attributes_exist?
-
-        # Create orchestrator for response validation
-        # Orchestrator filters data by attributes and performs transformation
-        orchestrator_class = Class.new(Treaty::Attribute::Validation::Orchestrator::Base) do
-          define_method(:collection_of_attributes) do
-            @version_factory.response_factory.collection_of_attributes
-          end
-        end
-
-        orchestrator_class.validate!(
-          version_factory: @version_factory,
-          data: @response_data
-        )
-      end
-
-      def response_attributes_exist?
-        return false if @version_factory.response_factory&.collection_of_attributes&.empty?
-
-        @version_factory.response_factory.collection_of_attributes.exists?
-      end
-    end
-  end
-end

data/lib/treaty/result.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  class Result
-    attr_reader :data, :status, :version
-
-    def initialize(data:, status:, version:)
-      @data = data
-      @status = status
-      @version = version
-    end
-
-    def inspect
-      "#<#{self.class.name} #{draw_result}>"
-    end
-
-    private
-
-    def draw_result
-      "@data=#{@data.inspect}, @status=#{@status.inspect}, @version=#{@version.inspect}"
-    end
-  end
-end

data/lib/treaty/versions/collection.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Versions
-    class Collection
-      extend Forwardable
-
-      def_delegators :@collection, :<<, :map, :find
-
-      def initialize(collection = Set.new)
-        @collection = collection
-      end
-    end
-  end
-end

data/lib/treaty/versions/dsl.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Versions
-    module DSL
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.include(Workspace)
-      end
-
-      module ClassMethods
-        private
-
-        def version(version, default: false, &block)
-          @version_factory = Factory.new(version:, default:)
-
-          @version_factory.instance_eval(&block)
-          @version_factory.validate_after_block!
-
-          validate_multiple_defaults! if @version_factory.default_result == true
-
-          collection_of_versions << @version_factory
-
-          @version_factory = nil
-        end
-
-        def collection_of_versions
-          @collection_of_versions ||= Collection.new
-        end
-
-        def validate_multiple_defaults!
-          existing_defaults = collection_of_versions.map(&:default_result).count(true)
-
-          return if existing_defaults.zero?
-
-          raise Treaty::Exceptions::VersionMultipleDefaults,
-                I18n.t("treaty.versioning.factory.multiple_defaults")
-        end
-      end
-    end
-  end
-end

data/lib/treaty/versions/execution/request.rb

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Versions
-    module Execution
-      class Request # rubocop:disable Metrics/ClassLength
-        def self.execute!(...)
-          new(...).execute!
-        end
-
-        def initialize(version_factory:, validated_params:, inventory: nil, context: nil)
-          @inventory = inventory
-          @context = context
-          @version_factory = version_factory
-          @validated_params = validated_params
-        end
-
-        def execute!
-          raise_executor_missing_error! if @version_factory.executor.nil?
-
-          extract_data_from_result
-        end
-
-        private
-
-        def extract_data_from_result
-          return execution_result if executor.is_a?(Proc)
-          return execution_result.data if execution_result.respond_to?(:data)
-
-          execution_result
-        end
-
-        ########################################################################
-
-        def execution_result
-          @execution_result ||=
-            if executor.is_a?(Proc)
-              execute_proc
-            elsif servactory_service?
-              execute_servactory
-            else
-              execute_regular_class
-            end
-        end
-
-        ########################################################################
-
-        def executor
-          @executor ||= resolve_executor(@version_factory.executor.executor)
-        end
-
-        ########################################################################
-
-        def resolve_executor(executor) # rubocop:disable Metrics/MethodLength
-          return executor if executor.is_a?(Proc) || executor.is_a?(Class)
-
-          if executor.is_a?(String) || executor.is_a?(Symbol)
-            string_executor = executor.to_s
-
-            if string_executor.empty?
-              raise Treaty::Exceptions::Execution,
-                    I18n.t("treaty.execution.executor_empty")
-            end
-
-            constant_name = normalize_constant_name(executor)
-
-            begin
-              constant_name.constantize
-            rescue NameError
-              raise Treaty::Exceptions::Execution,
-                    I18n.t("treaty.execution.executor_not_found", class_name: constant_name)
-            end
-          else
-            raise Treaty::Exceptions::Execution,
-                  I18n.t("treaty.execution.executor_invalid_type", type: executor.class)
-          end
-        end
-
-        ########################################################################
-
-        def normalize_constant_name(name)
-          string = name.to_s
-
-          return string if string.include?("::")
-          return string.split("/").map(&:camelize).join("::") if string.include?("/")
-
-          string
-        end
-
-        ########################################################################
-        ########################################################################
-        ########################################################################
-
-        # Creates inventory wrapper with lazy evaluation
-        #
-        # @return [Treaty::Executor::Inventory] Inventory wrapper with method-based access
-        def evaluated_inventory
-          @evaluated_inventory ||= Treaty::Executor::Inventory.new(@inventory, @context)
-        end
-
-        ########################################################################
-
-        def execute_proc
-          # For Proc executors, pass inventory if collection exists
-          executor.call(**build_call_params)
-        rescue StandardError => e
-          raise Treaty::Exceptions::Execution,
-                I18n.t("treaty.execution.proc_error", message: e.message)
-        end
-
-        def execute_servactory # rubocop:disable Metrics/MethodLength
-          # For Servactory services, pass inventory if collection exists
-          executor.call!(**build_call_params)
-        rescue Servactory::Exceptions::Input => e
-          raise Treaty::Exceptions::Execution,
-                I18n.t("treaty.execution.servactory_input_error", message: e.message)
-        rescue Servactory::Exceptions::Internal => e
-          raise Treaty::Exceptions::Execution,
-                I18n.t("treaty.execution.servactory_internal_error", message: e.message)
-        rescue Servactory::Exceptions::Output => e
-          raise Treaty::Exceptions::Execution,
-                I18n.t("treaty.execution.servactory_output_error", message: e.message)
-        rescue Servactory::Exceptions::Failure => e
-          raise Treaty::Exceptions::Execution,
-                I18n.t("treaty.execution.servactory_failure_error", message: e.message)
-        end
-
-        def execute_regular_class # rubocop:disable Metrics/MethodLength
-          method_name = @version_factory.executor.method
-
-          unless executor.respond_to?(method_name)
-            raise Treaty::Exceptions::Execution,
-                  I18n.t(
-                    "treaty.execution.method_not_found",
-                    method: method_name,
-                    class_name: executor
-                  )
-          end
-
-          # For regular classes, pass inventory if collection exists
-          executor.public_send(method_name, **build_call_params)
-        rescue StandardError => e
-          raise Treaty::Exceptions::Execution,
-                I18n.t("treaty.execution.regular_service_error", message: e.message)
-        end
-
-        ########################################################################
-        ########################################################################
-        ########################################################################
-
-        # Builds call parameters hash with inventory if it exists
-        #
-        # @return [Hash] Parameters hash with :params and optionally :inventory
-        def build_call_params
-          if @inventory&.exists?
-            { params: @validated_params, inventory: evaluated_inventory }
-          else
-            { params: @validated_params }
-          end
-        end
-
-        def raise_executor_missing_error!
-          raise Treaty::Exceptions::Execution,
-                I18n.t(
-                  "treaty.execution.executor_missing",
-                  version: @version_factory.version
-                )
-        end
-
-        def servactory_service?
-          executor.respond_to?(:servactory?) &&
-            executor.servactory?
-        end
-      end
-    end
-  end
-end

data/lib/treaty/versions/executor.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Versions
-    class Executor
-      attr_reader :executor, :method
-
-      def initialize(executor, method)
-        @executor = executor
-        @method = method
-      end
-    end
-  end
-end

data/lib/treaty/versions/factory.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Versions
-    class Factory
-      attr_reader :version,
-                  :default_result,
-                  :summary_text,
-                  :deprecated_result,
-                  :executor,
-                  :request_factory,
-                  :response_factory
-
-      def initialize(version:, default:)
-        @version = Semantic.new(version)
-        @default_result = default.is_a?(Proc) ? default.call : default
-        @summary_text = nil
-        @deprecated_result = false
-        @executor = nil
-
-        validate!
-      end
-
-      def validate!
-        validate_default_option!
-      end
-
-      def validate_after_block!
-        validate_default_deprecated_conflict!
-      end
-
-      def summary(text)
-        @summary_text = text
-      end
-
-      def deprecated(condition = nil)
-        result =
-          if condition.is_a?(Proc)
-            condition.call
-          elsif condition.is_a?(TrueClass) || condition.is_a?(FalseClass)
-            condition
-          else
-            yield
-          end
-
-        @deprecated_result = result
-      end
-
-      def request(entity_class = nil, &block)
-        @request_factory ||= Request::Factory.new
-
-        if entity_class.present?
-          @request_factory.use_entity(entity_class)
-        elsif block_given?
-          @request_factory.instance_eval(&block)
-        end
-      end
-
-      def response(status, entity_class = nil, &block)
-        @response_factory ||= Response::Factory.new(status)
-
-        if entity_class.present?
-          @response_factory.use_entity(entity_class)
-        elsif block_given?
-          @response_factory.instance_eval(&block)
-        end
-      end
-
-      def delegate_to(executor, method = :call)
-        @executor = Executor.new(executor, method)
-      end
-
-      ##########################################################################
-
-      private
-
-      def validate_default_option!
-        if @default_result.is_a?(TrueClass) || @default_result.is_a?(FalseClass) || @default_result.is_a?(Proc)
-          return @default_result
-        end
-
-        raise Treaty::Exceptions::Validation,
-              I18n.t(
-                "treaty.versioning.factory.invalid_default_option",
-                type: @default_result.class
-              )
-      end
-
-      def validate_default_deprecated_conflict!
-        return unless @default_result == true
-        return unless @deprecated_result == true
-
-        raise Treaty::Exceptions::VersionDefaultDeprecatedConflict,
-              I18n.t(
-                "treaty.versioning.factory.default_deprecated_conflict",
-                version: @version.version
-              )
-      end
-
-      ##########################################################################
-
-      def method_missing(name, *, &_block)
-        raise Treaty::Exceptions::MethodName,
-              I18n.t("treaty.versioning.factory.unknown_method", method: name)
-      end
-
-      def respond_to_missing?(name, *)
-        super
-      end
-    end
-  end
-end