Revert "Autoload Types (ruby-grape#2209)"

dm1try · dm1try · commit 1c425e6e62b7 · 2021-12-30T20:24:56.000+03:00
This reverts commit 224402f.
diff --git a/lib/grape.rb b/lib/grape.rb
@@ -45,7 +45,6 @@ module Grape
     autoload :Env, 'grape/util/env'
     autoload :Json, 'grape/util/json'
     autoload :Xml, 'grape/util/xml'
-    autoload :DryTypes
   end
 
   module Http
@@ -223,24 +222,6 @@ module ServeStream
   module Validations
     extend ::ActiveSupport::Autoload
 
-    module Types
-      extend ::ActiveSupport::Autoload
-
-      eager_autoload do
-        autoload :InvalidValue
-        autoload :File
-        autoload :Json
-        autoload :DryTypeCoercer
-        autoload :ArrayCoercer
-        autoload :SetCoercer
-        autoload :PrimitiveCoercer
-        autoload :CustomTypeCoercer
-        autoload :CustomTypeCollectionCoercer
-        autoload :MultipleTypeCoercer
-        autoload :VariantCollectionCoercer
-      end
-    end
-
     eager_autoload do
       autoload :AttributesIterator
       autoload :MultipleAttributesIterator
diff --git a/lib/grape/dry_types.rb b/lib/grape/dry_types.rb
diff --git a/lib/grape/validations/types.rb b/lib/grape/validations/types.rb
@@ -1,5 +1,14 @@
 # frozen_string_literal: true
 
+require_relative 'types/build_coercer'
+require_relative 'types/custom_type_coercer'
+require_relative 'types/custom_type_collection_coercer'
+require_relative 'types/multiple_type_coercer'
+require_relative 'types/variant_collection_coercer'
+require_relative 'types/json'
+require_relative 'types/file'
+require_relative 'types/invalid_value'
+
 module Grape
   module Validations
     # Module for code related to grape's system for
@@ -134,89 +143,6 @@ def self.collection_of_custom?(type)
       def self.map_special(type)
         SPECIAL.fetch(type, type)
       end
-
-      # Chooses the best coercer for the given type. For example, if the type
-      # is Integer, it will return a coercer which will be able to coerce a value
-      # to the integer.
-      #
-      # There are a few very special coercers which might be returned.
-      #
-      # +Grape::Types::MultipleTypeCoercer+ is a coercer which is returned when
-      # the given type implies values in an array with different types.
-      # For example, +[Integer, String]+ allows integer and string values in
-      # an array.
-      #
-      # +Grape::Types::CustomTypeCoercer+ is a coercer which is returned when
-      # a method is specified by a user with +coerce_with+ option or the user
-      # specifies a custom type which implements requirments of
-      # +Grape::Types::CustomTypeCoercer+.
-      #
-      # +Grape::Types::CustomTypeCollectionCoercer+ is a very similar to the
-      # previous one, but it expects an array or set of values having a custom
-      # type implemented by the user.
-      #
-      # There is also a group of custom types implemented by Grape, check
-      # +Grape::Validations::Types::SPECIAL+ to get the full list.
-      #
-      # @param type [Class] the type to which input strings
-      #   should be coerced
-      # @param method [Class,#call] the coercion method to use
-      # @return [Object] object to be used
-      #   for coercion and type validation
-      def self.build_coercer(type, method: nil, strict: false)
-        cache_instance(type, method, strict) do
-          create_coercer_instance(type, method, strict)
-        end
-      end
-
-      def self.create_coercer_instance(type, method, strict)
-        # Maps a custom type provided by Grape, it doesn't map types wrapped by collections!!!
-        type = Types.map_special(type)
-
-        # Use a special coercer for multiply-typed parameters.
-        if Types.multiple?(type)
-          MultipleTypeCoercer.new(type, method)
-
-          # Use a special coercer for custom types and coercion methods.
-        elsif method || Types.custom?(type)
-          CustomTypeCoercer.new(type, method)
-
-          # Special coercer for collections of types that implement a parse method.
-          # CustomTypeCoercer (above) already handles such types when an explicit coercion
-          # method is supplied.
-        elsif Types.collection_of_custom?(type)
-          Types::CustomTypeCollectionCoercer.new(
-            Types.map_special(type.first), type.is_a?(Set)
-          )
-        else
-          DryTypeCoercer.coercer_instance_for(type, strict)
-        end
-      end
-
-      def self.cache_instance(type, method, strict, &_block)
-        key = cache_key(type, method, strict)
-
-        return @__cache[key] if @__cache.key?(key)
-
-        instance = yield
-
-        @__cache_write_lock.synchronize do
-          @__cache[key] = instance
-        end
-
-        instance
-      end
-
-      def self.cache_key(type, method, strict)
-        [type, method, strict].each_with_object(+'_') do |val, memo|
-          next if val.nil?
-
-          memo << '_' << val.to_s
-        end
-      end
-
-      instance_variable_set(:@__cache,            {})
-      instance_variable_set(:@__cache_write_lock, Mutex.new)
     end
   end
 end
diff --git a/lib/grape/validations/types/array_coercer.rb b/lib/grape/validations/types/array_coercer.rb
@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'dry_type_coercer'
+
 module Grape
   module Validations
     module Types
diff --git a/lib/grape/validations/types/build_coercer.rb b/lib/grape/validations/types/build_coercer.rb
@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'array_coercer'
+require_relative 'set_coercer'
+require_relative 'primitive_coercer'
+
+module Grape
+  module Validations
+    module Types
+      # Chooses the best coercer for the given type. For example, if the type
+      # is Integer, it will return a coercer which will be able to coerce a value
+      # to the integer.
+      #
+      # There are a few very special coercers which might be returned.
+      #
+      # +Grape::Types::MultipleTypeCoercer+ is a coercer which is returned when
+      # the given type implies values in an array with different types.
+      # For example, +[Integer, String]+ allows integer and string values in
+      # an array.
+      #
+      # +Grape::Types::CustomTypeCoercer+ is a coercer which is returned when
+      # a method is specified by a user with +coerce_with+ option or the user
+      # specifies a custom type which implements requirments of
+      # +Grape::Types::CustomTypeCoercer+.
+      #
+      # +Grape::Types::CustomTypeCollectionCoercer+ is a very similar to the
+      # previous one, but it expects an array or set of values having a custom
+      # type implemented by the user.
+      #
+      # There is also a group of custom types implemented by Grape, check
+      # +Grape::Validations::Types::SPECIAL+ to get the full list.
+      #
+      # @param type [Class] the type to which input strings
+      #   should be coerced
+      # @param method [Class,#call] the coercion method to use
+      # @return [Object] object to be used
+      #   for coercion and type validation
+      def self.build_coercer(type, method: nil, strict: false)
+        cache_instance(type, method, strict) do
+          create_coercer_instance(type, method, strict)
+        end
+      end
+
+      def self.create_coercer_instance(type, method, strict)
+        # Maps a custom type provided by Grape, it doesn't map types wrapped by collections!!!
+        type = Types.map_special(type)
+
+        # Use a special coercer for multiply-typed parameters.
+        if Types.multiple?(type)
+          MultipleTypeCoercer.new(type, method)
+
+        # Use a special coercer for custom types and coercion methods.
+        elsif method || Types.custom?(type)
+          CustomTypeCoercer.new(type, method)
+
+        # Special coercer for collections of types that implement a parse method.
+        # CustomTypeCoercer (above) already handles such types when an explicit coercion
+        # method is supplied.
+        elsif Types.collection_of_custom?(type)
+          Types::CustomTypeCollectionCoercer.new(
+            Types.map_special(type.first), type.is_a?(Set)
+          )
+        else
+          DryTypeCoercer.coercer_instance_for(type, strict)
+        end
+      end
+
+      def self.cache_instance(type, method, strict, &_block)
+        key = cache_key(type, method, strict)
+
+        return @__cache[key] if @__cache.key?(key)
+
+        instance = yield
+
+        @__cache_write_lock.synchronize do
+          @__cache[key] = instance
+        end
+
+        instance
+      end
+
+      def self.cache_key(type, method, strict)
+        [type, method, strict].each_with_object(+'_') do |val, memo|
+          next if val.nil?
+
+          memo << '_' << val.to_s
+        end
+      end
+
+      instance_variable_set(:@__cache,            {})
+      instance_variable_set(:@__cache_write_lock, Mutex.new)
+    end
+  end
+end
diff --git a/lib/grape/validations/types/dry_type_coercer.rb b/lib/grape/validations/types/dry_type_coercer.rb
@@ -1,5 +1,14 @@
 # frozen_string_literal: true
 
+require 'dry-types'
+
+module DryTypes
+  # Call +Dry.Types()+ to add all registered types to +DryTypes+ which is
+  # a container in this case. Check documentation for more information
+  # https://dry-rb.org/gems/dry-types/1.2/getting-started/
+  include Dry.Types()
+end
+
 module Grape
   module Validations
     module Types
@@ -43,7 +52,7 @@ def collection_coercers
         def initialize(type, strict = false)
           @type = type
           @strict = strict
-          @scope = strict ? Grape::DryTypes::Strict : Grape::DryTypes::Params
+          @scope = strict ? DryTypes::Strict : DryTypes::Params
         end
 
         # Coerces the given value to a type which was specified during
diff --git a/lib/grape/validations/types/primitive_coercer.rb b/lib/grape/validations/types/primitive_coercer.rb
@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'dry_type_coercer'
+
 module Grape
   module Validations
     module Types
@@ -8,16 +10,16 @@ module Types
       # that it has the proper type.
       class PrimitiveCoercer < DryTypeCoercer
         MAPPING = {
-          Grape::API::Boolean => Grape::DryTypes::Params::Bool,
-          BigDecimal => Grape::DryTypes::Params::Decimal,
+          Grape::API::Boolean => DryTypes::Params::Bool,
+          BigDecimal => DryTypes::Params::Decimal,
 
           # unfortunately, a +Params+ scope doesn't contain String
-          String => Grape::DryTypes::Coercible::String
+          String => DryTypes::Coercible::String
         }.freeze
 
         STRICT_MAPPING = {
-          Grape::API::Boolean => Grape::DryTypes::Strict::Bool,
-          BigDecimal => Grape::DryTypes::Strict::Decimal
+          Grape::API::Boolean => DryTypes::Strict::Bool,
+          BigDecimal => DryTypes::Strict::Decimal
         }.freeze
 
         def initialize(type, strict = false)
diff --git a/lib/grape/validations/types/set_coercer.rb b/lib/grape/validations/types/set_coercer.rb
@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'set'
+require_relative 'array_coercer'
+
 module Grape
   module Validations
     module Types
