grape 1.3.3 → 1.6.2

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

@@ -4,12 +4,15 @@ require 'grape/validations/validators/multiple_params_base'
 
 module Grape
   module Validations
-    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.length.zero?
-        raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
+    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.length.zero?
+
+          raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
+        end
       end
     end
   end

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

@@ -2,20 +2,22 @@
 
 module Grape
   module Validations
-    class ExceptValuesValidator < Base
-      def initialize(attrs, options, required, scope, opts = {})
-        @except = options.is_a?(Hash) ? options[:value] : options
-        super
-      end
+    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.respond_to?(:key?) && params.key?(attr_name)
+        def validate_param!(attr_name, params)
+          return unless params.respond_to?(:key?) && params.key?(attr_name)
 
-        excepts = @except.is_a?(Proc) ? @except.call : @except
-        return if excepts.nil?
+          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) }
+          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

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

@@ -2,31 +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|
-          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.rb

@@ -4,11 +4,14 @@ require 'grape/validations/validators/multiple_params_base'
 
 module Grape
   module Validations
-    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))
+    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

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

@@ -2,10 +2,13 @@
 
 module Grape
   module Validations
-    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))
+    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

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

@@ -2,11 +2,14 @@
 
 module Grape
   module Validations
-    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))
+    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

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

@@ -2,23 +2,26 @@
 
 module Grape
   module Validations
-    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
+    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
+        private
 
-      def build_message
-        if options_key?(:message)
-          @option[:message]
-        else
-          format I18n.t(:same_as, scope: 'grape.errors.messages'), parameter: @option
+        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

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

@@ -2,81 +2,86 @@
 
 module Grape
   module Validations
-    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
+    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
-        super
-      end
 
-      def validate_param!(attr_name, params)
-        return unless params.is_a?(Hash)
+        def validate_param!(attr_name, params)
+          return unless params.is_a?(Hash)
 
-        val = params[attr_name]
+          val = params[attr_name]
 
-        return if val.nil? && !required_for_root_scope?
+          return if val.nil? && !required_for_root_scope?
 
-        # don't forget that +false.blank?+ is true
-        return if val != false && val.blank? && @allow_blank
+          # don't forget that +false.blank?+ is true
+          return if val != false && val.blank? && @allow_blank
 
-        param_array = val.nil? ? [nil] : Array.wrap(val)
+          param_array = val.nil? ? [nil] : Array.wrap(val)
 
-        raise validation_exception(attr_name, except_message) \
+          raise validation_exception(attr_name, except_message) \
           unless check_excepts(param_array)
 
-        raise validation_exception(attr_name, message(:values)) \
+          raise validation_exception(attr_name, message(:values)) \
           unless check_values(param_array, attr_name)
 
-        raise validation_exception(attr_name, message(:values)) \
+          raise validation_exception(attr_name, message(:values)) \
           if @proc && !param_array.all? { |param| @proc.call(param) }
-      end
+        end
+
+        private
 
-      private
+        def check_values(param_array, attr_name)
+          values = @values.is_a?(Proc) && @values.arity.zero? ? @values.call : @values
+          return true if values.nil?
 
-      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
+          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
-        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 check_excepts(param_array)
+          excepts = @excepts.is_a?(Proc) ? @excepts.call : @excepts
+          return true if excepts.nil?
 
-      def except_message
-        options = instance_variable_get(:@option)
-        options_key?(:except_message) ? options[:except_message] : message(:except_values)
-      end
+          param_array.none? { |param| excepts.include?(param) }
+        end
 
-      def required_for_root_scope?
-        @required && @scope.root?
-      end
+        def except_message
+          options = instance_variable_get(:@option)
+          options_key?(:except_message) ? options[:except_message] : message(:except_values)
+        end
 
-      def validation_exception(attr_name, message)
-        Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: message)
+        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

data/lib/grape/validations.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+require 'grape/validations/attributes_iterator'
+require 'grape/validations/single_attribute_iterator'
+require 'grape/validations/multiple_attributes_iterator'
+require 'grape/validations/params_scope'
+require 'grape/validations/types'
+
 module Grape
   # Registry to store and locate known Validators.
   module Validations

data/lib/grape/version.rb

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

data/lib/grape.rb

@@ -7,11 +7,14 @@ require 'rack/accept'
 require 'rack/auth/basic'
 require 'rack/auth/digest/md5'
 require 'set'
+require 'active_support'
 require 'active_support/version'
+require 'active_support/isolated_execution_state' if ActiveSupport::VERSION::MAJOR > 6
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/object/blank'
 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/deep_merge'
 require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/core_ext/hash/except'
@@ -21,7 +24,7 @@ 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
@@ -75,6 +78,7 @@ module Grape
       autoload :InvalidVersionHeader
       autoload :MethodNotAllowed
       autoload :InvalidResponse
+      autoload :EmptyMessageBody
     end
   end
 
@@ -206,12 +210,12 @@ module Grape
     end
   end
 
-  module ServeFile
+  module ServeStream
     extend ::ActiveSupport::Autoload
     eager_autoload do
-      autoload :FileResponse
       autoload :FileBody
       autoload :SendfileResponse
+      autoload :StreamResponse
     end
   end
 end

data/spec/grape/api/custom_validations_spec.rb

@@ -4,17 +4,6 @@ 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
-        end
-      end
-    end
     subject do
       Class.new(Grape::API) do
         params do
@@ -26,6 +15,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 +43,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 +58,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 +69,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 +94,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 +103,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 +114,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 +142,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 +155,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

@@ -41,18 +41,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

data/spec/grape/api/defines_boolean_in_params_spec.rb

@@ -31,8 +31,9 @@ describe Grape::API::Instance do
 
     context 'Params endpoint type' do
       subject { DefinesBooleanInstanceSpec::API.new.router.map['POST'].first.options[:params]['message'][:type] }
+
       it 'params type is a boolean' do
-        is_expected.to eq 'Grape::API::Boolean'
+        expect(subject).to eq 'Grape::API::Boolean'
       end
     end
   end