grape 0.3.0 → 0.7.0

data/spec/grape/api_spec.rb

@@ -4,7 +4,9 @@ require 'shared/versioning_examples'
 describe Grape::API do
   subject { Class.new(Grape::API) }
 
-  def app; subject end
+  def app
+    subject
+  end
 
   describe '.prefix' do
 
@@ -52,17 +54,18 @@ describe Grape::API do
     it_should_behave_like 'versioning' do
       let(:macro_options) do
         {
-          :using => :path
+          using: :path
         }
       end
     end
   end
+
   describe '.version using param' do
     it_should_behave_like 'versioning' do
       let(:macro_options) do
         {
-          :using => :param,
-          :parameter => "apiver"
+          using: :param,
+          parameter: "apiver"
         }
       end
     end
@@ -72,9 +75,9 @@ describe Grape::API do
     it_should_behave_like 'versioning' do
       let(:macro_options) do
         {
-          :using  => :header,
-          :vendor => 'mycompany',
-          :format => 'json'
+          using: :header,
+          vendor: 'mycompany',
+          format: 'json'
         }
       end
     end
@@ -82,7 +85,7 @@ describe Grape::API do
     # Behavior as defined by rfc2616 when no header is defined
     # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
     describe 'no specified accept header' do
-      # subject.version 'v1', :using => :header
+      # subject.version 'v1', using: :header
       # subject.get '/hello' do
       #   'hello'
       # end
@@ -93,22 +96,29 @@ describe Grape::API do
       # end
     end
 
-    it 'routes if any media type is allowed' do
+    # pending 'routes if any media type is allowed'
+  end
 
+  describe '.version using accept_version_header' do
+    it_should_behave_like 'versioning' do
+      let(:macro_options) do
+        {
+          using: :accept_version_header
+        }
+      end
     end
   end
 
   describe '.represent' do
     it 'requires a :with option' do
-      expect{ subject.represent Object, {} }.to raise_error(Grape::Exceptions::InvalidWithOptionForRepresent)
+      expect { subject.represent Object, {} }.to raise_error(Grape::Exceptions::InvalidWithOptionForRepresent)
     end
 
     it 'adds the association to the :representations setting' do
       klass = Class.new
-      subject.represent Object, :with => klass
+      subject.represent Object, with: klass
       subject.settings[:representations][Object].should == klass
     end
-
   end
 
   describe '.namespace' do
@@ -120,10 +130,10 @@ describe Grape::API do
 
     it 'comes after the prefix and version' do
       subject.prefix :rad
-      subject.version 'v1', :using => :path
+      subject.version 'v1', using: :path
 
       subject.namespace :awesome do
-        get('/hello'){ "worked" }
+        get('/hello') { "worked" }
       end
 
       get "/rad/v1/awesome/hello"
@@ -163,10 +173,10 @@ describe Grape::API do
 
     it 'is callable with nil just to push onto the stack' do
       subject.namespace do
-        version 'v2', :using => :path
-        get('/hello'){ "inner" }
+        version 'v2', using: :path
+        get('/hello') { "inner" }
       end
-      subject.get('/hello'){ "outer" }
+      subject.get('/hello') { "outer" }
 
       get '/v2/hello'
       last_response.body.should == "inner"
@@ -183,13 +193,42 @@ describe Grape::API do
     end
   end
 
+  describe '.route_param' do
+    it 'adds a parameterized route segment namespace' do
+      subject.namespace :users do
+        route_param :id do
+          get do
+            params[:id]
+          end
+        end
+      end
+
+      get '/users/23'
+      last_response.body.should == '23'
+    end
+
+    it 'should be able to define requirements with a single hash' do
+      subject.namespace :users do
+        route_param :id, requirements: /[0-9]+/ do
+          get do
+            params[:id]
+          end
+        end
+      end
+
+      get '/users/michael'
+      last_response.status.should == 404
+      get '/users/23'
+      last_response.status.should == 200
+    end
+  end
+
   describe '.route' do
     it 'allows for no path' do
       subject.namespace :votes do
         get do
           "Votes"
         end
-
         post do
           "Created a Vote"
         end
@@ -201,25 +240,32 @@ describe Grape::API do
       last_response.body.should eql 'Created a Vote'
     end
 
+    it 'handles empty calls' do
+      subject.get "/"
+      get "/"
+      last_response.body.should eql ""
+    end
+
     describe 'root routes should work with' do
       before do
+        subject.format :txt
         def subject.enable_root_route!
-          self.get("/") {"root"}
+          get("/") { "root" }
         end
       end
 
       after do
-        last_response.body.should eql 'root'
+        last_response.body.should eql "root"
       end
 
       describe 'path versioned APIs' do
         before do
-          subject.version 'v1', :using => :path
+          subject.version 'v1', using: :path
           subject.enable_root_route!
         end
 
         it 'without a format' do
-          versioned_get "/", "v1", :using => :path
+          versioned_get "/", "v1", using: :path
         end
 
         it 'with a format' do
@@ -228,17 +274,32 @@ describe Grape::API do
       end
 
       it 'header versioned APIs' do
-        subject.version 'v1', :using => :header, :vendor => 'test'
+        subject.version 'v1', using: :header, vendor: 'test'
         subject.enable_root_route!
 
-        versioned_get "/", "v1", :using => :header
+        versioned_get "/", "v1", using: :header, vendor: 'test'
+      end
+
+      it 'header versioned APIs with multiple headers' do
+        subject.version ['v1', 'v2'], using: :header, vendor: 'test'
+        subject.enable_root_route!
+
+        versioned_get "/", "v1", using: :header, vendor: 'test'
+        versioned_get "/", "v2", using: :header, vendor: 'test'
       end
 
       it 'param versioned APIs' do
-        subject.version 'v1', :using => :param
+        subject.version 'v1', using: :param
         subject.enable_root_route!
 
-        versioned_get "/", "v1", :using => :param
+        versioned_get "/", "v1", using: :param
+      end
+
+      it 'Accept-Version header versioned APIs' do
+        subject.version 'v1', using: :accept_version_header
+        subject.enable_root_route!
+
+        versioned_get "/", "v1", using: :accept_version_header
       end
 
       it 'unversioned APIs' do
@@ -262,7 +323,7 @@ describe Grape::API do
     context 'format' do
       before(:each) do
         subject.get("/abc") do
-          RSpec::Mocks::Mock.new(:to_json => 'abc', :to_txt => 'def')
+          RSpec::Mocks::Mock.new(to_json: 'abc', to_txt: 'def')
         end
       end
 
@@ -281,7 +342,7 @@ describe Grape::API do
 
     it 'allows for format without corrupting a param' do
       subject.get('/:id') do
-        {"id" => params[:id]}
+        { "id" => params[:id] }
       end
 
       get '/awesome.json'
@@ -314,6 +375,43 @@ describe Grape::API do
       last_response.body.should eql 'hiya'
     end
 
+    [:put, :post].each do |verb|
+      context verb do
+        ['string', :symbol, 1, -1.1, {}, [], true, false, nil].each do |object|
+          it "allows a(n) #{object.class} json object in params" do
+            subject.format :json
+            subject.send(verb) do
+              env['api.request.body']
+            end
+            send verb, '/', MultiJson.dump(object), 'CONTENT_TYPE' => 'application/json'
+            last_response.status.should == (verb == :post ? 201 : 200)
+            last_response.body.should eql MultiJson.dump(object)
+            last_request.params.should eql Hash.new
+          end
+          it "stores input in api.request.input" do
+            subject.format :json
+            subject.send(verb) do
+              env['api.request.input']
+            end
+            send verb, '/', MultiJson.dump(object), 'CONTENT_TYPE' => 'application/json'
+            last_response.status.should == (verb == :post ? 201 : 200)
+            last_response.body.should eql MultiJson.dump(object).to_json
+          end
+          context "chunked transfer encoding" do
+            it "stores input in api.request.input" do
+              subject.format :json
+              subject.send(verb) do
+                env['api.request.input']
+              end
+              send verb, '/', MultiJson.dump(object), 'CONTENT_TYPE' => 'application/json', 'HTTP_TRANSFER_ENCODING' => 'chunked', 'CONTENT_LENGTH' => nil
+              last_response.status.should == (verb == :post ? 201 : 200)
+              last_response.body.should eql MultiJson.dump(object).to_json
+            end
+          end
+        end
+      end
+    end
+
     it 'allows for multipart paths' do
 
       subject.route([:get, :post], '/:id/first') do
@@ -361,7 +459,7 @@ describe Grape::API do
         last_response.body.should eql verb == 'head' ? '' : verb
         # Call it with a method other than the properly constrained one.
         send(used_verb = verbs[(verbs.index(verb) + 2) % verbs.size], '/example')
-        last_response.status.should eql used_verb == 'options' ? 204 :405
+        last_response.status.should eql used_verb == 'options' ? 204 : 405
       end
     end
 
@@ -375,13 +473,15 @@ describe Grape::API do
       last_response.body.should eql 'Created'
     end
 
-    it 'returns a 405 for an unsupported method' do
+    it 'returns a 405 for an unsupported method with an X-Custom-Header' do
+      subject.before { header 'X-Custom-Header', 'foo' }
       subject.get 'example' do
         "example"
       end
       put '/example'
       last_response.status.should eql 405
       last_response.body.should eql ''
+      last_response.headers['X-Custom-Header'].should eql 'foo'
     end
 
     specify '405 responses includes an Allow header specifying supported methods' do
@@ -395,7 +495,19 @@ describe Grape::API do
       last_response.headers['Allow'].should eql 'OPTIONS, GET, POST, HEAD'
     end
 
-    it 'adds an OPTIONS route that returns a 204 and an Allow header' do
+    specify '405 responses includes an Content-Type header' do
+      subject.get 'example' do
+        "example"
+      end
+      subject.post 'example' do
+        "example"
+      end
+      put '/example'
+      last_response.headers['Content-Type'].should 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"
       end
@@ -403,6 +515,7 @@ describe Grape::API do
       last_response.status.should eql 204
       last_response.body.should eql ''
       last_response.headers['Allow'].should eql 'OPTIONS, GET, HEAD'
+      last_response.headers['X-Custom-Header'].should eql 'foo'
     end
 
     it 'allows HEAD on a GET request' do
@@ -470,17 +583,42 @@ describe Grape::API do
       last_response.body.should eql 'first second'
     end
 
+    it 'adds a before filter to current and child namespaces only' do
+      subject.get '/' do
+        "root - #{@foo}"
+      end
+      subject.namespace :blah do
+        before { @foo = 'foo' }
+        get '/' do
+          "blah - #{@foo}"
+        end
+
+        namespace :bar do
+          get '/' do
+            "blah - bar - #{@foo}"
+          end
+        end
+      end
+
+      get '/'
+      last_response.body.should eql 'root - '
+      get '/blah'
+      last_response.body.should eql 'blah - foo'
+      get '/blah/bar'
+      last_response.body.should eql 'blah - bar - foo'
+    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
+        requires :id, type: Integer
       end
       subject.get '/' do
         "#{@foo} #{@bar}"
       end
 
-      get '/', :id => "32"
+      get '/', id: "32"
       last_response.body.should eql 'first 32:Fixnum second'
     end
 
@@ -496,6 +634,94 @@ describe Grape::API do
       get '/'
       last_response.body.should eql 'default'
     end
+
+    it 'calls all filters when validation passes' do
+      a = double('before mock')
+      b = double('before_validation mock')
+      c = double('after_validation mock')
+      d = double('after mock')
+
+      subject.params do
+        requires :id, type: Integer
+      end
+      subject.resource ':id' do
+        before { a.do_something! }
+        before_validation { b.do_something! }
+        after_validation { c.do_something! }
+        after { d.do_something! }
+        get do
+          'got it'
+        end
+      end
+
+      a.should_receive(:do_something!).exactly(1).times
+      b.should_receive(:do_something!).exactly(1).times
+      c.should_receive(:do_something!).exactly(1).times
+      d.should_receive(:do_something!).exactly(1).times
+
+      get '/123'
+      last_response.status.should eql 200
+      last_response.body.should eql 'got it'
+    end
+
+    it 'calls only before filters when validation fails' do
+      a = double('before mock')
+      b = double('before_validation mock')
+      c = double('after_validation mock')
+      d = double('after mock')
+
+      subject.params do
+        requires :id, type: Integer
+      end
+      subject.resource ':id' do
+        before { a.do_something! }
+        before_validation { b.do_something! }
+        after_validation { c.do_something! }
+        after { d.do_something! }
+        get do
+          'got it'
+        end
+      end
+
+      a.should_receive(:do_something!).exactly(1).times
+      b.should_receive(:do_something!).exactly(1).times
+      c.should_receive(:do_something!).exactly(0).times
+      d.should_receive(:do_something!).exactly(0).times
+
+      get '/abc'
+      last_response.status.should eql 400
+      last_response.body.should eql 'id is invalid'
+    end
+
+    it 'calls filters in the correct order' do
+      i = 0
+      a = double('before mock')
+      b = double('before_validation mock')
+      c = double('after_validation mock')
+      d = double('after mock')
+
+      subject.params do
+        requires :id, type: Integer
+      end
+      subject.resource ':id' do
+        before { a.here(i += 1) }
+        before_validation { b.here(i += 1) }
+        after_validation { c.here(i += 1) }
+        after { d.here(i += 1) }
+        get do
+          'got it'
+        end
+      end
+
+      a.should_receive(:here).with(1).exactly(1).times
+      b.should_receive(:here).with(2).exactly(1).times
+      c.should_receive(:here).with(3).exactly(1).times
+      d.should_receive(:here).with(4).exactly(1).times
+
+      get '/123'
+      last_response.status.should eql 200
+      last_response.body.should eql 'got it'
+    end
   end
 
   context 'format' do
@@ -532,6 +758,26 @@ describe Grape::API do
       get '/error.xml'
       last_response.headers['Content-Type'].should eql 'application/xml'
     end
+
+    context 'with a custom content_type' do
+      before do
+        subject.content_type :custom, 'application/custom'
+        subject.formatter :custom, lambda { |object, env| "custom" }
+
+        subject.get('/custom') { 'bar' }
+        subject.get('/error') { error!('error in custom', 500) }
+      end
+
+      it 'sets content type' do
+        get '/custom.custom'
+        last_response.headers['Content-Type'].should eql 'application/custom'
+      end
+
+      it 'sets content type for error' do
+        get '/error.custom'
+        last_response.headers['Content-Type'].should eql 'application/custom'
+      end
+    end
   end
 
   context 'custom middleware' do
@@ -555,18 +801,19 @@ describe Grape::API do
     describe '.middleware' do
       it 'includes middleware arguments from settings' do
         settings = Grape::Util::HashStack.new
-        settings.stub!(:stack).and_return([{:middleware => [[ApiSpec::PhonyMiddleware, 'abc', 123]]}])
-        subject.stub!(:settings).and_return(settings)
+        settings.stub(:stack).and_return([{ middleware: [[ApiSpec::PhonyMiddleware, 'abc', 123]] }])
+        subject.stub(:settings).and_return(settings)
         subject.middleware.should eql [[ApiSpec::PhonyMiddleware, 'abc', 123]]
       end
 
       it 'includes all middleware from stacked settings' do
         settings = Grape::Util::HashStack.new
-        settings.stub!(:stack).and_return [
-          {:middleware => [[ApiSpec::PhonyMiddleware, 123],[ApiSpec::PhonyMiddleware, 'abc']]},
-          {:middleware => [[ApiSpec::PhonyMiddleware, 'foo']]}
+        settings.stub(:stack).and_return [
+          { middleware: [[ApiSpec::PhonyMiddleware, 123], [ApiSpec::PhonyMiddleware, 'abc']] },
+          { middleware: [[ApiSpec::PhonyMiddleware, 'foo']] }
         ]
-        subject.stub!(:settings).and_return(settings)
+
+        subject.stub(:settings).and_return(settings)
 
         subject.middleware.should eql [
           [ApiSpec::PhonyMiddleware, 123],
@@ -586,7 +833,7 @@ describe Grape::API do
         subject.use ApiSpec::PhonyMiddleware, 123
         subject.namespace :awesome do
           use ApiSpec::PhonyMiddleware, 'abc'
-          middleware.should == [[ApiSpec::PhonyMiddleware, 123],[ApiSpec::PhonyMiddleware, 'abc']]
+          middleware.should == [[ApiSpec::PhonyMiddleware, 123], [ApiSpec::PhonyMiddleware, 'abc']]
         end
 
         subject.middleware.should eql [[ApiSpec::PhonyMiddleware, 123]]
@@ -603,13 +850,13 @@ describe Grape::API do
       end
 
       it 'adds a block if one is given' do
-        block = lambda{ }
+        block = lambda {}
         subject.use ApiSpec::PhonyMiddleware, &block
         subject.middleware.should eql [[ApiSpec::PhonyMiddleware, block]]
       end
 
       it 'uses a block if one is given' do
-        block = lambda{ }
+        block = lambda {}
         subject.use ApiSpec::PhonyMiddleware, &block
         subject.get '/' do
           env['phony.block'].inspect
@@ -620,7 +867,7 @@ describe Grape::API do
       end
 
       it 'does not destroy the middleware settings on multiple runs' do
-        block = lambda{ }
+        block = lambda {}
         subject.use ApiSpec::PhonyMiddleware, &block
         subject.get '/' do
           env['phony.block'].inspect
@@ -631,28 +878,42 @@ describe Grape::API do
           last_response.body.should == 'true'
         end
       end
+
+      it 'mounts behind error middleware' do
+        m = Class.new(Grape::Middleware::Base) do
+          def before
+            throw :error, message: "Caught in the Net", status: 400
+          end
+        end
+        subject.use m
+        subject.get "/" do
+        end
+        get "/"
+        last_response.status.should == 400
+        last_response.body.should == "Caught in the Net"
+      end
     end
   end
-  describe '.basic' do
+  describe '.http_basic' do
     it 'protects any resources on the same scope' do
-      subject.http_basic do |u,p|
+      subject.http_basic do |u, p|
         u == 'allow'
       end
-      subject.get(:hello){ "Hello, world."}
+      subject.get(:hello) { "Hello, world." }
       get '/hello'
       last_response.status.should eql 401
-      get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow','whatever')
+      get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow', 'whatever')
       last_response.status.should eql 200
     end
 
     it 'is scopable' do
-      subject.get(:hello){ "Hello, world."}
+      subject.get(:hello) { "Hello, world." }
       subject.namespace :admin do
-        http_basic do |u,p|
+        http_basic do |u, p|
           u == 'allow'
         end
 
-        get(:hello){ "Hello, world." }
+        get(:hello) { "Hello, world." }
       end
 
       get '/hello'
@@ -662,15 +923,60 @@ describe Grape::API do
     end
 
     it 'is callable via .auth as well' do
-      subject.auth :http_basic do |u,p|
+      subject.auth :http_basic do |u, p|
         u == 'allow'
       end
 
-      subject.get(:hello){ "Hello, world."}
+      subject.get(:hello) { "Hello, world." }
       get '/hello'
       last_response.status.should eql 401
-      get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow','whatever')
+      get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow', 'whatever')
+      last_response.status.should eql 200
+    end
+
+    it 'has access to the current endpoint' do
+      basic_auth_context = nil
+
+      subject.http_basic do |u, p|
+        basic_auth_context = self
+
+        u == 'allow'
+      end
+
+      subject.get(:hello) { "Hello, world." }
+      get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow', 'whatever')
+      basic_auth_context.should be_an_instance_of(Grape::Endpoint)
+    end
+
+    it 'has access to helper methods' do
+      subject.helpers do
+        def authorize(u, p)
+          u == 'allow' && p == 'whatever'
+        end
+      end
+
+      subject.http_basic do |u, p|
+        authorize(u, p)
+      end
+
+      subject.get(:hello) { "Hello, world." }
+      get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow', 'whatever')
+      last_response.status.should eql 200
+      get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('disallow', 'whatever')
+      last_response.status.should eql 401
+    end
+
+    it 'can set instance variables accessible to routes' do
+      subject.http_basic do |u, p|
+        @hello = "Hello, world."
+
+        u == 'allow'
+      end
+
+      subject.get(:hello) { @hello }
+      get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic_auth('allow', 'whatever')
       last_response.status.should eql 200
+      last_response.body.should eql "Hello, world."
     end
   end
 
@@ -685,6 +991,13 @@ describe Grape::API do
       mylogger.should_receive(:info).exactly(1).times
       subject.logger.info "this will be logged"
     end
+
+    it "defaults to a standard logger log format" do
+      t = Time.at(100)
+      Time.stub(:now).and_return(t)
+      STDOUT.should_receive(:write).with("I, [#{Logger::Formatter.new.send(:format_datetime, t)}\##{Process.pid}]  INFO -- : this will be logged\n")
+      subject.logger.info "this will be logged"
+    end
   end
 
   describe '.helpers' do
@@ -749,7 +1062,7 @@ describe Grape::API do
         [one, two]
       end
 
-      lambda{get '/howdy'}.should_not raise_error
+      lambda { get '/howdy' }.should_not raise_error
     end
 
     it 'allows for modules' do
@@ -787,7 +1100,7 @@ describe Grape::API do
       subject.get 'howdy' do
         [one, two, three]
       end
-      lambda{get '/howdy'}.should_not raise_error
+      lambda { get '/howdy' }.should_not raise_error
     end
   end
 
@@ -833,39 +1146,58 @@ describe Grape::API do
         raise "rain!"
       end
       get '/exception'
-      last_response.status.should eql 403
+      last_response.status.should eql 500
     end
 
     it 'rescues only certain errors if rescue_from is called with specific errors' do
       subject.rescue_from ArgumentError
-      subject.get('/rescued'){ raise ArgumentError }
-      subject.get('/unrescued'){ raise "beefcake" }
+      subject.get('/rescued') { raise ArgumentError }
+      subject.get('/unrescued') { raise "beefcake" }
 
       get '/rescued'
-      last_response.status.should eql 403
+      last_response.status.should eql 500
 
-      lambda{ get '/unrescued' }.should raise_error
+      lambda { get '/unrescued' }.should raise_error
     end
 
-    it 'does not re-raise exceptions of type Grape::Exception::Base' do
-      class CustomError < Grape::Exceptions::Base; end
-      subject.get('/custom_exception'){ raise CustomError }
+    context 'CustomError subclass of Grape::Exceptions::Base' do
+      before do
+        class CustomError < Grape::Exceptions::Base; end
+      end
 
-      lambda{ get '/custom_exception' }.should_not raise_error
-    end
+      it 'does not re-raise exceptions of type Grape::Exceptions::Base' do
+        subject.get('/custom_exception') { raise CustomError }
 
-    it 'rescues custom grape exceptions' do
-      class CustomError < Grape::Exceptions::Base; end
-      subject.rescue_from CustomError do |e|
-        rack_response('New Error', e.status)
+        lambda { get '/custom_exception' }.should_not raise_error
       end
-      subject.get '/custom_error' do
-        raise CustomError, :status => 400, :message => 'Custom Error'
+
+      it 'rescues custom grape exceptions' do
+        subject.rescue_from CustomError do |e|
+          rack_response('New Error', e.status)
+        end
+        subject.get '/custom_error' do
+          raise CustomError, status: 400, message: 'Custom Error'
+        end
+
+        get '/custom_error'
+        last_response.status.should == 400
+        last_response.body.should == 'New Error'
       end
+    end
 
-      get '/custom_error'
-      last_response.status.should == 400
-      last_response.body.should == 'New Error'
+    it 'can rescue exceptions raised in the formatter' do
+      formatter = double(:formatter)
+      formatter.stub(:call) { raise StandardError }
+      Grape::Formatter::Base.stub(:formatter_for) { formatter }
+
+      subject.rescue_from :all do |e|
+        rack_response('Formatter Error', 500)
+      end
+      subject.get('/formatter_exception') { 'Hello world' }
+
+      get '/formatter_exception'
+      last_response.status.should eql 500
+      last_response.body.should == 'Formatter Error'
     end
   end
 
@@ -881,61 +1213,144 @@ describe Grape::API do
       last_response.status.should eql 202
       last_response.body.should == 'rescued from rain!'
     end
-    it 'rescues an error via rescue_from :all' do
-      class ConnectionError < RuntimeError; end
-      subject.rescue_from :all do |e|
-        rack_response("rescued from #{e.class.name}", 500)
+
+    context 'custom errors' do
+      before do
+        class ConnectionError < RuntimeError; end
+        class DatabaseError < RuntimeError; end
+        class CommunicationError < StandardError; end
       end
-      subject.get '/exception' do
-        raise ConnectionError
+
+      it 'rescues an error via rescue_from :all' do
+        subject.rescue_from :all do |e|
+          rack_response("rescued from #{e.class.name}", 500)
+        end
+        subject.get '/exception' do
+          raise ConnectionError
+        end
+        get '/exception'
+        last_response.status.should eql 500
+        last_response.body.should == 'rescued from ConnectionError'
+      end
+      it 'rescues a specific error' do
+        subject.rescue_from ConnectionError do |e|
+          rack_response("rescued from #{e.class.name}", 500)
+        end
+        subject.get '/exception' do
+          raise ConnectionError
+        end
+        get '/exception'
+        last_response.status.should eql 500
+        last_response.body.should == 'rescued from ConnectionError'
+      end
+      it 'rescues multiple specific errors' do
+        subject.rescue_from ConnectionError do |e|
+          rack_response("rescued from #{e.class.name}", 500)
+        end
+        subject.rescue_from DatabaseError do |e|
+          rack_response("rescued from #{e.class.name}", 500)
+        end
+        subject.get '/connection' do
+          raise ConnectionError
+        end
+        subject.get '/database' do
+          raise DatabaseError
+        end
+        get '/connection'
+        last_response.status.should eql 500
+        last_response.body.should == 'rescued from ConnectionError'
+        get '/database'
+        last_response.status.should eql 500
+        last_response.body.should == 'rescued from DatabaseError'
+      end
+      it 'does not rescue a different error' do
+        subject.rescue_from RuntimeError do |e|
+          rack_response("rescued from #{e.class.name}", 500)
+        end
+        subject.get '/uncaught' do
+          raise CommunicationError
+        end
+        lambda { get '/uncaught' }.should raise_error(CommunicationError)
       end
-      get '/exception'
-      last_response.status.should eql 500
-      last_response.body.should == 'rescued from ConnectionError'
     end
-    it 'rescues a specific error' do
-      class ConnectionError < RuntimeError; end
-      subject.rescue_from ConnectionError do |e|
-        rack_response("rescued from #{e.class.name}", 500)
+  end
+
+  describe '.rescue_from klass, lambda' do
+    it 'rescues an error with the lambda' do
+      subject.rescue_from ArgumentError, lambda {
+        rack_response("rescued with a lambda", 400)
+      }
+      subject.get('/rescue_lambda') { raise ArgumentError }
+
+      get '/rescue_lambda'
+      last_response.status.should == 400
+      last_response.body.should == "rescued with a lambda"
+    end
+
+    it 'can execute the lambda with an argument' do
+      subject.rescue_from ArgumentError, lambda { |e|
+        rack_response(e.message, 400)
+      }
+      subject.get('/rescue_lambda') { raise ArgumentError, 'lambda takes an argument' }
+
+      get '/rescue_lambda'
+      last_response.status.should == 400
+      last_response.body.should == 'lambda takes an argument'
+    end
+  end
+
+  describe '.rescue_from klass, with: method' do
+    it 'rescues an error with the specified message' do
+      def rescue_arg_error
+        Rack::Response.new('rescued with a method', 400)
       end
-      subject.get '/exception' do
-        raise ConnectionError
+
+      subject.rescue_from ArgumentError, with: rescue_arg_error
+      subject.get('/rescue_method') { raise ArgumentError }
+
+      get '/rescue_method'
+      last_response.status.should == 400
+      last_response.body.should == 'rescued with a method'
+    end
+  end
+
+  describe '.rescue_from klass, rescue_subclasses: boolean' do
+    before do
+      module APIErrors
+        class ParentError < StandardError; end
+        class ChildError < ParentError; end
       end
-      get '/exception'
-      last_response.status.should eql 500
-      last_response.body.should == 'rescued from ConnectionError'
     end
-    it 'rescues multiple specific errors' do
-      class ConnectionError < RuntimeError; end
-      class DatabaseError < RuntimeError; end
-      subject.rescue_from ConnectionError do |e|
+
+    it 'rescues error as well as subclass errors with rescue_subclasses option set' do
+      subject.rescue_from APIErrors::ParentError, rescue_subclasses: true do |e|
         rack_response("rescued from #{e.class.name}", 500)
       end
-      subject.rescue_from DatabaseError do |e|
-        rack_response("rescued from #{e.class.name}", 500)
+      subject.get '/caught_child' do
+        raise APIErrors::ChildError
       end
-      subject.get '/connection' do
-        raise ConnectionError
+      subject.get '/caught_parent' do
+        raise APIErrors::ParentError
       end
-      subject.get '/database' do
-        raise DatabaseError
+      subject.get '/uncaught_parent' do
+        raise StandardError
       end
-      get '/connection'
+
+      get '/caught_child'
       last_response.status.should eql 500
-      last_response.body.should == 'rescued from ConnectionError'
-      get '/database'
+      get '/caught_parent'
       last_response.status.should eql 500
-      last_response.body.should == 'rescued from DatabaseError'
+      lambda { get '/uncaught_parent' }.should raise_error(StandardError)
     end
-    it 'does not rescue a different error' do
-      class CommunicationError < RuntimeError; end
-      subject.rescue_from RuntimeError do |e|
+
+    it 'does not rescue child errors if rescue_subclasses is false' do
+      subject.rescue_from APIErrors::ParentError, rescue_subclasses: false do |e|
         rack_response("rescued from #{e.class.name}", 500)
       end
       subject.get '/uncaught' do
-        raise CommunicationError
+        raise APIErrors::ChildError
       end
-      lambda { get '/uncaught' }.should raise_error(CommunicationError)
+      lambda { get '/uncaught' }.should raise_error(APIErrors::ChildError)
     end
   end
 
@@ -951,13 +1366,13 @@ describe Grape::API do
     end
 
     it 'rescues all errors and return :txt with backtrace' do
-      subject.rescue_from :all, :backtrace => true
+      subject.rescue_from :all, backtrace: true
       subject.format :txt
       subject.get '/exception' do
         raise "rain!"
       end
       get '/exception'
-      last_response.body.start_with?("rain!\r\n").should be_true
+      last_response.body.start_with?("rain!\r\n").should be true
     end
 
     it 'rescues all errors with a default formatter' do
@@ -994,7 +1409,7 @@ describe Grape::API do
         end
       end
       it 'returns a custom error format' do
-        subject.rescue_from :all, :backtrace => true
+        subject.rescue_from :all, backtrace: true
         subject.error_formatter :txt, CustomErrorFormatter
         subject.get '/exception' do
           raise "rain!"
@@ -1004,6 +1419,27 @@ describe Grape::API do
       end
     end
 
+    describe 'with' do
+      context 'class' do
+        before :each do
+          class CustomErrorFormatter
+            def self.call(message, backtrace, option, env)
+              "message: #{message} @backtrace"
+            end
+          end
+        end
+
+        it 'returns a custom error format' do
+          subject.rescue_from :all, backtrace: true
+          subject.error_formatter :txt, with: CustomErrorFormatter
+          subject.get('/exception') { raise "rain!" }
+
+          get '/exception'
+          last_response.body.should == 'message: rain! @backtrace'
+        end
+      end
+    end
+
     it 'rescues all errors and return :json' do
       subject.rescue_from :all
       subject.format :json
@@ -1014,7 +1450,7 @@ describe Grape::API do
       last_response.body.should eql '{"error":"rain!"}'
     end
     it 'rescues all errors and return :json with backtrace' do
-      subject.rescue_from :all, :backtrace => true
+      subject.rescue_from :all, backtrace: true
       subject.format :json
       subject.get '/exception' do
         raise "rain!"
@@ -1073,10 +1509,10 @@ describe Grape::API do
   describe '.formatter' do
     context 'multiple formatters' do
       before :each do
-        subject.formatter :json, lambda { |object, env| "{\"custom_formatter\":\"#{object[:some]}\"}" }
-        subject.formatter :txt, lambda { |object, env| "custom_formatter: #{object[:some]}" }
+        subject.formatter :json, lambda { |object, env| "{\"custom_formatter\":\"#{object[:some] }\"}" }
+        subject.formatter :txt, lambda { |object, env| "custom_formatter: #{object[:some] }" }
         subject.get :simple do
-          {:some => 'hash'}
+          { some: 'hash' }
         end
       end
       it 'sets one formatter' do
@@ -1092,9 +1528,9 @@ describe Grape::API do
       before :each do
         subject.content_type :json, 'application/json'
         subject.content_type :custom, 'application/custom'
-        subject.formatter :custom, lambda { |object, env| "{\"custom_formatter\":\"#{object[:some]}\"}" }
+        subject.formatter :custom, lambda { |object, env| "{\"custom_formatter\":\"#{object[:some] }\"}" }
         subject.get :simple do
-          {:some => 'hash'}
+          { some: 'hash' }
         end
       end
       it 'uses json' do
@@ -1102,14 +1538,14 @@ describe Grape::API do
         last_response.body.should eql '{"some":"hash"}'
       end
       it 'uses custom formatter' do
-        get '/simple.custom', { 'HTTP_ACCEPT' => 'application/custom' }
+        get '/simple.custom', 'HTTP_ACCEPT' => 'application/custom'
         last_response.body.should eql '{"custom_formatter":"hash"}'
       end
     end
     context 'custom formatter class' do
       module CustomFormatter
         def self.call(object, env)
-          "{\"custom_formatter\":\"#{object[:some]}\"}"
+          "{\"custom_formatter\":\"#{object[:some] }\"}"
         end
       end
       before :each do
@@ -1117,7 +1553,7 @@ describe Grape::API do
         subject.content_type :custom, 'application/custom'
         subject.formatter :custom, CustomFormatter
         subject.get :simple do
-          {:some => 'hash'}
+          { some: 'hash' }
         end
       end
       it 'uses json' do
@@ -1125,13 +1561,22 @@ describe Grape::API do
         last_response.body.should eql '{"some":"hash"}'
       end
       it 'uses custom formatter' do
-        get '/simple.custom', { 'HTTP_ACCEPT' => 'application/custom' }
+        get '/simple.custom', 'HTTP_ACCEPT' => 'application/custom'
         last_response.body.should eql '{"custom_formatter":"hash"}'
       end
     end
   end
 
   describe '.parser' do
+    it 'parses data in format requested by content-type' do
+      subject.format :json
+      subject.post '/data' do
+        { x: params[:x] }
+      end
+      post "/data", '{"x":42}', 'CONTENT_TYPE' => 'application/json'
+      last_response.status.should == 201
+      last_response.body.should == '{"x":42}'
+    end
     context 'lambda parser' do
       before :each do
         subject.content_type :txt, "text/plain"
@@ -1141,7 +1586,7 @@ describe Grape::API do
           params[:simple]
         end
       end
-      [ "text/custom", "text/custom; charset=UTF-8" ].each do |content_type|
+      ["text/custom", "text/custom; charset=UTF-8"].each do |content_type|
         it "uses parser for #{content_type}" do
           put '/simple', "simple", "CONTENT_TYPE" => content_type
           last_response.status.should == 200
@@ -1179,6 +1624,42 @@ describe Grape::API do
         last_response.body.should eql 'Disallowed type attribute: "symbol"'
       end
     end
+    context "none parser class" do
+      before :each do
+        subject.parser :json, nil
+        subject.put "data" do
+          "body: #{env['api.request.body'] }"
+        end
+      end
+      it "does not parse data" do
+        put '/data', 'not valid json', "CONTENT_TYPE" => "application/json"
+        last_response.status.should == 200
+        last_response.body.should == "body: not valid json"
+      end
+    end
+  end
+
+  describe '.default_format' do
+    before :each do
+      subject.format :json
+      subject.default_format :json
+    end
+    it 'returns data in default format' do
+      subject.get '/data' do
+        { x: 42 }
+      end
+      get "/data"
+      last_response.status.should == 200
+      last_response.body.should == '{"x":42}'
+    end
+    it 'parses data in default format' do
+      subject.post '/data' do
+        { x: params[:x] }
+      end
+      post "/data", '{"x":42}', "CONTENT_TYPE" => ""
+      last_response.status.should == 201
+      last_response.body.should == '{"x":42}'
+    end
   end
 
   describe '.default_error_status' do
@@ -1197,7 +1678,16 @@ describe Grape::API do
         raise "rain!"
       end
       get '/exception'
-      last_response.status.should eql 403
+      last_response.status.should eql 500
+    end
+    it 'uses the default error status in error!' do
+      subject.rescue_from :all
+      subject.default_error_status 400
+      subject.get '/exception' do
+        error! "rain!"
+      end
+      get '/exception'
+      last_response.status.should eql 400
     end
   end
 
@@ -1210,76 +1700,76 @@ describe Grape::API do
     describe 'single method api structure' do
       before(:each) do
         subject.get :ping do
-           'pong'
+          'pong'
         end
       end
       it 'returns one route' do
-         subject.routes.size.should == 1
-         route = subject.routes[0]
-         route.route_version.should be_nil
-         route.route_path.should == "/ping(.:format)"
-         route.route_method.should == "GET"
+        subject.routes.size.should == 1
+        route = subject.routes[0]
+        route.route_version.should be_nil
+        route.route_path.should == "/ping(.:format)"
+        route.route_method.should == "GET"
       end
     end
     describe 'api structure with two versions and a namespace' do
       before :each do
-        subject.version 'v1', :using => :path
+        subject.version 'v1', using: :path
         subject.get 'version' do
-           api.version
+          api.version
         end
         # version v2
-        subject.version 'v2', :using => :path
+        subject.version 'v2', using: :path
         subject.prefix 'p'
         subject.namespace 'n1' do
           namespace 'n2' do
             get 'version' do
-               api.version
+              api.version
             end
           end
         end
       end
       it 'returns the latest version set' do
-         subject.version.should == 'v2'
+        subject.version.should == 'v2'
       end
       it 'returns versions' do
-         subject.versions.should == [ 'v1', 'v2' ]
+        subject.versions.should == ['v1', 'v2']
       end
       it 'sets route paths' do
-         subject.routes.size.should >= 2
-         subject.routes[0].route_path.should == "/:version/version(.:format)"
-         subject.routes[1].route_path.should == "/p/:version/n1/n2/version(.:format)"
+        subject.routes.size.should >= 2
+        subject.routes[0].route_path.should == "/:version/version(.:format)"
+        subject.routes[1].route_path.should == "/p/:version/n1/n2/version(.:format)"
       end
       it 'sets route versions' do
-         subject.routes[0].route_version.should == 'v1'
-         subject.routes[1].route_version.should == 'v2'
+        subject.routes[0].route_version.should == 'v1'
+        subject.routes[1].route_version.should == 'v2'
       end
       it 'sets a nested namespace' do
-         subject.routes[1].route_namespace.should == "/n1/n2"
+        subject.routes[1].route_namespace.should == "/n1/n2"
       end
       it 'sets prefix' do
-         subject.routes[1].route_prefix.should == 'p'
+        subject.routes[1].route_prefix.should == 'p'
       end
     end
     describe 'api structure with additional parameters' do
       before(:each) do
-        subject.get 'split/:string', { :params => { "token" => "a token" }, :optional_params => { "limit" => "the limit" } } do
+        subject.get 'split/:string', params: { "token" => "a token" }, optional_params: { "limit" => "the limit" } do
           params[:string].split(params[:token], (params[:limit] || 0).to_i)
         end
       end
       it 'splits a string' do
-        get "/split/a,b,c.json", :token => ','
+        get "/split/a,b,c.json", token: ','
         last_response.body.should == '["a","b","c"]'
       end
       it 'splits a string with limit' do
-        get "/split/a,b,c.json", :token => ',', :limit => '2'
+        get "/split/a,b,c.json", token: ',', limit: '2'
         last_response.body.should == '["a","b,c"]'
       end
       it 'sets route_params' do
         subject.routes.map { |route|
-          { :params => route.route_params, :optional_params => route.route_optional_params }
+          { params: route.route_params, optional_params: route.route_optional_params }
         }.should eq [
-          { :params => { "string" => "", "token" => "a token" }, :optional_params => { "limit" => "the limit" } }
-        ]
+          { params: { "string" => "", "token" => "a token" }, optional_params: { "limit" => "the limit" } }
+      ]
       end
     end
   end
@@ -1299,7 +1789,7 @@ describe Grape::API do
       route = subject.routes.first
       route.route_description.should == "first method"
       route.route_foo.should be_nil
-      route.route_params.should == { }
+      route.route_params.should == {}
     end
     it 'describes methods separately' do
       subject.desc "first method"
@@ -1308,122 +1798,120 @@ describe Grape::API do
       subject.get :second do ; end
       subject.routes.count.should == 2
       subject.routes.map { |route|
-        { :description => route.route_description, :params => route.route_params }
+        { description: route.route_description, params: route.route_params }
       }.should eq [
-        { :description => "first method", :params => {} },
-        { :description => "second method", :params => {} }
-      ]
+        { description: "first method", params: {} },
+        { description: "second method", params: {} }
+    ]
     end
     it 'resets desc' do
       subject.desc "first method"
       subject.get :first do ; end
       subject.get :second do ; end
       subject.routes.map { |route|
-        { :description => route.route_description, :params => route.route_params }
+        { description: route.route_description, params: route.route_params }
       }.should eq [
-        { :description => "first method", :params => {} },
-        { :description => nil, :params => {} }
-      ]
+        { description: "first method", params: {} },
+        { description: nil, params: {} }
+    ]
     end
     it 'namespaces and describe arbitrary parameters' do
       subject.namespace 'ns' do
-        desc "ns second", :foo => "bar"
+        desc "ns second", foo: "bar"
         get 'second' do ; end
       end
       subject.routes.map { |route|
-        { :description => route.route_description, :foo => route.route_foo, :params => route.route_params }
+        { description: route.route_description, foo: route.route_foo, params: route.route_params }
       }.should eq [
-        { :description => "ns second", :foo => "bar", :params => {} },
-      ]
+        { description: "ns second", foo: "bar", params: {} },
+    ]
     end
     it 'includes details' do
-      subject.desc "method", :details => "method details"
+      subject.desc "method", details: "method details"
       subject.get 'method' do ; end
       subject.routes.map { |route|
-        { :description => route.route_description, :details => route.route_details, :params => route.route_params }
+        { description: route.route_description, details: route.route_details, params: route.route_params }
       }.should eq [
-        { :description => "method", :details => "method details", :params => {} },
-      ]
+        { description: "method", details: "method details", params: {} },
+    ]
     end
     it 'describes a method with parameters' do
-      subject.desc "Reverses a string.", { :params =>
-        { "s" => { :desc => "string to reverse", :type => "string" }}
-      }
+      subject.desc "Reverses a string.", params: { "s" => { desc: "string to reverse", type: "string" } }
       subject.get 'reverse' do
         params[:s].reverse
       end
       subject.routes.map { |route|
-        { :description => route.route_description, :params => route.route_params }
+        { description: route.route_description, params: route.route_params }
       }.should eq [
-        { :description => "Reverses a string.", :params => { "s" => { :desc => "string to reverse", :type => "string" } } }
-      ]
+        { description: "Reverses a string.", params: { "s" => { desc: "string to reverse", type: "string" } } }
+    ]
     end
     it 'merges the parameters of the namespace with the parameters of the method' do
       subject.desc "namespace"
       subject.params do
-        requires :ns_param, :desc => "namespace parameter"
+        requires :ns_param, desc: "namespace parameter"
       end
       subject.namespace 'ns' do
         desc "method"
         params do
-          optional :method_param, :desc => "method parameter"
+          optional :method_param, desc: "method parameter"
         end
         get 'method' do ; end
       end
       subject.routes.map { |route|
-        { :description => route.route_description, :params => route.route_params }
+        { description: route.route_description, params: route.route_params }
       }.should eq [
-        { :description => "method",
-          :params => {
-            "ns_param" => { :required => true, :desc => "namespace parameter" },
-            "method_param" => { :required => false, :desc => "method parameter" }
+        { description: "method",
+          params: {
+            "ns_param" => { required: true, desc: "namespace parameter" },
+            "method_param" => { required: false, desc: "method parameter" }
           }
         }
-      ]
+    ]
     end
     it 'merges the parameters of nested namespaces' do
       subject.desc "ns1"
       subject.params do
-        optional :ns_param, :desc => "ns param 1"
-        requires :ns1_param, :desc => "ns1 param"
+        optional :ns_param, desc: "ns param 1"
+        requires :ns1_param, desc: "ns1 param"
       end
       subject.namespace 'ns1' do
         desc "ns2"
         params do
-          requires :ns_param, :desc => "ns param 2"
-          requires :ns2_param, :desc => "ns2 param"
+          requires :ns_param, desc: "ns param 2"
+          requires :ns2_param, desc: "ns2 param"
         end
         namespace 'ns2' do
           desc "method"
           params do
-            optional :method_param, :desc => "method param"
+            optional :method_param, desc: "method param"
           end
           get 'method' do ; end
         end
       end
       subject.routes.map { |route|
-        { :description => route.route_description, :params => route.route_params }
+        { description: route.route_description, params: route.route_params }
       }.should eq [
-        { :description => "method",
-          :params => {
-            "ns_param" => { :required => true, :desc => "ns param 2" },
-            "ns1_param" => { :required => true, :desc => "ns1 param" },
-            "ns2_param" => { :required => true, :desc => "ns2 param" },
-            "method_param" => { :required => false, :desc => "method param" }
+        { description: "method",
+          params: {
+            "ns_param" => { required: true, desc: "ns param 2" },
+            "ns1_param" => { required: true, desc: "ns1 param" },
+            "ns2_param" => { required: true, desc: "ns2 param" },
+            "method_param" => { required: false, desc: "method param" }
           }
         }
-      ]
+    ]
     end
     it "groups nested params and prevents overwriting of params with same name in different groups" do
       subject.desc "method"
       subject.params do
         group :group1 do
-          optional :param1, :desc => "group1 param1 desc"
-          requires :param2, :desc => "group1 param2 desc"
+          optional :param1, desc: "group1 param1 desc"
+          requires :param2, desc: "group1 param2 desc"
         end
         group :group2 do
-          optional :param1, :desc => "group2 param1 desc"
-          requires :param2, :desc => "group2 param2 desc"
+          optional :param1, desc: "group2 param1 desc"
+          requires :param2, desc: "group2 param2 desc"
         end
       end
       subject.get "method" do ; end
@@ -1431,60 +1919,68 @@ describe Grape::API do
       subject.routes.map { |route|
         route.route_params
       }.should eq [{
-        "group1[param1]" => { :required => false, :desc => "group1 param1 desc" },
-        "group1[param2]" => { :required => true, :desc => "group1 param2 desc" },
-        "group2[param1]" => { :required => false, :desc => "group2 param1 desc" },
-        "group2[param2]" => { :required => true, :desc => "group2 param2 desc" }
+        "group1"         => { required: true, type: "Array" },
+        "group1[param1]" => { required: false, desc: "group1 param1 desc" },
+        "group1[param2]" => { required: true, desc: "group1 param2 desc" },
+        "group2"         => { required: true, type: "Array" },
+        "group2[param1]" => { required: false, desc: "group2 param1 desc" },
+        "group2[param2]" => { required: true, desc: "group2 param2 desc" }
       }]
     end
     it 'uses full name of parameters in nested groups' do
       subject.desc "nesting"
       subject.params do
-        requires :root_param, :desc => "root param"
+        requires :root_param, desc: "root param"
         group :nested do
-          requires :nested_param, :desc => "nested param"
+          requires :nested_param, desc: "nested param"
         end
       end
       subject.get 'method' do ; end
       subject.routes.map { |route|
-        { :description => route.route_description, :params => route.route_params }
+        { description: route.route_description, params: route.route_params }
       }.should eq [
-        { :description => "nesting",
-          :params => {
-            "root_param" => { :required => true, :desc => "root param" },
-            "nested[nested_param]" => { :required => true, :desc => "nested param" }
+        { description: "nesting",
+          params: {
+            "root_param" => { required: true, desc: "root param" },
+            "nested" => { required: true, type: "Array" },
+            "nested[nested_param]" => { required: true, desc: "nested param" }
           }
         }
-      ]
+    ]
+    end
+    it 'allows to set the type attribute on :group element' do
+      subject.params do
+        group :foo, type: Array do
+          optional :bar
+        end
+      end
     end
     it 'parses parameters when no description is given' do
       subject.params do
-        requires :one_param, :desc => "one param"
+        requires :one_param, desc: "one param"
       end
       subject.get 'method' do ; end
       subject.routes.map { |route|
-        { :description => route.route_description, :params => route.route_params }
+        { description: route.route_description, params: route.route_params }
       }.should eq [
-        { :description => nil, :params => { "one_param" => { :required => true, :desc => "one param" } } }
-      ]
+        { description: nil, params: { "one_param" => { required: true, desc: "one param" } } }
+    ]
     end
     it 'does not symbolize params' do
-      subject.desc "Reverses a string.", { :params =>
-        { "s" => { :desc => "string to reverse", :type => "string" }}
-      }
+      subject.desc "Reverses a string.", params: { "s" => { desc: "string to reverse", type: "string" } }
       subject.get 'reverse/:s' do
         params[:s].reverse
       end
       subject.routes.map { |route|
-        { :description => route.route_description, :params => route.route_params }
+        { description: route.route_description, params: route.route_params }
       }.should eq [
-        { :description => "Reverses a string.", :params => { "s" => { :desc => "string to reverse", :type => "string" } } }
-      ]
+        { description: "Reverses a string.", params: { "s" => { desc: "string to reverse", type: "string" } } }
+    ]
     end
   end
 
   describe '.mount' do
-    let(:mounted_app){ lambda{|env| [200, {}, ["MOUNTED"]]} }
+    let(:mounted_app) { lambda { |env| [200, {}, ["MOUNTED"]] } }
 
     context 'with a bare rack app' do
       before do
@@ -1502,7 +1998,7 @@ describe Grape::API do
       end
 
       it 'is able to cascade' do
-        subject.mount lambda{ |env|
+        subject.mount lambda { |env|
           headers = {}
           headers['X-Cascade'] == 'pass' unless env['PATH_INFO'].include?('boo')
           [200, headers, ["Farfegnugen"]]
@@ -1525,7 +2021,7 @@ describe Grape::API do
 
     context 'mounting an API' do
       it 'applies the settings of the mounting api' do
-        subject.version 'v1', :using => :path
+        subject.version 'v1', using: :path
 
         subject.namespace :cool do
           app = Class.new(Grape::API)
@@ -1535,6 +2031,25 @@ describe Grape::API do
 
           mount app
         end
+
+        get '/v1/cool/awesome'
+        last_response.body.should == 'yo'
+      end
+
+      it 'applies the settings to nested mounted apis' do
+        subject.version 'v1', using: :path
+
+        subject.namespace :cool do
+          inner_app = Class.new(Grape::API)
+          inner_app.get('/awesome') do
+            "yo"
+          end
+
+          app = Class.new(Grape::API)
+          app.mount inner_app
+          mount app
+        end
+
         get '/v1/cool/awesome'
         last_response.body.should == 'yo'
       end
@@ -1562,8 +2077,8 @@ describe Grape::API do
           mount app
         end
         subject.routes.size.should == 2
-        subject.routes.first.route_path.should =~ /\/cool\/awesome/
-        subject.routes.last.route_path.should =~ /\/cool\/sauce/
+        subject.routes.first.route_path.should =~ %r{\/cool\/awesome}
+        subject.routes.last.route_path.should =~ %r{\/cool\/sauce}
       end
 
       it 'mounts on a path' do
@@ -1591,6 +2106,50 @@ describe Grape::API do
         get "/app1/app2/nice"
         last_response.status.should == 200
         last_response.body.should == "play"
+        options "/app1/app2/nice"
+        last_response.status.should == 204
+      end
+
+      it 'responds to options' do
+        app = Class.new(Grape::API)
+        app.get '/colour' do
+          'red'
+        end
+        app.namespace :pears do
+          get '/colour' do
+            'green'
+          end
+        end
+        subject.namespace :apples do
+          mount app
+        end
+        get '/apples/colour'
+        last_response.status.should eql 200
+        last_response.body.should == 'red'
+        options '/apples/colour'
+        last_response.status.should eql 204
+        get '/apples/pears/colour'
+        last_response.status.should eql 200
+        last_response.body.should == 'green'
+        options '/apples/pears/colour'
+        last_response.status.should eql 204
+      end
+
+      it 'responds to options with path versioning' do
+        subject.version 'v1', using: :path
+        subject.namespace :apples do
+          app = Class.new(Grape::API)
+          app.get('/colour') do
+            "red"
+          end
+          mount app
+        end
+
+        get '/v1/apples/colour'
+        last_response.status.should eql 200
+        last_response.body.should == 'red'
+        options '/v1/apples/colour'
+        last_response.status.should eql 204
       end
 
     end
@@ -1625,8 +2184,8 @@ describe Grape::API do
       subject.format :json
       subject.get '/endpoint/options' do
         {
-          :path => options[:path],
-          :source_location => source.source_location
+          path: options[:path],
+          source_location: source.source_location
         }
       end
     end
@@ -1662,7 +2221,7 @@ describe Grape::API do
         subject.get '/description' do
           route.route_description
         end
-        subject.desc 'returns parameters', { :params => { "x" => "y" }}
+        subject.desc 'returns parameters', params: { "x" => "y" }
         subject.get '/params/:id' do
           route.route_params[params[:id]]
         end
@@ -1677,46 +2236,46 @@ describe Grape::API do
       end
     end
   end
-  context 'format' do
+  describe '.format' do
     context ':txt' do
       before(:each) do
         subject.format :txt
         subject.content_type :json, "application/json"
         subject.get '/meaning_of_life' do
-          { :meaning_of_life => 42 }
+          { meaning_of_life: 42 }
         end
       end
       it 'forces txt without an extension' do
         get '/meaning_of_life'
-        last_response.body.should == { :meaning_of_life => 42 }.to_s
+        last_response.body.should == { meaning_of_life: 42 }.to_s
       end
       it 'does not force txt with an extension' do
         get '/meaning_of_life.json'
-        last_response.body.should == { :meaning_of_life => 42 }.to_json
+        last_response.body.should == { meaning_of_life: 42 }.to_json
       end
       it 'forces txt from a non-accepting header' do
-        get '/meaning_of_life', {}, { 'HTTP_ACCEPT' => 'application/json' }
-        last_response.body.should == { :meaning_of_life => 42 }.to_s
+        get '/meaning_of_life', {}, 'HTTP_ACCEPT' => 'application/json'
+        last_response.body.should == { meaning_of_life: 42 }.to_s
       end
     end
     context ':txt only' do
       before(:each) do
         subject.format :txt
         subject.get '/meaning_of_life' do
-          { :meaning_of_life => 42 }
+          { meaning_of_life: 42 }
         end
       end
       it 'forces txt without an extension' do
         get '/meaning_of_life'
-        last_response.body.should == { :meaning_of_life => 42 }.to_s
+        last_response.body.should == { meaning_of_life: 42 }.to_s
       end
       it 'forces txt with the wrong extension' do
         get '/meaning_of_life.json'
-        last_response.body.should == { :meaning_of_life => 42 }.to_s
+        last_response.body.should == { meaning_of_life: 42 }.to_s
       end
       it 'forces txt from a non-accepting header' do
-        get '/meaning_of_life', {}, { 'HTTP_ACCEPT' => 'application/json' }
-        last_response.body.should == { :meaning_of_life => 42 }.to_s
+        get '/meaning_of_life', {}, 'HTTP_ACCEPT' => 'application/json'
+        last_response.body.should == { meaning_of_life: 42 }.to_s
       end
     end
     context ':json' do
@@ -1724,48 +2283,71 @@ describe Grape::API do
         subject.format :json
         subject.content_type :txt, "text/plain"
         subject.get '/meaning_of_life' do
-          { :meaning_of_life => 42 }
+          { meaning_of_life: 42 }
         end
       end
       it 'forces json without an extension' do
         get '/meaning_of_life'
-        last_response.body.should == { :meaning_of_life => 42 }.to_json
+        last_response.body.should == { meaning_of_life: 42 }.to_json
       end
       it 'does not force json with an extension' do
         get '/meaning_of_life.txt'
-        last_response.body.should == { :meaning_of_life => 42 }.to_s
+        last_response.body.should == { meaning_of_life: 42 }.to_s
       end
       it 'forces json from a non-accepting header' do
-        get '/meaning_of_life', {}, { 'HTTP_ACCEPT' => 'text/html' }
-        last_response.body.should == { :meaning_of_life => 42 }.to_json
+        get '/meaning_of_life', {}, 'HTTP_ACCEPT' => 'text/html'
+        last_response.body.should == { meaning_of_life: 42 }.to_json
+      end
+      it 'can be overwritten with an explicit content type' do
+        subject.get '/meaning_of_life_with_content_type' do
+          content_type "text/plain"
+          { meaning_of_life: 42 }.to_s
+        end
+        get '/meaning_of_life_with_content_type'
+        last_response.body.should == { meaning_of_life: 42 }.to_s
+      end
+      it 'raised :error from middleware' do
+        middleware = Class.new(Grape::Middleware::Base) do
+          def before
+            throw :error, message: "Unauthorized", status: 42
+          end
+        end
+        subject.use middleware
+        subject.get do
+
+        end
+        get "/"
+        last_response.status.should == 42
+        last_response.body.should == { error: "Unauthorized" }.to_json
       end
+
     end
     context ':serializable_hash' do
       before(:each) do
-        class SimpleExample
+        class SerializableHashExample
           def serializable_hash
-            {:abc => 'def'}
+            { abc: 'def' }
           end
         end
         subject.format :serializable_hash
       end
       it 'instance' do
         subject.get '/example' do
-          SimpleExample.new
+          SerializableHashExample.new
         end
         get '/example'
         last_response.body.should == '{"abc":"def"}'
       end
       it 'root' do
         subject.get '/example' do
-          { "root" => SimpleExample.new }
+          { "root" => SerializableHashExample.new }
         end
         get '/example'
         last_response.body.should == '{"root":{"abc":"def"}}'
       end
       it 'array' do
         subject.get '/examples' do
-          [ SimpleExample.new, SimpleExample.new ]
+          [SerializableHashExample.new, SerializableHashExample.new]
         end
         get '/examples'
         last_response.body.should == '[{"abc":"def"},{"abc":"def"}]'
@@ -1793,7 +2375,7 @@ XML
           ActiveSupport::OrderedHash[
             :example1, "example1",
             :example2, "example2"
-          ]
+        ]
         end
         get '/example'
         last_response.status.should == 200
@@ -1807,7 +2389,7 @@ XML
       end
       it 'array' do
         subject.get "/example" do
-          [ "example1", "example2" ]
+          ["example1", "example2"]
         end
         get '/example'
         last_response.status.should == 200
@@ -1817,6 +2399,25 @@ XML
   <string>example1</string>
   <string>example2</string>
 </strings>
+XML
+      end
+      it 'raised :error from middleware' do
+        middleware = Class.new(Grape::Middleware::Base) do
+          def before
+            throw :error, message: "Unauthorized", status: 42
+          end
+        end
+        subject.use middleware
+        subject.get do
+
+        end
+        get "/"
+        last_response.status.should == 42
+        last_response.body.should == <<-XML
+<?xml version="1.0" encoding="UTF-8"?>
+<error>
+  <message>Unauthorized</message>
+</error>
 XML
       end
     end
@@ -1825,22 +2426,22 @@ XML
   context "catch-all" do
     before do
       api1 = Class.new(Grape::API)
-      api1.version 'v1', :using => :path
+      api1.version 'v1', using: :path
       api1.get "hello" do
         "v1"
       end
       api2 = Class.new(Grape::API)
-      api2.version 'v2', :using => :path
+      api2.version 'v2', using: :path
       api2.get "hello" do
         "v2"
       end
       subject.mount api1
       subject.mount api2
     end
-    [ true, false ].each do |anchor|
+    [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)
+        subject.route :any, '*path', anchor: anchor do
+          error!("Unrecognized request path: #{params[:path] } - #{env['PATH_INFO'] }#{env['SCRIPT_NAME'] }", 404)
         end
         get "/v1/hello"
         last_response.status.should == 200
@@ -1856,18 +2457,46 @@ XML
   end
 
   context "cascading" do
-    it "cascades" do
-      subject.version 'v1', :using => :path, :cascade => true
-      get "/v1/hello"
-      last_response.status.should == 404
-      last_response.headers["X-Cascade"].should == "pass"
+    context "via version" do
+      it "cascades" do
+        subject.version 'v1', using: :path, cascade: true
+        get "/v1/hello"
+        last_response.status.should == 404
+        last_response.headers["X-Cascade"].should == "pass"
+      end
+      it "does not cascade" do
+        subject.version 'v2', using: :path, cascade: false
+        get "/v2/hello"
+        last_response.status.should == 404
+        last_response.headers.keys.should_not include "X-Cascade"
+      end
     end
+    context "via endpoint" do
+      it "cascades" do
+        subject.cascade true
+        get "/hello"
+        last_response.status.should == 404
+        last_response.headers["X-Cascade"].should == "pass"
+      end
+      it "does not cascade" do
+        subject.cascade false
+        get "/hello"
+        last_response.status.should == 404
+        last_response.headers.keys.should_not include "X-Cascade"
+      end
+    end
+  end
 
-    it "does not cascade" do
-      subject.version 'v2', :using => :path, :cascade => false
-      get "/v2/hello"
-      last_response.status.should == 404
-      last_response.headers.keys.should_not include "X-Cascade"
+  context 'with json default_error_formatter' do
+    it 'returns json error' do
+      subject.content_type :json, "application/json"
+      subject.default_error_formatter :json
+      subject.get '/something' do
+        'foo'
+      end
+      get '/something'
+      last_response.status.should == 406
+      last_response.body.should == "{\"error\":\"The requested format 'txt' is not supported.\"}"
     end
   end
 end