grape 1.5.2 → 1.7.0

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

@@ -2,32 +2,36 @@
 
 module Grape
   module Validations
-    class MultipleParamsBase < Base
-      def validate!(params)
-        attributes = MultipleAttributesIterator.new(self, @scope, params)
-        array_errors = []
-
-        attributes.each do |resource_params, skip_value|
-          next if skip_value
-          begin
-            validate_params!(resource_params)
-          rescue Grape::Exceptions::Validation => e
-            array_errors << e
+    module Validators
+      class MultipleParamsBase < Base
+        def validate!(params)
+          attributes = MultipleAttributesIterator.new(self, @scope, params)
+          array_errors = []
+
+          attributes.each do |resource_params, skip_value|
+            next if skip_value
+
+            begin
+              validate_params!(resource_params)
+            rescue Grape::Exceptions::Validation => e
+              array_errors << e
+            end
           end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(array_errors) if array_errors.any?
         end
 
-        raise Grape::Exceptions::ValidationArrayErrors, array_errors if array_errors.any?
-      end
+        private
 
-      private
+        def keys_in_common(resource_params)
+          return [] unless resource_params.is_a?(Hash)
 
-      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
+          all_keys & resource_params.keys.map! { |attr| @scope.full_name(attr) }
+        end
 
-      def all_keys
-        attrs.map { |attr| @scope.full_name(attr) }
+        def all_keys
+          attrs.map { |attr| @scope.full_name(attr) }
+        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

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class PresenceValidator < Base
+        def validate_param!(attr_name, params)
+          return if params.respond_to?(:key?) && params.key?(attr_name)
+
+          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:presence))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class RegexpValidator < Base
+        def validate_param!(attr_name, params)
+          return unless params.respond_to?(:key?) && params.key?(attr_name)
+          return if Array.wrap(params[attr_name]).all? { |param| param.nil? || param.to_s.match?((options_key?(:value) ? @option[:value] : @option)) }
+
+          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message(:regexp))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class SameAsValidator < Base
+        def validate_param!(attr_name, params)
+          confirmation = options_key?(:value) ? @option[:value] : @option
+          return if params[attr_name] == params[confirmation]
+
+          raise Grape::Exceptions::Validation.new(
+            params: [@scope.full_name(attr_name)],
+            message: build_message
+          )
+        end
+
+        private
+
+        def build_message
+          if options_key?(:message)
+            @option[:message]
+          else
+            format I18n.t(:same_as, scope: 'grape.errors.messages'), parameter: @option
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    module Validators
+      class ValuesValidator < Base
+        def initialize(attrs, options, required, scope, **opts)
+          if options.is_a?(Hash)
+            @excepts = options[:except]
+            @values = options[:value]
+            @proc = options[:proc]
+
+            warn '[DEPRECATION] The values validator except option is deprecated. ' \
+                 'Use the except validator instead.' if @excepts
+
+            raise ArgumentError, 'proc must be a Proc' if @proc && !@proc.is_a?(Proc)
+
+            warn '[DEPRECATION] The values validator proc option is deprecated. ' \
+                 'The lambda expression can now be assigned directly to values.' if @proc
+          else
+            @excepts = nil
+            @values = nil
+            @proc = nil
+            @values = options
+          end
+          super
+        end
+
+        def validate_param!(attr_name, params)
+          return unless params.is_a?(Hash)
+
+          val = params[attr_name]
+
+          return if val.nil? && !required_for_root_scope?
+
+          # don't forget that +false.blank?+ is true
+          return if val != false && val.blank? && @allow_blank
+
+          param_array = val.nil? ? [nil] : Array.wrap(val)
+
+          raise validation_exception(attr_name, except_message) \
+          unless check_excepts(param_array)
+
+          raise validation_exception(attr_name, message(:values)) \
+          unless check_values(param_array, attr_name)
+
+          raise validation_exception(attr_name, message(:values)) \
+          if @proc && !param_array.all? { |param| @proc.call(param) }
+        end
+
+        private
+
+        def check_values(param_array, attr_name)
+          values = @values.is_a?(Proc) && @values.arity.zero? ? @values.call : @values
+          return true if values.nil?
+
+          begin
+            return param_array.all? { |param| values.call(param) } if values.is_a? Proc
+          rescue StandardError => e
+            warn "Error '#{e}' raised while validating attribute '#{attr_name}'"
+            return false
+          end
+          param_array.all? { |param| values.include?(param) }
+        end
+
+        def check_excepts(param_array)
+          excepts = @excepts.is_a?(Proc) ? @excepts.call : @excepts
+          return true if excepts.nil?
+
+          param_array.none? { |param| excepts.include?(param) }
+        end
+
+        def except_message
+          options = instance_variable_get(:@option)
+          options_key?(:except_message) ? options[:except_message] : message(:except_values)
+        end
+
+        def required_for_root_scope?
+          @required && @scope.root?
+        end
+
+        def validation_exception(attr_name, message)
+          Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message)
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations.rb

@@ -3,22 +3,32 @@
 module Grape
   # Registry to store and locate known Validators.
   module Validations
-    class << self
-      attr_accessor :validators
-    end
+    module_function
 
-    self.validators = {}
+    def validators
+      @validators ||= {}
+    end
 
     # Register a new validator, so it can be used to validate parameters.
     # @param short_name [String] all lower-case, no spaces
     # @param klass [Class] the validator class. Should inherit from
     #   Validations::Base.
-    def self.register_validator(short_name, klass)
+    def register_validator(short_name, klass)
       validators[short_name] = klass
     end
 
-    def self.deregister_validator(short_name)
+    def deregister_validator(short_name)
       validators.delete(short_name)
     end
+
+    # Find a validator and if not found will try to load it
+    def require_validator(short_name)
+      str_name = short_name.to_s
+      validators.fetch(str_name) do
+        Grape::Validations::Validators.const_get("#{str_name.camelize}Validator")
+      end
+    rescue NameError
+      raise Grape::Exceptions::UnknownValidator.new(short_name)
+    end
   end
 end

data/lib/grape/version.rb

@@ -2,5 +2,5 @@
 
 module Grape
   # The current version of Grape.
-  VERSION = '1.5.2'
+  VERSION = '1.7.0'
 end

data/lib/grape.rb

@@ -7,22 +7,27 @@ require 'rack/accept'
 require 'rack/auth/basic'
 require 'rack/auth/digest/md5'
 require 'set'
+require 'bigdecimal'
+require 'date'
+require 'active_support'
+require 'active_support/concern'
 require 'active_support/version'
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/object/blank'
+require 'active_support/isolated_execution_state' if ActiveSupport::VERSION::MAJOR > 6
+require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/array/conversions'
+require 'active_support/core_ext/hash/conversions'
 require 'active_support/core_ext/hash/deep_merge'
-require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/core_ext/hash/slice'
-require 'active_support/core_ext/hash/conversions'
+require 'active_support/core_ext/object/blank'
 require 'active_support/dependencies/autoload'
 require 'active_support/notifications'
 require 'i18n'
 
-I18n.load_path << File.expand_path('../grape/locale/en.yml', __FILE__)
+I18n.load_path << File.expand_path('grape/locale/en.yml', __dir__)
 
 module Grape
   extend ::ActiveSupport::Autoload
@@ -43,6 +48,7 @@ module Grape
     autoload :Env, 'grape/util/env'
     autoload :Json, 'grape/util/json'
     autoload :Xml, 'grape/util/xml'
+    autoload :DryTypes
   end
 
   module Http
@@ -69,13 +75,17 @@ module Grape
       autoload :UnknownParameter
       autoload :InvalidWithOptionForRepresent
       autoload :IncompatibleOptionValues
-      autoload :MissingGroupTypeError,          'grape/exceptions/missing_group_type'
-      autoload :UnsupportedGroupTypeError,      'grape/exceptions/unsupported_group_type'
+      autoload :MissingGroupType
+      autoload :UnsupportedGroupType
       autoload :InvalidMessageBody
       autoload :InvalidAcceptHeader
       autoload :InvalidVersionHeader
       autoload :MethodNotAllowed
       autoload :InvalidResponse
+      autoload :EmptyMessageBody
+      autoload :TooManyMultipartFiles
+      autoload :MissingGroupTypeError, 'grape/exceptions/missing_group_type'
+      autoload :UnsupportedGroupTypeError, 'grape/exceptions/unsupported_group_type'
     end
   end
 
@@ -215,6 +225,58 @@ module Grape
       autoload :StreamResponse
     end
   end
+
+  module Validations
+    extend ::ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :AttributesIterator
+      autoload :MultipleAttributesIterator
+      autoload :SingleAttributeIterator
+      autoload :Types
+      autoload :ParamsScope
+      autoload :ValidatorFactory
+      autoload :Base, 'grape/validations/validators/base'
+    end
+
+    module Types
+      extend ::ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :InvalidValue
+        autoload :DryTypeCoercer
+        autoload :ArrayCoercer
+        autoload :SetCoercer
+        autoload :PrimitiveCoercer
+        autoload :CustomTypeCoercer
+        autoload :CustomTypeCollectionCoercer
+        autoload :MultipleTypeCoercer
+        autoload :VariantCollectionCoercer
+      end
+    end
+
+    module Validators
+      extend ::ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :Base
+        autoload :MultipleParamsBase
+        autoload :AllOrNoneOfValidator
+        autoload :AllowBlankValidator
+        autoload :AsValidator
+        autoload :AtLeastOneOfValidator
+        autoload :CoerceValidator
+        autoload :DefaultValidator
+        autoload :ExactlyOneOfValidator
+        autoload :ExceptValuesValidator
+        autoload :MutualExclusionValidator
+        autoload :PresenceValidator
+        autoload :RegexpValidator
+        autoload :SameAsValidator
+        autoload :ValuesValidator
+      end
+    end
+  end
 end
 
 require 'grape/config'
@@ -224,25 +286,4 @@ require 'grape/util/lazy_value'
 require 'grape/util/lazy_block'
 require 'grape/util/endpoint_configuration'
 
-require 'grape/validations/validators/base'
-require 'grape/validations/attributes_iterator'
-require 'grape/validations/single_attribute_iterator'
-require 'grape/validations/multiple_attributes_iterator'
-require 'grape/validations/validators/allow_blank'
-require 'grape/validations/validators/as'
-require 'grape/validations/validators/at_least_one_of'
-require 'grape/validations/validators/coerce'
-require 'grape/validations/validators/default'
-require 'grape/validations/validators/exactly_one_of'
-require 'grape/validations/validators/mutual_exclusion'
-require 'grape/validations/validators/presence'
-require 'grape/validations/validators/regexp'
-require 'grape/validations/validators/same_as'
-require 'grape/validations/validators/values'
-require 'grape/validations/validators/except_values'
-require 'grape/validations/params_scope'
-require 'grape/validations/validators/all_or_none'
-require 'grape/validations/types'
-require 'grape/validations/validator_factory'
-
 require 'grape/version'

data/spec/grape/api/custom_validations_spec.rb

@@ -1,20 +1,48 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 describe Grape::Validations do
-  context 'using a custom length validator' do
-    before do
-      module CustomValidationsSpec
-        class DefaultLength < Grape::Validations::Base
-          def validate_param!(attr_name, params)
-            @option = params[:max].to_i if params.key?(:max)
-            return if params[attr_name].length <= @option
-            raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: "must be at the most #{@option} characters long")
-          end
+  context 'deprecated Grape::Validations::Base' do
+    subject do
+      Class.new(Grape::API) do
+        params do
+          requires :text, validator_with_old_base: true
+        end
+        get do
+        end
+      end
+    end
+
+    let(:validator_with_old_base) do
+      Class.new(Grape::Validations::Base) do
+        def validate_param!(_attr_name, _params)
+          true
         end
       end
     end
+
+    before do
+      described_class.register_validator('validator_with_old_base', validator_with_old_base)
+      allow(Warning).to receive(:warn)
+    end
+
+    after do
+      described_class.deregister_validator('validator_with_old_base')
+    end
+
+    def app
+      subject
+    end
+
+    it 'puts a deprecation warning' do
+      expect(Warning).to receive(:warn) do |message|
+        expect(message).to include('`Grape::Validations::Base` is deprecated')
+      end
+
+      get '/'
+    end
+  end
+
+  context 'using a custom length validator' do
     subject do
       Class.new(Grape::API) do
         params do
@@ -26,6 +54,25 @@ describe Grape::Validations do
       end
     end
 
+    let(:default_length_validator) do
+      Class.new(Grape::Validations::Validators::Base) do
+        def validate_param!(attr_name, params)
+          @option = params[:max].to_i if params.key?(:max)
+          return if params[attr_name].length <= @option
+
+          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: "must be at the most #{@option} characters long")
+        end
+      end
+    end
+
+    before do
+      described_class.register_validator('default_length', default_length_validator)
+    end
+
+    after do
+      described_class.deregister_validator('default_length')
+    end
+
     def app
       subject
     end
@@ -35,11 +82,13 @@ describe Grape::Validations do
       expect(last_response.status).to eq 200
       expect(last_response.body).to eq 'bacon'
     end
+
     it 'over 140 characters' do
       get '/', text: 'a' * 141
       expect(last_response.status).to eq 400
       expect(last_response.body).to eq 'text must be at the most 140 characters long'
     end
+
     it 'specified in the query string' do
       get '/', text: 'a' * 141, max: 141
       expect(last_response.status).to eq 200
@@ -48,15 +97,6 @@ describe Grape::Validations do
   end
 
   context 'using a custom body-only validator' do
-    before do
-      module CustomValidationsSpec
-        class InBody < Grape::Validations::PresenceValidator
-          def validate(request)
-            validate!(request.env['api.request.body'])
-          end
-        end
-      end
-    end
     subject do
       Class.new(Grape::API) do
         params do
@@ -68,6 +108,22 @@ describe Grape::Validations do
       end
     end
 
+    let(:in_body_validator) do
+      Class.new(Grape::Validations::Validators::PresenceValidator) do
+        def validate(request)
+          validate!(request.env['api.request.body'])
+        end
+      end
+    end
+
+    before do
+      described_class.register_validator('in_body', in_body_validator)
+    end
+
+    after do
+      described_class.deregister_validator('in_body')
+    end
+
     def app
       subject
     end
@@ -77,6 +133,7 @@ describe Grape::Validations do
       expect(last_response.status).to eq 200
       expect(last_response.body).to eq 'bacon'
     end
+
     it 'ignores field in query' do
       get '/', nil, text: 'abc'
       expect(last_response.status).to eq 400
@@ -85,15 +142,6 @@ describe Grape::Validations do
   end
 
   context 'using a custom validator with message_key' do
-    before do
-      module CustomValidationsSpec
-        class WithMessageKey < Grape::Validations::PresenceValidator
-          def validate_param!(attr_name, _params)
-            raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: :presence)
-          end
-        end
-      end
-    end
     subject do
       Class.new(Grape::API) do
         params do
@@ -105,6 +153,22 @@ describe Grape::Validations do
       end
     end
 
+    let(:message_key_validator) do
+      Class.new(Grape::Validations::Validators::PresenceValidator) do
+        def validate_param!(attr_name, _params)
+          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: :presence)
+        end
+      end
+    end
+
+    before do
+      described_class.register_validator('with_message_key', message_key_validator)
+    end
+
+    after do
+      described_class.deregister_validator('with_message_key')
+    end
+
     def app
       subject
     end
@@ -117,22 +181,6 @@ describe Grape::Validations do
   end
 
   context 'using a custom request/param validator' do
-    before do
-      module CustomValidationsSpec
-        class Admin < Grape::Validations::Base
-          def validate(request)
-            # return if the param we are checking was not in request
-            # @attrs is a list containing the attribute we are currently validating
-            return unless request.params.key? @attrs.first
-            # check if admin flag is set to true
-            return unless @option
-            # check if user is admin or not
-            # as an example get a token from request and check if it's admin or not
-            raise Grape::Exceptions::Validation.new(params: @attrs, message: 'Can not set Admin only field.') unless request.headers['X-Access-Token'] == 'admin'
-          end
-        end
-      end
-    end
     subject do
       Class.new(Grape::API) do
         params do
@@ -146,6 +194,29 @@ describe Grape::Validations do
       end
     end
 
+    let(:admin_validator) do
+      Class.new(Grape::Validations::Validators::Base) do
+        def validate(request)
+          # return if the param we are checking was not in request
+          # @attrs is a list containing the attribute we are currently validating
+          return unless request.params.key? @attrs.first
+          # check if admin flag is set to true
+          return unless @option
+          # check if user is admin or not
+          # as an example get a token from request and check if it's admin or not
+          raise Grape::Exceptions::Validation.new(params: @attrs, message: 'Can not set Admin only field.') unless request.headers['X-Access-Token'] == 'admin'
+        end
+      end
+    end
+
+    before do
+      described_class.register_validator('admin', admin_validator)
+    end
+
+    after do
+      described_class.deregister_validator('admin')
+    end
+
     def app
       subject
     end

data/spec/grape/api/deeply_included_options_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
-
 module DeeplyIncludedOptionsSpec
   module Defaults
     extend ActiveSupport::Concern
@@ -41,18 +39,18 @@ describe Grape::API do
 
   it 'works for unspecified format' do
     get '/users'
-    expect(last_response.status).to eql 200
+    expect(last_response.status).to be 200
     expect(last_response.content_type).to eql 'application/json'
   end
 
   it 'works for specified format' do
     get '/users.json'
-    expect(last_response.status).to eql 200
+    expect(last_response.status).to be 200
     expect(last_response.content_type).to eql 'application/json'
   end
 
   it "doesn't work for format different than specified" do
     get '/users.txt'
-    expect(last_response.status).to eql 404
+    expect(last_response.status).to be 404
   end
 end