rad_core 0.2.6 → 0.2.7

data/spec/remote/remote_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe "Remote Basic" do
   isolate :conveyors
-  
+
   before do
     rad.conveyors.services do |ss|
       ss.use Rad::Remote::Processors::RemoteCaller, :content
     end
   end
-  
+
   old_mode = rad.mode
   after :all do
     remove_constants %w(
@@ -16,73 +16,73 @@ describe "Remote Basic" do
       JsonErrorSpec
       UnregisteredReturnValueSpec
     )
-    
+
     rad.mode = old_mode, true
   end
-  
+
   it "basic" do
     class BasicSpec
       inherit Rad::Remote::RemoteController
-      
+
       def call
         {result: 'some result'}
       end
     end
-    
+
     workspace = rcall BasicSpec, :call, format: 'json'
-    
+
     workspace.delete(:remote_object).should be_a(BasicSpec)
-    expected_result = {      
+    expected_result = {
       params: {format: 'json'},
-      
-      class: BasicSpec,   
-      method_name: :call, 
-      
+
+      class: BasicSpec,
+      method_name: :call,
+
       remote_result: {result: "some result"},
       content: %({"result":"some result"})
     }
     workspace.to_h(true).subset(expected_result.keys).should == expected_result
   end
-  
+
   describe "error handling should behave different in :production, :development and :test modes" do
-    it "error in :development mode" do    
+    it "error in :development mode" do
       class JsonErrorSpec
         inherit Rad::Remote::RemoteController
-      
+
         def call_with_error
           raise 'some error'
         end
       end
-    
+
       rad.mode = :development, true
-    
+
       workspace = rcall JsonErrorSpec, 'call_with_error', format: 'json'
-    
+
       workspace.delete(:remote_object).should be_a(JsonErrorSpec)
       workspace.include?(:remote_result).should be_false
       expected_result = {
         params: {format: 'json'},
-      
-        class: JsonErrorSpec,   
-        method_name: "call_with_error", 
-      
+
+        class: JsonErrorSpec,
+        method_name: "call_with_error",
+
         content: %({"error":"some error"})
       }
       workspace.to_h.subset(expected_result.keys).should == expected_result
     end
   end
-  
+
   it "should be able to protect methods from GET request"
-  
+
   it "should not allow unregistered object types be used as return value" do
     class UnregisteredReturnValueSpec
       inherit Rad::Remote::RemoteController
-      
+
       def call
         Object.new
       end
     end
-   
+
     lambda{
       rcall UnregisteredReturnValueSpec, 'call', format: 'json'
     }.should raise_error(/You can't use object of type 'Object' as Remote's return value!/)

data/spec/router/alias_router_spec.rb

@@ -5,91 +5,91 @@ describe "AliasRouter" do
     class SomeController
     end
   end
-  
+
   after :all do
     remove_constants %w(SomeController)
   end
-  
+
   before do
     @router = Rad::Router::AliasRouter.new
   end
-    
+
   it "encode / decode" do
     @router.add '/login', class_name: 'SomeController', method: :login
 
     @router.encode(SomeController, :login, {}).should == ["/login", {}]
-    @router.encode_method('login_path', false).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_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, {}]
-    
+
     @router.encode(SomeController, :twitter, {}).should == ["/login/twitter", {}]
     @router.decode("/login/twitter", {}).should == [SomeController, :twitter, {}]
   end
-  
+
   it "input validation" do
     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', method: :login}.should raise_error(/class/)
     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_name: 'SomeController', method: :login, url_root: '/space'
-    
+
     @router.encode(SomeController, :login, {}).should == ["/login", {url_root: '/space'}]
     @router.decode("/space/login", {}).should == [SomeController, :login, {}]
-  end  
-  
+  end
+
   it "should return nil if route unknown" do
     @router.encode(SomeController, :unknown, {}).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_name: 'SomeController', method: :home
 
     @router.encode(SomeController, :home, {}).should == ["/", {}]
     @router.decode("/", {}).should == [SomeController, :home, {}]
-    
+
     # should not support 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_name: 'SomeController', method: :statistics, prefix: [:l, :space]
-    
+
       @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_name: 'SomeController', method: :show, prefix: [:l, :space]
-    
+
       @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_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_name: 'SomeController', method: :show, prefix: :l, url_root: '/users'
-    
+
       @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

data/spec/router/basic_router_spec.rb

@@ -4,36 +4,36 @@ 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            
+
+  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

data/spec/router/configurator_spec.rb

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

data/spec/router/integration_spec.rb

@@ -1,47 +1,47 @@
 require 'spec_helper'
 
-describe "Remote Basic" do  
-  before :all do    
+describe "Remote Basic" do
+  before :all do
     class ::AnRemote
       def call; end
     end
-  end  
-  
+  end
+
   isolate :conveyors, :router
-  
+
   after :all do
     remove_constants %w(AnRemote)
   end
-  
+
   before do
     rad.conveyors.web.use Rad::Router::Processors::Router, :class_variable, :method_variable
     rad.router.routers = [
       [:simple_router, Rad::Router::SimpleRouter.new]
     ]
   end
-  
-  def call_router path, params 
+
+  def call_router path, params
     rad.conveyors.web.call path: path, params: Rad::Conveyors::Params.new(params)
   end
-  
-  it "basic" do    
+
+  it "basic" do
     workspace = call_router '/an_remote/call', format: 'json'
-    
-    expected_result = {      
-      path: "/an_remote/call", 
+
+    expected_result = {
+      path: "/an_remote/call",
       params: {format: 'json'},
-      
-      class_variable: AnRemote,       
+
+      class_variable: AnRemote,
       method_variable: :call
     }
     workspace.to_h(true).subset(expected_result.keys).should == expected_result
   end
-    
+
   it "params must be casted to string" do
     workspace = call_router '/an_remote/call', a: 'b'
     workspace.params.to_h.subset(:a).should == {a: 'b'}
   end
-  
+
   it "default router should raise error if route is invalid" do
     lambda{call_router '/invalid/call', format: 'json'}.should raise_error(/uninitialized constant Invalid/)
   end

data/spec/router/object_router_spec.rb

@@ -1,26 +1,26 @@
 require 'spec_helper'
 
-describe "ObjectRouter" do  
+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
   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(
@@ -30,23 +30,23 @@ describe "ObjectRouter" do
         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
   end
-  
+
   describe "Object Resource" do
     before do
       @router.configure(
@@ -55,30 +55,30 @@ describe "ObjectRouter" do
         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            
+    #
+    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        
-    
+    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 = {
@@ -88,95 +88,95 @@ describe "ObjectRouter" do
         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      
+
+    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.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.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 "miscellaneous check" do    
+
+  describe "miscellaneous 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 
+      @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      
+
+    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