grape 0.2.2 → 0.2.3

data/lib/grape/middleware/base.rb

@@ -5,6 +5,16 @@ require 'multi_xml'
 module Grape
   module Middleware
     class Base
+      # Content types are listed in order of preference.
+      CONTENT_TYPES = ActiveSupport::OrderedHash[
+        :xml,  'application/xml',
+        :serializable_hash, 'application/json',
+        :json, 'application/json',
+        :atom, 'application/atom+xml',
+        :rss,  'application/rss+xml',
+        :txt,  'text/plain',
+      ]
+
       attr_reader :app, :env, :options
 
       # @param [Rack Application] app The standard argument for a Rack middleware.
@@ -43,111 +53,16 @@ module Grape
         Rack::Response.new(@app_response)
       end
 
+      def content_types
+        options[:content_types] || CONTENT_TYPES
+      end
 
-      module Formats
-        # Content types are listed in order of preference.
-        CONTENT_TYPES = ActiveSupport::OrderedHash[
-          :xml,  'application/xml',
-          :json, 'application/json',
-          :atom, 'application/atom+xml',
-          :rss,  'application/rss+xml',
-          :txt,  'text/plain',
-        ]
-        FORMATTERS = {
-          :json => :encode_json,
-          :txt => :encode_txt,
-          :xml => :encode_xml
-        }
-        PARSERS = {
-          :json => :decode_json,
-          :xml => :decode_xml
-        }
-
-        def formatters
-          FORMATTERS.merge(options[:formatters] || {})
-        end
-
-        def parsers
-          PARSERS.merge(options[:parsers] || {})
-        end
-
-        def content_types
-          CONTENT_TYPES.merge(options[:content_types] || {})
-        end
-
-        def content_type
-          content_types[options[:format]] || 'text/html'
-        end
-
-        def mime_types
-          content_types.invert
-        end
-
-        def formatter_for(api_format)
-          spec = formatters[api_format]
-          case spec
-          when nil
-            lambda { |obj| obj }
-          when Symbol
-            method(spec)
-          else
-            spec
-          end
-        end
-
-        def parser_for(api_format)
-          spec = parsers[api_format]
-          case spec
-          when nil
-            nil
-          when Symbol
-            method(spec)
-          else
-            spec
-          end
-        end
-
-        def decode_json(object)
-          MultiJson.load(object)
-        end
-
-        def serializable?(object)
-         object.respond_to?(:serializable_hash) ||
-           object.kind_of?(Array) && !object.map {|o| o.respond_to? :serializable_hash }.include?(false) ||
-           object.kind_of?(Hash)
-        end
-
-        def serialize(object)
-          if object.respond_to? :serializable_hash
-            object.serializable_hash
-          elsif object.kind_of?(Array) && !object.map {|o| o.respond_to? :serializable_hash }.include?(false)
-            object.map {|o| o.serializable_hash }
-          elsif object.kind_of?(Hash)
-            object.inject({}) { |h,(k,v)| h[k] = serialize(v); h }
-          else
-            object
-          end
-        end
-
-        def encode_json(object)
-          return object if object.is_a?(String)
-          return MultiJson.dump(serialize(object)) if serializable?(object)
-          return object.to_json if object.respond_to?(:to_json)
-
-          MultiJson.dump(object)
-        end
-
-        def encode_txt(object)
-          object.respond_to?(:to_txt) ? object.to_txt : object.to_s
-        end
-
-        def decode_xml(object)
-          MultiXml.parse(object)
-        end
+      def content_type
+        content_types[env['api.format'] || options[:format]] || 'text/html'
+      end
 
-        def encode_xml(object)
-          object.respond_to?(:to_xml) ? object.to_xml : object.to_s
-        end
+      def mime_types
+        content_types.invert
       end
 
     end

data/lib/grape/middleware/error.rb

@@ -4,44 +4,27 @@ require 'multi_json'
 module Grape
   module Middleware
     class Error < Base
-      include Formats
 
       def default_options
-      { 
+      {
         :default_status => 403, # default status returned on error
         :default_message => "",
         :format => :txt,
         :formatters => {},
-        :rescue_all => false, # true to rescue all exceptions        
+        :error_formatters => {},
+        :rescue_all => false, # true to rescue all exceptions
         :rescue_options => { :backtrace => false }, # true to display backtrace
         :rescue_handlers => {}, # rescue handler blocks
         :rescued_errors => []
       }
       end
 
-      def encode_json(message, backtrace)
-        result = message.is_a?(Hash) ? message : { :error => message }
-        if (options[:rescue_options] || {})[:backtrace] && backtrace && ! backtrace.empty?
-          result = result.merge({ :backtrace => backtrace })
-        end
-        MultiJson.dump(result)
-      end
-      
-      def encode_txt(message, backtrace)
-        result = message.is_a?(Hash) ? MultiJson.dump(message) : message
-        if (options[:rescue_options] || {})[:backtrace] && backtrace && ! backtrace.empty?
-          result += "\r\n "
-          result += backtrace.join("\r\n ")
-        end
-        result
-      end
-
       def call!(env)
         @env = env
-        
+
         begin
-          error_response(catch(:error){ 
-            return @app.call(@env) 
+          error_response(catch(:error){
+            return @app.call(@env)
           })
         rescue Exception => e
           is_rescuable = rescuable?(e.class)
@@ -58,30 +41,31 @@ module Grape
       def rescuable?(klass)
         options[:rescue_all] || (options[:rescued_errors] || []).include?(klass)
       end
-      
+
       def handle_error(e)
         error_response({ :message => e.message, :backtrace => e.backtrace })
       end
-      
+
       def error_response(error = {})
         status = error[:status] || options[:default_status]
         message = error[:message] || options[:default_message]
         headers = {'Content-Type' => content_type}
         headers.merge!(error[:headers]) if error[:headers].is_a?(Hash)
         backtrace = error[:backtrace] || []
-        rack_response(format_message(message, backtrace, status), status, headers)
+        rack_response(format_message(message, backtrace), status, headers)
       end
 
       def rack_response(message, status = options[:default_status], headers = { 'Content-Type' => content_type })
         Rack::Response.new([ message ], status, headers).finish
       end
-            
-      def format_message(message, backtrace, status)
-        formatter = formatter_for(options[:format])
-        throw :error, :status => 406, :message => "The requested format #{options[:format]} is not supported." unless formatter
-        formatter.call(message, backtrace)
+
+      def format_message(message, backtrace)
+        format = env['api.format'] || options[:format]
+        formatter = Grape::ErrorFormatter::Base.formatter_for(format, options)
+        throw :error, :status => 406, :message => "The requested format #{format} is not supported." unless formatter
+        formatter.call(message, backtrace, options, env)
       end
-      
+
     end
   end
 end

data/lib/grape/middleware/formatter.rb

@@ -3,13 +3,11 @@ require 'grape/middleware/base'
 module Grape
   module Middleware
     class Formatter < Base
-      include Formats
 
       def default_options
         {
           :default_format => :txt,
           :formatters => {},
-          :content_types => {},
           :parsers => {}
         }
       end
@@ -22,10 +20,10 @@ module Grape
         fmt = format_from_extension || format_from_params || options[:format] || format_from_header || options[:default_format]
         if content_types.key?(fmt)
           if !env['rack.input'].nil? and (body = env['rack.input'].read).strip.length != 0
-            parser = parser_for fmt
+            parser = Grape::Parser::Base.parser_for fmt, options
             unless parser.nil?
               begin
-                body = parser.call(body)
+                body = parser.call body, env
                 env['rack.request.form_hash'] = !env['rack.request.form_hash'].nil? ? env['rack.request.form_hash'].merge(body) : body
                 env['rack.request.form_input'] = env['rack.input']
               rescue
@@ -42,10 +40,10 @@ module Grape
 
       def format_from_extension
         parts = request.path.split('.')
-        extension = parts.last.to_sym
 
-        if parts.size > 1 && content_types.key?(extension)
-          return extension
+        if parts.size > 1
+          extension = parts.last.to_sym
+          return extension if content_types.key?(extension)
         end
         nil
       end
@@ -74,13 +72,14 @@ module Grape
 
       def after
         status, headers, bodies = *@app_response
-        formatter = formatter_for env['api.format']
+        formatter = Grape::Formatter::Base.formatter_for env['api.format'], options
         bodymap = bodies.collect do |body|
-          formatter.call(body)
+          formatter.call body, env
         end
         headers['Content-Type'] = content_types[env['api.format']] unless headers['Content-Type']
         Rack::Response.new(bodymap, status, headers).to_a
       end
+
     end
   end
 end

data/lib/grape/middleware/versioner.rb

@@ -3,6 +3,7 @@
 #
 #   :header - version from HTTP Accept header.
 #   :path   - version from uri. e.g. /v1/resource
+#   :param  - version from uri query string, e.g. /v1/resource?apiver=v1
 #
 # See individual classes for details.
 module Grape
@@ -10,7 +11,7 @@ module Grape
     module Versioner
       extend self
 
-      # @param strategy [Symbol] :path or :header
+      # @param strategy [Symbol] :path, :header or :param
       # @return a middleware class based on strategy
       def using(strategy)
         case strategy
@@ -26,4 +27,4 @@ module Grape
       end
     end
   end
-end
+end

data/lib/grape/middleware/versioner/header.rb

@@ -25,7 +25,6 @@ module Grape
       #
       # @throws [RuntimeError] if Accept header is invalid
       class Header < Base
-        include Formats
 
         def before
           header = Rack::Accept::MediaType.new env['HTTP_ACCEPT']
@@ -112,6 +111,7 @@ module Grape
           type, subtype = Rack::Accept::Header.parse_media_type media_type
           subtype[/\Avnd\.[a-z0-9*.]+-[a-z0-9*\-.]+/]
         end
+
       end
     end
   end

data/lib/grape/parser/base.rb

@@ -0,0 +1,31 @@
+module Grape
+  module Parser
+    module Base
+
+      class << self
+
+        PARSERS = {
+          :json => Grape::Parser::Json,
+          :xml => Grape::Parser::Xml
+        }
+
+        def parsers(options)
+          PARSERS.merge(options[:parsers] || {})
+        end
+
+        def parser_for(api_format, options = {})
+          spec = parsers(options)[api_format]
+          case spec
+          when nil
+            nil
+          when Symbol
+            method(spec)
+          else
+            spec
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/grape/parser/json.rb

@@ -0,0 +1,13 @@
+module Grape
+  module Parser
+    module Json
+      class << self
+
+        def call(object, env)
+          MultiJson.load(object)
+        end
+
+      end
+    end
+  end
+end

data/lib/grape/parser/xml.rb

@@ -0,0 +1,13 @@
+module Grape
+  module Parser
+    module Xml
+      class << self
+
+        def call(object, env)
+          MultiXml.parse(object)
+        end
+
+      end
+    end
+  end
+end

data/lib/grape/validations.rb

@@ -102,7 +102,7 @@ module Grape
       end
 
       def group(element, &block)
-        scope = ParamsScope.new(@api, element, self, &block)
+        ParamsScope.new(@api, element, self, &block)
       end
 
       def params(params)

data/lib/grape/validations/coerce.rb

@@ -12,7 +12,7 @@ module Grape
         if valid_type?(new_value)
           params[attr_name] = new_value
         else
-          raise ValidationError, :status => 400, :param => attr_name, :message => "invalid parameter: #{attr_name}"
+          raise Grape::Exceptions::ValidationError, :status => 400, :param => attr_name, :message => "invalid parameter: #{attr_name}"
         end
       end
   

data/lib/grape/validations/presence.rb

@@ -3,7 +3,7 @@ module Grape
     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}"
+          raise Grape::Exceptions::ValidationError, :status => 400, :param => attr_name, :message => "missing parameter: #{attr_name}"
         end
       end
     end

data/lib/grape/validations/regexp.rb

@@ -4,7 +4,7 @@ module Grape
     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}"
+          raise Grape::Exceptions::ValidationError, :status => 400, :param => attr_name, :message => "invalid parameter: #{attr_name}"
         end
       end
     end

data/lib/grape/version.rb

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

data/spec/grape/api_spec.rb

@@ -189,6 +189,53 @@ describe Grape::API do
       last_response.body.should eql 'Created a Vote'
     end
 
+    describe "root routes should work with" do
+      before do
+        def subject.enable_root_route!
+          self.get("/") {"root"}
+        end
+      end
+
+      after do
+        last_response.body.should eql 'root'
+      end
+
+      describe "path versioned APIs" do
+        before do
+          subject.version 'v1', :using => :path
+          subject.enable_root_route!
+        end
+
+        it "without a format" do
+          versioned_get "/", "v1", :using => :path
+        end
+
+        it "with a format" do
+          get "/v1/.json"
+        end
+      end
+
+      it "header versioned APIs" do
+        subject.version 'v1', :using => :header, :vendor => 'test'
+        subject.enable_root_route!
+
+        versioned_get "/", "v1", :using => :header
+      end
+
+      it "param versioned APIs" do
+        subject.version 'v1', :using => :param
+        subject.enable_root_route!
+
+        versioned_get "/", "v1", :using => :param
+      end
+
+      it "unversioned APIs" do
+        subject.enable_root_route!
+
+        get "/"
+      end
+    end
+
     it 'should allow for multiple paths' do
       subject.get(["/abc", "/def"]) do
         "foo"
@@ -409,11 +456,18 @@ describe Grape::API do
     end
 
     it 'should set content type for error' do
-      subject.error_format :json
+      subject.format :json
       subject.get('/error') { error!('error in json', 500) }
       get '/error.json'
       last_response.headers['Content-Type'].should eql 'application/json'
     end
+
+    it 'should set content type for xml' do
+      subject.format :xml
+      subject.get('/error') { error!('error in xml', 500) }
+      get '/error.xml'
+      last_response.headers['Content-Type'].should eql 'application/xml'
+    end
   end
 
   context 'custom middleware' do
@@ -821,10 +875,10 @@ describe Grape::API do
     end
   end
 
-  describe ".error_format" do
+  describe ".format for error" do
     it 'should rescue all errors and return :txt' do
       subject.rescue_from :all
-      subject.error_format :txt
+      subject.format :txt
       subject.get '/exception' do
         raise "rain!"
       end
@@ -832,9 +886,9 @@ describe Grape::API do
       last_response.body.should eql "rain!"
     end
 
-    it 'should rescue all errros and return :txt with backtrace' do
+    it 'should rescue all errors and return :txt with backtrace' do
       subject.rescue_from :all, :backtrace => true
-      subject.error_format :txt
+      subject.format :txt
       subject.get '/exception' do
         raise "rain!"
       end
@@ -842,9 +896,28 @@ describe Grape::API do
       last_response.body.start_with?("rain!\r\n").should be_true
     end
 
+    context "class" do
+      before :each do
+        class CustomErrorFormatter
+          def self.call(message, backtrace, options, env)
+            "message: #{message} @backtrace"
+          end
+        end
+      end
+      it 'should return a custom error format' do
+        subject.rescue_from :all, :backtrace => true
+        subject.error_formatter :txt, CustomErrorFormatter
+        subject.get '/exception' do
+          raise "rain!"
+        end
+        get '/exception'
+        last_response.body.should == "message: rain! @backtrace"
+      end
+    end
+
     it 'should rescue all errors and return :json' do
       subject.rescue_from :all
-      subject.error_format :json
+      subject.format :json
       subject.get '/exception' do
         raise "rain!"
       end
@@ -853,7 +926,7 @@ describe Grape::API do
     end
     it 'should rescue all errors and return :json with backtrace' do
       subject.rescue_from :all, :backtrace => true
-      subject.error_format :json
+      subject.format :json
       subject.get '/exception' do
         raise "rain!"
       end
@@ -863,7 +936,7 @@ describe Grape::API do
       json["backtrace"].length.should > 0
     end
     it 'should rescue error! and return txt' do
-      subject.error_format :txt
+      subject.format :txt
       subject.get '/error' do
         error!("Access Denied", 401)
       end
@@ -871,7 +944,7 @@ describe Grape::API do
       last_response.body.should eql "Access Denied"
     end
     it 'should rescue error! and return json' do
-      subject.error_format :json
+      subject.format :json
       subject.get '/error' do
         error!("Access Denied", 401)
       end
@@ -897,6 +970,76 @@ describe Grape::API do
       get '/content'
       last_response.content_type.should == "text/javascript"
     end
+    it "removes existing content types" do
+      subject.content_type :xls, "application/vnd.ms-excel"
+      subject.get :excel do
+        "some binary content"
+      end
+      get '/excel.json'
+      last_response.status.should == 406
+      last_response.body.should == "The requested format is not supported."
+    end
+  end
+
+  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.get :simple do
+          {:some => 'hash'}
+        end
+      end
+      it 'sets one formatter' do
+        get '/simple.json'
+        last_response.body.should eql '{"custom_formatter":"hash"}'
+      end
+      it 'sets another formatter' do
+        get '/simple.txt'
+        last_response.body.should eql 'custom_formatter: hash'
+      end
+    end
+    context "custom formatter" 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.get :simple do
+          {:some => 'hash'}
+        end
+      end
+      it 'uses json' do
+        get '/simple.json'
+        last_response.body.should eql '{"some":"hash"}'
+      end
+      it 'uses custom formatter' do
+        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]}\"}"
+        end
+      end
+      before :each do
+        subject.content_type :json, 'application/json'
+        subject.content_type :custom, 'application/custom'
+        subject.formatter :custom, CustomFormatter
+        subject.get :simple do
+          {:some => 'hash'}
+        end
+      end
+      it 'uses json' do
+        get '/simple.json'
+        last_response.body.should eql '{"some":"hash"}'
+      end
+      it 'uses custom formatter' do
+        get '/simple.custom', { 'HTTP_ACCEPT' => 'application/custom' }
+        last_response.body.should eql '{"custom_formatter":"hash"}'
+      end
+    end
   end
 
   describe ".default_error_status" do
@@ -1337,5 +1480,36 @@ describe Grape::API do
         last_response.body.should == { :meaning_of_life => 42 }.to_json
       end
     end
+    context ":serializable_hash" do
+      before(:each) do
+        class SimpleExample
+          def serializable_hash
+            {:abc => 'def'}
+          end
+        end
+        subject.format :serializable_hash
+      end
+      it "instance" do
+        subject.get '/example' do
+          SimpleExample.new
+        end
+        get '/example'
+        last_response.body.should == '{"abc":"def"}'
+      end
+      it "root" do
+        subject.get '/example' do
+          { "root" => SimpleExample.new }
+        end
+        get '/example'
+        last_response.body.should == '{"root":{"abc":"def"}}'
+      end
+      it "array" do
+        subject.get '/examples' do
+          [ SimpleExample.new, SimpleExample.new ]
+        end
+        get '/examples'
+        last_response.body.should == '[{"abc":"def"},{"abc":"def"}]'
+      end
+    end
   end
 end