grape 0.1.1 → 2.4.0

data/Rakefile

@@ -1,70 +0,0 @@
-require 'rubygems'
-require 'bundler'
-
-Bundler.setup :default, :test, :development
-
-def version
-  @version ||= open('VERSION').read.trim
-end
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "grape"
-    gem.summary = %Q{A Ruby framework for rapid API development.}
-    gem.description = %Q{A Ruby framework for rapid API development with great conventions.}
-    gem.email = "michael@intridea.com"
-    gem.homepage = "http://github.com/intridea/grape"
-    gem.authors = ["Michael Bleigh"]
-    gem.add_bundler_dependencies
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-end
-
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-task :spec => :check_dependencies
-task :default => :spec
-
-begin
-  require 'yard'
-  YARD_OPTS = ['-m', 'markdown', '-M', 'maruku']
-  DOC_FILES = ['lib/**/*.rb', 'README.markdown']
-  
-  YARD::Rake::YardocTask.new(:doc) do |t|
-    t.files   = DOC_FILES
-    t.options = YARD_OPTS
-  end
-  
-  namespace :doc do
-    YARD::Rake::YardocTask.new(:pages) do |t|
-      t.files   = DOC_FILES
-      t.options = YARD_OPTS + ['-o', '../grape.doc']
-    end
-    
-    namespace :pages do
-      desc 'Generate and publish YARD docs to GitHub pages.'
-      task :publish => ['doc:pages'] do
-        Dir.chdir(File.dirname(__FILE__) + '/../grape.doc') do
-          system("git add .")
-          system("git add -u")
-          system("git commit -m 'Generating docs for version #{version}.'")
-          system("git push origin gh-pages")
-        end
-      end
-    end
-  end
-rescue LoadError
-  puts "You need to install YARD."
-end

data/VERSION

@@ -1 +0,0 @@
-0.1.1

data/autotest/discover.rb

@@ -1 +0,0 @@
-Autotest.add_discovery { "rspec2" }

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

@@ -1,30 +0,0 @@
-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/auth/oauth2.rb

@@ -1,55 +0,0 @@
-module Grape::Middleware::Auth
-  class OAuth2 < Grape::Middleware::Base
-    def default_options
-      {
-        :token_class => 'AccessToken',
-        :realm => 'OAuth API'
-      }
-    end
-    
-    def before
-      if request['oauth_token']
-        verify_token(request['oauth_token'])
-      elsif env['Authorization'] && t = parse_authorization_header
-        verify_token(t)
-      end
-    end
-    
-    def token_class
-      @klass ||= eval(options[:token_class])
-    end
-    
-    def verify_token(token)
-      if token = token_class.verify(token)
-        if token.expired?
-          error_out(401, 'expired_token')
-        else
-          if token.permission_for?(env)
-            env['api.token'] = token
-          else
-            error_out(403, 'insufficient_scope')
-          end
-        end
-      else
-        error_out(401, 'invalid_token')
-      end
-    end
-    
-    def parse_authorization_header
-      if env['Authorization'] =~ /oauth (.*)/i
-        $1
-      end
-    end
-    
-    def error_out(status, error)
-      throw :error, {
-        :message => 'The token provided has expired.',
-        :status => status,
-        :headers => {
-          'WWW-Authenticate' => "OAuth realm='#{options[:realm]}', error='#{error}'"
-        }
-      }
-    end
-  end
-end
-    

data/lib/grape/middleware/prefixer.rb

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

data/lib/grape/middleware_stack.rb

@@ -1,35 +0,0 @@
-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

@@ -1,343 +0,0 @@
-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.send(: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
-    
-    it 'should allow for multiple paths' do
-      subject.get("/abc", "/def") do
-        "foo"
-      end
-      
-      get '/abc'
-      last_response.body.should == 'foo'
-      get '/def'
-      last_response.body.should == 'foo'
-    end
-    
-    it 'should allow for multiple verbs' do
-      subject.route([:get, :post], '/abc') do
-        "hiya"
-      end
-      
-      get '/abc'
-      last_response.body.should == 'hiya'
-      post '/abc'
-      last_response.body.should == 'hiya'
-    end
-    
-    it 'should allow for :any as a verb' do
-      subject.route(:any, '/abc') do
-        "lol"
-      end
-      
-      %w(get post put delete).each do |m|
-        send(m, '/abc')
-        last_response.body.should == 'lol'
-      end
-    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
-  
-  describe '.scope' do
-    it 'should scope the various settings' do
-      subject.version 'v2'
-      
-      subject.scope :legacy do
-        version 'v1'
-        
-        get '/abc' do
-          version
-        end
-      end
-      
-      subject.get '/def' do
-        version
-      end
-      
-      get '/v2/abc'
-      last_response.status.should == 404
-      get '/v1/abc'
-      last_response.status.should == 200
-      get '/v1/def'
-      last_response.status.should == 404
-      get '/v2/def'
-      last_response.status.should == 200
-    end
-  end
-end

data/spec/grape/endpoint_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-describe Grape::Endpoint do
-  subject { Class.new(Grape::API) }
-  before { subject.default_format :txt }
-  def app; subject end
-  
-  describe '#status' do
-    it 'should be callable from within a block' do
-      subject.get('/home') do
-        status 206
-        "Hello"
-      end
-      
-      get '/home'
-      last_response.status.should == 206
-      last_response.body.should == "Hello"
-    end
-  end
-  
-  describe '#header' do
-    it 'should be callable from within a block' do
-      subject.get('/hey') do
-        header 'X-Awesome', 'true'
-        "Awesome"
-      end
-      
-      get '/hey'
-      last_response.headers['X-Awesome'].should == 'true'
-    end
-  end
-  
-  describe '#params' do
-    it 'should be available to the caller' do
-      subject.get('/hey') do
-        params[:howdy]
-      end
-      
-      get '/hey?howdy=hey'
-      last_response.body.should == 'hey'
-    end
-    
-    it 'should parse from path segments' do
-      subject.get('/hey/:id') do
-        params[:id]
-      end
-      
-      get '/hey/12'
-      last_response.body.should == '12'
-    end
-  end
-  
-  describe '#error!' do
-    it 'should accept a message' do
-      subject.get('/hey') do
-        error! "This is not valid."
-        "This is valid."
-      end
-      
-      get '/hey'
-      last_response.status.should == 403
-      last_response.body.should == "This is not valid."
-    end
-    
-    it 'should accept a code' do
-      subject.get('/hey') do
-        error! "Unauthorized.", 401
-      end
-      
-      get '/hey'
-      last_response.status.should == 401
-      last_response.body.should == "Unauthorized."
-    end
-  end
-  
-  it 'should not persist params between calls' do
-    subject.post('/new') do
-      params[:text]
-    end
-    
-    post '/new', :text => 'abc'
-    last_response.body.should == 'abc'
-    
-    post '/new', :text => 'def'
-    last_response.body.should == 'def'
-  end
-  
-  it 'should reset all instance variables (except block) between calls' do
-    subject.helpers do
-      def memoized
-        @memoized ||= params[:howdy]
-      end
-    end
-    
-    subject.get('/hello') do
-      memoized
-    end
-    
-    get '/hello?howdy=hey'
-    last_response.body.should == 'hey'
-    get '/hello?howdy=yo'
-    last_response.body.should == 'yo'
-  end
-end

data/spec/grape/middleware/auth/basic_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-require 'base64'
-
-describe Grape::Middleware::Auth::Basic do
-  def app
-    Rack::Builder.new do |b|
-      b.use Grape::Middleware::Error
-      b.use(Grape::Middleware::Auth::Basic) do |u,p| 
-        u && p && u == p
-      end
-      b.run lambda{|env| [200, {}, "Hello there."]}
-    end
-  end
-  
-  it 'should throw a 401 if no auth is given' do
-    @proc = lambda{ false }
-    get '/whatever'
-    last_response.status.should == 401
-  end
-  
-  it 'should authenticate if given valid creds' do
-    get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic('admin','admin')
-    last_response.status.should == 200
-  end
-  
-  it 'should throw a 401 is wrong auth is given' do
-    get '/whatever', {}, 'HTTP_AUTHORIZATION' => encode_basic('admin','wrong')
-    last_response.status.should == 401
-  end
-end