grape 0.0.0.alpha.2 → 0.1.0

data/lib/grape/middleware/auth/basic.rb

@@ -0,0 +1,30 @@
+require 'rack/auth/basic'
+
+module Grape
+  module Middleware
+    module Auth
+      class Basic < Grape::Middleware::Base
+        attr_reader :authenticator
+        
+        def initialize(app, options = {}, &authenticator)
+          super(app, options)
+          @authenticator = authenticator
+        end
+        
+        def basic_request
+          Rack::Auth::Basic::Request.new(env)
+        end
+        
+        def credentials
+          basic_request.provided?? basic_request.credentials : [nil, nil]
+        end
+        
+        def before
+          unless authenticator.call(*credentials)
+            throw :error, :status => 401, :message => "API Authorization Failed."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/middleware/base.rb

@@ -3,6 +3,8 @@ module Grape
     class Base
       attr_reader :app, :env, :options
       
+      # @param [Rack Application] app The standard argument for a Rack middleware.
+      # @param [Hash] options A hash of options, simply stored for use by subclasses.
       def initialize(app, options = {})
         @app = app
         @options = default_options.merge(options)
@@ -21,7 +23,12 @@ module Grape
         after || @app_response
       end
       
+      # @abstract
+      # Called before the application is called in the middleware lifecycle.
       def before; end
+      # @abstract
+      # Called after the application is called in the middleware lifecycle.
+      # @returns [Response, nil] a Rack SPEC response or nil to call the application afterwards.
       def after; end
       
       def request

data/lib/grape/middleware/error.rb

@@ -5,11 +5,12 @@ module Grape
     class Error < Base
       def call!(env)
         @env = env
-        err = catch :error do
+        result = catch :error do
           @app.call(@env)
         end
         
-        error_response(err)
+        result ||= {}
+        result.is_a?(Hash) ? error_response(result) : result
       end
       
       def error_response(error = {})

data/lib/grape/middleware/formatter.rb

@@ -1,5 +1,5 @@
 require 'grape/middleware/base'
-require 'active_support/json'
+require 'multi_json'
 
 module Grape
   module Middleware
@@ -8,12 +8,13 @@ module Grape
         :xml => 'application/xml',
         :json => 'application/json',
         :atom => 'application/atom+xml',
-        :rss => 'application/rss+xml'
+        :rss => 'application/rss+xml',
+        :txt => 'text/plain'
       }
       
       def default_options
         { 
-          :default_format => :json,
+          :default_format => :txt,
           :content_types => {}
         }
       end
@@ -22,9 +23,17 @@ module Grape
         CONTENT_TYPES.merge(options[:content_types])
       end
       
+      def mime_types
+        content_types.invert
+      end
+      
+      def headers
+        env.dup.inject({}){|h,(k,v)| h[k.downcase] = v; h}
+      end
+      
       def before
         fmt = format_from_extension || format_from_header || options[:default_format]
-        
+                
         if content_types.key?(fmt)
           env['api.format'] = fmt          
         else
@@ -44,15 +53,53 @@ module Grape
       end
       
       def format_from_header
-        # TODO: Implement Accept header parsing.
+        mime_array.each do |t| 
+          if mime_types.key?(t)
+            return mime_types[t]
+          end
+        end
+        nil
+      end
+      
+      def mime_array
+        accept = headers['accept']
+        if accept
+          accept.gsub(/\b/,'').
+            scan(/(\w+\/[\w+]+)(?:;[^,]*q=([0-9.]+)[^,]*)?/i).
+            sort_by{|a| -a[1].to_f}.
+            map{|a| a[0]}
+        else
+          []
+        end
       end
       
       def after
         status, headers, bodies = *@app_response
-        bodies.map! do |body|
-          ActiveSupport::JSON.encode(body)
+        bodymap = []
+        bodies.each do |body|
+          bodymap << case env['api.format']
+            when :json
+              encode_json(body)
+            when :txt
+              encode_txt(body)
+          end
+        end
+        headers['Content-Type'] = 'application/json'
+        Rack::Response.new(bodymap, status, headers).to_a
+      end
+      
+      def encode_json(object)
+        if object.respond_to? :serializable_hash
+          MultiJson.encode(object.serializable_hash)
+        elsif object.respond_to? :to_json
+          object.to_json
+        else
+          MultiJson.encode(object)
         end
-        [status, headers, bodies]
+      end
+      
+      def encode_txt(object)
+        body.respond_to?(:to_txt) ? body.to_txt : body.to_s
       end
     end
   end

data/lib/grape/middleware/prefixer.rb

@@ -1,18 +1,19 @@
-require 'grape/middleware/base'
+require 'rack/mount/utils'
+require 'grape'
 
 module Grape
   module Middleware
     class Prefixer < Base
       def prefix
         prefix = options[:prefix] || ""
-        prefix.insert(0, '/') unless prefix.index('/') == 0
+        prefix = Rack::Mount::Utils.normalize_path(prefix)
         prefix
       end
       
       def before
         if env['PATH_INFO'].index(prefix) == 0
-          env['PATH_INFO'].gsub!(prefix, '')
-          env['PATH_INFO'].insert(0, '/') unless env['PATH_INFO'].index('/') == 0
+          env['PATH_INFO'].sub!(prefix, '')
+          env['PATH_INFO'] = Rack::Mount::Utils.normalize_path(env['PATH_INFO'])
         end
       end
     end

data/lib/grape/middleware/versioner.rb

@@ -13,6 +13,10 @@ module Grape
         pieces = env['PATH_INFO'].split('/')
         potential_version = pieces[1]
         if potential_version =~ options[:pattern]
+          if options[:versions] && !options[:versions].include?(potential_version)
+            throw :error, :status => 404, :message => "404 API Version Not Found"
+          end
+          
           truncated_path = "/#{pieces[2..-1].join('/')}"
           env['api.version'] = potential_version
           env['PATH_INFO'] = truncated_path

data/lib/grape/middleware_stack.rb

@@ -0,0 +1,35 @@
+require 'grape'
+
+module Grape
+  class MiddlewareStack
+    attr_reader :stack
+    
+    def initialize
+      @stack = []
+    end
+    
+    # Add a new middleware to the stack. Syntax
+    # is identical to normal middleware <tt>#use</tt>
+    # functionality.
+    #
+    # @param [Class] klass The middleware class.
+    def use(klass, *args)
+      if index = @stack.index(@stack.find{|a| a.first == klass})
+        @stack[index] = [klass, *args]
+      else
+        @stack << [klass, *args]
+      end
+    end
+    
+    # Apply this middleware stack to a
+    # Rack application.
+    def to_app(app)
+      b = Rack::Builder.new
+      for middleware in stack
+        b.use *middleware
+      end
+      b.run app
+      b.to_app
+    end
+  end
+end

data/spec/grape/api_spec.rb

@@ -0,0 +1,283 @@
+require 'spec_helper'
+
+describe Grape::API do
+  subject { Class.new(Grape::API) }
+  before { subject.default_format :txt }
+  
+  def app; subject end
+  
+  describe '.prefix' do
+    it 'should route through with the prefix' do
+      subject.prefix 'awesome/sauce'
+      subject.get :hello do
+        "Hello there."
+      end
+    
+      get 'awesome/sauce/hello'
+      last_response.body.should == "Hello there."
+      
+      get '/hello'
+      last_response.status.should == 404
+    end
+  end
+  
+  describe '.version' do
+    it 'should set the API version' do
+      subject.version 'v1'
+      subject.get :hello do
+        "Version: #{request.env['api.version']}"
+      end
+      
+      get '/v1/hello'
+      last_response.body.should == "Version: v1"
+    end
+    
+    it 'should add the prefix before the API version' do
+      subject.prefix 'api'
+      subject.version 'v1'
+      subject.get :hello do
+        "Version: #{request.env['api.version']}"
+      end
+      
+      get '/api/v1/hello'
+      last_response.body.should == "Version: v1"
+    end
+    
+    it 'should be able to specify version as a nesting' do
+      subject.version 'v2'
+      subject.get '/awesome' do
+        "Radical"
+      end
+      
+      subject.version 'v1' do
+        get '/legacy' do
+          "Totally"
+        end
+      end
+      
+      get '/v1/awesome'
+      last_response.status.should == 404
+      get '/v2/awesome'
+      last_response.status.should == 200
+      get '/v1/legacy'
+      last_response.status.should == 200
+      get '/v2/legacy'
+      last_response.status.should == 404
+    end
+    
+    it 'should be able to specify multiple versions' do
+      subject.version 'v1', 'v2'
+      subject.get 'awesome' do
+        "I exist"
+      end
+      
+      get '/v1/awesome'
+      last_response.status.should == 200
+      get '/v2/awesome'
+      last_response.status.should == 200
+      get '/v3/awesome'
+      last_response.status.should == 404
+    end
+  end
+  
+  describe '.namespace' do
+    it 'should be retrievable and converted to a path' do
+      subject.namespace :awesome do
+        namespace.should == '/awesome'
+      end
+    end
+    
+    it 'should come after the prefix and version' do
+      subject.prefix :rad
+      subject.version :v1
+      
+      subject.namespace :awesome do
+        compile_path('hello').should == '/rad/:version/awesome/hello'
+      end
+    end
+    
+    it 'should cancel itself after the block is over' do
+      subject.namespace :awesome do
+        namespace.should == '/awesome'
+      end
+      
+      subject.namespace.should == '/'
+    end
+    
+    it 'should be stackable' do
+      subject.namespace :awesome do
+        namespace :rad do
+          namespace.should == '/awesome/rad'
+        end
+        namespace.should == '/awesome'
+      end
+      subject.namespace.should == '/'
+    end
+    
+    it 'should be callable with nil just to push onto the stack' do
+      subject.namespace do
+        version 'v2'
+        compile_path('hello').should == '/:version/hello'
+      end
+      subject.compile_path('hello').should == '/hello'
+    end
+    
+    %w(group resource resources).each do |als|
+      it "`.#{als}` should be an alias" do
+        subject.send(als, :awesome) do
+          namespace.should == "/awesome"
+        end
+      end
+    end
+  end
+  
+  describe '.route' do
+    it 'should allow for no path' do
+      subject.namespace :votes do
+        get do
+          "Votes"
+        end
+        
+        post do
+          "Created a Vote"
+        end
+      end
+      
+      get '/votes'
+      last_response.body.should == 'Votes'
+      post '/votes'
+      last_response.body.should == 'Created a Vote'
+    end
+    
+    verbs = %w(post get head delete put)
+    verbs.each do |verb|
+      it "should allow and properly constrain a #{verb.upcase} method" do
+        subject.send(verb, '/example') do
+          verb
+        end
+        send(verb, '/example')
+        last_response.body.should == 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 == 404
+      end
+    end
+    
+    it 'should return a 201 response code for POST by default' do
+      subject.post('example') do
+        "Created"
+      end
+      
+      post '/example'
+      last_response.status.should == 201
+      last_response.body.should == 'Created'
+    end
+  end
+  
+  describe '.basic' do
+    it 'should protect any resources on the same scope' do
+      subject.http_basic do |u,p|
+        u == 'allow'
+      end
+      subject.get(:hello){ "Hello, world."}
+      get '/hello'
+      last_response.status.should == 401
+      get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic('allow','whatever')
+      last_response.status.should == 200
+    end
+    
+    it 'should be scopable' do
+      subject.get(:hello){ "Hello, world."}
+      subject.namespace :admin do
+        http_basic do |u,p|
+          u == 'allow'
+        end
+        
+        get(:hello){ "Hello, world." }
+      end
+      
+      get '/hello'
+      last_response.status.should == 200
+      get '/admin/hello'
+      last_response.status.should == 401
+    end
+    
+    it 'should be callable via .auth as well' do
+      subject.auth :http_basic do |u,p|
+        u == 'allow'
+      end
+      
+      subject.get(:hello){ "Hello, world."}
+      get '/hello'
+      last_response.status.should == 401
+      get '/hello', {}, 'HTTP_AUTHORIZATION' => encode_basic('allow','whatever')
+      last_response.status.should == 200
+    end
+  end
+  
+  describe '.helpers' do
+    it 'should be accessible from the endpoint' do
+      subject.helpers do
+        def hello
+          "Hello, world."
+        end
+      end
+      
+      subject.get '/howdy' do
+        hello
+      end
+      
+      get '/howdy'
+      last_response.body.should == 'Hello, world.'
+    end
+    
+    it 'should be scopable' do
+      subject.helpers do
+        def generic
+          'always there'
+        end
+      end
+      
+      subject.namespace :admin do
+        helpers do
+          def secret
+            'only in admin'
+          end
+        end
+        
+        get '/secret' do
+          [generic, secret].join ':'
+        end
+      end
+      
+      subject.get '/generic' do
+        [generic, respond_to?(:secret)].join ':'
+      end
+      
+      get '/generic'
+      last_response.body.should == 'always there:false'
+      get '/admin/secret'
+      last_response.body.should == 'always there:only in admin'
+    end
+    
+    it 'should be reopenable' do
+      subject.helpers do
+        def one
+          1
+        end
+      end
+      
+      subject.helpers do
+        def two
+          2
+        end
+      end
+      
+      subject.get 'howdy' do
+        [one, two]
+      end
+      
+      lambda{get '/howdy'}.should_not raise_error
+    end
+  end
+end