Autoload Types (#2209)

Author: ericproulx

CHANGELOG.md

@@ -15,6 +15,7 @@
 * [#2202](https://github.com/ruby-grape/grape/pull/2202): Fix random mock spec error - [@ericproulx](https://github.com/ericproulx).
 * [#2203](https://github.com/ruby-grape/grape/pull/2203): Add rubocop-rspec - [@ericproulx](https://github.com/ericproulx).
 * [#2207](https://github.com/ruby-grape/grape/pull/2207): Autoload Validations/Validators - [@ericproulx](https://github.com/ericproulx).
+* [#2209](https://github.com/ruby-grape/grape/pull/2209): Autoload Validations/Types - [@ericproulx](https://github.com/ericproulx).
 * Your contribution here.
 
 ### 1.6.0 (2021/10/04)

lib/grape.rb

@@ -45,6 +45,7 @@ module Grape
     autoload :Env, 'grape/util/env'
     autoload :Json, 'grape/util/json'
     autoload :Xml, 'grape/util/xml'
+    autoload :DryTypes
   end
 
   module Http
@@ -222,6 +223,24 @@ 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

lib/grape/dry_types.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'dry-types'
+
+module Grape
+  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
+end

lib/grape/validations/types.rb

@@ -1,14 +1,5 @@
 # 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
@@ -143,6 +134,89 @@ 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

lib/grape/validations/types/array_coercer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'dry_type_coercer'
-
 module Grape
   module Validations
     module Types

lib/grape/validations/types/build_coercer.rb

@@ -1,14 +1,5 @@
 # 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
@@ -52,7 +43,7 @@ def collection_coercers
         def initialize(type, strict = false)
           @type = type
           @strict = strict
-          @scope = strict ? DryTypes::Strict : DryTypes::Params
+          @scope = strict ? Grape::DryTypes::Strict : Grape::DryTypes::Params
         end
 
         # Coerces the given value to a type which was specified during

lib/grape/validations/types/dry_type_coercer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'dry_type_coercer'
-
 module Grape
   module Validations
     module Types
@@ -10,16 +8,16 @@ module Types
       # that it has the proper type.
       class PrimitiveCoercer < DryTypeCoercer
         MAPPING = {
-          Grape::API::Boolean => DryTypes::Params::Bool,
-          BigDecimal => DryTypes::Params::Decimal,
+          Grape::API::Boolean => Grape::DryTypes::Params::Bool,
+          BigDecimal => Grape::DryTypes::Params::Decimal,
 
           # unfortunately, a +Params+ scope doesn't contain String
-          String => DryTypes::Coercible::String
+          String => Grape::DryTypes::Coercible::String
         }.freeze
 
         STRICT_MAPPING = {
-          Grape::API::Boolean => DryTypes::Strict::Bool,
-          BigDecimal => DryTypes::Strict::Decimal
+          Grape::API::Boolean => Grape::DryTypes::Strict::Bool,
+          BigDecimal => Grape::DryTypes::Strict::Decimal
         }.freeze
 
         def initialize(type, strict = false)

lib/grape/validations/types/primitive_coercer.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-require_relative 'array_coercer'
-
 module Grape
   module Validations
     module Types