grape 0.2.0 → 0.2.1

data/lib/grape.rb

@@ -26,6 +26,7 @@ module Grape
     module Versioner
       autoload :Path,   'grape/middleware/versioner/path'
       autoload :Header, 'grape/middleware/versioner/header'
+      autoload :Param,  'grape/middleware/versioner/param'
     end
   end
 

data/lib/grape/api.rb

@@ -208,9 +208,14 @@ module Grape
       #         end
       #       end
       #     end
-      def helpers(mod = nil, &block)
-        if block_given? || mod
-          mod ||= settings.peek[:helpers] || Module.new
+      def helpers(new_mod = nil, &block)
+        if block_given? || new_mod
+          mod = settings.peek[:helpers] || Module.new
+          if new_mod
+            mod.class_eval do
+              include new_mod
+            end
+          end
           mod.class_eval &block if block_given?
           set(:helpers, mod)
         else

data/lib/grape/endpoint.rb

@@ -52,7 +52,9 @@ module Grape
           anchor = options[:route_options][:anchor]
           anchor = anchor.nil? ? true : anchor
 
-          path = compile_path(prepared_path, anchor && !options[:app])
+          requirements = options[:route_options][:requirements] || {}
+
+          path = compile_path(prepared_path, anchor && !options[:app], requirements)
           regex = Rack::Mount::RegexpWithNamedGroups.new(path)
           path_params = {}
           # named parameters in the api path
@@ -83,17 +85,17 @@ module Grape
       parts << ':version' if settings[:version] && settings[:version_options][:using] == :path
       parts << namespace.to_s if namespace
       parts << path.to_s if path && '/' != path
-      parts.last << '(.:format)'
-      Rack::Mount::Utils.normalize_path(parts.join('/'))
+      Rack::Mount::Utils.normalize_path(parts.join('/') + '(.:format)')
     end
 
     def namespace
       Rack::Mount::Utils.normalize_path(settings.stack.map{|s| s[:namespace]}.join('/'))
     end
 
-    def compile_path(prepared_path, anchor = true)
+    def compile_path(prepared_path, anchor = true, requirements = {})
       endpoint_options = {}
       endpoint_options[:version] = /#{settings[:version].join('|')}/ if settings[:version]
+      endpoint_options.merge!(requirements)
       Rack::Mount::Strexp.compile(prepared_path, endpoint_options, %w( / . ? ), anchor)
     end
 
@@ -115,7 +117,26 @@ module Grape
     # The parameters passed into the request as
     # well as parsed from URL segments.
     def params
-      @params ||= Hashie::Mash.new.deep_merge(request.params).deep_merge(env['rack.routing_args'] || {})
+      @params ||= Hashie::Mash.new.
+        deep_merge(request.params).
+        deep_merge(env['rack.routing_args'] || {}).
+        deep_merge(self.body_params)
+    end
+
+    # Pull out request body params if the content type matches and we're on a POST or PUT
+    def body_params
+      if ['POST', 'PUT'].include?(request.request_method.to_s.upcase)
+        return case env['CONTENT_TYPE']
+          when 'application/json'
+            MultiJson.decode(request.body.read)
+          when 'application/xml'
+            MultiXml.parse(request.body.read)
+          else
+            {}
+          end
+      end
+
+      {}
     end
 
     # The API version as specified in the URL.
@@ -130,6 +151,26 @@ module Grape
       throw :error, :message => message, :status => status
     end
 
+    # Redirect to a new url.
+    #
+    # @param url [String] The url to be redirect.
+    # @param options [Hash] The options used when redirect.
+    #                       :permanent, default true.
+    def redirect(url, options = {})
+      merged_options = {:permanent => false }.merge(options)
+      if merged_options[:permanent]
+        status 304
+      else
+        if env['HTTP_VERSION'] == 'HTTP/1.1' && request.request_method.to_s.upcase != "GET"
+          status 303
+        else
+          status 302
+        end
+      end
+      header "Location", url
+      body ""
+    end
+
     # Set or retrieve the HTTP status code.
     #
     # @param status [Integer] The HTTP Status Code to return for this request.
@@ -156,7 +197,12 @@ module Grape
         @header
       end
     end
-
+    
+    # Set response content-type
+    def content_type(val)
+      header('Content-Type', val)
+    end
+    
     # Set or get a cookie
     #
     # @example
@@ -255,6 +301,7 @@ module Grape
     def build_middleware
       b = Rack::Builder.new
 
+      b.use Rack::Head
       b.use Grape::Middleware::Error,
         :default_status => settings[:default_error_status] || 403,
         :rescue_all => settings[:rescue_all],

data/lib/grape/entity.rb

@@ -3,7 +3,8 @@ require 'hashie'
 module Grape
   # An Entity is a lightweight structure that allows you to easily
   # represent data from your application in a consistent and abstracted
-  # way in your API.
+  # way in your API. Entities can also provide documentation for the
+  # fields exposed.
   #
   # @example Entity Definition
   #
@@ -11,6 +12,7 @@ module Grape
   #     module Entities
   #       class User < Grape::Entity
   #         expose :first_name, :last_name, :screen_name, :location
+  #         expose :field, :documentation => {:type => "string", :desc => "describe the field"}
   #         expose :latest_status, :using => API::Status, :as => :status, :unless => {:collection => true}
   #         expose :email, :if => {:type => :full}
   #         expose :new_attribute, :if => {:version => 'v2'}
@@ -30,6 +32,7 @@ module Grape
   #     class Users < Grape::API
   #       version 'v2'
   #
+  #       desc 'User index', { :object_fields => API::Entities::User.documentation }
   #       get '/users' do
   #         @users = User.all
   #         type = current_user.admin? ? :full : :default
@@ -63,6 +66,8 @@ module Grape
     #   will be called with the represented object as well as the
     #   runtime options that were passed in. You can also just supply a
     #   block to the expose call to achieve the same effect.
+    # @option options :documentation Define documenation for an exposed 
+    #   field, typically the value is a hash with two fields, type and desc. 
     def self.expose(*args, &block)
       options = args.last.is_a?(Hash) ? args.pop : {}
 
@@ -71,6 +76,8 @@ module Grape
         raise ArgumentError, "You may not use block-setting on multi-attribute exposures." if block_given?
       end
 
+      raise ArgumentError, "You may not use block-setting when also using format_with" if block_given? && options[:format_with].respond_to?(:call)
+
       options[:proc] = block if block_given?
 
       args.each do |attribute|
@@ -91,6 +98,68 @@ module Grape
       @exposures
     end
 
+    # Returns a hash, the keys are symbolized references to fields in the entity, 
+    # the values are document keys in the entity's documentation key. When calling 
+    # #docmentation, any exposure without a documentation key will be ignored.
+    def self.documentation
+      @documentation ||= exposures.inject({}) do |memo, value|
+                           unless value[1][:documentation].nil? || value[1][:documentation].empty?
+                             memo[value[0]] = value[1][:documentation] 
+                           end
+                           memo
+                         end
+
+      if superclass.respond_to? :documentation
+        @documentation = superclass.documentation.merge(@documentation)
+      end
+
+      @documentation
+    end
+
+    # This allows you to declare a Proc in which exposures can be formatted with.
+    # It take a block with an arity of 1 which is passed as the value of the exposed attribute.
+    # 
+    # @param name [Symbol] the name of the formatter
+    # @param block [Proc] the block that will interpret the exposed attribute
+    #
+    #
+    #
+    # @example Formatter declaration
+    #
+    #   module API
+    #     module Entities
+    #       class User < Grape::Entity
+    #         format_with :timestamp do |date|
+    #           date.strftime('%m/%d/%Y')
+    #         end
+    #
+    #         expose :birthday, :last_signed_in, :format_with => :timestamp
+    #       end
+    #     end
+    #   end
+    #
+    # @example Formatters are available to all decendants
+    #
+    #   Grape::Entity.format_with :timestamp do |date|
+    #     date.strftime('%m/%d/%Y')
+    #   end
+    #
+    def self.format_with(name, &block)
+      raise ArgumentError, "You must pass a block for formatters" unless block_given?
+      formatters[name.to_sym] = block
+    end
+
+    # Returns a hash of all formatters that are registered for this and it's ancestors.
+    def self.formatters
+      @formatters ||= {}
+
+      if superclass.respond_to? :formatters
+        @formatters = superclass.formatters.merge(@formatters)
+      end
+
+      @formatters
+    end
+
     # This allows you to set a root element name for your representation.
     #
     # @param plural   [String] the root key to use when representing
@@ -171,6 +240,14 @@ module Grape
       self.class.exposures
     end
 
+    def documentation
+      self.class.documentation
+    end
+
+    def formatters
+      self.class.formatters
+    end
+
     # The serializable hash is the Entity's primary output. It is the transformed
     # hash for the given data model and is used as the basis for serialization to
     # JSON and other formats.
@@ -202,6 +279,16 @@ module Grape
         exposure_options[:proc].call(object, options)
       elsif exposure_options[:using]
         exposure_options[:using].represent(object.send(attribute), :root => nil)
+      elsif exposure_options[:format_with]
+        format_with = exposure_options[:format_with]
+
+        if format_with.is_a?(Symbol) && formatters[format_with]
+          formatters[format_with].call(object.send(attribute))
+        elsif format_with.is_a?(Symbol)
+          self.send(format_with, object.send(attribute))
+        elsif format_with.respond_to? :call
+          format_with.call(object.send(attribute))
+        end
       else
         object.send(attribute)
       end

data/lib/grape/middleware/base.rb

@@ -107,20 +107,20 @@ module Grape
         end
 
         def decode_json(object)
-          MultiJson.decode(object)
+          MultiJson.load(object)
         end
 
         def encode_json(object)
           return object if object.is_a?(String)
 
           if object.respond_to? :serializable_hash
-            MultiJson.encode(object.serializable_hash)
+            MultiJson.dump(object.serializable_hash)
           elsif object.kind_of?(Array) && !object.map {|o| o.respond_to? :serializable_hash }.include?(false)
-            MultiJson.encode(object.map {|o| o.serializable_hash })
+            MultiJson.dump(object.map {|o| o.serializable_hash })
           elsif object.respond_to? :to_json
             object.to_json
           else
-            MultiJson.encode(object)
+            MultiJson.dump(object)
           end
         end
 

data/lib/grape/middleware/error.rb

@@ -24,11 +24,11 @@ module Grape
         if (options[:rescue_options] || {})[:backtrace] && backtrace && ! backtrace.empty?
           result = result.merge({ :backtrace => backtrace })
         end
-        MultiJson.encode(result)
+        MultiJson.dump(result)
       end
       
       def encode_txt(message, backtrace)
-        result = message.is_a?(Hash) ? MultiJson.encode(message) : message
+        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 ")

data/lib/grape/middleware/formatter.rb

@@ -13,11 +13,11 @@ module Grape
           :parsers => {}
         }
       end
-      
+
       def headers
-        env.dup.inject({}){|h,(k,v)| h[k.downcase[5..-1]] = v if k.downcase.start_with?('http_'); h}
+        env.dup.inject({}){|h,(k,v)| h[k.to_s.downcase[5..-1]] = v if k.to_s.downcase.start_with?('http_'); h}
       end
-      
+
       def before
         fmt = format_from_extension || options[:format] || format_from_header || options[:default_format]
         if content_types.key?(fmt)
@@ -39,18 +39,17 @@ module Grape
           throw :error, :status => 406, :message => 'The requested format is not supported.'
         end
       end
-      
+
       def format_from_extension
         parts = request.path.split('.')
-        hit = parts.last.to_sym
-        
-        if parts.size <= 1
-          nil
-        else
-          hit
+        extension = parts.last.to_sym
+
+        if parts.size > 1 && content_types.key?(extension)
+          return extension
         end
+        nil
       end
-      
+
       def format_from_header
         mime_array.each do |t|
           if mime_types.key?(t)
@@ -59,7 +58,7 @@ module Grape
         end
         nil
       end
-      
+
       def mime_array
         accept = headers['accept'] or return []
 
@@ -67,14 +66,14 @@ module Grape
           mime.sub(%r(vnd\.[^+]+\+), '')
         }
       end
-      
+
       def after
         status, headers, bodies = *@app_response
         formatter = formatter_for env['api.format']
         bodymap = bodies.collect do |body|
           formatter.call(body)
         end
-        headers['Content-Type'] = content_types[env['api.format']]
+        headers['Content-Type'] = content_types[env['api.format']] unless headers['Content-Type']
         Rack::Response.new(bodymap, status, headers).to_a
       end
     end

data/lib/grape/middleware/versioner.rb

@@ -18,6 +18,8 @@ module Grape
           Path
         when :header
           Header
+        when :param
+          Param
         else
           raise ArgumentError.new("Unknown :using for versioner: #{strategy}")
         end

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

@@ -0,0 +1,44 @@
+require 'grape/middleware/base'
+
+module Grape
+  module Middleware
+    module Versioner
+      # This middleware sets various version related rack environment variables
+      # based on the request parameters and removes that parameter from the 
+      # request parameters for subsequent middleware and API.
+      # If the version substring does not match any potential initialized
+      # versions, a 404 error is thrown.
+      # If the version substring is not passed the version (highest mounted)
+      # version will be used.
+      # 
+      # Example: For a uri path
+      #   /resource?apiver=v1
+      # 
+      # The following rack env variables are set and path is rewritten to
+      # '/resource':
+      # 
+      #   env['api.version'] => 'v1'
+      class Param < Base
+        def default_options
+          {
+            :parameter => "apiver"
+          }
+        end
+
+        def before
+          paramkey = options[:parameter]
+          potential_version = request.params[paramkey]
+
+          unless potential_version.nil?
+            if options[:versions] && !options[:versions].include?(potential_version)
+              throw :error, :status => 404, :message => "404 API Version Not Found", :headers => {'X-Cascade' => 'pass'}
+            end
+            env['api.version'] = potential_version
+            env['rack.request.query_hash'].delete(paramkey)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/grape/version.rb

@@ -1,3 +1,3 @@
 module Grape
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/spec/grape/api_spec.rb

@@ -31,6 +31,17 @@ describe Grape::API do
     end
   end
 
+  describe '.version using param' do
+    it_should_behave_like 'versioning' do
+      let(:macro_options) do
+        {
+          :using => :param,
+          :parameter => "apiver"
+        }
+      end
+    end
+  end
+
   describe '.version using header' do
     it_should_behave_like 'versioning' do
       let(:macro_options) do
@@ -219,6 +230,10 @@ describe Grape::API do
         "hiya"
       end
 
+      subject.endpoints.first.routes.each do |route|
+        route.route_path.should eql '/abc(.:format)'
+      end
+
       get '/abc'
       last_response.body.should eql 'hiya'
       post '/abc'
@@ -269,7 +284,7 @@ describe Grape::API do
           verb
         end
         send(verb, '/example')
-        last_response.body.should eql verb
+        last_response.body.should eql verb == 'head' ? '' : 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 eql 404
@@ -480,6 +495,19 @@ describe Grape::API do
     end
   end
 
+  describe '.logger' do
+    it 'should return an instance of Logger class by default' do
+      subject.logger.class.should eql Logger
+    end
+
+    it 'should allow setting a custom logger' do
+      mylogger = Class.new
+      subject.logger mylogger
+      mylogger.should_receive(:info).exactly(1).times
+      subject.logger.info "this will be logged"
+    end
+  end
+
   describe '.helpers' do
     it 'should be accessible from the endpoint' do
       subject.helpers do
@@ -560,6 +588,28 @@ describe Grape::API do
       get '/howdy'
       last_response.body.should eql 'Hello, world.'
     end
+
+    it 'should allow multiple calls with modules and blocks' do
+      subject.helpers Module.new do
+        def one
+          1
+        end
+      end
+      subject.helpers Module.new do
+        def two
+          2
+        end
+      end
+      subject.helpers do
+        def three
+          3
+        end
+      end
+      subject.get 'howdy' do
+        [one, two, three]
+      end
+      lambda{get '/howdy'}.should_not raise_error
+    end
   end
 
   describe '.scope' do
@@ -656,7 +706,7 @@ describe Grape::API do
         raise "rain!"
       end
       get '/exception'
-      json = MultiJson.decode(last_response.body)
+      json = MultiJson.load(last_response.body)
       json["error"].should eql 'rain!'
       json["backtrace"].length.should > 0
     end
@@ -681,12 +731,20 @@ describe Grape::API do
   describe ".content_type" do
     it "sets additional content-type" do
       subject.content_type :xls, "application/vnd.ms-excel"
-      subject.get(:hello) do
+      subject.get :excel do
         "some binary content"
       end
-      get '/hello.xls'
+      get '/excel.xls'
       last_response.content_type.should == "application/vnd.ms-excel"
     end
+    it "allows to override content-type" do
+      subject.get :content do
+        content_type "text/javascript"
+        "var x = 1;"
+      end
+      get '/content'
+      last_response.content_type.should == "text/javascript"
+    end
   end
 
   describe ".default_error_status" do
@@ -730,16 +788,15 @@ describe Grape::API do
       end
     end
     describe "api structure with two versions and a namespace" do
-      class TwitterAPI < Grape::API
-        # version v1
-        version 'v1', :using => :path
-        get "version" do
+      before :each do
+        subject.version 'v1', :using => :path
+        subject.get "version" do
            api.version
         end
         # version v2
-        version 'v2', :using => :path
-        prefix 'p'
-        namespace "n1" do
+        subject.version 'v2', :using => :path
+        subject.prefix 'p'
+        subject.namespace "n1" do
           namespace "n2" do
             get "version" do
                api.version
@@ -748,22 +805,22 @@ describe Grape::API do
         end
       end
       it "should return versions" do
-         TwitterAPI::versions.should == [ 'v1', 'v2' ]
+         subject.versions.should == [ 'v1', 'v2' ]
       end
       it "should set route paths" do
-         TwitterAPI::routes.size.should >= 2
-         TwitterAPI::routes[0].route_path.should == "/:version/version(.:format)"
-         TwitterAPI::routes[1].route_path.should == "/p/:version/n1/n2/version(.:format)"
+         subject.routes.size.should >= 2
+         subject.routes[0].route_path.should == "/:version/version(.:format)"
+         subject.routes[1].route_path.should == "/p/:version/n1/n2/version(.:format)"
       end
       it "should set route versions" do
-         TwitterAPI::routes[0].route_version.should == 'v1'
-         TwitterAPI::routes[1].route_version.should == 'v2'
+         subject.routes[0].route_version.should == 'v1'
+         subject.routes[1].route_version.should == 'v2'
       end
       it "should set a nested namespace" do
-         TwitterAPI::routes[1].route_namespace.should == "/n1/n2"
+         subject.routes[1].route_namespace.should == "/n1/n2"
       end
       it "should set prefix" do
-         TwitterAPI::routes[1].route_prefix.should == 'p'
+         subject.routes[1].route_prefix.should == 'p'
       end
     end
     describe "api structure with additional parameters" do
@@ -781,87 +838,101 @@ describe Grape::API do
         last_response.body.should == '["a","b,c"]'
       end
       it "should set route_params" do
-        subject.routes.size.should == 1
-        subject.routes[0].route_params.should == { "string" => "", "token" => "a token" }
-        subject.routes[0].route_optional_params.should == { "limit" => "the limit" }
+        subject.routes.map { |route|
+          { :params => route.route_params, :optional_params => route.route_optional_params }
+        }.should eq [
+          { :params => { "string" => "", "token" => "a token" }, :optional_params => { "limit" => "the limit" } }
+        ]
       end
     end
   end
 
   context "desc" do
-    describe "empty api structure" do
-      it "returns an empty array of routes" do
-        subject.desc "grape api"
-        subject.routes.should == []
-      end
-    end
-    describe "single method with a desc" do
-      before(:each) do
-        subject.desc "ping method"
-        subject.get :ping do
-          'pong'
-        end
-      end
-      it "returns route description" do
-        subject.routes[0].route_description.should == "ping method"
-      end
-    end
-    describe "single method with a an array of params and a desc hash block" do
-      before(:each) do
-        subject.desc "ping method", { :params => { "x" => "y" } }
-        subject.get "ping/:x" do
-          'pong'
-        end
-      end
-      it "returns route description" do
-        subject.routes[0].route_description.should == "ping method"
-      end
-    end
-    describe "api structure with multiple methods and descriptions" do
-      before(:each) do
-        class JitterAPI < Grape::API
-          desc "first method"
-          get "first" do; end
-          get "second" do; end
-          desc "third method"
-          get "third" do; end
-        end
-      end
-      it "should return a description for the first method" do
-        JitterAPI::routes[0].route_description.should == "first method"
-        JitterAPI::routes[1].route_description.should be_nil
-        JitterAPI::routes[2].route_description.should == "third method"
-      end
-    end
-    describe "api structure with multiple methods, namespaces, descriptions and options" do
-      before(:each) do
-        class LitterAPI < Grape::API
-          desc "first method"
-          get "first" do; end
-          get "second" do; end
-          namespace "ns" do
-            desc "ns second", :foo => "bar"
-            get "second" do; end
-          end
-          desc "third method", :details => "details of third method"
-          get "third" do; end
-          desc "Reverses a string.", { :params =>
-            { "s" => { :desc => "string to reverse", :type => "string" }}
-          }
-          get "reverse" do
-            params[:s].reverse
-          end
-        end
-      end
-      it "should return a description for the first method" do
-        LitterAPI::routes[0].route_description.should == "first method"
-        LitterAPI::routes[1].route_description.should be_nil
-        LitterAPI::routes[2].route_description.should == "ns second"
-        LitterAPI::routes[2].route_foo.should == "bar"
-        LitterAPI::routes[3].route_description.should == "third method"
-        LitterAPI::routes[4].route_description.should == "Reverses a string."
-        LitterAPI::routes[4].route_params.should == { "s" => { :desc => "string to reverse", :type => "string" }}
-      end
+    it "empty array of routes" do
+      subject.routes.should == []
+    end
+    it "empty array of routes" do
+      subject.desc "grape api"
+      subject.routes.should == []
+    end
+    it "should describe a method" do
+      subject.desc "first method"
+      subject.get :first do ; end
+      subject.routes.length.should == 1
+      route = subject.routes.first
+      route.route_description.should == "first method"
+      route.route_foo.should be_nil
+      route.route_params.should == { }
+    end
+    it "should describe methods separately" do
+      subject.desc "first method"
+      subject.get :first do ; end
+      subject.desc "second method"
+      subject.get :second do ; end
+      subject.routes.count.should == 2
+      subject.routes.map { |route|
+        { :description => route.route_description, :params => route.route_params }
+      }.should eq [
+        { :description => "first method", :params => {} },
+        { :description => "second method", :params => {} }
+      ]
+    end
+    it "should reset desc" do
+      subject.desc "first method"
+      subject.get :first do ; end
+      subject.get :second do ; end
+      subject.routes.map { |route|
+        { :description => route.route_description, :params => route.route_params }
+      }.should eq [
+        { :description => "first method", :params => {} },
+        { :description => nil, :params => {} }
+      ]
+    end
+    it "should namespace and describe arbitrary parameters" do
+      subject.namespace "ns" do
+        desc "ns second", :foo => "bar"
+        get "second" do ; end
+      end
+      subject.routes.map { |route|
+        { :description => route.route_description, :foo => route.route_foo, :params => route.route_params }
+      }.should eq [
+        { :description => "ns second", :foo => "bar", :params => {} },
+      ]
+    end
+    it "should include details" do
+      subject.desc "method", :details => "method details"
+      subject.get "method" do ; end
+      subject.routes.map { |route|
+        { :description => route.route_description, :details => route.route_details, :params => route.route_params }
+      }.should eq [
+        { :description => "method", :details => "method details", :params => {} },
+      ]
+    end
+    it "should describe a method with parameters" do
+      subject.desc "Reverses a string.", { :params =>
+        { "s" => { :desc => "string to reverse", :type => "string" }}
+      }
+      subject.get "reverse" do
+        params[:s].reverse
+      end
+      subject.routes.map { |route|
+        { :description => route.route_description, :params => route.route_params }
+      }.should eq [
+        { :description => "Reverses a string.", :params => { "s" => { :desc => "string to reverse", :type => "string" } } }
+      ]
+    end
+    it "should not symbolize params" do
+      subject.desc "Reverses a string.", { :params =>
+        { "s" => { :desc => "string to reverse", :type => "string" }}
+      }
+      subject.get "reverse/:s" do
+        params[:s].reverse
+      end
+      subject.routes.map { |route|
+        { :description => route.route_description, :params => route.route_params }
+      }.should eq [
+        { :description => "Reverses a string.", :params => { "s" => { :desc => "string to reverse", :type => "string" } } }
+      ]
     end
   end