Module: Grape::Validations::Types

Extended by:
ActiveSupport::Autoload
Defined in:
lib/grape/validations/types.rb,
lib/grape.rb,
lib/grape/validations/types/file.rb,
lib/grape/validations/types/json.rb,
lib/grape/validations/types/set_coercer.rb,
lib/grape/validations/types/array_coercer.rb,
lib/grape/validations/types/build_coercer.rb,
lib/grape/validations/types/invalid_value.rb,
lib/grape/validations/types/dry_type_coercer.rb,
lib/grape/validations/types/primitive_coercer.rb,
lib/grape/validations/types/custom_type_coercer.rb,
lib/grape/validations/types/multiple_type_coercer.rb,
lib/grape/validations/types/variant_collection_coercer.rb,
lib/grape/validations/types/custom_type_collection_coercer.rb

Overview

Module for code related to grape's system for coercion and type validation of incoming request parameters.

Grape uses a number of tests and assertions to work out exactly how a parameter should be handled, based on the +type+ and +coerce_with+ options that may be supplied to Dsl::Parameters#requires and Dsl::Parameters#optional. The main entry point for this process is Types.build_coercer.

Defined Under Namespace

Classes: ArrayCoercer, CustomTypeCoercer, CustomTypeCollectionCoercer, DryTypeCoercer, File, InvalidValue, Json, JsonArray, MultipleTypeCoercer, PrimitiveCoercer, SetCoercer, VariantCollectionCoercer

Constant Summary collapse

PRIMITIVES = 
[
  # Numerical
  Integer,
  Float,
  BigDecimal,
  Numeric,

  # Date/time
  Date,
  DateTime,
  Time,

  # Misc
  Grape::API::Boolean,
  String,
  Symbol,
  TrueClass,
  FalseClass
].freeze
STRUCTURES =

Types representing data structures.

[Hash, Array, Set].freeze
SPECIAL = 
{
  ::JSON => Json,
  Array[JSON] => JsonArray,
  ::File => File,
  Rack::Multipart::UploadedFile => File
}.freeze
GROUPS = 
[Array, Hash, JSON, Array[JSON]].freeze

Class Method Summary collapse

Class Method Details

.build_coercer(type, method: nil, strict: false) ⇒ Object

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.

Parameters:

  • type (Class) —

    the type to which input strings should be coerced

  • method (Class, #call) (defaults to: nil) —

    the coercion method to use

Returns:

  • (Object) —

    object to be used for coercion and type validation



160
161
162
163
164
 
# File 'lib/grape/validations/types.rb', line 160

def build_coercer(type, method: nil, strict: false)
  cache_instance(type, method, strict) do
    create_coercer_instance(type, method, strict)
  end
end

.cache_instance(type, method, strict, &_block) ⇒ Object 



190
191
192
193
194
195
196
197
198
199
200
201
202
 
# File 'lib/grape/validations/types.rb', line 190

def 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

.cache_key(type, method, strict) ⇒ Object 



204
205
206
207
208
209
210
 
# File 'lib/grape/validations/types.rb', line 204

def cache_key(type, method, strict)
  [type, method, strict].each_with_object(+'_') do |val, memo|
    next if val.nil?

    memo << '_' << val.to_s
  end
end

.collection_of_custom?(type) ⇒ Boolean

Is the declared type an +Array+ or +Set+ of a #custom? type?

Parameters:

  • type (Array<Class>, Class) —

    type to check

Returns:

  • (Boolean) —

    true if +type+ is a collection of a type that implements its own +#parse+ method.



122
123
124
125
126
 
# File 'lib/grape/validations/types.rb', line 122

def collection_of_custom?(type)
  (type.is_a?(Array) || type.is_a?(Set)) &&
    type.length == 1 &&
    (custom?(type.first) || special?(type.first))
end

.create_coercer_instance(type, method, strict) ⇒ Object 



166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/grape/validations/types.rb', line 166

def 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

.custom?(type) ⇒ Boolean

A valid custom type must implement a class-level parse method, taking one String argument and returning the parsed value in its correct type.

Parameters:

  • type (Class) —

    type to check

Returns:

  • (Boolean) —

    whether or not the type can be used as a custom type



109
110
111
112
113
114
115
 
# File 'lib/grape/validations/types.rb', line 109

def custom?(type)
  !primitive?(type) &&
    !structure?(type) &&
    !multiple?(type) &&
    type.respond_to?(:parse) &&
    type.method(:parse).arity == 1
end

.group?(type) ⇒ Boolean

Is the declared type a supported group type? Currently supported group types are Array, Hash, JSON, and Array[JSON]

Parameters:

  • type (Array<Class>, Class) —

    type to check

Returns:

  • (Boolean) —

    +true+ if the type is a supported group type



100
101
102
 
# File 'lib/grape/validations/types.rb', line 100

def group?(type)
  GROUPS.include? type
end

.map_special(type) ⇒ Object 



128
129
130
 
# File 'lib/grape/validations/types.rb', line 128

def map_special(type)
  SPECIAL.fetch(type, type)
end

.multiple?(type) ⇒ Boolean

Is the declared type in fact an array of multiple allowed types? For example the declaration +types: [Integer,String]+ will attempt first to coerce given values to integer, but will also accept any other string.

Parameters:

  • type (Array<Class>, Set<Class>) —

    type (or type list!) to check

Returns:

  • (Boolean) —

    +true+ if the given value will be treated as a list of types.



80
81
82
 
# File 'lib/grape/validations/types.rb', line 80

def multiple?(type)
  (type.is_a?(Array) || type.is_a?(Set)) && type.size > 1
end

.primitive?(type) ⇒ Boolean

Is the given class a primitive type as recognized by Grape?

Parameters:

  • type (Class) —

    type to check

Returns:

  • (Boolean) —

    whether or not the type is known by Grape as a valid type for a single value



58
59
60
 
# File 'lib/grape/validations/types.rb', line 58

def primitive?(type)
  PRIMITIVES.include?(type)
end

.special?(type) ⇒ Boolean

Does Grape provide special coercion and validation routines for the given class? This does not include automatic handling for primitives, structures and otherwise recognized types. See SPECIAL.

Parameters:

  • type (Class) —

    type to check

Returns:

  • (Boolean) —

    +true+ if special routines are available



91
92
93
 
# File 'lib/grape/validations/types.rb', line 91

def special?(type)
  SPECIAL.key? type
end

.structure?(type) ⇒ Boolean

Is the given class a standard data structure (collection or map) as recognized by Grape?

Parameters:

  • type (Class) —

    type to check

Returns:

  • (Boolean) —

    whether or not the type is known by Grape as a valid data structure type



68
69
70
 
# File 'lib/grape/validations/types.rb', line 68

def structure?(type)
  STRUCTURES.include?(type)
end