rad_core 0.0.13 → 0.0.14

data/spec/router/alias_router_spec.rb

@@ -1,6 +1,6 @@
-require 'router/spec_helper'
+require 'spec_helper'
 
-describe "AliasRouter" do  
+describe "AliasRouter" do
   before :all do
     class SomeController
     end
@@ -10,21 +10,21 @@ describe "AliasRouter" do
     remove_constants %w(SomeController)
   end
   
-  before :each do
-    @router = Rad::AliasRouter.new
+  before do
+    @router = Rad::Router::AliasRouter.new
   end
     
   it "encode / decode" do
-    @router.add '/login', class: SomeController, method: :login
+    @router.add '/login', class_name: 'SomeController', method: :login
 
     @router.encode(SomeController, :login, {}).should == ["/login", {}]
-    @router.encode_method('login_path').should == [SomeController, :login] 
+    @router.encode_method('login_path', false).should == [SomeController, :login] 
     @router.decode("/login", {}).should == [SomeController, :login, {}]
   end
   
   it "should differentiate aliases with similar path elements" do
-    @router.add '/login', class: SomeController, method: :login
-    @router.add '/login/twitter', class: SomeController, method: :twitter
+    @router.add '/login', class_name: 'SomeController', method: :login
+    @router.add '/login/twitter', class_name: 'SomeController', method: :twitter
     
     @router.encode(SomeController, :login, {}).should == ["/login", {}]
     @router.decode("/login", {}).should == [SomeController, :login, {}]
@@ -34,65 +34,64 @@ describe "AliasRouter" do
   end
   
   it "input validation" do
-    lambda{@router.add :login, class: SomeController, method: :login}.should raise_error(/\//)
-    lambda{@router.add '/login', class: SomeController}.should raise_error(/method/)
+    lambda{@router.add :login, class_name: 'SomeController', method: :login}.should raise_error(/\//)
+    lambda{@router.add '/login', class_name: 'SomeController'}.should raise_error(/method/)
     lambda{@router.add '/login', method: :login}.should raise_error(/class/)    
-    lambda{@router.add '/login', class: SomeController, method: :login, invalid: 'value'}.should raise_error(/unknown/)
-    lambda{@router.add '/login', class: SomeController, method: :login, url_root: 'users'}.should raise_error(/\//)
-    lambda{@router.add '/login', class: SomeController, method: :login, prefix: []}.should raise_error(/empty/)
+    lambda{@router.add '/login', class_name: 'SomeController', method: :login, invalid: 'value'}.should raise_error(/unknown/)
+    lambda{@router.add '/login', class_name: 'SomeController', method: :login, url_root: 'users'}.should raise_error(/\//)
   end
   
   it "should use :url_root" do
-    @router.add '/login', class: SomeController, method: :login, url_root: '/space'
+    @router.add '/login', class_name: 'SomeController', method: :login, url_root: '/space'
     
-    @router.encode(SomeController, :login, {}).should == ["/space/login", {}]
+    @router.encode(SomeController, :login, {}).should == ["/login", {url_root: '/space'}]
     @router.decode("/space/login", {}).should == [SomeController, :login, {}]
   end  
   
   it "should return nil if route unknown" do
     @router.encode(SomeController, :unknown, {}).should be_nil
-    @router.encode_method(:unknown_path).should be_nil
+    @router.encode_method(:unknown_path, false).should be_nil
     @router.decode("/login", {}).should be_nil
   end
   
   it 'root alias' do
-    @router.add '/', class: SomeController, method: :home
+    @router.add '/', class_name: 'SomeController', method: :home
 
     @router.encode(SomeController, :home, {}).should == ["/", {}]
     @router.decode("/", {}).should == [SomeController, :home, {}]
     
     # should not support url_root
-    -> {@router.add '/', class: SomeController, method: :home, url_root: '/space'}.should raise_error(/url_root/)
+    -> {@router.add '/', class_name: 'SomeController', method: :home, url_root: '/space'}.should raise_error(/url_root/)
   end
   
   describe "prefixes" do
     it "basics" do
-      @router.add '/statistics', class: SomeController, method: :statistics, prefix: [:l, :space]
+      @router.add '/statistics', class_name: 'SomeController', method: :statistics, prefix: [:l, :space]
     
-      @router.encode(SomeController, :statistics, l: 'en', space: 'personal').should == ["/l/en/space/personal/statistics", {}]
-      @router.encode_method("statistics_path").should == [SomeController, :statistics]
-      @router.decode("/l/en/space/personal/statistics", {}).should == [SomeController, :statistics, {l: 'en', space: 'personal'}]
+      @router.encode(SomeController, :statistics, l: 'en', space: 'personal').should == ["/en/personal/statistics", {}]
+      @router.encode_method("statistics_path", false).should == [SomeController, :statistics]
+      @router.decode("/en/personal/statistics", {}).should == [SomeController, :statistics, {l: 'en', space: 'personal'}]
     end
     
     it "should also works with path with slashes" do
-      @router.add '/blogs/show', class: SomeController, method: :show, prefix: [:l, :space]
+      @router.add '/blogs/show', class_name: 'SomeController', method: :show, prefix: [:l, :space]
     
-      @router.encode(SomeController, :show, l: 'en', space: 'personal').should == ["/l/en/space/personal/blogs/show", {}]
-      @router.decode("/l/en/space/personal/blogs/show", {}).should == [SomeController, :show, {l: 'en', space: 'personal'}]
+      @router.encode(SomeController, :show, l: 'en', space: 'personal').should == ["/en/personal/blogs/show", {}]
+      @router.decode("/en/personal/blogs/show", {}).should == [SomeController, :show, {l: 'en', space: 'personal'}]
     end
     
     it "should raise error if prefixes not provided" do
-      @router.add '/login', class: SomeController, method: :login, prefix: [:l]
-      
+      @router.add '/login', class_name: 'SomeController', method: :login, prefix: :l
+
       lambda{@router.encode(SomeController, :login, {})}.should raise_error(/prefix/)
       lambda{@router.decode('/login', {})}.should raise_error(/prefix/)
     end
     
     it "should works with :url_root" do
-      @router.add '/blogs/show', class: SomeController, method: :show, prefix: [:l], url_root: '/users'
+      @router.add '/blogs/show', class_name: 'SomeController', method: :show, prefix: :l, url_root: '/users'
     
-      @router.encode(SomeController, :show, l: 'en').should == ["/users/l/en/blogs/show", {}]
-      @router.decode("/users/l/en/blogs/show", {}).should == [SomeController, :show, {l: 'en'}]
+      @router.encode(SomeController, :show, l: 'en').should == ["/en/blogs/show", {url_root: '/users'}]
+      @router.decode("/users/en/blogs/show", {}).should == [SomeController, :show, {l: 'en'}]
     end
   end
 end

data/spec/router/basic_router_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe "RedirectRouter" do
+  before do
+    @router = Rad::Router::BasicRouter.new
+  end
+  
+  it "skip" do
+    @router.skip(/\/fs/)
+    
+    halt = catch :halt do
+      @router.decode("/users/all", {})
+      nil
+    end
+    halt.should be_nil
+    
+    halt = catch :halt do
+      @router.decode("/fs/user/avatar", {})
+      nil
+    end
+    halt.should_not be_nil
+  end
+    
+  it "redirect" do            
+    workspace = Rad::Conveyors::Workspace.new
+    workspace.response = Rad::Http::Response.new
+    @router.stub!(:workspace).and_return(workspace)
+    
+    @router.redirect(/^\/([^\/]+)$/, "/\\1/Items")
+    
+    halt = catch :halt do
+      @router.decode("/default/Items", {})
+      nil
+    end
+    halt.should be_nil
+    
+    halt = catch :halt do
+      @router.decode("/default", {})
+      nil
+    end
+    halt.should_not be_nil
+    workspace.response.headers['Location'].should == '/default/Items'
+  end
+end

data/spec/router/configurator_spec.rb

@@ -1,18 +1,21 @@
-require 'router/spec_helper'
+require 'spec_helper'
 
 describe "Configurator" do  
-  before :each do
-    @router = Rad::Router.new :class
-    Rad::Routes::Configurator.stub(:router).and_return(@router)
+  before do
+    @basic_router = Rad::Router::BasicRouter.new
+    @router = Rad::Router.new(:class, [
+      [:basic_router, @basic_router]
+    ])
+    Rad::Router::Configurator.stub(:router).and_return(@router)
   end
   
   it "named routes" do
-    rad.routes do |config|
+    rad.router.configure do |config|
       config.stub(:router).and_return(@router)
       
       config.skip(/^\/favicon/)
     end
     
-    @router.skip.size.should > 0
+    @basic_router.skip_routes.size.should > 0
   end
 end

data/spec/router/integration_spec.rb

@@ -1,21 +1,24 @@
-require 'router/spec_helper'
+require 'spec_helper'
 
 describe "Remote Basic" do  
-  with_environment
-  with_router_spec
-  
-  before :all do
+  before :all do    
     class ::AnRemote
       def call; end
     end
-  end
+  end  
+  
+  isolate :conveyors
   
   after :all do
     remove_constants %w(AnRemote)
   end
   
+  before do
+    rad.conveyors.web.use Rad::Router::Processors::Router, :class_variable, :method_variable
+  end
+  
   def call_router path, params 
-    rad.conveyors.web.call path: path, params: Rad::Params.new(params)
+    rad.conveyors.web.call path: path, params: Rad::Conveyors::Params.new(params)
   end
   
   it "basic" do    

data/spec/router/object_router_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+describe "ObjectRouter" do  
+  before :all do
+    class ::Blogs
+      # Object methods
+      def show; end
+      def update; end
+      
+      # Singleton methods
+      def all; end
+      def some; end
+    end        
+  end
+  
+  after :all do
+    remove_constants %w(Blogs)
+  end
+      
+  before do
+    @router = Rad::Router::ObjectRouter.new
+  end
+  
+  describe 'Singleton Resource' do
+    before do
+      @router.configure(
+        default_class_name: 'Blogs',
+        class_to_resource: -> klass      {klass.name},
+        resource_to_class: -> resource   {resource.constantize;},
+        id_to_class:       -> id, params {nil}
+      )
+    end
+    
+    it "basic" do
+      @router.encode(Blogs, :some, {}).should == ["/Blogs/some", {}]
+      @router.encode_method('some_blog_path', false).should == [Blogs, :some]
+      @router.encode_method('some_blogs_path', false).should == [Blogs, :some]
+      @router.decode("/Blogs/some", {}).should == [Blogs, :some, {}]
+    end
+    
+    it "by default should use :all method if the method not explicitly specified" do
+      @router.encode(Blogs, :all, {}).should == ["/Blogs", {}]
+      @router.encode(Blogs, nil, {}).should == ["/Blogs", {}]
+      @router.encode_method('blog_path', false).should == [Blogs, :all]
+      @router.encode_method('blogs_path', false).should == [Blogs, :all]
+      @router.decode("/Blogs", {}).should == [Blogs, :all, {}]
+    end        
+  end
+  
+  describe "Object Resource" do
+    before do
+      @router.configure(
+        default_class_name: 'Blogs',
+        id_to_class:       -> id, params {id == 'about' ? Blogs : nil},
+        resource_to_class: -> resource   {resource.constantize}
+      )
+    end
+    
+    # TODO3 remove also class from :encode, use:
+    # 
+    # @router.encode('about', :update, view: 'full').should == ["/about/update", {view: 'full'}]
+    # @router.encode_method('update_path').should == [:update]
+    # 
+    it "basic" do            
+      @router.encode(Blogs, :update, id: 'about', view: 'full').should == ["/about/update", {view: 'full'}]
+      @router.encode_method('update_path', true).should == [Blogs, :update]
+      @router.decode("/about/update", {view: 'full'}).should == [Blogs, :update, {id: 'about', view: 'full'}]
+    end        
+    
+    it "by default should use :show method if the method not explicitly specified" do
+      @router.encode(Blogs, :show, id: 'about', view: 'full').should == ["/about", {view: 'full'}]
+      @router.encode(Blogs, nil, id: 'about', view: 'full').should == ["/about", {view: 'full'}]
+      @router.encode_method('path', true).should == [Blogs, :show]
+      @router.decode("/about", {view: 'full'}).should == [Blogs, :show, {id: 'about', view: 'full'}]
+    end
+    
+    it "should raise error if :class for :id is not resolved" do
+      lambda{@router.decode("/non-existing-id", {view: 'full'})}.should raise_error(/no class for .* id/)
+    end
+  end
+  
+  describe "prefixes" do
+    before do
+      @common_options = {
+        default_class_name: 'Blogs',
+        class_to_resource: -> klass      {klass.name},
+        resource_to_class: -> resource   {resource.constantize},
+        id_to_class:       -> id, params {id == 'about' ? Blogs : nil}
+      }
+    end
+    
+    it "class resource" do
+      @router.configure @common_options.merge(prefix: [:l, :space])
+      
+      @router.encode(Blogs, :some, l: 'en', space: 'personal').should == ["/en/personal/Blogs/some", {}]
+      @router.encode(Blogs, :all, l: 'en', space: 'personal').should == ["/en/personal/Blogs", {}]
+      @router.decode("/en/personal/Blogs/some", {}).should == [Blogs, :some, {l: 'en', space: 'personal'}]
+      @router.decode("/en/personal/Blogs", {}).should == [Blogs, :all, {l: 'en', space: 'personal'}]
+    end
+    
+    it "object resource" do
+      @router.configure @common_options.merge(prefix: [:l, :space])
+      
+      @router.encode(Blogs, :update, id: 'about', l: 'en', space: 'personal').should == ["/en/personal/about/update", {}]
+      @router.encode(Blogs, nil, id: 'about', l: 'en', space: 'personal').should == ["/en/personal/about", {}]
+      @router.decode("/en/personal/about/update", {}).should == [Blogs, :update, {id: 'about', l: 'en', space: 'personal'}]
+      @router.decode("/en/personal/about", {}).should == [Blogs, :show, {id: 'about', l: 'en', space: 'personal'}]
+    end
+        
+    it "should raise error if prefixes not provided" do      
+      @router.configure @common_options.merge(prefix: :l)
+      
+      lambda{@router.encode(Blogs, :some, {})}.should raise_error(/prefix/)      
+      lambda{@router.encode(Blogs, :all, {})}.should raise_error(/prefix/)      
+      lambda{@router.decode('/Blogs/some', {})}.should raise_error(/no class for .* id/)
+      lambda{@router.decode('/Blogs', {})}.should raise_error(/invalid 'size' of path/)
+      
+      
+      lambda{@router.encode(Blogs, :update, id: 'about')}.should raise_error(/prefix/)      
+      lambda{@router.encode(Blogs, :show, id: 'about')}.should raise_error(/prefix/)      
+      lambda{@router.decode('/about/update', {})}.should raise_error(/no class for .* id/)
+      lambda{@router.decode('/about', {})}.should raise_error(/invalid 'size' of path/)
+    end
+    
+    it "should works with :url_root" do
+      @router.configure @common_options.merge(prefix: [:l], url_root: '/users')
+            
+      @router.encode(Blogs, :some, l: 'en').should == ["/en/Blogs/some", {url_root: '/users'}]
+      @router.decode("/users/en/Blogs/some", {}).should == [Blogs, :some, {l: 'en'}]
+      
+      @router.encode(Blogs, :update, id: 'about', l: 'en').should == ["/en/about/update", {url_root: '/users'}]
+      @router.decode("/users/en/about/update", {}).should == [Blogs, :update, {id: 'about', l: 'en'}]
+    end
+  end
+  
+  describe "micelaneous check" do    
+    before{@common_options = {default_class_name: 'Blogs'}}
+    
+    # it "should raise if :id and not default class " do
+    #   @router.configure @common_options
+    #   lambda{@router.encode(Blogs, :some, id: 'about')}.should raise_error(/:id can't be used with :class/)
+    # end
+   
+    it "should return nil if resource name is not in plural form" do
+      @router.configure @common_options
+      lambda{@router.decode('/Blog/some', {})}.should raise_error(/resource must be in plural form/)
+    end
+  
+    it "object id should not start with capital letter" do
+      @router.configure @common_options 
+      lambda{@router.encode(Blogs, :some, {id: 'About'})}.should raise_error(/capital/)
+    end
+    
+    it "resource name should be uppercased" do
+      @router.configure @common_options.merge(class_to_resource: -> klass {'blogs'})
+      lambda{@router.encode(Blogs, :some, {})}.should raise_error(/capital/)
+    end
+    
+    it "should not be allowed to called twice" do
+      @router.configure @common_options
+      lambda{@router.configure @common_options}.should raise_error(/twice/)
+    end
+    
+    it "should allow only plural form in resource names" do      
+      @router.configure @common_options.merge(class_to_resource: -> klass {'Blog'})
+      lambda{@router.encode(Blogs, :some, {})}.should raise_error(/plural/)
+    end
+    
+    it "shouldn't allow slashes in resource name" do
+      @router.configure @common_options.merge(class_to_resource: -> klass {'Site/Blog'})
+      lambda{@router.encode(Blogs, :some, {})}.should raise_error(/\//)
+    end
+    
+    # it "should correctly works with unknown routes" do
+    #   @router.encode(Blogs, :show, {}).should be_nil
+    #   @router.encode_method('show_blog_path').should be_nil
+    #   @router.encode_method('show_blogs_path').should be_nil
+    #   @router.decode("/Blogs/show", {}).should be_nil
+    #         
+    #   @router.encode(Blogs, :show, id: 'about', view: 'full').should be_nil
+    #   @router.encode_method('show_blog_path').should be_nil
+    #   @router.encode_method('show_blogs_path').should be_nil
+    #   @router.decode("/Blogs/about/show", view: 'full').should be_nil
+    # end
+  end
+end

data/spec/router/persistent_params_spec.rb

@@ -1,14 +1,14 @@
-require 'router/spec_helper'
+require 'spec_helper'
 
 describe "Persistent Params" do
   after :all do
     remove_constants %w(PathParamsRouter)
   end
   
-  before :each do
+  before do
     @router = Rad::Router.new :class
 
-    @params = Rad::Params.new
+    @params = Rad::Conveyors::Params.new
     @router.stub(:safe_workspace).and_return({params: @params}.to_openobject)
 
     @router.persistent_params << :l
@@ -56,7 +56,7 @@ describe "Persistent Params" do
     
     router = Rad::Router.new :class, [[:prefix_router, PathParamsRouter.new]]
     router.persistent_params << :l    
-    params = Rad::Params.new
+    params = Rad::Conveyors::Params.new
     params.l = 'en'    
     router.stub(:safe_workspace).and_return({params: params}.to_openobject)            
     

data/spec/router/restful_router_spec.rb

@@ -1,120 +1,128 @@
-require 'router/spec_helper'
+require 'spec_helper'
 
 describe "RestfulRouter" do  
   before :all do
-    class ::BlogControllerSpec
+    class ::BlogController
       def show; end
     end    
   end
   
   after :all do
-    remove_constants %w(BlogControllerSpec)
+    remove_constants %w(BlogController)
   end
       
-  before :each do
-    @router = Rad::RestfulRouter.new
+  before do
+    @router = Rad::Router::RestfulRouter.new
   end
   
   describe 'core API' do      
-    it "singleton resource" do
-      @router.add :blogs, class: BlogControllerSpec
+    it "class resource" do
+      @router.add :blogs, class_name: 'BlogController'
     
-      @router.encode(BlogControllerSpec, :show, {}).should == ["/blogs/show", {}]
-      @router.encode_method('show_blog_path').should == [BlogControllerSpec, :show]
-      @router.encode_method('show_blogs_path').should == [BlogControllerSpec, :show]
-      @router.decode("/blogs/show", {}).should == [BlogControllerSpec, :show, {}]
+      @router.encode(BlogController, :show, {}).should == ["/blogs/show", {}]
+      @router.encode_method('show_blog_path', false).should == [BlogController, :show]
+      @router.encode_method('show_blogs_path', false).should == [BlogController, :show]
+      @router.decode("/blogs/show", {}).should == [BlogController, :show, {}]
     end
     
     it "object resource" do
-      @router.add :blogs, class: BlogControllerSpec
+      @router.add :blogs, class_name: 'BlogController'
       
-      @router.encode(BlogControllerSpec, :show, id: '10', view: 'full').should == ["/blogs/10/show", {view: 'full'}]
-      @router.encode_method('show_blog_path').should == [BlogControllerSpec, :show]
-      @router.encode_method('show_blogs_path').should == [BlogControllerSpec, :show]
-      @router.decode("/blogs/10/show", {view: 'full'}).should == [BlogControllerSpec, :show, {id: '10', view: 'full'}]
+      @router.encode(BlogController, :show, id: '10', view: 'full').should == ["/blogs/10/show", {view: 'full'}]
+      @router.encode_method('show_blog_path', true).should == [BlogController, :show]
+      @router.encode_method('show_blogs_path', true).should == [BlogController, :show]
+      @router.decode("/blogs/10/show", {view: 'full'}).should == [BlogController, :show, {id: '10', view: 'full'}]
     end    
   end
   
   describe "prefixes" do
-    it "singleton resource" do
-      @router.add :blogs, class: BlogControllerSpec, prefix: [:l, :space]
+    it "class resource" do
+      @router.add :blogs, class_name: 'BlogController', prefix: [:l, :space]
       
-      @router.encode(BlogControllerSpec, :show, l: 'en', space: 'personal').should == ["/l/en/space/personal/blogs/show", {}]
-      @router.decode("/l/en/space/personal/blogs/show", {}).should == [BlogControllerSpec, :show, {l: 'en', space: 'personal'}]
+      @router.encode(BlogController, :show, l: 'en', space: 'personal').should == ["/en/personal/blogs/show", {}]
+      @router.decode("/en/personal/blogs/show", {}).should == [BlogController, :show, {l: 'en', space: 'personal'}]
     end
     
     it "object resource" do
-      @router.add :blogs, class: BlogControllerSpec, prefix: [:l, :space]
+      @router.add :blogs, class_name: 'BlogController', prefix: [:l, :space]
       
-      @router.encode(BlogControllerSpec, :show, id: '10', l: 'en', space: 'personal').should == ["/l/en/space/personal/blogs/10/show", {}]
-      @router.decode("/l/en/space/personal/blogs/10/show", {}).should == [BlogControllerSpec, :show, {id: '10', l: 'en', space: 'personal'}]
+      @router.encode(BlogController, :show, id: '10', l: 'en', space: 'personal').should == ["/en/personal/blogs/10/show", {}]
+      @router.decode("/en/personal/blogs/10/show", {}).should == [BlogController, :show, {id: '10', l: 'en', space: 'personal'}]
     end
         
     it "should raise error or return nil if prefixes not provided" do      
-      @router.add :blogs, class: BlogControllerSpec, prefix: [:l]
+      @router.add :blogs, class_name: 'BlogController', prefix: :l
       
-      lambda{@router.encode(BlogControllerSpec, :show, {})}.should raise_error(/prefix/)      
+      lambda{@router.encode(BlogController, :show, {})}.should raise_error(/prefix/)      
       @router.decode('/blogs/show', {}).should be_nil
       
-      lambda{@router.encode(BlogControllerSpec, :show, id: '10')}.should raise_error(/prefix/)      
+      lambda{@router.encode(BlogController, :show, id: '10')}.should raise_error(/prefix/)      
       @router.decode('/blogs/10/show', {}).should be_nil
     end
     
     it "should works with :url_root" do
-      @router.add :blogs, class: BlogControllerSpec, prefix: [:l], url_root: '/users'
+      @router.add :blogs, class_name: 'BlogController', prefix: :l, url_root: '/users'
             
-      @router.encode(BlogControllerSpec, :show, l: 'en').should == ["/users/l/en/blogs/show", {}]
-      @router.decode("/users/l/en/blogs/show", {}).should == [BlogControllerSpec, :show, {l: 'en'}]
+      @router.encode(BlogController, :show, l: 'en').should == ["/en/blogs/show", {url_root: '/users'}]
+      @router.decode("/users/en/blogs/show", {}).should == [BlogController, :show, {l: 'en'}]
       
-      @router.encode(BlogControllerSpec, :show, id: '10', l: 'en').should == ["/users/l/en/blogs/10/show", {}]
-      @router.decode("/users/l/en/blogs/10/show", {}).should == [BlogControllerSpec, :show, {id: '10', l: 'en'}]
+      @router.encode(BlogController, :show, id: '10', l: 'en').should == ["/en/blogs/10/show", {url_root: '/users'}]
+      @router.decode("/users/en/blogs/10/show", {}).should == [BlogController, :show, {id: '10', l: 'en'}]
     end
     
     it "should be able to use alias for prefix parameter" do
-      @router.add :blogs, class: BlogControllerSpec, prefix: [:l, [:space_id, 'space']]
+      @router.add :blogs, class_name: 'BlogController', prefix: [:l, :space_id]
       
-      @router.encode(BlogControllerSpec, :show, l: 'en', space_id: 'personal').should == ["/l/en/space/personal/blogs/show", {}]
-      @router.decode("/l/en/space/personal/blogs/show", {}).should == [BlogControllerSpec, :show, {l: 'en', space_id: 'personal'}]
+      @router.encode(BlogController, :show, l: 'en', space_id: 'personal').should == ["/en/personal/blogs/show", {}]
+      @router.decode("/en/personal/blogs/show", {}).should == [BlogController, :show, {l: 'en', space_id: 'personal'}]
     end
   end
   
   describe "micelaneous check" do    
     it "should allow only plural form in resource definition" do      
-      lambda{@router.add :blog, class: BlogControllerSpec}.should raise_error(/plural/)
-      @router.add :blogs, class: BlogControllerSpec
+      lambda{@router.add :blog, class_name: 'BlogController'}.should raise_error(/plural/)
+      @router.add :blogs, class_name: 'BlogController'
     end
     
     it "shouldn't allow slashes in resource name" do
-      lambda{@router.add '/admin/blogs', class: BlogControllerSpec}.should raise_error(/\//)
+      lambda{@router.add '/admin/blogs', class_name: 'BlogController'}.should raise_error(/\//)
     end
     
     it "should correctly works with unknown routes" do
-      @router.encode(BlogControllerSpec, :show, {}).should be_nil
-      @router.encode_method('show_blog_path').should be_nil
-      @router.encode_method('show_blogs_path').should be_nil
+      @router.encode(BlogController, :show, {}).should be_nil
+      @router.encode_method('show_blog_path', false).should be_nil
+      @router.encode_method('show_blogs_path', false).should be_nil
       @router.decode("/blogs/show", {}).should be_nil
             
-      @router.encode(BlogControllerSpec, :show, id: '10', view: 'full').should be_nil
-      @router.encode_method('show_blog_path').should be_nil
-      @router.encode_method('show_blogs_path').should be_nil
+      @router.encode(BlogController, :show, id: '10', view: 'full').should be_nil
+      @router.encode_method('show_blog_path', true).should be_nil
+      @router.encode_method('show_blogs_path', true).should be_nil
       @router.decode("/blogs/10/show", view: 'full').should be_nil
     end
   end
   
-  it "should use :url_root" do
-    @router.add :blogs, class: BlogControllerSpec, url_root: '/users'
+  describe ":url_root" do
+    it "should use :url_root" do
+      @router.add :blogs, class_name: 'BlogController', url_root: '/users'
     
-    @router.encode(BlogControllerSpec, :show, {}).should == ["/users/blogs/show", {}]
-    @router.decode("/users/blogs/show", {}).should == [BlogControllerSpec, :show, {}]
+      @router.encode(BlogController, :show, {}).should == ["/blogs/show", {url_root: '/users'}]
+      @router.decode("/users/blogs/show", {}).should == [BlogController, :show, {}]
         
-    @router.encode(BlogControllerSpec, :show, id: '10').should == ["/users/blogs/10/show", {}]
-    @router.decode("/users/blogs/10/show", {}).should == [BlogControllerSpec, :show, {id: '10'}]
-  end  
+      @router.encode(BlogController, :show, id: '10').should == ["/blogs/10/show", {url_root: '/users'}]
+      @router.decode("/users/blogs/10/show", {}).should == [BlogController, :show, {id: '10'}]
+    end  
+    
+    it "should ignore slash" do
+      @router.add :blogs, class_name: 'BlogController', url_root: '/'
+    
+      @router.encode(BlogController, :show, {}).should == ["/blogs/show", {}]
+      @router.decode("/blogs/show", {}).should == [BlogController, :show, {}]
+    end
+  end
   
   it "input validation" do
-    lambda{@router.add :blogs, class: BlogControllerSpec, invalid: 'value'}.should raise_error(/unknown/)
+    lambda{@router.add :blogs, class_name: 'BlogController', invalid: 'value'}.should raise_error(/unknown/)
     lambda{@router.add :blogs}.should raise_error(/class/)    
-    lambda{@router.add :blogs, class: BlogControllerSpec, url_root: 'users'}.should raise_error(/\//)
-    lambda{@router.add :blogs, class: BlogControllerSpec, prefix: []}.should raise_error(/empty/)
+    lambda{@router.add :blogs, class_name: 'BlogController', url_root: 'users'}.should raise_error(/\//)
   end
 end