Fixed typo.

Author: dblock

README.markdown

@@ -36,7 +36,7 @@ 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'
 
@@ -87,7 +87,7 @@ end
 
 The above sample creates a Rack application that can be run from a rackup *config.ru* file:
 
-```ruby
+``` ruby
 run Twitter::API
 ```
 And would respond to the following routes:
@@ -99,7 +99,7 @@ And would respond to the following routes:
 
 In a Rails application, modify *config/routes*:
 
-```ruby
+``` ruby
 mount Twitter::API => "/"
 ```
 
@@ -124,7 +124,7 @@ Serialization takes place automatically.
 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}"
@@ -147,13 +147,13 @@ 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
+``` ruby
 class API < Grape::API
   get '/counter' do
     cookies[:counter] ||= 0
@@ -165,32 +165,32 @@ class API < Grape::API
     { :result => cookies.delete(:counter) }
   end
 end
-````
+```
 
 To set more than value use hash-based syntax:
 
-````ruby
+``` 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)
 ```
 
@@ -199,15 +199,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
@@ -216,7 +216,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
@@ -225,7 +225,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}" })
@@ -236,30 +236,32 @@ 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
   end
 end
 ```
 
-    class Twitter::API < Grape::API
-      rescue_from ArgumentError do |e|
-        Rack::Response.new([ "ArgumentError: #{e.message}" ], 500)
-      end
-      rescue_from NotImplementedError do |e|
-        Rack::Response.new([ "NotImplementedError: #{e.message}" ], 500)
-      end
-    end
+``` ruby
+class Twitter::API < Grape::API
+  rescue_from ArgumentError do |e|
+    Rack::Response.new([ "ArgumentError: #{e.message}" ], 500)
+  end
+  rescue_from NotImplementedError do |e|
+    Rack::Response.new([ "NotImplementedError: #{e.message}" ], 500)
+  end
+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
 request's extension or `Accept` header.
 
-```ruby
+``` ruby
 class Twitter::API < Grape::API
   content_type :xls, "application/vnd.ms-excel"
 end
@@ -273,10 +275,10 @@ You can also set the default format. The order for choosing the format is the fo
 * Use the default format, if specified by the `default_format` option.
 * Default to `:txt` otherwise.
 
-```ruby
+``` ruby
 class Twitter::API < Grape::API
   format :json
-  defalt_format :json
+  default_format :json
 end
 ```
 
@@ -287,7 +289,7 @@ must go into the `spec/request` group. You may want your API code to go into
 `app/api` - you can match that layout under `spec` by adding the following in
 `spec/spec_helper.rb`.
 
-```ruby
+``` ruby
 RSpec.configure do |config|
   config.include RSpec::Rails::RequestExampleGroup, :type => :request, :example_group => {
     :file_path => /spec\/api/
@@ -297,7 +299,7 @@ end
 
 A simple RSpec API test makes a `get` request and parses the response.
 
-```ruby
+``` ruby
 require 'spec_helper'
 
 describe Twitter::API do
@@ -317,7 +319,7 @@ Grape lets you add a description to an API along with any other optional
 elements that can also be inspected at runtime.
 This can be useful for generating documentation.
 
-```ruby
+``` ruby
 class TwitterAPI < Grape::API
 
   version 'v1'
@@ -342,7 +344,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'
@@ -351,7 +353,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))
@@ -364,7 +366,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
@@ -387,7 +389,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