grape 0.12.0 → 0.13.0

data/spec/grape/dsl/inside_route_spec.rb

@@ -201,8 +201,43 @@ module Grape
             subject.file 'file'
           end
 
-          it 'returns value' do
-            expect(subject.file).to eq 'file'
+          it 'returns value wrapped in FileResponse' do
+            expect(subject.file).to eq Grape::Util::FileResponse.new('file')
+          end
+        end
+
+        it 'returns default' do
+          expect(subject.file).to be nil
+        end
+      end
+
+      describe '#stream' do
+        describe 'set' do
+          before do
+            subject.header 'Cache-Control', 'cache'
+            subject.header 'Content-Length', 123
+            subject.header 'Transfer-Encoding', 'base64'
+            subject.stream 'file'
+          end
+
+          it 'returns value wrapped in FileResponse' do
+            expect(subject.stream).to eq Grape::Util::FileResponse.new('file')
+          end
+
+          it 'also sets result of file to value wrapped in FileResponse' do
+            expect(subject.file).to eq Grape::Util::FileResponse.new('file')
+          end
+
+          it 'sets Cache-Control header to no-cache' do
+            expect(subject.header['Cache-Control']).to eq 'no-cache'
+          end
+
+          it 'sets Content-Length header to nil' do
+            expect(subject.header['Content-Length']).to eq nil
+          end
+
+          it 'sets Transfer-Encoding header to nil' do
+            expect(subject.header['Transfer-Encoding']).to eq nil
           end
         end
 

data/spec/grape/dsl/validations_spec.rb

@@ -15,9 +15,15 @@ module Grape
         before do
           subject.namespace_stackable :declared_params, ['dummy']
           subject.namespace_stackable :validations, ['dummy']
+          subject.namespace_stackable :params, ['dummy']
+          subject.route_setting :description, description: 'lol', params: ['dummy']
           subject.reset_validations!
         end
 
+        after do
+          subject.unset_route_setting :description
+        end
+
         it 'resets declared params' do
           expect(subject.namespace_stackable(:declared_params)).to eq []
         end
@@ -25,6 +31,18 @@ module Grape
         it 'resets validations' do
           expect(subject.namespace_stackable(:validations)).to eq []
         end
+
+        it 'resets params' do
+          expect(subject.namespace_stackable(:params)).to eq []
+        end
+
+        it 'resets documentation params' do
+          expect(subject.route_setting(:description)[:params]).to be_nil
+        end
+
+        it 'does not reset documentation description' do
+          expect(subject.route_setting(:description)[:description]).to eq 'lol'
+        end
       end
 
       describe '.params' do

data/spec/grape/endpoint_spec.rb

@@ -941,4 +941,87 @@ describe Grape::Endpoint do
       expect(last_response.body).to eq File.read(__FILE__)
     end
   end
+
+  context 'validation errors' do
+    before do
+      subject.before do
+        header['Access-Control-Allow-Origin'] = '*'
+      end
+      subject.params do
+        requires :id, type: String
+      end
+      subject.get do
+        'should not get here'
+      end
+    end
+
+    it 'returns the errors, and passes headers' do
+      get '/'
+      expect(last_response.status).to eq 400
+      expect(last_response.body).to eq 'id is missing'
+      expect(last_response.headers['Access-Control-Allow-Origin']).to eq('*')
+    end
+  end
+
+  context 'instrumentation' do
+    before do
+      subject.before do
+        # Placeholder
+      end
+      subject.get do
+        'hello'
+      end
+
+      @events = []
+      @subscriber = ActiveSupport::Notifications.subscribe(/grape/) do |*args|
+        @events << ActiveSupport::Notifications::Event.new(*args)
+      end
+    end
+
+    after do
+      ActiveSupport::Notifications.unsubscribe(@subscriber)
+    end
+
+    it 'notifies AS::N' do
+      get '/'
+
+      # In order that the events finalized (time each block ended)
+      expect(@events).to contain_exactly(
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+                                                                       filters: a_collection_containing_exactly(an_instance_of(Proc)),
+                                                                       type: :before }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+                                                                       filters: [],
+                                                                       type: :before_validation }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+                                                                       filters: [],
+                                                                       type: :after_validation }),
+        have_attributes(name: 'endpoint_render.grape',      payload: { endpoint: an_instance_of(Grape::Endpoint) }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+                                                                       filters: [],
+                                                                       type: :after }),
+        have_attributes(name: 'endpoint_run.grape',         payload: { endpoint: an_instance_of(Grape::Endpoint),
+                                                                       env: an_instance_of(Hash) })
+      )
+
+      # In order that events were initialized
+      expect(@events.sort_by(&:time)).to contain_exactly(
+        have_attributes(name: 'endpoint_run.grape',         payload: { endpoint: an_instance_of(Grape::Endpoint),
+                                                                       env: an_instance_of(Hash) }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+                                                                       filters: a_collection_containing_exactly(an_instance_of(Proc)),
+                                                                       type: :before }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+                                                                       filters: [],
+                                                                       type: :before_validation }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+                                                                       filters: [],
+                                                                       type: :after_validation }),
+        have_attributes(name: 'endpoint_render.grape',      payload: { endpoint: an_instance_of(Grape::Endpoint) }),
+        have_attributes(name: 'endpoint_run_filters.grape', payload: { endpoint: an_instance_of(Grape::Endpoint),
+                                                                       filters: [],
+                                                                       type: :after })
+      )
+    end
+  end
 end

data/spec/grape/exceptions/validation_errors_spec.rb

@@ -5,6 +5,22 @@ describe Grape::Exceptions::ValidationErrors do
   let(:validation_message) { 'FooBar is invalid' }
   let(:validation_error) { OpenStruct.new(params: [validation_message]) }
 
+  context 'initialize' do
+    let(:headers) {
+      {
+        'A-Header-Key' => 'A-Header-Value'
+      }
+    }
+
+    subject do
+      described_class.new(errors: [validation_error], headers: headers)
+    end
+
+    it 'should assign headers through base class' do
+      expect(subject.headers).to eq(headers)
+    end
+  end
+
   context 'message' do
     context 'is not repeated' do
       let(:error) do
@@ -17,6 +33,18 @@ describe Grape::Exceptions::ValidationErrors do
     end
   end
 
+  describe '#full_messages' do
+    context 'with errors' do
+      let(:validation_error_1) { Grape::Exceptions::Validation.new(params: ['id'], message_key: 'presence') }
+      let(:validation_error_2) { Grape::Exceptions::Validation.new(params: ['name'], message_key: 'presence') }
+      subject { described_class.new(errors: [validation_error_1, validation_error_2]).full_messages }
+
+      it 'returns an array with each errors full message' do
+        expect(subject).to contain_exactly('id is missing', 'name is missing')
+      end
+    end
+  end
+
   context 'api' do
     subject { Class.new(Grape::API) }
 

data/spec/grape/middleware/base_spec.rb

@@ -36,21 +36,43 @@ describe Grape::Middleware::Base do
 
   describe '#response' do
     subject { Grape::Middleware::Base.new(response) }
-    let(:response) { ->(_) { [204, { abc: 1 }, 'test'] } }
 
-    it 'status' do
-      subject.call({})
-      expect(subject.response.status).to eq(204)
-    end
+    context Array do
+      let(:response) { ->(_) { [204, { abc: 1 }, 'test'] } }
+
+      it 'status' do
+        subject.call({})
+        expect(subject.response.status).to eq(204)
+      end
 
-    it 'body' do
-      subject.call({})
-      expect(subject.response.body).to eq(['test'])
+      it 'body' do
+        subject.call({})
+        expect(subject.response.body).to eq(['test'])
+      end
+
+      it 'header' do
+        subject.call({})
+        expect(subject.response.header).to have_key(:abc)
+      end
     end
 
-    it 'header' do
-      subject.call({})
-      expect(subject.response.header).to have_key(:abc)
+    context Rack::Response do
+      let(:response) { ->(_) { Rack::Response.new('test', 204, abc: 1) } }
+
+      it 'status' do
+        subject.call({})
+        expect(subject.response.status).to eq(204)
+      end
+
+      it 'body' do
+        subject.call({})
+        expect(subject.response.body).to eq(['test'])
+      end
+
+      it 'header' do
+        subject.call({})
+        expect(subject.response.header).to have_key(:abc)
+      end
     end
   end
 

data/spec/grape/middleware/formatter_spec.rb

@@ -110,11 +110,6 @@ describe Grape::Middleware::Formatter do
       expect(subject.env['api.format']).to eq(:xml)
     end
 
-    it 'looks for case-indifferent headers' do
-      subject.call('PATH_INFO' => '/info', 'http_accept' => 'application/xml')
-      expect(subject.env['api.format']).to eq(:xml)
-    end
-
     it 'uses quality rankings to determine formats' do
       subject.call('PATH_INFO' => '/info', 'HTTP_ACCEPT' => 'application/json; q=0.3,application/xml; q=1.0')
       expect(subject.env['api.format']).to eq(:xml)

data/spec/grape/util/inheritable_values_spec.rb

@@ -58,6 +58,20 @@ module Grape
           expect(subject.to_hash).to eq(some_thing: :foo, some_thing_more: :foo_bar)
         end
       end
+
+      describe '#clone' do
+        let(:obj_cloned) { subject.clone }
+
+        context 'complex (i.e. not primitive) data types (ex. entity classes, please see bug #891)' do
+          let(:description) { { entity: double } }
+
+          before { subject[:description] = description }
+
+          it 'copies values; does not duplicate them' do
+            expect(obj_cloned[:description]).to eq description
+          end
+        end
+      end
     end
   end
 end

data/spec/grape/util/parameter_types_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Grape::ParameterTypes do
+  class FooType
+    def self.parse(_)
+    end
+  end
+
+  class BarType
+    def self.parse
+    end
+  end
+
+  describe '::primitive?' do
+    [
+      Integer, Float, Numeric, BigDecimal,
+      Virtus::Attribute::Boolean, String, Symbol,
+      Date, DateTime, Time, Rack::Multipart::UploadedFile
+    ].each do |type|
+      it "recognizes #{type} as a primitive" do
+        expect(described_class.primitive?(type)).to be_truthy
+      end
+    end
+
+    it 'identifies unknown types' do
+      expect(described_class.primitive?(Object)).to be_falsy
+      expect(described_class.primitive?(FooType)).to be_falsy
+    end
+  end
+
+  describe '::structure?' do
+    [
+      Hash, Array, Set
+    ].each do |type|
+      it "recognizes #{type} as a structure" do
+        expect(described_class.structure?(type)).to be_truthy
+      end
+    end
+  end
+
+  describe '::custom_type?' do
+    it 'returns false if the type does not respond to :parse' do
+      expect(described_class.custom_type?(Object)).to be_falsy
+    end
+
+    it 'returns true if the type responds to :parse with one argument' do
+      expect(described_class.custom_type?(FooType)).to be_truthy
+    end
+
+    it 'returns false if the type\'s #parse method takes other than one argument' do
+      expect(described_class.custom_type?(BarType)).to be_falsy
+    end
+  end
+end

data/spec/grape/util/stackable_values_spec.rb

@@ -109,6 +109,16 @@ module Grape
 
           expect(grandchild.clone.to_hash).to eq(some_thing: [:foo, [:bar, :more], :grand_foo_bar], some_thing_more: [:foo_bar])
         end
+
+        context 'complex (i.e. not primitive) data types (ex. middleware, please see bug #930)' do
+          let(:middleware) { double }
+
+          before { subject[:middleware] = middleware }
+
+          it 'copies values; does not duplicate them' do
+            expect(obj_cloned[:middleware]).to eq [middleware]
+          end
+        end
       end
     end
   end

data/spec/grape/validations/params_scope_spec.rb

@@ -89,6 +89,35 @@ describe Grape::Validations::ParamsScope do
     end
   end
 
+  context 'when using custom types' do
+    class CustomType
+      attr_reader :value
+      def self.parse(value)
+        fail if value == 'invalid'
+        new(value)
+      end
+
+      def initialize(value)
+        @value = value
+      end
+    end
+
+    it 'coerces the parameter via the type\'s parse method' do
+      subject.params do
+        requires :foo, type: CustomType
+      end
+      subject.get('/types') { params[:foo].value }
+
+      get '/types', foo: 'valid'
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to eq('valid')
+
+      get '/types', foo: 'invalid'
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to match(/foo is invalid/)
+    end
+  end
+
   context 'array without coerce type explicitly given' do
     it 'sets the type based on first element' do
       subject.params do
@@ -242,4 +271,59 @@ describe Grape::Validations::ParamsScope do
       end.to raise_error Grape::Exceptions::UnsupportedGroupTypeError
     end
   end
+
+  context 'when validations are dependent on a parameter' do
+    before do
+      subject.params do
+        optional :a
+        given :a do
+          requires :b
+        end
+      end
+      subject.get('/test') { declared(params).to_json }
+    end
+
+    it 'applies the validations only if the parameter is present' do
+      get '/test'
+      expect(last_response.status).to eq(200)
+
+      get '/test', a: true
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('b is missing')
+
+      get '/test', a: true, b: true
+      expect(last_response.status).to eq(200)
+    end
+
+    it 'raises an error if the dependent parameter was never specified' do
+      expect do
+        subject.params do
+          given :c do
+          end
+        end
+      end.to raise_error(Grape::Exceptions::UnknownParameter)
+    end
+
+    it 'includes the parameter within #declared(params)' do
+      get '/test', a: true, b: true
+
+      expect(JSON.parse(last_response.body)).to eq('a' => 'true', 'b' => 'true')
+    end
+
+    it 'returns a sensible error message within a nested context' do
+      subject.params do
+        requires :bar, type: Hash do
+          optional :a
+          given :a do
+            requires :b
+          end
+        end
+      end
+      subject.get('/nested') { 'worked' }
+
+      get '/nested', bar: { a: true }
+      expect(last_response.status).to eq(400)
+      expect(last_response.body).to eq('bar[b] is missing')
+    end
+  end
 end

data/spec/grape/validations/validators/coerce_spec.rb

@@ -11,6 +11,14 @@ describe Grape::Validations::CoerceValidator do
   end
 
   describe 'coerce' do
+    module CoerceValidatorSpec
+      class User
+        include Virtus.model
+        attribute :id, Integer
+        attribute :name, String
+      end
+    end
+
     context 'i18n' do
       after :each do
         I18n.locale = :en
@@ -82,14 +90,6 @@ describe Grape::Validations::CoerceValidator do
     end
 
     context 'complex objects' do
-      module CoerceValidatorSpec
-        class User
-          include Virtus.model
-          attribute :id, Integer
-          attribute :name, String
-        end
-      end
-
       it 'error on malformed input for complex objects' do
         subject.params do
           requires :user, type: CoerceValidatorSpec::User
@@ -148,6 +148,27 @@ describe Grape::Validations::CoerceValidator do
           expect(last_response.status).to eq(200)
           expect(last_response.body).to eq('TrueClass')
         end
+
+        it 'Array of Complex' do
+          subject.params do
+            requires :arry, coerce: Array[CoerceValidatorSpec::User]
+          end
+          subject.get '/array' do
+            params[:arry].size
+          end
+
+          get 'array', arry: [31]
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('arry is invalid')
+
+          get 'array', arry: { id: 31, name: 'Alice' }
+          expect(last_response.status).to eq(400)
+          expect(last_response.body).to eq('arry is invalid')
+
+          get 'array', arry: [{ id: 31, name: 'Alice' }]
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('1')
+        end
       end
 
       context 'Set' do

data/spec/grape/validations/validators/values_spec.rb

@@ -56,6 +56,13 @@ describe Grape::Validations::ValuesValidator do
           { type: params[:type] }
         end
 
+        params do
+          optional :type, type: Boolean, desc: 'A boolean', values: [true]
+        end
+        get '/values/optional_boolean' do
+          { type: params[:type] }
+        end
+
         params do
           requires :type, type: Integer, desc: 'An integer', values: [10, 11], default: 10
         end
@@ -174,6 +181,11 @@ describe Grape::Validations::ValuesValidator do
     end.to raise_error Grape::Exceptions::IncompatibleOptionValues
   end
 
+  it 'allows values to be true or false when setting the type to boolean' do
+    get('/values/optional_boolean', type: true)
+    expect(last_response.status).to eq 200
+    expect(last_response.body).to eq({ type: true }.to_json)
+  end
   it 'allows values to be a kind of the coerced type not just an instance of it' do
     get('/values/coercion', type: 10)
     expect(last_response.status).to eq 200

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grape
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Michael Bleigh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-18 00:00:00.000000000 Z
+date: 2015-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -317,8 +317,6 @@ files:
 - gemfiles/rails_4.gemfile
 - grape.gemspec
 - grape.png
-- lib/backports/active_support/deep_dup.rb
-- lib/backports/active_support/duplicable.rb
 - lib/grape.rb
 - lib/grape/api.rb
 - lib/grape/api/helpers.rb
@@ -351,6 +349,7 @@ files:
 - lib/grape/exceptions/missing_option.rb
 - lib/grape/exceptions/missing_vendor_option.rb
 - lib/grape/exceptions/unknown_options.rb
+- lib/grape/exceptions/unknown_parameter.rb
 - lib/grape/exceptions/unknown_validator.rb
 - lib/grape/exceptions/unsupported_group_type.rb
 - lib/grape/exceptions/validation.rb
@@ -385,8 +384,10 @@ files:
 - lib/grape/presenters/presenter.rb
 - lib/grape/route.rb
 - lib/grape/util/content_types.rb
+- lib/grape/util/file_response.rb
 - lib/grape/util/inheritable_setting.rb
 - lib/grape/util/inheritable_values.rb
+- lib/grape/util/parameter_types.rb
 - lib/grape/util/stackable_values.rb
 - lib/grape/util/strict_hash_configuration.rb
 - lib/grape/validations.rb
@@ -450,6 +451,7 @@ files:
 - spec/grape/presenters/presenter_spec.rb
 - spec/grape/util/inheritable_setting_spec.rb
 - spec/grape/util/inheritable_values_spec.rb
+- spec/grape/util/parameter_types_spec.rb
 - spec/grape/util/stackable_values_spec.rb
 - spec/grape/util/strict_hash_configuration_spec.rb
 - spec/grape/validations/attributes_iterator_spec.rb
@@ -473,7 +475,7 @@ files:
 - spec/support/endpoint_faker.rb
 - spec/support/file_streamer.rb
 - spec/support/versioned_helpers.rb
-homepage: https://github.com/intridea/grape
+homepage: https://github.com/ruby-grape/grape
 licenses:
 - MIT
 metadata: {}
@@ -492,7 +494,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: grape
+rubyforge_project: 
 rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
@@ -543,6 +545,7 @@ test_files:
 - spec/grape/presenters/presenter_spec.rb
 - spec/grape/util/inheritable_setting_spec.rb
 - spec/grape/util/inheritable_values_spec.rb
+- spec/grape/util/parameter_types_spec.rb
 - spec/grape/util/stackable_values_spec.rb
 - spec/grape/util/strict_hash_configuration_spec.rb
 - spec/grape/validations/attributes_iterator_spec.rb

data/lib/backports/active_support/deep_dup.rb

@@ -1,49 +0,0 @@
-# Backport from Rails 4.x
-# https://github.com/rails/rails/blob/4-0-stable/activesupport/lib/active_support/core_ext/object/deep_dup.rb
-
-require_relative 'duplicable'
-
-class Object
-  # Returns a deep copy of object if it's duplicable. If it's
-  # not duplicable, returns +self+.
-  #
-  #   object = Object.new
-  #   dup    = object.deep_dup
-  #   dup.instance_variable_set(:@a, 1)
-  #
-  #   object.instance_variable_defined?(:@a) #=> false
-  #   dup.instance_variable_defined?(:@a)    #=> true
-  def deep_dup
-    duplicable? ? dup : self
-  end
-end
-
-class Array
-  # Returns a deep copy of array.
-  #
-  #   array = [1, [2, 3]]
-  #   dup   = array.deep_dup
-  #   dup[1][2] = 4
-  #
-  #   array[1][2] #=> nil
-  #   dup[1][2]   #=> 4
-  def deep_dup
-    map(&:deep_dup)
-  end
-end
-
-class Hash
-  # Returns a deep copy of hash.
-  #
-  #   hash = { a: { b: 'b' } }
-  #   dup  = hash.deep_dup
-  #   dup[:a][:c] = 'c'
-  #
-  #   hash[:a][:c] #=> nil
-  #   dup[:a][:c]  #=> "c"
-  def deep_dup
-    each_with_object(dup) do |(key, value), hash|
-      hash[key.deep_dup] = value.deep_dup
-    end
-  end
-end