Allowing arbitrary option hashes along with the api declaration.

Author: dblock

README.markdown

@@ -105,6 +105,18 @@ Grape exposes arrays of API versions and compiled routes. Each route contains a
 
     TwitterAPI::versions # yields [ 'v1', 'v2' ]
     TwitterAPI::routes # yields an array of Grape::Route objects
+    TwitterAPI::routes[0].route_version # yields 'v1'
+
+Grape also supports storing additional options with the route information. This can be useful for generating documentation. 
+The optional hash that follows the API path may contain any number of keys and values are accessible via `route_[name]`.
+
+    class StringAPI < Grape::API      
+      get :split, { :params => [ :string, :token ] } do 
+        params[:string].split(params[:token])
+      end
+    end
+
+    StringAPI::routes[0].route_params # yields an array [ :string, :token ]
 
 ## Note on Patches/Pull Requests
 

lib/grape/api.rb

@@ -182,25 +182,32 @@ def http_digest(options = {}, &block)
       #       {:hello => 'world'}
       #     end
       #   end
-      def route(methods, paths, &block)
+      def route(methods, paths = ['/'], route_options = {}, &block)
         methods = Array(methods)
-        paths = ['/'] if paths == []
+        
+        paths = ['/'] if ! paths || paths == []
         paths = Array(paths)
+        
         endpoint = build_endpoint(&block)        
-        options = {}
 
-        options[:version] = /#{version.join('|')}/ if version
+        endpoint_options = {}
+        endpoint_options[:version] = /#{version.join('|')}/ if version
 
         methods.each do |method|
           paths.each do |path|
+
             compiled_path = compile_path(path)
-            path = Rack::Mount::Strexp.compile(compiled_path, options, %w( / . ? ), true)
+            path = Rack::Mount::Strexp.compile(compiled_path, endpoint_options, %w( / . ? ), true)
             request_method = (method.to_s.upcase unless method == :any)
-            routes << Route.new(prefix, 
-              version ? version.join('|') : nil, 
-              namespace, 
-              request_method, 
-              compiled_path)
+
+            routes << Route.new({
+              :prefix => prefix, 
+              :version => version ? version.join('|') : nil, 
+              :namespace => namespace, 
+              :method => request_method, 
+              :path => compiled_path}
+              .merge(route_options || {}))
+
             route_set.add_route(endpoint, 
               :path_info => path, 
               :request_method => request_method
@@ -209,11 +216,11 @@ def route(methods, paths, &block)
         end
       end
 
-      def get(*paths, &block); route('GET', paths, &block) end
-      def post(*paths, &block); route('POST', paths, &block) end
-      def put(*paths, &block); route('PUT', paths, &block) end
-      def head(*paths, &block); route('HEAD', paths, &block) end
-      def delete(*paths, &block); route('DELETE', paths, &block) end
+      def get(paths = ['/'], options = {}, &block); route('GET', paths, options, &block) end
+      def post(paths = ['/'], options = {}, &block); route('POST', paths, options, &block) end
+      def put(paths = ['/'], options = {}, &block); route('PUT', paths, options, &block) end
+      def head(paths = ['/'], options = {}, &block); route('HEAD', paths, options, &block) end
+      def delete(paths = ['/'], options = {}, &block); route('DELETE', paths, options, &block) end
 
       def namespace(space = nil, &block)
         if space || block_given?

lib/grape/route.rb

@@ -3,22 +3,20 @@ module Grape
   # A compiled route for inspection.
   class Route
 
-    attr_reader :prefix
-    attr_reader :version
-    attr_reader :namespace
-    attr_reader :method
-    attr_reader :path
+    def initialize(options = {})
+      @options = options || {}
+    end
 
-    def initialize(prefix, version, namespace, method, path)
-      @prefix = prefix
-      @version = version
-      @namespace = namespace
-      @method = method
-      @path = path
+    def method_missing(method_id, *arguments)
+      if match = /route_(?<name>[_a-zA-Z]\w*)/.match(method_id.to_s)
+        @options[match['name'].to_sym]
+      else
+        super
+      end
     end
 
     def to_s
-      "#{method} #{path}"
+      "#{route_method} #{route_path}"
     end
 
   end

spec/grape/api_spec.rb

@@ -171,7 +171,7 @@ def app; subject end
     end
 
     it 'should allow for multiple paths' do
-      subject.get("/abc", "/def") do
+      subject.get(["/abc", "/def"]) do
         "foo"
       end
 
@@ -223,19 +223,16 @@ def app; subject end
 
     it 'should allow for multipart paths' do
 
-
       subject.route([:get, :post], '/:id/first') do
         "first"
       end
-
 
       subject.route([:get, :post], '/:id') do
         "ola"
       end
       subject.route([:get, :post], '/:id/first/second') do
         "second"
       end
-      
 
       get '/1'
       last_response.body.should eql 'ola'
@@ -633,9 +630,9 @@ def two
       it "returns one route" do
         subject.routes.size.should == 1
         route = subject.routes[0]
-        route.version.should be_nil
-        route.path.should == "/ping(.:format)"
-        route.method.should == "GET"
+        route.route_version.should be_nil
+        route.route_path.should == "/ping(.:format)"
+        route.route_method.should == "GET"
       end
     end    
     describe "api structure with two versions and a namespace" do
@@ -661,18 +658,33 @@ class TwitterAPI < Grape::API
       end
       it "should set route paths" do
         TwitterAPI::routes.size.should == 2
-        TwitterAPI::routes[0].path.should == "/:version/version(.:format)"
-        TwitterAPI::routes[1].path.should == "/p/:version/n1/n2/version(.:format)"
+        TwitterAPI::routes[0].route_path.should == "/:version/version(.:format)"
+        TwitterAPI::routes[1].route_path.should == "/p/:version/n1/n2/version(.:format)"
       end
       it "should set route versions" do
-        TwitterAPI::routes[0].version.should == 'v1'
-        TwitterAPI::routes[1].version.should == 'v2'
+        TwitterAPI::routes[0].route_version.should == 'v1'
+        TwitterAPI::routes[1].route_version.should == 'v2'
       end
       it "should set a nested namespace" do
-        TwitterAPI::routes[1].namespace.should == "/n1/n2"
+        TwitterAPI::routes[1].route_namespace.should == "/n1/n2"
       end
       it "should set prefix" do
-        TwitterAPI::routes[1].prefix.should == 'p'
+        TwitterAPI::routes[1].route_prefix.should == 'p'
+      end
+    end
+    describe "api structure with additional parameters" do
+      before(:each) do
+        subject.get :split, { :params => [ :string, :token ] } do 
+          params[:string].split(params[:token])
+        end
+      end
+      it "should split a string" do
+        get "/split", :string => "a,b,c", :token => ','
+        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 ]
       end
     end
   end