namespace support options argument, only requirements options now

CHANGELOG.md

@@ -8,6 +8,7 @@ Next Release
 * Parsed body input from POST and PUT requests is now available in `api.request.body` - [@dblock](/~https://github.com/dblock).
 * [#343](/~https://github.com/intridea/grape/pull/343): Fix: return `Content-Type: text/plain` with error 405 - [@gustavosaume](/~https://github.com/gustavosaume), [@wyattisimo](/~https://github.com/wyattisimo).
 * [#357](/~https://github.com/intridea/grape/pull/357): Grape now requires Rack 1.3.0 or newer - [@jhecking](/~https://github.com/jhecking).
+* [#320](/~https://github.com/intridea/grape/issues/320): Namespace accept requirements now - [@niedhui](/~https://github.com/niedhui).
 * Your contribution here.
 
 0.3.2 (2/28/2013)

README.md

@@ -403,12 +403,20 @@ header "X-Robots-Tag", "noindex"
 ## Routes
 
 Optionally, you can define requirements for your named route parameters using regular
-expressions. The route will match only if all requirements are met.
+expressions on namespace or endpoint. The route will match only if all requirements are met.
 
 ```ruby
 get ':id', :requirements => { :id => /[0-9]*/ } do
   Status.find(params[:id])
 end
+
+namespace :outer, :requirements => { :id => /[0-9]*/ } do
+  get :id do
+  end
+
+  get ":id/edit" do
+  end
+end
 ```
 
 ## Helpers
@@ -855,7 +863,7 @@ section above. It also supports custom data formats. You must declare additional
 `content_type` and optionally supply a parser via `parser` unless a parser is already available within
 Grape to enable a custom format. Such a parser can be a function or a class.
 
-With a parser, parsed data is available "as-is" in `env['api.request.body']`. 
+With a parser, parsed data is available "as-is" in `env['api.request.body']`.
 Without a parser, data is available "as-is" and in `env['api.request.input']`.
 
 The following example is a trivial parser that will assign any input with the "text/custom" content-type

lib/grape.rb

@@ -20,6 +20,7 @@ module Grape
   autoload :API,                 'grape/api'
   autoload :Endpoint,            'grape/endpoint'
   autoload :Route,               'grape/route'
+  autoload :Namespace,           'grape/namespace'
   autoload :Cookies,             'grape/cookies'
   autoload :Validations,         'grape/validations'
 

lib/grape/api.rb

@@ -356,17 +356,17 @@ def delete(paths = ['/'], options = {}, &block); route('DELETE', paths, options,
       def options(paths = ['/'], options = {}, &block); route('OPTIONS', paths, options, &block) end
       def patch(paths = ['/'], options = {}, &block); route('PATCH', paths, options, &block) end
 
-      def namespace(space = nil, &block)
+      def namespace(space = nil, options = {},  &block)
         if space || block_given?
           previous_namespace_description = @namespace_description
           @namespace_description = (@namespace_description || {}).deep_merge(@last_description || {})
           @last_description = nil
           nest(block) do
-            set(:namespace, space.to_s) if space
+            set(:namespace, Namespace.new(space, options)) if space
           end
           @namespace_description = previous_namespace_description
         else
-          Rack::Mount::Utils.normalize_path(settings.stack.map{|s| s[:namespace]}.join('/'))
+          Rack::Mount::Utils.normalize_path(settings.stack.map{|s| s[:namespace].try(:space)}.join('/'))
         end
       end
 

lib/grape/endpoint.rb

@@ -35,9 +35,9 @@ def generate_api_method(method_name, &block)
     def initialize(settings, options = {}, &block)
       @settings = settings
       if block_given?
-        method_name = [ 
+        method_name = [
           options[:method],
-          settings.gather(:namespace).join("/"),
+          settings.gather(:namespace).map(&:space).join("/"),
           settings.gather(:mount_path).join("/"),
           Array(options[:path]).join("/")
         ].join(" ")
@@ -88,7 +88,11 @@ def prepare_routes
           anchor = options[:route_options][:anchor]
           anchor = anchor.nil? ? true : anchor
 
-          requirements = options[:route_options][:requirements] || {}
+          endpoint_requirements = options[:route_options][:requirements] || {}
+          all_requirements = (settings.gather(:namespace).map(&:requirements) << endpoint_requirements)
+          requirements = all_requirements.reduce({}) do |base_requirements, single_requirements|
+            base_requirements.merge!(single_requirements)
+          end
 
           path = compile_path(prepared_path, anchor && !options[:app], requirements)
           regex = Rack::Mount::RegexpWithNamedGroups.new(path)
@@ -137,7 +141,7 @@ def prepare_path(path)
     end
 
     def namespace
-      Rack::Mount::Utils.normalize_path(settings.stack.map{|s| s[:namespace]}.join('/'))
+      Rack::Mount::Utils.normalize_path(settings.stack.map{|s| s[:namespace].try(:space)}.join('/'))
     end
 
     def compile_path(prepared_path, anchor = true, requirements = {})

lib/grape/namespace.rb

@@ -0,0 +1,16 @@
+module Grape
+  class Namespace
+    attr_reader :space, :options
+
+    # options:
+    #   requirements: a hash
+    def initialize(space, options = {})
+      @space, @options = space.to_s, options
+    end
+
+    def requirements
+      options[:requirements] || {}
+    end
+
+  end
+end

spec/grape/endpoint_spec.rb

@@ -241,6 +241,7 @@ def app; subject end
     end
 
     context 'with special requirements' do
+
       it 'parses email param with provided requirements for params' do
         subject.get('/:person_email', :requirements => { :person_email => /.*/ }) do
         params[:person_email]
@@ -273,6 +274,36 @@ def app; subject end
         get 'rodzyn@test.com/wrong_middle/1'
         last_response.status.should == 404
       end
+
+      context ' namespace requirements' do
+        before :each do
+          subject.namespace :outer, :requirements => { :person_email => /abc@(.*).com/ } do
+            get('/:person_email') do
+              params[:person_email]
+            end
+
+            namespace :inner, :requirements => {:number => /[0-9]/, :person_email => /rodzyn@(.*).com/ }do
+              get '/:person_email/test/:number' do
+                params[:person_email] << params[:number]
+              end
+            end
+          end
+        end
+        it "parse email param with provided requirements for params" do
+          get '/outer/abc@grape.com'
+          last_response.body.should == 'abc@grape.com'
+        end
+
+        it "should override outer namespace's requirements" do
+          get '/outer/inner/rodzyn@testing.wrong/test/1'
+          last_response.status.should == 404
+
+          get '/outer/inner/rodzyn@testing.com/test/1'
+          last_response.status.should == 200
+          last_response.body.should == 'rodzyn@testing.com1'
+        end
+
+      end
     end
 
     context 'from body parameters' do