Merged from upstream.

Author: dblock

CHANGELOG.markdown

@@ -11,6 +11,7 @@ Next Release
 * [#159](https://github.com/intridea/grape/pull/159): Added `:requirements` to routes, allowing to use reserved characters in paths - [@gaiottino](https://github.com/gaiottino).
 * [#156](https://github.com/intridea/grape/pull/156): Added support for adding formatters to entities - [@bobbytables](https://github.com/bobbytables).
 * [#183](https://github.com/intridea/grape/pull/183): Added ability to include documentation in entities - [@flah00](https://github.com/flah00).
+* [#189](https://github.com/intridea/grape/pull/189): `HEAD` requests no longer return a body - [@stephencelis](https://github.com/stephencelis).
 * [#97](https://github.com/intridea/grape/issues/97): Allow overriding `Content-Type` - [@dblock](https://github.com/dblock).
 
 0.2.0 (3/28/2012)

lib/grape/endpoint.rb

@@ -301,6 +301,7 @@ def run(env)
     def build_middleware
       b = Rack::Builder.new
 
+      b.use Rack::Head
       b.use Grape::Middleware::Error,
         :default_status => settings[:default_error_status] || 403,
         :rescue_all => settings[:rescue_all],

spec/grape/api_spec.rb

@@ -284,7 +284,7 @@ def app; subject end
           verb
         end
         send(verb, '/example')
-        last_response.body.should eql verb
+        last_response.body.should eql verb == 'head' ? '' : verb
         # Call it with a method other than the properly constrained one.
         send(verbs[(verbs.index(verb) + 1) % verbs.size], '/example')
         last_response.status.should eql 404
@@ -788,16 +788,15 @@ def three
       end
     end
     describe "api structure with two versions and a namespace" do
-      class TwitterAPI < Grape::API
-        # version v1
-        version 'v1', :using => :path
-        get "version" do
+      before :each do
+        subject.version 'v1', :using => :path
+        subject.get "version" do
            api.version
         end
         # version v2
-        version 'v2', :using => :path
-        prefix 'p'
-        namespace "n1" do
+        subject.version 'v2', :using => :path
+        subject.prefix 'p'
+        subject.namespace "n1" do
           namespace "n2" do
             get "version" do
                api.version
@@ -806,22 +805,22 @@ class TwitterAPI < Grape::API
         end
       end
       it "should return versions" do
-         TwitterAPI::versions.should == [ 'v1', 'v2' ]
+         subject.versions.should == [ 'v1', 'v2' ]
       end
       it "should set route paths" do
-         TwitterAPI::routes.size.should >= 2
-         TwitterAPI::routes[0].route_path.should == "/:version/version(.:format)"
-         TwitterAPI::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 "should set route versions" do
-         TwitterAPI::routes[0].route_version.should == 'v1'
-         TwitterAPI::routes[1].route_version.should == 'v2'
+         subject.routes[0].route_version.should == 'v1'
+         subject.routes[1].route_version.should == 'v2'
       end
       it "should set a nested namespace" do
-         TwitterAPI::routes[1].route_namespace.should == "/n1/n2"
+         subject.routes[1].route_namespace.should == "/n1/n2"
       end
       it "should set prefix" do
-         TwitterAPI::routes[1].route_prefix.should == 'p'
+         subject.routes[1].route_prefix.should == 'p'
       end
     end
     describe "api structure with additional parameters" do
@@ -839,87 +838,101 @@ class TwitterAPI < Grape::API
         last_response.body.should == '["a","b,c"]'
       end
       it "should set route_params" do
-        subject.routes.size.should == 1
-        subject.routes[0].route_params.should == { "string" => "", "token" => "a token" }
-        subject.routes[0].route_optional_params.should == { "limit" => "the limit" }
+        subject.routes.map { |route|
+          { :params => route.route_params, :optional_params => route.route_optional_params }
+        }.should eq [
+          { :params => { "string" => "", "token" => "a token" }, :optional_params => { "limit" => "the limit" } }
+        ]
       end
     end
   end
 
   context "desc" do
-    describe "empty api structure" do
-      it "returns an empty array of routes" do
-        subject.desc "grape api"
-        subject.routes.should == []
-      end
-    end
-    describe "single method with a desc" do
-      before(:each) do
-        subject.desc "ping method"
-        subject.get :ping do
-          'pong'
-        end
-      end
-      it "returns route description" do
-        subject.routes[0].route_description.should == "ping method"
-      end
-    end
-    describe "single method with a an array of params and a desc hash block" do
-      before(:each) do
-        subject.desc "ping method", { :params => { "x" => "y" } }
-        subject.get "ping/:x" do
-          'pong'
-        end
-      end
-      it "returns route description" do
-        subject.routes[0].route_description.should == "ping method"
-      end
-    end
-    describe "api structure with multiple methods and descriptions" do
-      before(:each) do
-        class JitterAPI < Grape::API
-          desc "first method"
-          get "first" do; end
-          get "second" do; end
-          desc "third method"
-          get "third" do; end
-        end
-      end
-      it "should return a description for the first method" do
-        JitterAPI::routes[0].route_description.should == "first method"
-        JitterAPI::routes[1].route_description.should be_nil
-        JitterAPI::routes[2].route_description.should == "third method"
-      end
-    end
-    describe "api structure with multiple methods, namespaces, descriptions and options" do
-      before(:each) do
-        class LitterAPI < Grape::API
-          desc "first method"
-          get "first" do; end
-          get "second" do; end
-          namespace "ns" do
-            desc "ns second", :foo => "bar"
-            get "second" do; end
-          end
-          desc "third method", :details => "details of third method"
-          get "third" do; end
-          desc "Reverses a string.", { :params =>
-            { "s" => { :desc => "string to reverse", :type => "string" }}
-          }
-          get "reverse" do
-            params[:s].reverse
-          end
-        end
-      end
-      it "should return a description for the first method" do
-        LitterAPI::routes[0].route_description.should == "first method"
-        LitterAPI::routes[1].route_description.should be_nil
-        LitterAPI::routes[2].route_description.should == "ns second"
-        LitterAPI::routes[2].route_foo.should == "bar"
-        LitterAPI::routes[3].route_description.should == "third method"
-        LitterAPI::routes[4].route_description.should == "Reverses a string."
-        LitterAPI::routes[4].route_params.should == { "s" => { :desc => "string to reverse", :type => "string" }}
-      end
+    it "empty array of routes" do
+      subject.routes.should == []
+    end
+    it "empty array of routes" do
+      subject.desc "grape api"
+      subject.routes.should == []
+    end
+    it "should describe a method" do
+      subject.desc "first method"
+      subject.get :first do ; end
+      subject.routes.length.should == 1
+      route = subject.routes.first
+      route.route_description.should == "first method"
+      route.route_foo.should be_nil
+      route.route_params.should == { }
+    end
+    it "should describe methods separately" do
+      subject.desc "first method"
+      subject.get :first do ; end
+      subject.desc "second method"
+      subject.get :second do ; end
+      subject.routes.count.should == 2
+      subject.routes.map { |route|
+        { :description => route.route_description, :params => route.route_params }
+      }.should eq [
+        { :description => "first method", :params => {} },
+        { :description => "second method", :params => {} }
+      ]
+    end
+    it "should reset 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 }
+      }.should eq [
+        { :description => "first method", :params => {} },
+        { :description => nil, :params => {} }
+      ]
+    end
+    it "should namespace and describe arbitrary parameters" do
+      subject.namespace "ns" do
+        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 }
+      }.should eq [
+        { :description => "ns second", :foo => "bar", :params => {} },
+      ]
+    end
+    it "should include details" do
+      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 }
+      }.should eq [
+        { :description => "method", :details => "method details", :params => {} },
+      ]
+    end
+    it "should describe a method with parameters" do
+      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 }
+      }.should eq [
+        { :description => "Reverses a string.", :params => { "s" => { :desc => "string to reverse", :type => "string" } } }
+      ]
+    end
+    it "should not symbolize params" do
+      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 }
+      }.should eq [
+        { :description => "Reverses a string.", :params => { "s" => { :desc => "string to reverse", :type => "string" } } }
+      ]
     end
   end
 

spec/grape/endpoint_spec.rb

@@ -410,7 +410,7 @@ def memoized
         end
         send(verb, '/example/and/some/more')
         last_response.status.should eql (verb == "post" ? 201 : 200)
-        last_response.body.should eql verb
+        last_response.body.should eql verb == 'head' ? '' : verb
       end
     end
   end