Merged from upstream.

Author: dblock

.gitignore

@@ -17,6 +17,9 @@ tmtags
 ## VIM
 *.swp
 
+## RUBYMINE
+.idea
+
 ## PROJECT::GENERAL
 coverage
 doc

README.markdown

@@ -36,9 +36,9 @@ Grape APIs are Rack applications that are created by subclassing `Grape::API`.
 Below is a simple example showing some of the more common features of Grape in
 the context of recreating parts of the Twitter API.
 
-```ruby
+``` ruby
 class Twitter::API < Grape::API
-  version 'v1', :using => :header, :vendor => 'twitter', :format => :json
+  version 'v1', :using => :header, :vendor => 'twitter'
 
   helpers do
     def current_user
@@ -89,7 +89,7 @@ end
 The above sample creates a Rack application that can be run from a rackup *config.ru* file 
 with `rackup`:
 
-```ruby
+``` ruby
 run Twitter::API
 ```
 
@@ -102,9 +102,10 @@ And would respond to the following routes:
 
 In a Rails application, modify *config/routes*:
 
-```ruby
+``` ruby
 mount Twitter::API => "/"
 ```
+
 You can mount multiple API implementations inside another one.
 
 ```ruby
@@ -126,8 +127,8 @@ Using this versioning strategy, clients should pass the desired version in the H
     curl -H Accept=application/vnd.twitter-v1+json http://localhost:9292/statuses/public_timeline
 
 By default, the first matching version is used when no Accept header is
-supplied. This behavior is similar to routing in Rails. To circumvent this default behavior, 
-one could use the `:strict` option. When this option is set to `true`, a `404 Not found` error 
+supplied. This behavior is similar to routing in Rails. To circumvent this default behavior,
+one could use the `:strict` option. When this option is set to `true`, a `404 Not found` error
 is returned when no correct Accept header is supplied.
 
     version 'v1', :using => :path
@@ -165,7 +166,7 @@ Headers are available through the `env` hash object.
 You can define helper methods that your endpoints can use with the `helpers`
 macro by either giving a block or a module:
 
-````ruby
+``` ruby
 module MyHelpers
   def say_hello(user)
     "hey there #{user.name}"
@@ -188,20 +189,50 @@ class API < Grape::API
     say_hello(current_user)
   end
 end
-````
+```
+
+## Cookies
+
+You can set, get and delete your cookies very simply using `cookies` method:
+
+``` ruby
+class API < Grape::API
+  get '/counter' do
+    cookies[:counter] ||= 0
+    cookies[:counter] += 1
+    { :counter => cookies[:counter] }
+  end
+
+  delete '/counter' do
+    { :result => cookies.delete(:counter) }
+  end
+end
+```
+
+To set more than value use hash-based syntax:
+
+``` ruby
+cookies[:counter] = {
+    :value => 0,
+    :expires => Time.tomorrow,
+    :domain => '.example.com',
+    :path => '/'
+}
+cookies[:counter][:value] +=1
+```
 
 ## Raising Errors
 
 You can raise errors explicitly.
 
-```ruby
+``` ruby
 error!("Access Denied", 401)
 ```
 
 You can also return JSON formatted objects explicitly by raising error! and
 passing a hash instead of a message.
 
-```ruby
+``` ruby
 error!({ "error" => "unexpected error", "detail" => "missing widget" }, 500)
 ```
 
@@ -210,15 +241,15 @@ error!({ "error" => "unexpected error", "detail" => "missing widget" }, 500)
 Grape can be told to rescue all exceptions and instead return them in
 text or json formats.
 
-```ruby
+``` ruby
 class Twitter::API < Grape::API
   rescue_from :all
 end
 ```
 
 You can also rescue specific exceptions.
 
-```ruby
+``` ruby
 class Twitter::API < Grape::API
   rescue_from ArgumentError, NotImplementedError
 end
@@ -227,7 +258,7 @@ end
 The error format can be specified using `error_format`. Available formats are
 `:json` and `:txt` (default).
 
-```ruby
+``` ruby
 class Twitter::API < Grape::API
   error_format :json
 end
@@ -236,7 +267,7 @@ end
 You can rescue all exceptions with a code block. The `rack_response` wrapper
 automatically sets the default error code and content-type.
 
-```ruby
+``` ruby
 class Twitter::API < Grape::API
   rescue_from :all do |e|
     rack_response({ :message => "rescued from #{e.class.name}" })
@@ -247,7 +278,7 @@ end
 You can also rescue specific exceptions with a code block and handle the Rack
 response at the lowest level.
 
-```ruby
+``` ruby
 class Twitter::API < Grape::API
   rescue_from :all do |e|
     Rack::Response.new([ e.message ], 500, { "Content-type" => "text/error" }).finish
@@ -257,7 +288,7 @@ end
 
 Or rescue specific exceptions.
 
-```ruby
+``` ruby
 class Twitter::API < Grape::API
   rescue_from ArgumentError do |e|
     Rack::Response.new([ "ArgumentError: #{e.message}" ], 500)
@@ -270,16 +301,31 @@ end
 
 ## Content-Types
 
-By default, Grape supports _XML_, _JSON_, _Atom_, _RSS_, and _text_ content-types. 
-Your API can declare additional types to support. Response format is determined by the 
+By default, Grape supports _XML_, _JSON_, _Atom_, _RSS_, and _text_ content-types.
+Your API can declare additional types to support. Response format is determined by the
 request's extension or `Accept` header.
 
-```ruby
+``` ruby
 class Twitter::API < Grape::API
   content_type :xls, "application/vnd.ms-excel"
 end
 ```
 
+You can also set the default format. The order for choosing the format is the following.
+
+* Use the file extension, if specified. If the file is .json, choose the JSON format.
+* Use the format, if specified by the `format` option.
+* Attempt to find an acceptable format from the `Accept` header.
+* Use the default format, if specified by the `default_format` option.
+* Default to `:txt` otherwise.
+
+``` ruby
+class Twitter::API < Grape::API
+  format :json
+  default_format :json
+end
+```
+
 ## Writing Tests
 
 You can test a Grape API with RSpec by making HTTP requests and examining the response. 
@@ -319,7 +365,7 @@ end
 
 ### Writing Tests with Rails
 
-```ruby
+``` ruby
 require 'spec_helper'
 
 describe Twitter::API do
@@ -354,10 +400,10 @@ end
 ## Describing and Inspecting an API
 
 Grape lets you add a description to an API along with any other optional
-elements that can also be inspected at runtime. 
+elements that can also be inspected at runtime.
 This can be useful for generating documentation.
 
-```ruby
+``` ruby
 class TwitterAPI < Grape::API
 
   version 'v1'
@@ -382,7 +428,7 @@ contains a `route_prefix`, `route_version`, `route_namespace`, `route_method`,
 follows the API path may contain any number of keys and its values are also
 accessible via dynamically-generated `route_[name]` functions.
 
-```ruby
+``` ruby
 TwitterAPI::versions # yields [ 'v1', 'v2' ]
 TwitterAPI::routes # yields an array of Grape::Route objects
 TwitterAPI::routes[0].route_version # yields 'v1'
@@ -391,7 +437,7 @@ TwitterAPI::routes[0].route_description # yields [ { "s" => { :desc => "string t
 
 Parameters can also be tagged to the method declaration itself.
 
-```ruby
+``` ruby
 class StringAPI < Grape::API
   get "split/:string", { :params => [ "token" ], :optional_params => [ "limit" ] } do
     params[:string].split(params[:token], (params[:limit] || 0))
@@ -404,7 +450,7 @@ StringAPI::routes[0].route_optional_params # yields an array [ "limit" ]
 
 It's possible to retrieve the information about the current route from within an API call with `route`.
 
-```ruby
+``` ruby
 class MyAPI < Grape::API
   desc "Returns a description of a parameter.", { :params => { "id" => "a required id" } }
   get "params/:id" do
@@ -427,7 +473,7 @@ In Grape this option can be used as well when a method is defined.
 
 For instance when you're API needs to get part of an URL, for instance:
 
-```ruby
+``` ruby
 class UrlAPI < Grape::API
   namespace :urls do
     get '/(*:url)', :anchor => false do
@@ -458,5 +504,5 @@ MIT License. See LICENSE for details.
 
 ## Copyright
 
-Copyright (c) 2010-2012 Michael Bleigh and Intridea, Inc. 
+Copyright (c) 2010-2012 Michael Bleigh and Intridea, Inc.
 

lib/grape.rb

@@ -8,6 +8,7 @@ module Grape
   autoload :Client,          'grape/client'
   autoload :Route,           'grape/route'
   autoload :Entity,          'grape/entity'
+  autoload :Cookies,         'grape/cookies'
 
   module Middleware
     autoload :Base,      'grape/middleware/base'

lib/grape/api.rb

@@ -109,13 +109,18 @@ def desc(description, options = {})
         @last_description = options.merge(:description => description)
       end
 
-      # Specify the default format for the API's
-      # serializers. Currently only `:json` is
-      # supported.
+      # Specify the default format for the API's serializers.
+      # May be `:json` or `:txt` (default).
       def default_format(new_format = nil)
         new_format ? set(:default_format, new_format.to_sym) : settings[:default_format]
       end
 
+      # Specify the format for the API's serializers.
+      # May be `:json` or `:txt`.
+      def format(new_format = nil)
+        new_format ? set(:format, new_format.to_sym) : settings[:format]
+      end
+      
       # Specify the format for error messages.
       # May be `:json` or `:txt` (default).
       def error_format(new_format = nil)

lib/grape/cookies.rb

@@ -0,0 +1,41 @@
+module Grape
+  class Cookies
+
+      def initialize
+        @cookies = {}
+        @send_cookies = {}
+      end
+
+      def read(request)
+        request.cookies.each do |name, value|
+          @cookies[name.to_sym] = value
+        end
+      end
+
+      def write(header)
+        @cookies.select { |key, value|
+            @send_cookies[key.to_sym] == true
+        }.each { |name, value|
+          Rack::Utils.set_cookie_header!(
+            header, name, value.instance_of?(Hash) ? value : { :value => value })
+        }
+      end
+
+      def [](name)
+        @cookies[name]
+      end
+
+      def []=(name, value)
+        @cookies[name.to_sym] = value
+        @send_cookies[name.to_sym] = true
+      end
+
+      def each(&block)
+        @cookies.each(&block)
+      end
+
+      def delete(name)
+        self.[]=(name, { :value => 'deleted', :expires => Time.at(0) })
+      end
+    end
+end

lib/grape/endpoint.rb

@@ -157,6 +157,18 @@ def header(key = nil, val = nil)
       end
     end
 
+    # Set or get a cookie
+    #
+    # @example
+    #   cookies[:mycookie] = 'mycookie val'
+    #   cookies['mycookie-string'] = 'mycookie string val'
+    #   cookies[:more] = { :value => '123', :expires => Time.at(0) }
+    #   cookies.delete :more
+    #
+    def cookies
+      @cookies ||= Cookies.new
+    end
+
     # Allows you to define the response body as something other than the
     # return value.
     #
@@ -231,10 +243,12 @@ def run(env)
       @request = Rack::Request.new(@env)
 
       self.extend helpers
+      cookies.read(@request)
       run_filters befores
       response_text = instance_eval &self.block
       run_filters afters
-
+      cookies.write(header)
+      
       [status, header, [body || response_text]]
     end
 
@@ -259,9 +273,10 @@ def build_middleware
           :version_options => settings[:version_options]
         }
       end
-
+      
       b.use Grape::Middleware::Formatter,
-        :default_format => settings[:default_format] || :json,
+        :format => settings[:format],
+        :default_format => settings[:default_format] || :txt,
         :content_types => settings[:content_types]
 
       aggregate_setting(:middleware).each do |m|