treaty 0.19.0 → 0.20.0

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

data/lib/treaty/versions/resolver.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Versions
-    class Resolver
-      def self.resolve!(...)
-        new(...).resolve!
-      end
-
-      def initialize(specified_version:, collection_of_versions:)
-        @specified_version = specified_version
-        @collection_of_versions = collection_of_versions
-      end
-
-      def resolve!
-        determined_factory =
-          if specified_version_blank?
-            default_version_factory || raise_specified_version_not_found!
-          else
-            version_factory || raise_version_not_found!
-          end
-
-        raise_version_deprecated! if determined_factory.deprecated_result
-
-        determined_factory
-      end
-
-      private
-
-      def version_factory
-        @version_factory ||=
-          @collection_of_versions.find do |factory|
-            factory.version.version == @specified_version
-          end
-      end
-
-      def default_version_factory
-        @default_version_factory ||=
-          @collection_of_versions.find(&:default_result)
-      end
-
-      def specified_version_blank?
-        @specified_version.to_s.strip.empty?
-      end
-
-      ##########################################################################
-
-      def raise_specified_version_not_found!
-        raise Treaty::Exceptions::SpecifiedVersionNotFound,
-              I18n.t("treaty.versioning.resolver.specified_version_required")
-      end
-
-      def raise_version_not_found!
-        raise Treaty::Exceptions::VersionNotFound,
-              I18n.t(
-                "treaty.versioning.resolver.version_not_found",
-                version: @specified_version
-              )
-      end
-
-      def raise_version_deprecated!
-        raise Treaty::Exceptions::Deprecated,
-              I18n.t(
-                "treaty.versioning.resolver.version_deprecated",
-                version: @specified_version
-              )
-      end
-    end
-  end
-end

data/lib/treaty/versions/semantic.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Versions
-    class Semantic
-      attr_reader :version
-
-      def initialize(version)
-        version =
-          if version.is_a?(Array)
-            version.join(".")
-          # elsif version.is_a?(Integer)
-          #   version.to_s
-          else
-            version # rubocop:disable Style/RedundantSelfAssignmentBranch
-          end
-
-        @version = Gem::Version.new(version)
-      end
-    end
-  end
-end

data/lib/treaty/versions/workspace.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Versions
-    module Workspace
-      private
-
-      def call!(context:, inventory:, version:, params:, **) # rubocop:disable Metrics/MethodLength
-        super
-
-        version_factory = Resolver.resolve!(
-          specified_version: version,
-          collection_of_versions: @collection_of_versions
-        )
-
-        validated_params = Request::Validator.validate!(
-          params:,
-          version_factory:
-        )
-
-        executor_result = Execution::Request.execute!(
-          context:,
-          inventory:,
-          version_factory:,
-          validated_params:
-        )
-
-        validated_response = Response::Validator.validate!(
-          version_factory:,
-          response_data: executor_result
-        )
-
-        status = version_factory.response_factory&.status || 200
-
-        Treaty::Result.new(
-          data: validated_response,
-          status:,
-          version: version_factory.version.version
-        )
-      end
-    end
-  end
-end