grape 0.1.1 → 2.4.0

data/lib/grape/validations/types.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    # 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 {Grape::Dsl::Parameters#requires}
+    # and {Grape::Dsl::Parameters#optional}. The main
+    # entry point for this process is {Types.build_coercer}.
+    module Types
+      module_function
+
+      PRIMITIVES = [
+        # Numerical
+        Integer,
+        Float,
+        BigDecimal,
+        Numeric,
+
+        # Date/time
+        Date,
+        DateTime,
+        Time,
+
+        # Misc
+        Grape::API::Boolean,
+        String,
+        Symbol,
+        TrueClass,
+        FalseClass
+      ].freeze
+
+      # Types representing data structures.
+      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
+
+      # Is the given class a primitive type as recognized by Grape?
+      #
+      # @param type [Class] type to check
+      # @return [Boolean] whether or not the type is known by Grape as a valid
+      #   type for a single value
+      def primitive?(type)
+        PRIMITIVES.include?(type)
+      end
+
+      # Is the given class a standard data structure (collection or map)
+      # as recognized by Grape?
+      #
+      # @param type [Class] type to check
+      # @return [Boolean] whether or not the type is known by Grape as a valid
+      #   data structure type
+      def structure?(type)
+        STRUCTURES.include?(type)
+      end
+
+      # 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.
+      #
+      # @param type [Array<Class>,Set<Class>] type (or type list!) to check
+      # @return [Boolean] +true+ if the given value will be treated as
+      #   a list of types.
+      def multiple?(type)
+        (type.is_a?(Array) || type.is_a?(Set)) && type.size > 1
+      end
+
+      # 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 {Types::SPECIAL}.
+      #
+      # @param type [Class] type to check
+      # @return [Boolean] +true+ if special routines are available
+      def special?(type)
+        SPECIAL.key? type
+      end
+
+      # Is the declared type a supported group type?
+      # Currently supported group types are Array, Hash, JSON, and Array[JSON]
+      #
+      # @param type [Array<Class>,Class] type to check
+      # @return [Boolean] +true+ if the type is a supported group type
+      def group?(type)
+        GROUPS.include? type
+      end
+
+      # A valid custom type must implement a class-level `parse` method, taking
+      # one String argument and returning the parsed value in its correct type.
+      #
+      # @param type [Class] type to check
+      # @return [Boolean] whether or not the type can be used as a custom type
+      def custom?(type)
+        !primitive?(type) &&
+          !structure?(type) &&
+          !multiple?(type) &&
+          type.respond_to?(:parse) &&
+          type.method(:parse).arity == 1
+      end
+
+      # Is the declared type an +Array+ or +Set+ of a {#custom?} type?
+      #
+      # @param type [Array<Class>,Class] type to check
+      # @return [Boolean] true if +type+ is a collection of a type that implements
+      #   its own +#parse+ method.
+      def collection_of_custom?(type)
+        (type.is_a?(Array) || type.is_a?(Set)) &&
+          type.length == 1 &&
+          (custom?(type.first) || special?(type.first))
+      end
+
+      def 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 build_coercer(type, method: nil, strict: false)
+        cache_instance(type, method, strict) do
+          create_coercer_instance(type, method, strict)
+        end
+      end
+
+      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
+
+      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
+
+      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
+
+      instance_variable_set(:@__cache,            {})
+      instance_variable_set(:@__cache_write_lock, Mutex.new)
+    end
+  end
+end

data/lib/grape/validations/validator_factory.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    class ValidatorFactory
+      def self.create_validator(options)
+        options[:validator_class].new(options[:attributes],
+                                      options[:options],
+                                      options[:required],
+                                      options[:params_scope],
+                                      options[:opts])
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/all_or_none_of_validator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class AllOrNoneOfValidator < MultipleParamsBase
+        def validate_params!(params)
+          keys = keys_in_common(params)
+          return if keys.empty? || keys.length == all_keys.length
+
+          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:all_or_none))
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/allow_blank_validator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class AllowBlankValidator < Base
+        def validate_param!(attr_name, params)
+          return if (options_key?(:value) ? @option[:value] : @option) || !params.is_a?(Hash)
+
+          value = params[attr_name]
+          value = value.scrub if value.respond_to?(:scrub)
+
+          return if value == false || value.present?
+
+          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:blank))
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/as_validator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class AsValidator < Base
+        # We use a validator for renaming parameters. This is just a marker for
+        # the parameter scope to handle the renaming. No actual validation
+        # happens here.
+        def validate_param!(*); end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/at_least_one_of_validator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class AtLeastOneOfValidator < MultipleParamsBase
+        def validate_params!(params)
+          return unless keys_in_common(params).empty?
+
+          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:at_least_one))
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/base.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class Base
+        attr_reader :attrs
+
+        # Creates a new Validator from options specified
+        # by a +requires+ or +optional+ directive during
+        # parameter definition.
+        # @param attrs [Array] names of attributes to which the Validator applies
+        # @param options [Object] implementation-dependent Validator options
+        # @param required [Boolean] attribute(s) are required or optional
+        # @param scope [ParamsScope] parent scope for this Validator
+        # @param opts [Hash] additional validation options
+        def initialize(attrs, options, required, scope, opts)
+          @attrs = Array(attrs)
+          @option = options
+          @required = required
+          @scope = scope
+          @fail_fast = opts[:fail_fast]
+          @allow_blank = opts[:allow_blank]
+        end
+
+        # Validates a given request.
+        # @note Override #validate! unless you need to access the entire request.
+        # @param request [Grape::Request] the request currently being handled
+        # @raise [Grape::Exceptions::Validation] if validation failed
+        # @return [void]
+        def validate(request)
+          return unless @scope.should_validate?(request.params)
+
+          validate!(request.params)
+        end
+
+        # Validates a given parameter hash.
+        # @note Override #validate if you need to access the entire request.
+        # @param params [Hash] parameters to validate
+        # @raise [Grape::Exceptions::Validation] if validation failed
+        # @return [void]
+        def validate!(params)
+          attributes = SingleAttributeIterator.new(self, @scope, params)
+          # we collect errors inside array because
+          # there may be more than one error per field
+          array_errors = []
+
+          attributes.each do |val, attr_name, empty_val|
+            next if !@scope.required? && empty_val
+            next unless @scope.meets_dependency?(val, params)
+
+            validate_param!(attr_name, val) if @required || val.try(:key?, attr_name)
+          rescue Grape::Exceptions::Validation => e
+            array_errors << e
+          end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
+        end
+
+        def self.inherited(klass)
+          super
+          Validations.register(klass)
+        end
+
+        def message(default_key = nil)
+          options = instance_variable_get(:@option)
+          options_key?(:message) ? options[:message] : default_key
+        end
+
+        def options_key?(key, options = nil)
+          options = instance_variable_get(:@option) if options.nil?
+          options.try(:key?, key) && !options[key].nil?
+        end
+
+        def fail_fast?
+          @fail_fast
+        end
+      end
+    end
+  end
+end
+
+Grape::Validations::Base = Class.new(Grape::Validations::Validators::Base) do
+  def self.inherited(*)
+    Grape.deprecator.warn 'Grape::Validations::Base is deprecated! Use Grape::Validations::Validators::Base instead.'
+    super
+  end
+end

data/lib/grape/validations/validators/coerce_validator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class CoerceValidator < Base
+        def initialize(attrs, options, required, scope, opts)
+          super
+
+          @converter = if type.is_a?(Grape::Validations::Types::VariantCollectionCoercer)
+                         type
+                       else
+                         Types.build_coercer(type, method: @option[:method])
+                       end
+        end
+
+        def validate_param!(attr_name, params)
+          raise validation_exception(attr_name) unless params.is_a? Hash
+
+          new_value = coerce_value(params[attr_name])
+
+          raise validation_exception(attr_name, new_value.message) unless valid_type?(new_value)
+
+          # Don't assign a value if it is identical. It fixes a problem with Hashie::Mash
+          # which looses wrappers for hashes and arrays after reassigning values
+          #
+          #     h = Hashie::Mash.new(list: [1, 2, 3, 4])
+          #     => #<Hashie::Mash list=#<Hashie::Array [1, 2, 3, 4]>>
+          #     list = h.list
+          #     h[:list] = list
+          #     h
+          #     => #<Hashie::Mash list=[1, 2, 3, 4]>
+          return if params[attr_name].instance_of?(new_value.class) && params[attr_name] == new_value
+
+          params[attr_name] = new_value
+        end
+
+        private
+
+        # @!attribute [r] converter
+        # Object that will be used for parameter coercion and type checking.
+        #
+        # See {Types.build_coercer}
+        #
+        # @return [Object]
+        attr_reader :converter
+
+        def valid_type?(val)
+          !val.is_a?(Types::InvalidValue)
+        end
+
+        def coerce_value(val)
+          converter.call(val)
+          # Some custom types might fail, so it should be treated as an invalid value
+        rescue StandardError
+          Types::InvalidValue.new
+        end
+
+        # Type to which the parameter will be coerced.
+        #
+        # @return [Class]
+        def type
+          @option[:type].is_a?(Hash) ? @option[:type][:value] : @option[:type]
+        end
+
+        def validation_exception(attr_name, custom_msg = nil)
+          Grape::Exceptions::Validation.new(
+            params: [@scope.full_name(attr_name)],
+            message: custom_msg || message(:coerce)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/contract_scope_validator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class ContractScopeValidator < Base
+        attr_reader :schema
+
+        def initialize(_attrs, _options, _required, _scope, opts)
+          super
+          @schema = opts.fetch(:schema)
+        end
+
+        # Validates a given request.
+        # @param request [Grape::Request] the request currently being handled
+        # @raise [Grape::Exceptions::ValidationArrayErrors] if validation failed
+        # @return [void]
+        def validate(request)
+          res = schema.call(request.params)
+
+          if res.success?
+            request.params.deep_merge!(res.to_h)
+            return
+          end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(build_errors_from_messages(res.errors.messages))
+        end
+
+        private
+
+        def build_errors_from_messages(messages)
+          messages.map do |message|
+            full_name = message.path.first.to_s
+            full_name << "[#{message.path[1..].join('][')}]" if message.path.size > 1
+            Grape::Exceptions::Validation.new(params: [full_name], message: message.text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/default_validator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class DefaultValidator < Base
+        def initialize(attrs, options, required, scope, opts = {})
+          @default = options
+          super
+        end
+
+        def validate_param!(attr_name, params)
+          params[attr_name] = if @default.is_a? Proc
+                                if @default.parameters.empty?
+                                  @default.call
+                                else
+                                  @default.call(params)
+                                end
+                              elsif @default.frozen? || !@default.duplicable?
+                                @default
+                              else
+                                @default.dup
+                              end
+        end
+
+        def validate!(params)
+          attrs = SingleAttributeIterator.new(self, @scope, params)
+          attrs.each do |resource_params, attr_name|
+            next unless @scope.meets_dependency?(resource_params, params)
+
+            validate_param!(attr_name, resource_params) if resource_params.is_a?(Hash) && resource_params[attr_name].nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/exactly_one_of_validator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class ExactlyOneOfValidator < MultipleParamsBase
+        def validate_params!(params)
+          keys = keys_in_common(params)
+          return if keys.length == 1
+          raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:exactly_one)) if keys.empty?
+
+          raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/except_values_validator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class ExceptValuesValidator < Base
+        def initialize(attrs, options, required, scope, opts)
+          @except = options.is_a?(Hash) ? options[:value] : options
+          super
+        end
+
+        def validate_param!(attr_name, params)
+          return unless params.try(:key?, attr_name)
+
+          excepts = @except.is_a?(Proc) ? @except.call : @except
+          return if excepts.nil?
+
+          param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
+          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:except_values)) if param_array.any? { |param| excepts.include?(param) }
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/length_validator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class LengthValidator < Base
+        def initialize(attrs, options, required, scope, opts)
+          @min = options[:min]
+          @max = options[:max]
+          @is = options[:is]
+
+          super
+
+          raise ArgumentError, 'min must be an integer greater than or equal to zero' if !@min.nil? && (!@min.is_a?(Integer) || @min.negative?)
+          raise ArgumentError, 'max must be an integer greater than or equal to zero' if !@max.nil? && (!@max.is_a?(Integer) || @max.negative?)
+          raise ArgumentError, "min #{@min} cannot be greater than max #{@max}" if !@min.nil? && !@max.nil? && @min > @max
+
+          return if @is.nil?
+          raise ArgumentError, 'is must be an integer greater than zero' if !@is.is_a?(Integer) || !@is.positive?
+          raise ArgumentError, 'is cannot be combined with min or max' if !@min.nil? || !@max.nil?
+        end
+
+        def validate_param!(attr_name, params)
+          param = params[attr_name]
+
+          return unless param.respond_to?(:length)
+
+          return unless (!@min.nil? && param.length < @min) || (!@max.nil? && param.length > @max) || (!@is.nil? && param.length != @is)
+
+          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: build_message)
+        end
+
+        def build_message
+          if options_key?(:message)
+            @option[:message]
+          elsif @min && @max
+            format I18n.t(:length, scope: 'grape.errors.messages'), min: @min, max: @max
+          elsif @min
+            format I18n.t(:length_min, scope: 'grape.errors.messages'), min: @min
+          elsif @max
+            format I18n.t(:length_max, scope: 'grape.errors.messages'), max: @max
+          else
+            format I18n.t(:length_is, scope: 'grape.errors.messages'), is: @is
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/multiple_params_base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class MultipleParamsBase < Base
+        def validate!(params)
+          attributes = MultipleAttributesIterator.new(self, @scope, params)
+          array_errors = []
+
+          attributes.each do |resource_params|
+            validate_params!(resource_params)
+          rescue Grape::Exceptions::Validation => e
+            array_errors << e
+          end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
+        end
+
+        private
+
+        def keys_in_common(resource_params)
+          return [] unless resource_params.is_a?(Hash)
+
+          all_keys & resource_params.keys.map! { |attr| @scope.full_name(attr) }
+        end
+
+        def all_keys
+          attrs.map { |attr| @scope.full_name(attr) }
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/validators/mutual_exclusion_validator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class MutualExclusionValidator < MultipleParamsBase
+        def validate_params!(params)
+          keys = keys_in_common(params)
+          return if keys.length <= 1
+
+          raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
+        end
+      end
+    end
+  end
+end