grape 0.2.1.1 → 0.2.2

data/lib/grape/validations/coerce.rb

@@ -0,0 +1,61 @@
+module Grape
+
+  class API
+    Boolean = Virtus::Attribute::Boolean
+  end
+  
+  module Validations
+    
+    class CoerceValidator < SingleOptionValidator
+      def validate_param!(attr_name, params)
+        new_value = coerce_value(@option, params[attr_name])
+        if valid_type?(new_value)
+          params[attr_name] = new_value
+        else
+          raise ValidationError, :status => 400, :param => attr_name, :message => "invalid parameter: #{attr_name}"
+        end
+      end
+  
+      class InvalidValue; end
+    private
+    
+      def _valid_array_type?(type, values)
+        values.all? do |val|
+          _valid_single_type?(type, val)
+        end
+      end
+      
+      def _valid_single_type?(klass, val)
+        # allow nil, to ignore when a parameter is absent
+        return true if val.nil?
+        if klass == Virtus::Attribute::Boolean
+          val.is_a?(TrueClass) || val.is_a?(FalseClass)
+        elsif klass == Rack::Multipart::UploadedFile
+          val.is_a?(Hashie::Mash) && val.key?(:tempfile)
+        else
+          val.is_a?(klass)
+        end
+      end
+      
+      def valid_type?(val)
+        if @option.is_a?(Array)
+          _valid_array_type?(@option[0], val)
+        else
+          _valid_single_type?(@option, val)
+        end
+      end
+      
+      def coerce_value(type, val)
+        converter = Virtus::Attribute.build(:a, type)
+        converter.coerce(val)
+      
+      # not the prettiest but some invalid coercion can currently trigger
+      # errors in Virtus (see coerce_spec.rb)
+      rescue
+        InvalidValue.new
+      end
+      
+    end
+    
+  end
+end

data/lib/grape/validations/presence.rb

@@ -0,0 +1,11 @@
+module Grape
+  module Validations
+    class PresenceValidator < Validator
+      def validate_param!(attr_name, params)
+        unless params.has_key?(attr_name)
+          raise ValidationError, :status => 400, :param => attr_name, :message => "missing parameter: #{attr_name}"
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/regexp.rb

@@ -0,0 +1,13 @@
+module Grape
+  module Validations
+    
+    class RegexpValidator < SingleOptionValidator
+      def validate_param!(attr_name, params)
+        if params[attr_name] && !( params[attr_name].to_s =~ @option )
+          raise ValidationError, :status => 400, :param => attr_name, :message => "invalid parameter: #{attr_name}"
+        end
+      end
+    end
+
+  end
+end

data/lib/grape/version.rb

@@ -1,3 +1,3 @@
 module Grape
-  VERSION = '0.2.1.1'
+  VERSION = '0.2.2'
 end

data/spec/grape/api_spec.rb

@@ -21,6 +21,21 @@ describe Grape::API do
     end
   end
 
+  describe '.version' do
+    context 'when defined' do
+      it 'should return version value' do
+        subject.version 'v1'
+        subject.version.should == 'v1'
+      end
+    end
+
+    context 'when not defined' do
+      it 'should return nil' do
+        subject.version.should be_nil
+      end
+    end
+  end
+
   describe '.version using path' do
     it_should_behave_like 'versioning' do
       let(:macro_options) do
@@ -68,7 +83,7 @@ describe Grape::API do
     end
 
     it 'should route if any media type is allowed' do
-      
+
     end
   end
 
@@ -133,7 +148,7 @@ describe Grape::API do
       get '/members/23'
       last_response.body.should == "23"
     end
-    
+
     it 'should be callable with nil just to push onto the stack' do
       subject.namespace do
         version 'v2', :using => :path
@@ -146,7 +161,7 @@ describe Grape::API do
       get '/hello'
       last_response.body.should == "outer"
     end
-    
+
     %w(group resource resources segment).each do |als|
       it "`.#{als}` should be an alias" do
         subject.send(als, :awesome) do
@@ -191,7 +206,7 @@ describe Grape::API do
           RSpec::Mocks::Mock.new(:to_json => 'abc', :to_txt => 'def')
         end
       end
-    
+
       it "should allow .json" do
         get '/abc.json'
         last_response.status.should == 200
@@ -245,7 +260,7 @@ describe Grape::API do
       subject.route([:get, :post], '/:id/first') do
         "first"
       end
-      
+
       subject.route([:get, :post], '/:id') do
         "ola"
       end
@@ -286,8 +301,8 @@ describe Grape::API do
         send(verb, '/example')
         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
+        send(used_verb = verbs[(verbs.index(verb) + 1) % verbs.size], '/example')
+        last_response.status.should eql used_verb == 'options' ? 204 :405
       end
     end
 
@@ -300,6 +315,36 @@ describe Grape::API do
       last_response.status.should eql 201
       last_response.body.should eql 'Created'
     end
+
+    it 'should return a 405 for an unsupported method' do
+      subject.get 'example' do
+        "example"
+      end
+      put '/example'
+      last_response.status.should eql 405
+      last_response.body.should eql ''
+    end
+
+    specify '405 responses should include an Allow header specifying supported methods' do
+      subject.get 'example' do
+        "example"
+      end
+      subject.post 'example' do
+        "example"
+      end
+      put '/example'
+      last_response.headers['Allow'].should eql 'OPTIONS, GET, POST'
+    end
+
+    it 'should add an OPTIONS route that returns a 204 and an Allow header' do
+      subject.get 'example' do
+        "example"
+      end
+      options '/example'
+      last_response.status.should eql 204
+      last_response.body.should eql ''
+      last_response.headers['Allow'].should eql 'OPTIONS, GET'
+    end
   end
 
   describe 'filters' do
@@ -314,6 +359,20 @@ describe Grape::API do
       last_response.body.should eql 'first second'
     end
 
+    it 'should add a after_validation filter' do
+      subject.after_validation { @foo = "first #{params[:id]}:#{params[:id].class}"  }
+      subject.after_validation { @bar = 'second' }
+      subject.params do
+        requires :id, :type => Integer
+      end
+      subject.get '/' do
+        "#{@foo} #{@bar}"
+      end
+
+      get '/', :id => "32"
+      last_response.body.should eql 'first 32:Fixnum second'
+    end
+
     it 'should add a after filter' do
       m = double('after mock')
       subject.after { m.do_something! }
@@ -356,65 +415,67 @@ describe Grape::API do
       last_response.headers['Content-Type'].should eql 'application/json'
     end
   end
-  
+
   context 'custom middleware' do
-    class PhonyMiddleware
-      def initialize(app, *args)
-        @args = args
-        @app = app
-        @block = true if block_given?
-      end
+    module ApiSpec
+      class PhonyMiddleware
+        def initialize(app, *args)
+          @args = args
+          @app = app
+          @block = true if block_given?
+        end
 
-      def call(env)
-        env['phony.args'] ||= []
-        env['phony.args'] << @args
-        env['phony.block'] = true if @block
-        @app.call(env)
+        def call(env)
+          env['phony.args'] ||= []
+          env['phony.args'] << @args
+          env['phony.block'] = true if @block
+          @app.call(env)
+        end
       end
     end
 
     describe '.middleware' do
       it 'should include middleware arguments from settings' do
         settings = Grape::Util::HashStack.new
-        settings.stub!(:stack).and_return([{:middleware => [[PhonyMiddleware, 'abc', 123]]}])
+        settings.stub!(:stack).and_return([{:middleware => [[ApiSpec::PhonyMiddleware, 'abc', 123]]}])
         subject.stub!(:settings).and_return(settings)
-        subject.middleware.should eql [[PhonyMiddleware, 'abc', 123]]
+        subject.middleware.should eql [[ApiSpec::PhonyMiddleware, 'abc', 123]]
       end
 
       it 'should include all middleware from stacked settings' do
         settings = Grape::Util::HashStack.new
         settings.stub!(:stack).and_return [
-          {:middleware => [[PhonyMiddleware, 123],[PhonyMiddleware, 'abc']]},
-          {:middleware => [[PhonyMiddleware, 'foo']]}
+          {:middleware => [[ApiSpec::PhonyMiddleware, 123],[ApiSpec::PhonyMiddleware, 'abc']]},
+          {:middleware => [[ApiSpec::PhonyMiddleware, 'foo']]}
         ]
         subject.stub!(:settings).and_return(settings)
-  
+
         subject.middleware.should eql [
-          [PhonyMiddleware, 123],
-          [PhonyMiddleware, 'abc'],
-          [PhonyMiddleware, 'foo']
+          [ApiSpec::PhonyMiddleware, 123],
+          [ApiSpec::PhonyMiddleware, 'abc'],
+          [ApiSpec::PhonyMiddleware, 'foo']
         ]
       end
     end
 
     describe '.use' do
       it 'should add middleware' do
-        subject.use PhonyMiddleware, 123
-        subject.middleware.should eql [[PhonyMiddleware, 123]]
+        subject.use ApiSpec::PhonyMiddleware, 123
+        subject.middleware.should eql [[ApiSpec::PhonyMiddleware, 123]]
       end
 
       it 'should not show up outside the namespace' do
-        subject.use PhonyMiddleware, 123
+        subject.use ApiSpec::PhonyMiddleware, 123
         subject.namespace :awesome do
-          use PhonyMiddleware, 'abc'
-          middleware.should == [[PhonyMiddleware, 123],[PhonyMiddleware, 'abc']]
+          use ApiSpec::PhonyMiddleware, 'abc'
+          middleware.should == [[ApiSpec::PhonyMiddleware, 123],[ApiSpec::PhonyMiddleware, 'abc']]
         end
 
-        subject.middleware.should eql [[PhonyMiddleware, 123]]
+        subject.middleware.should eql [[ApiSpec::PhonyMiddleware, 123]]
       end
 
       it 'should actually call the middleware' do
-        subject.use PhonyMiddleware, 'hello'
+        subject.use ApiSpec::PhonyMiddleware, 'hello'
         subject.get '/' do
           env['phony.args'].first.first
         end
@@ -425,13 +486,13 @@ describe Grape::API do
 
       it 'should add a block if one is given' do
         block = lambda{ }
-        subject.use PhonyMiddleware, &block
-        subject.middleware.should eql [[PhonyMiddleware, block]]
+        subject.use ApiSpec::PhonyMiddleware, &block
+        subject.middleware.should eql [[ApiSpec::PhonyMiddleware, block]]
       end
 
       it 'should use a block if one is given' do
         block = lambda{ }
-        subject.use PhonyMiddleware, &block
+        subject.use ApiSpec::PhonyMiddleware, &block
         subject.get '/' do
           env['phony.block'].inspect
         end
@@ -442,7 +503,7 @@ describe Grape::API do
 
       it 'should not destroy the middleware settings on multiple runs' do
         block = lambda{ }
-        subject.use PhonyMiddleware, &block
+        subject.use ApiSpec::PhonyMiddleware, &block
         subject.get '/' do
           env['phony.block'].inspect
         end
@@ -628,7 +689,7 @@ describe Grape::API do
       subject.get '/def' do
         'def'
       end
-      
+
       get '/new/abc'
       last_response.status.should eql 404
       get '/legacy/abc'
@@ -667,6 +728,97 @@ describe Grape::API do
 
       lambda{ get '/unrescued' }.should raise_error
     end
+
+    it 'should not re-raise exceptions of type Grape::Exception::Base' do
+      class CustomError < Grape::Exceptions::Base; end
+      subject.get('/custom_exception'){ raise CustomError }
+
+      lambda{ get '/custom_exception' }.should_not raise_error
+    end
+
+    it 'should rescue custom grape exceptions' do
+      class CustomError < Grape::Exceptions::Base; end
+      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
+
+  describe ".rescue_from klass, block" do
+    it 'should rescue Exception' do
+      subject.rescue_from RuntimeError do |e|
+        rack_response("rescued from #{e.message}", 202)
+      end
+      subject.get '/exception' do
+        raise "rain!"
+      end
+      get '/exception'
+      last_response.status.should eql 202
+      last_response.body.should == 'rescued from rain!'
+    end
+    it 'should rescue 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)
+      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 'should rescue a specific error' do
+      class ConnectionError < RuntimeError; end
+      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 'should rescue multiple specific errors' do
+      class ConnectionError < RuntimeError; end
+      class DatabaseError < RuntimeError; end
+      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 'should not rescue a different error' do
+      class CommunicationError < RuntimeError; end
+      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
   end
 
   describe ".error_format" do
@@ -766,19 +918,7 @@ describe Grape::API do
       last_response.status.should eql 403
     end
   end
-  
-  context "muti_xml" do
-    it "doesn't parse yaml" do
-      subject.put :yaml do
-        params[:tag]
-      end
 
-	    expect {
-        put '/yaml', '<tag type="symbol">a123</tag>', "CONTENT_TYPE" => "application/xml"
-      }.to raise_error(MultiXml::DisallowedTypeError)
-    end
-  end
-  
   context "routes" do
     describe "empty api structure" do
       it "returns an empty array of routes" do
@@ -816,6 +956,9 @@ describe Grape::API do
           end
         end
       end
+      it "should return the latest version set" do
+         subject.version.should == 'v2'
+      end
       it "should return versions" do
          subject.versions.should == [ 'v1', 'v2' ]
       end
@@ -933,99 +1076,99 @@ describe Grape::API do
         { :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
+    it "should merge the parameters of the namespace with the parameters of the method" do
+      subject.desc "namespace"
+      subject.params do
+        requires :ns_param, :desc => "namespace parameter"
+      end
+      subject.namespace "ns" do
+        desc "method"
+        params do
+          optional :method_param, :desc => "method parameter"
+        end
+        get "method" do ; end
       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" } } }
+        { :description => "method", :params => { "ns_param" => { :required => true, :desc => "namespace parameter", :full_name=>"ns_param" }, "method_param" => { :required => false, :desc => "method parameter", :full_name=>"method_param" } } }
       ]
     end
-  end
-  
-  describe ".rescue_from klass, block" do
-    it 'should rescue Exception' do
-      subject.rescue_from RuntimeError do |e|
-        rack_response("rescued from #{e.message}", 202)
-      end
-      subject.get '/exception' do
-        raise "rain!"
-      end
-      get '/exception'
-      last_response.status.should eql 202
-      last_response.body.should == 'rescued from rain!'
-    end
-    it 'should rescue 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)
-      end
-      subject.get '/exception' do
-        raise ConnectionError
+    it "should merge 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"
+      end
+      subject.namespace "ns1" do
+        desc "ns2"
+        params do
+          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"
+          end
+          get "method" do ; end
+        end
       end
-      get '/exception'
-      last_response.status.should eql 500
-      last_response.body.should == 'rescued from ConnectionError'
+      subject.routes.map { |route|
+        { :description => route.route_description, :params => route.route_params }
+      }.should eq [
+        { :description => "method", :params => { "ns_param" => { :required => true, :desc => "ns param 2", :full_name=>"ns_param" }, "ns1_param" => { :required => true, :desc => "ns1 param", :full_name=>"ns1_param" }, "ns2_param" => { :required => true, :desc => "ns2 param", :full_name=>"ns2_param" }, "method_param" => { :required => false, :desc => "method param", :full_name=>"method_param" } } }
+      ]
     end
-    it 'should rescue a specific error' do
-      class ConnectionError < RuntimeError; end
-      subject.rescue_from ConnectionError do |e|
-        rack_response("rescued from #{e.class.name}", 500)
-      end
-      subject.get '/exception' do
-        raise ConnectionError
+    it "should provide a full_name for parameters in nested groups" do
+      subject.desc "nesting"
+      subject.params do
+        requires :root_param, :desc => "root param"
+        group :nested do
+          requires :nested_param, :desc => "nested param"
+        end
       end
-      get '/exception'
-      last_response.status.should eql 500
-      last_response.body.should == 'rescued from ConnectionError'
+      subject.get "method" do ; end
+      subject.routes.map { |route|
+        { :description => route.route_description, :params => route.route_params }
+      }.should eq [
+        { :description => "nesting", :params => { "root_param" => { :required => true, :desc => "root param", :full_name=>"root_param" }, "nested_param" => { :required => true, :desc => "nested param", :full_name=>"nested[nested_param]" } } }
+      ]
     end
-    it 'should rescue multiple specific errors' do
-      class ConnectionError < RuntimeError; end
-      class DatabaseError < RuntimeError; end
-      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
+    it "should parse parameters when no description is given" do
+      subject.params do
+        requires :one_param, :desc => "one param"
       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'
+      subject.get "method" do ; end
+      subject.routes.map { |route|
+        { :description => route.route_description, :params => route.route_params }
+      }.should eq [
+        { :description => nil, :params => { "one_param" => { :required => true, :desc => "one param", :full_name=>"one_param" } } }
+      ]
     end
-    it 'should not rescue a different error' do
-      class CommunicationError < RuntimeError; end
-      subject.rescue_from RuntimeError do |e|
-        rack_response("rescued from #{e.class.name}", 500)
-      end
-      subject.get '/uncaught' do
-        raise CommunicationError
+    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
-      lambda { get '/uncaught' }.should raise_error(CommunicationError)
+      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
 
   describe '.mount' do
     let(:mounted_app){ lambda{|env| [200, {}, ["MOUNTED"]]} }
-  
+
     context 'with a bare rack app' do
       before do
         subject.mount mounted_app => '/mounty'
       end
-    
+
       it 'should make a bare Rack app available at the endpoint' do
         get '/mounty'
         last_response.body.should == 'MOUNTED'
@@ -1073,6 +1216,21 @@ describe Grape::API do
         get '/v1/cool/awesome'
         last_response.body.should == 'yo'
       end
+
+      it 'should inherit rescues even when some defined by mounted' do
+        subject.rescue_from :all do |e|
+          rack_response("rescued from #{e.message}", 202)
+        end
+        subject.namespace :mounted do
+          app = Class.new(Grape::API)
+          app.rescue_from ArgumentError
+          app.get('/fail') { raise "doh!" }
+          mount app
+        end
+        get '/mounted/fail'
+        last_response.status.should eql 202
+        last_response.body.should == 'rescued from doh!'
+      end
     end
   end
 
@@ -1099,7 +1257,7 @@ describe Grape::API do
       subject.instance.should be_nil
     end
   end
-  
+
   describe ".route" do
     context "plain" do
       before(:each) do