rad_core 0.2.6 → 0.2.7

data/spec/router/persistent_params_spec.rb

@@ -4,7 +4,7 @@ describe "Persistent Params" do
   after :all do
     remove_constants %w(PathParamsRouter)
   end
-  
+
   before do
     @router = Rad::Router.new :class
 
@@ -13,53 +13,53 @@ describe "Persistent Params" do
 
     @router.persistent_params << :l
   end
-  
-  describe 'Basics' do  
-    it "global persistent params" do                  
+
+  describe 'Basics' do
+    it "global persistent params" do
       @params.merge! l: 'ru', id: 1
 
       @router.encode(Object, :send).should == ["/object/send", {l: 'ru'}]
       @router.encode(Object, :send, l: 'en').should == ["/object/send", {l: 'en'}]
     end
-      
+
     it "should persist params with begining underscore" do
       @params.merge! _space: 'space_id', id: 1
-    
+
       @router.encode(Object, :send).should == ['/object/send', {}]
-    
+
       @router.persist_params do
         @router.encode(Object, :send).should == ["/object/send", {_space: 'space_id'}]
         @router.encode(Object, :send, _space: 'another_id').should == ["/object/send", {_space: 'another_id'}]
       end
     end
   end
-  
+
   describe "Miscellaneous checks" do
     it "should not persist special params" do
       @params.merge! _method: 'get'
-      
-      @router.persist_params do        
+
+      @router.persist_params do
         @router.encode(Object, :send).should == ["/object/send", {}]
       end
-    end    
+    end
   end
-  
+
   it "should correctly works when params are encoded in url path" do
     class PathParamsRouter
       def encode klass, method, params
         [%(#{klass.name}/#{method}#{'/' unless params.empty?}#{params.to_a.collect{|k, v| "#{k}/#{v}"}.join('/')}), {}]
       end
-      
+
       def decode path, params
       end
     end
-    
+
     router = Rad::Router.new :class, [[:prefix_router, PathParamsRouter.new]]
-    router.persistent_params << :l    
+    router.persistent_params << :l
     params = Rad::Conveyors::Params.new
-    params.l = 'en'    
-    router.stub(:safe_workspace).and_return({params: params}.to_openobject)            
-    
+    params.l = 'en'
+    router.stub(:safe_workspace).and_return({params: params}.to_openobject)
+
     router.encode(Object, :send).should == ["Object/send/l/en", {}]
   end
 end

data/spec/router/restful_router_spec.rb

@@ -1,128 +1,128 @@
 require 'spec_helper'
 
-describe "RestfulRouter" do  
+describe "RestfulRouter" do
   before :all do
     class ::BlogController
       def show; end
-    end    
+    end
   end
-  
+
   after :all do
     remove_constants %w(BlogController)
   end
-      
+
   before do
     @router = Rad::Router::RestfulRouter.new
   end
-  
-  describe 'core API' do      
+
+  describe 'core API' do
     it "class resource" do
       @router.add :blogs, class_name: 'BlogController'
-    
+
       @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_name: 'BlogController'
-      
+
       @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
   end
-  
+
   describe "prefixes" do
     it "class resource" do
       @router.add :blogs, class_name: 'BlogController', prefix: [:l, :space]
-      
+
       @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_name: 'BlogController', prefix: [:l, :space]
-      
+
       @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      
+
+    it "should raise error or return nil if prefixes not provided" do
       @router.add :blogs, class_name: 'BlogController', prefix: :l
-      
-      lambda{@router.encode(BlogController, :show, {})}.should raise_error(/prefix/)      
+
+      lambda{@router.encode(BlogController, :show, {})}.should raise_error(/prefix/)
       @router.decode('/blogs/show', {}).should be_nil
-      
-      lambda{@router.encode(BlogController, :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_name: 'BlogController', prefix: :l, url_root: '/users'
-            
+
       @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(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_name: 'BlogController', prefix: [:l, :space_id]
-      
+
       @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 "miscellaneous check" do    
-    it "should allow only plural form in resource definition" do      
+
+  describe "miscellaneous check" do
+    it "should allow only plural form in resource definition" do
       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_name: 'BlogController'}.should raise_error(/\//)
     end
-    
+
     it "should correctly works with unknown routes" do
       @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(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
-  
+
   describe ":url_root" do
     it "should use :url_root" do
       @router.add :blogs, class_name: 'BlogController', url_root: '/users'
-    
+
       @router.encode(BlogController, :show, {}).should == ["/blogs/show", {url_root: '/users'}]
       @router.decode("/users/blogs/show", {}).should == [BlogController, :show, {}]
-        
+
       @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  
-    
+    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_name: 'BlogController', invalid: 'value'}.should raise_error(/unknown/)
-    lambda{@router.add :blogs}.should raise_error(/class/)    
+    lambda{@router.add :blogs}.should raise_error(/class/)
     lambda{@router.add :blogs, class_name: 'BlogController', url_root: 'users'}.should raise_error(/\//)
   end
 end

data/spec/router/router_spec.rb

@@ -1,111 +1,111 @@
 require 'spec_helper'
 
-describe "Router Basic" do  
-  before :all do    
+describe "Router Basic" do
+  before :all do
     class ::BlogsController
       include Rad::Router::CoreRoutingHelper
-      
+
       def show; end
     end
   end
-  
+
   after :all do
     remove_constants %w(BlogsController)
   end
-  
+
   before do
     @router = Rad::Router.new :class
-    
+
     @params = Rad::Conveyors::Params.new
     @router.stub(:safe_workspace).and_return({params: @params}.to_openobject)
   end
-  
+
   it "encode" do
     @router.encode(BlogsController, :show, format: 'json').should == ["/blogs_controller/show.json", {}]
   end
-    
+
   it "encode_method" do
-    lambda{@router.encode_method :some_method, false}.should raise_error(/route method/)    
-    first_router_in_chain = @router.routers.to_a[0][1]    
+    lambda{@router.encode_method :some_method, false}.should raise_error(/route method/)
+    first_router_in_chain = @router.routers.to_a[0][1]
     first_router_in_chain.should_receive(:encode_method).and_return([BlogsController, :show])
     @router.encode_method(:some_method, false).should == [BlogsController, :show]
   end
-    
-  it "decode" do    
+
+  it "decode" do
     @router.decode("/blogs_controller/show", {}).should == [BlogsController, :show, {}]
-  end    
-    
+  end
+
   describe "url_for" do
     it "should convert complex params to json" do
       @router.url_for(BlogsController, :show, a: :b, as_json: true).should == %(/blogs_controller/show?json=%7B%22a%22%3A%22b%22%7D)
     end
-    
+
     it "should works with full url" do
       @router.url_for('http://google.com').should == "http://google.com"
     end
-    
+
     it "should not allow to use url_root/params/format with full url (http://)" do
-      lambda{@router.url_for('http://google.com', {a: 'b'})}.should raise_error(/can't use option/)      
+      lambda{@router.url_for('http://google.com', {a: 'b'})}.should raise_error(/can't use option/)
     end
-    
+
     it "should escape params" do
       @router.url_for(BlogsController, :show, a: 'b/c').should == "/blogs_controller/show?a=b%2Fc"
     end
-    
+
     it "url_for" do
       @router.stub(:current_class).and_return(BlogsController)
-    
-      @router.url_for(BlogsController, :show, format: 'json').should == "/blogs_controller/show.json"    
+
+      @router.url_for(BlogsController, :show, format: 'json').should == "/blogs_controller/show.json"
       @router.url_for(:show, format: 'json').should == "/blogs_controller/show.json"
-        
+
       @router.url_for(BlogsController, :show).should == "/blogs_controller/show"
       @router.url_for(:show).should == "/blogs_controller/show"
       @router.url_for(:show).should == "/blogs_controller/show"
     end
-      
+
     it "url_for_path should recognize first slash as to use url_for_path" do
       @router.url_for('/some_path', key: :value).should == "/some_path?key=value"
       @router.url_for('/some_path').should == "/some_path"
     end
-    
+
     it "should mark url string with format" do
-      @router.stub(:current_class).and_return(BlogsController)      
+      @router.stub(:current_class).and_return(BlogsController)
       @router.url_for(:show, format: 'js').marks.format.should == 'js'
-      
+
       @router.url_for('/path').marks.format.should be_nil
       @router.url_for('/path', format: 'js').marks.format.should == 'js'
     end
-    
+
     it "shouldn't modify arguments (from error)" do
       options = {format: :js}
       @router.url_for(BlogsController, :show, options).should == "/blogs_controller/show.js"
       options.should == {format: :js}
     end
-    
+
     # it "should check for false :url_root (from error)" do
     #   config.set! :url_root, '/bag'
-    # 
+    #
     #   @router.url_for("/some_url", url_root: false).should == "/some_url"
-    # end    
+    # end
   end
-  
+
   describe "persistent params" do
     before do
       @router.persistent_params << :l
     end
-    
-    it "global persistent params" do                  
+
+    it "global persistent params" do
       @params.l, @params.id = 'ru', 1
 
-      @router.url_for(BlogsController, :show).should == "/blogs_controller/show?l=ru"      
+      @router.url_for(BlogsController, :show).should == "/blogs_controller/show?l=ru"
       @router.url_for(BlogsController, :show, l: 'en').should == "/blogs_controller/show?l=en"
     end
-        
+
     it "should persist params with begining underscore" do
       @params._space, @params.id = 'space_id', 1
-      
+
       @router.url_for(BlogsController, :show).should == '/blogs_controller/show'
-      
+
       @router.persist_params do
         @router.url_for(BlogsController, :show).should == '/blogs_controller/show?_space=space_id'
         @router.url_for(BlogsController, :show, _space: 'another_id').should == '/blogs_controller/show?_space=another_id'

data/spec/router/routing_helper_spec.rb

@@ -1,54 +1,54 @@
 require 'spec_helper'
 
-describe "Routing Helper" do    
+describe "Routing Helper" do
   before :all do
     class ::BlogsController
       include Rad::Router::CoreRoutingHelper
-      
+
       def show; end
     end
   end
-  
+
   after :all do
     remove_constants %w(BlogsController)
   end
-  
+
   before do
     @router = Rad::Router.new :class
-    
+
     @params = Rad::Conveyors::Params.new
     @router.stub(:safe_workspace).and_return({params: @params}.to_openobject)
-    
+
     @controller = BlogsController.new
     @controller.stub(:router).and_return(@router)
   end
-      
-  it "basic" do          
-    @router.stub(:encode_method).and_return([BlogsController, :show])      
+
+  it "basic" do
+    @router.stub(:encode_method).and_return([BlogsController, :show])
     @controller.show_blogs_path.should == "/blogs_controller/show"
   end
-  
+
   it "correct works if there's no route" do
     lambda{@controller.undefined_path}.should raise_error(/no route for/)
-    lambda{@controller.show_blogs}.should raise_error(/undefined method/) 
+    lambda{@controller.show_blogs}.should raise_error(/undefined method/)
   end
-  
+
   it "argument parsing" do
-    @router.stub(:encode_method).and_return([BlogsController, :show])      
-    
+    @router.stub(:encode_method).and_return([BlogsController, :show])
+
     @controller.show_blogs_path.should == "/blogs_controller/show"
     @controller.show_blogs_path(a: 'b').should == "/blogs_controller/show?a=b"
-    @controller.show_blogs_path(10, a: 'b').should == "/blogs_controller/show?a=b&id=10"      
+    @controller.show_blogs_path(10, a: 'b').should == "/blogs_controller/show?a=b&id=10"
   end
-  
-  it "helper_method should take any object as :id" do      
+
+  it "helper_method should take any object as :id" do
     class IdStub
       def to_param
         'some_id'
       end
     end
 
-    @router.stub(:encode_method).and_return([BlogsController, :show])      
+    @router.stub(:encode_method).and_return([BlogsController, :show])
     @controller.show_blogs_path(IdStub.new, a: 'b').should == "/blogs_controller/show?a=b&id=some_id"
   end
 end