grape 0.13.0 → 0.14.0

data/lib/grape/validations/types/virtus_collection_patch.rb

@@ -0,0 +1,16 @@
+require 'virtus/attribute/collection'
+
+# See https://github.com/solnic/virtus/pull/343
+# This monkey-patch fixes type validation for collections,
+# ensuring that type assertions are applied to collection
+# members.
+#
+# This patch duplicates the code in the above pull request.
+# Once the request, or equivalent functionality, has been
+# published into the +virtus+ gem this file should be deleted.
+Virtus::Attribute::Collection.class_eval do
+  # @api public
+  def value_coerced?(value)
+    super && value.all? { |item| member_type.value_coerced? item }
+  end
+end

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

@@ -13,7 +13,7 @@ module Grape
       private
 
       def only_subset_present
-        scoped_params.any? { |resource_params| keys_in_common(resource_params).length > 0 && keys_in_common(resource_params).length < attrs.length  }
+        scoped_params.any? { |resource_params| keys_in_common(resource_params).length > 0 && keys_in_common(resource_params).length < attrs.length }
       end
     end
   end

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

@@ -21,9 +21,9 @@ module Grape
 
         return unless should_validate
 
-        unless value == false || value.present?
-          fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :blank
-        end
+        return if value == false || value.present?
+
+        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :blank
       end
     end
   end

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

@@ -3,6 +3,13 @@ module Grape
     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
       def initialize(attrs, options, required, scope)
         @attrs = Array(attrs)
         @option = options

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

@@ -1,13 +1,13 @@
 module Grape
   class API
-    Boolean = Virtus::Attribute::Boolean # rubocop:disable ConstantName
+    Boolean = Virtus::Attribute::Boolean
   end
 
   module Validations
     class CoerceValidator < Base
       def validate_param!(attr_name, params)
         fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :coerce unless params.is_a? Hash
-        new_value = coerce_value(@option, params[attr_name])
+        new_value = coerce_value(params[attr_name])
         if valid_type?(new_value)
           params[attr_name] = new_value
         else
@@ -15,61 +15,50 @@ module Grape
         end
       end
 
-      class InvalidValue; end
-
       private
 
-      def _valid_array_type?(type, values)
-        values.all? do |val|
-          _valid_single_type?(type, val)
-        end
-      end
+      def valid_type?(val)
+        # Special value to denote coercion failure
+        return false if val.instance_of?(Types::InvalidValue)
 
-      def _valid_single_type?(klass, val)
-        # allow nil, to ignore when a parameter is absent
+        # Allow nil, to ignore when a parameter is absent
         return true if val.nil?
-        if klass == Virtus::Attribute::Boolean
-          val.is_a?(TrueClass) || val.is_a?(FalseClass) || (val.is_a?(String) && val.empty?)
-        elsif klass == Rack::Multipart::UploadedFile
-          val.is_a?(Hashie::Mash) && val.key?(:tempfile)
-        elsif [DateTime, Date, Numeric].any? { |vclass| vclass >= klass }
-          return true if val.is_a?(String) && val.empty?
-          val.is_a?(klass)
-        else
-          val.is_a?(klass)
-        end
-      end
 
-      def valid_type?(val)
-        if val.instance_of?(InvalidValue)
-          false
-        elsif @option.is_a?(Array) || @option.is_a?(Set)
-          _valid_array_type?(@option.first, val)
-        else
-          _valid_single_type?(@option, val)
-        end
+        converter.value_coerced? val
       end
 
-      def coerce_value(type, val)
+      def coerce_value(val)
         # Don't coerce things other than nil to Arrays or Hashes
-        return val || []      if type == Array
-        return val || Set.new if type == Set
-        return val || {}      if type == Hash
-
-        # To support custom types that Virtus can't easily coerce, pass in an
-        # explicit coercer. Custom types must implement a `parse` class method.
-        converter_options = {}
-        if ParameterTypes.custom_type?(type)
-          converter_options[:coercer] = type.method(:parse)
+        unless (@option[:method] && !val.nil?) || type.is_a?(Virtus::Attribute)
+          return val || []      if type == Array
+          return val || Set.new if type == Set
+          return val || {}      if type == Hash
         end
 
-        converter = Virtus::Attribute.build(type, converter_options)
         converter.coerce(val)
 
       # not the prettiest but some invalid coercion can currently trigger
       # errors in Virtus (see coerce_spec.rb:75)
       rescue
-        InvalidValue.new
+        Types::InvalidValue.new
+      end
+
+      # Type to which the parameter will be coerced.
+      #
+      # @return [Class]
+      def type
+        @option[:type]
+      end
+
+      # Create and cache the attribute object
+      # that will be used for parameter coercion
+      # and type checking.
+      #
+      # See {Types.build_coercer}
+      #
+      # @return [Virtus::Attribute]
+      def converter
+        @converter ||= Types.build_coercer(type, @option[:method])
       end
     end
   end

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

@@ -7,9 +7,8 @@ module Grape
       end
 
       def validate_param!(attr_name, params)
-        unless params.respond_to?(:key?) && params.key?(attr_name)
-          fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :presence
-        end
+        return if params.respond_to?(:key?) && params.key?(attr_name)
+        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :presence
       end
     end
   end

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

@@ -2,10 +2,8 @@ module Grape
   module Validations
     class RegexpValidator < Base
       def validate_param!(attr_name, params)
-        if params.key?(attr_name) &&
-           !params[attr_name].nil? && !(params[attr_name].to_s =~ @option)
-          fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :regexp
-        end
+        return unless params.key?(attr_name) && !params[attr_name].nil? && !(params[attr_name].to_s =~ @option)
+        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :regexp
       end
     end
   end

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

@@ -7,13 +7,13 @@ module Grape
       end
 
       def validate_param!(attr_name, params)
+        return unless params.is_a?(Hash)
         return unless params[attr_name] || required_for_root_scope?
 
         values = @values.is_a?(Proc) ? @values.call : @values
         param_array = params[attr_name].nil? ? [nil] : Array.wrap(params[attr_name])
-        unless param_array.all? { |param| values.include?(param) }
-          fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :values
-        end
+        return if param_array.all? { |param| values.include?(param) }
+        fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :values
       end
 
       private

data/lib/grape/version.rb

@@ -1,4 +1,4 @@
 module Grape
   # The current version of Grape.
-  VERSION = '0.13.0'
+  VERSION = '0.14.0'
 end

data/spec/grape/api/custom_validations_spec.rb

@@ -2,10 +2,11 @@ require 'spec_helper'
 
 describe Grape::Validations do
   before do
-    class DefaultLength < Grape::Validations::Base
-      def validate_param!(attr_name, params)
-        @option = params[:max].to_i if params.key?(:max)
-        unless params[attr_name].length <= @option
+    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
           fail Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message: "must be at the most #{@option} characters long"
         end
       end

data/spec/grape/api/deeply_included_options_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module API
+module DeeplyIncludedOptionsSpec
   module Defaults
     extend ActiveSupport::Concern
     included do
@@ -11,11 +11,11 @@ module API
   module Admin
     module Defaults
       extend ActiveSupport::Concern
-      include API::Defaults
+      include DeeplyIncludedOptionsSpec::Defaults
     end
 
     class Users < Grape::API
-      include API::Admin::Defaults
+      include DeeplyIncludedOptionsSpec::Admin::Defaults
 
       resource :users do
         get do
@@ -24,14 +24,14 @@ module API
       end
     end
   end
-end
 
-class Main < Grape::API
-  mount API::Admin::Users
+  class Main < Grape::API
+    mount DeeplyIncludedOptionsSpec::Admin::Users
+  end
 end
 
 describe Grape::API do
-  subject { Main }
+  subject { DeeplyIncludedOptionsSpec::Main }
 
   def app
     subject

data/spec/grape/api/nested_helpers_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Grape::API::Helpers do
-  subject do
+  module NestedHelpersSpec
     module HelperMethods
       extend Grape::API::Helpers
       def current_user
@@ -28,8 +28,10 @@ describe Grape::API::Helpers do
     class Main < Grape::API
       mount Nested
     end
+  end
 
-    Main
+  subject do
+    NestedHelpersSpec::Main
   end
 
   def app

data/spec/grape/api/shared_helpers_spec.rb

@@ -1,18 +1,18 @@
 require 'spec_helper'
 
 describe Grape::API::Helpers do
-  module SharedParams
-    extend Grape::API::Helpers
+  subject do
+    shared_params = Module.new do
+      extend Grape::API::Helpers
 
-    params :pagination do
-      optional :page, type: Integer
-      optional :size, type: Integer
+      params :pagination do
+        optional :page, type: Integer
+        optional :size, type: Integer
+      end
     end
-  end
 
-  subject do
     Class.new(Grape::API) do
-      helpers SharedParams
+      helpers shared_params
       format :json
 
       params do

data/spec/grape/api_spec.rb

@@ -537,16 +537,38 @@ describe Grape::API do
       expect(last_response.headers['Content-Type']).to eql 'text/plain'
     end
 
-    it 'adds an OPTIONS route that returns a 204, an Allow header and a X-Custom-Header' do
-      subject.before { header 'X-Custom-Header', 'foo' }
-      subject.get 'example' do
-        'example'
+    describe 'adds an OPTIONS route that' do
+      before do
+        subject.before { header 'X-Custom-Header', 'foo' }
+        subject.get 'example' do
+          'example'
+        end
+        options '/example'
+      end
+
+      it 'returns a 204' do
+        expect(last_response.status).to eql 204
+      end
+
+      it 'has an empty body' do
+        expect(last_response.body).to be_blank
+      end
+
+      it 'has an Allow header' do
+        expect(last_response.headers['Allow']).to eql 'OPTIONS, GET, HEAD'
+      end
+
+      it 'has a X-Custom-Header' do
+        expect(last_response.headers['X-Custom-Header']).to eql 'foo'
+      end
+
+      it 'has no Content-Type' do
+        expect(last_response.content_type).to be_nil
+      end
+
+      it 'has no Content-Length' do
+        expect(last_response.content_length).to be_nil
       end
-      options '/example'
-      expect(last_response.status).to eql 204
-      expect(last_response.body).to eql ''
-      expect(last_response.headers['Allow']).to eql 'OPTIONS, GET, HEAD'
-      expect(last_response.headers['X-Custom-Header']).to eql 'foo'
     end
 
     it 'allows HEAD on a GET request' do
@@ -640,7 +662,7 @@ describe Grape::API do
     end
 
     it 'adds a after_validation filter' do
-      subject.after_validation { @foo = "first #{params[:id] }:#{params[:id].class}"  }
+      subject.after_validation { @foo = "first #{params[:id]}:#{params[:id].class}" }
       subject.after_validation { @bar = 'second' }
       subject.params do
         requires :id, type: Integer
@@ -787,7 +809,7 @@ describe Grape::API do
 
     it 'returns raw data when content type binary' do
       image_filename = 'grape.png'
-      file = File.open(image_filename, 'rb') { |io| io.read }
+      file = File.open(image_filename, 'rb', &:read)
       subject.format :binary
       subject.get('/binary_file') { File.binread(image_filename) }
       get '/binary_file'
@@ -1066,7 +1088,7 @@ describe Grape::API do
 
       subject.get(:hello) { 'Hello, world.' }
       get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow', 'whatever')
-      expect(basic_auth_context).to be_an_instance_of(Grape::Endpoint)
+      expect(basic_auth_context).to be_a_kind_of(Grape::Endpoint)
     end
 
     it 'has access to helper methods' do
@@ -1309,21 +1331,23 @@ describe Grape::API do
 
     context 'CustomError subclass of Grape::Exceptions::Base' do
       before do
-        class CustomError < Grape::Exceptions::Base; end
+        module ApiSpec
+          class CustomError < Grape::Exceptions::Base; end
+        end
       end
 
       it 'does not re-raise exceptions of type Grape::Exceptions::Base' do
-        subject.get('/custom_exception') { fail CustomError }
+        subject.get('/custom_exception') { fail ApiSpec::CustomError }
 
         expect { get '/custom_exception' }.not_to raise_error
       end
 
       it 'rescues custom grape exceptions' do
-        subject.rescue_from CustomError do |e|
+        subject.rescue_from ApiSpec::CustomError do |e|
           rack_response('New Error', e.status)
         end
         subject.get '/custom_error' do
-          fail CustomError, status: 400, message: 'Custom Error'
+          fail ApiSpec::CustomError, status: 400, message: 'Custom Error'
         end
 
         get '/custom_error'
@@ -1435,7 +1459,7 @@ describe Grape::API do
 
   describe '.rescue_from klass, lambda' do
     it 'rescues an error with the lambda' do
-      subject.rescue_from ArgumentError, -> {
+      subject.rescue_from ArgumentError, lambda {
         rack_response('rescued with a lambda', 400)
       }
       subject.get('/rescue_lambda') { fail ArgumentError }
@@ -1446,7 +1470,7 @@ describe Grape::API do
     end
 
     it 'can execute the lambda with an argument' do
-      subject.rescue_from ArgumentError, ->(e) {
+      subject.rescue_from ArgumentError, lambda { |e|
         rack_response(e.message, 400)
       }
       subject.get('/rescue_lambda') { fail ArgumentError, 'lambda takes an argument' }
@@ -1474,21 +1498,23 @@ describe Grape::API do
 
   describe '.rescue_from klass, rescue_subclasses: boolean' do
     before do
-      module APIErrors
-        class ParentError < StandardError; end
-        class ChildError < ParentError; end
+      module ApiSpec
+        module APIErrors
+          class ParentError < StandardError; end
+          class ChildError < ParentError; end
+        end
       end
     end
 
     it 'rescues error as well as subclass errors with rescue_subclasses option set' do
-      subject.rescue_from APIErrors::ParentError, rescue_subclasses: true do |e|
+      subject.rescue_from ApiSpec::APIErrors::ParentError, rescue_subclasses: true do |e|
         rack_response("rescued from #{e.class.name}", 500)
       end
       subject.get '/caught_child' do
-        fail APIErrors::ChildError
+        fail ApiSpec::APIErrors::ChildError
       end
       subject.get '/caught_parent' do
-        fail APIErrors::ParentError
+        fail ApiSpec::APIErrors::ParentError
       end
       subject.get '/uncaught_parent' do
         fail StandardError
@@ -1502,11 +1528,11 @@ describe Grape::API do
     end
 
     it 'sets rescue_subclasses to true by default' do
-      subject.rescue_from APIErrors::ParentError do |e|
+      subject.rescue_from ApiSpec::APIErrors::ParentError do |e|
         rack_response("rescued from #{e.class.name}", 500)
       end
       subject.get '/caught_child' do
-        fail APIErrors::ChildError
+        fail ApiSpec::APIErrors::ChildError
       end
 
       get '/caught_child'
@@ -1514,13 +1540,13 @@ describe Grape::API do
     end
 
     it 'does not rescue child errors if rescue_subclasses is false' do
-      subject.rescue_from APIErrors::ParentError, rescue_subclasses: false do |e|
+      subject.rescue_from ApiSpec::APIErrors::ParentError, rescue_subclasses: false do |e|
         rack_response("rescued from #{e.class.name}", 500)
       end
       subject.get '/uncaught' do
-        fail APIErrors::ChildError
+        fail ApiSpec::APIErrors::ChildError
       end
-      expect { get '/uncaught' }.to raise_error(APIErrors::ChildError)
+      expect { get '/uncaught' }.to raise_error(ApiSpec::APIErrors::ChildError)
     end
   end
 
@@ -1572,15 +1598,17 @@ describe Grape::API do
 
     context 'class' do
       before :each do
-        class CustomErrorFormatter
-          def self.call(message, _backtrace, _options, _env)
-            "message: #{message} @backtrace"
+        module ApiSpec
+          class CustomErrorFormatter
+            def self.call(message, _backtrace, _options, _env)
+              "message: #{message} @backtrace"
+            end
           end
         end
       end
       it 'returns a custom error format' do
         subject.rescue_from :all, backtrace: true
-        subject.error_formatter :txt, CustomErrorFormatter
+        subject.error_formatter :txt, ApiSpec::CustomErrorFormatter
         subject.get '/exception' do
           fail 'rain!'
         end
@@ -1592,16 +1620,18 @@ describe Grape::API do
     describe 'with' do
       context 'class' do
         before :each do
-          class CustomErrorFormatter
-            def self.call(message, _backtrace, _option, _env)
-              "message: #{message} @backtrace"
+          module ApiSpec
+            class CustomErrorFormatter
+              def self.call(message, _backtrace, _option, _env)
+                "message: #{message} @backtrace"
+              end
             end
           end
         end
 
         it 'returns a custom error format' do
           subject.rescue_from :all, backtrace: true
-          subject.error_formatter :txt, with: CustomErrorFormatter
+          subject.error_formatter :txt, with: ApiSpec::CustomErrorFormatter
           subject.get('/exception') { fail 'rain!' }
 
           get '/exception'
@@ -1679,8 +1709,8 @@ describe Grape::API do
   describe '.formatter' do
     context 'multiple formatters' do
       before :each do
-        subject.formatter :json, ->(object, _env) { "{\"custom_formatter\":\"#{object[:some] }\"}" }
-        subject.formatter :txt, ->(object, _env) { "custom_formatter: #{object[:some] }" }
+        subject.formatter :json, ->(object, _env) { "{\"custom_formatter\":\"#{object[:some]}\"}" }
+        subject.formatter :txt, ->(object, _env) { "custom_formatter: #{object[:some]}" }
         subject.get :simple do
           { some: 'hash' }
         end
@@ -1698,7 +1728,7 @@ describe Grape::API do
       before :each do
         subject.content_type :json, 'application/json'
         subject.content_type :custom, 'application/custom'
-        subject.formatter :custom, ->(object, _env) { "{\"custom_formatter\":\"#{object[:some] }\"}" }
+        subject.formatter :custom, ->(object, _env) { "{\"custom_formatter\":\"#{object[:some]}\"}" }
         subject.get :simple do
           { some: 'hash' }
         end
@@ -1713,15 +1743,17 @@ describe Grape::API do
       end
     end
     context 'custom formatter class' do
-      module CustomFormatter
-        def self.call(object, _env)
-          "{\"custom_formatter\":\"#{object[:some] }\"}"
+      module ApiSpec
+        module CustomFormatter
+          def self.call(object, _env)
+            "{\"custom_formatter\":\"#{object[:some]}\"}"
+          end
         end
       end
       before :each do
         subject.content_type :json, 'application/json'
         subject.content_type :custom, 'application/custom'
-        subject.formatter :custom, CustomFormatter
+        subject.formatter :custom, ApiSpec::CustomFormatter
         subject.get :simple do
           { some: 'hash' }
         end
@@ -1765,15 +1797,17 @@ describe Grape::API do
       end
     end
     context 'custom parser class' do
-      module CustomParser
-        def self.call(object, _env)
-          { object.to_sym => object.to_s.reverse }
+      module ApiSpec
+        module CustomParser
+          def self.call(object, _env)
+            { object.to_sym => object.to_s.reverse }
+          end
         end
       end
       before :each do
         subject.content_type :txt, 'text/plain'
         subject.content_type :custom, 'text/custom'
-        subject.parser :custom, CustomParser
+        subject.parser :custom, ApiSpec::CustomParser
         subject.put :simple do
           params[:simple]
         end
@@ -1798,7 +1832,7 @@ describe Grape::API do
       before :each do
         subject.parser :json, nil
         subject.put 'data' do
-          "body: #{env['api.request.body'] }"
+          "body: #{env['api.request.body']}"
         end
       end
       it 'does not parse data' do
@@ -2812,10 +2846,10 @@ XML
       end
       it 'hash' do
         subject.get '/example' do
-          ActiveSupport::OrderedHash[
-            :example1, 'example1',
-            :example2, 'example2'
-        ]
+          {
+            example1: 'example1',
+            example2: 'example2'
+          }
         end
         get '/example'
         expect(last_response.status).to eq(200)
@@ -2880,7 +2914,7 @@ XML
     [true, false].each do |anchor|
       it "anchor=#{anchor}" do
         subject.route :any, '*path', anchor: anchor do
-          error!("Unrecognized request path: #{params[:path] } - #{env['PATH_INFO'] }#{env['SCRIPT_NAME'] }", 404)
+          error!("Unrecognized request path: #{params[:path]} - #{env['PATH_INFO']}#{env['SCRIPT_NAME']}", 404)
         end
         get '/v1/hello'
         expect(last_response.status).to eq(200)