rad_core 0.2.6 → 0.2.7

data/spec/controller/render_spec.rb

@@ -2,8 +2,8 @@ require "spec_helper"
 
 describe "Controller render" do
   with_view_path "#{spec_dir}/views"
-  with_abstract_controller  
-  
+  with_abstract_controller
+
   after :all do
     remove_constants %w(
       LayoutFiltersSpec
@@ -16,91 +16,91 @@ describe "Controller render" do
       AlreadyRenderedSpec
       SpecialFormatSpec
       AnotherActionSpec
-      InlineRenderSpec      
+      InlineRenderSpec
       InlineWithLayoutSpec
       MultipleActions
       RelativeSpec
     )
   end
-    
-  describe 'layout' do  
+
+  describe 'layout' do
     it "should use :except and :only in layout" do
       class ::LayoutFiltersSpec
         inherit Rad::Controller::Abstract
         layout '/layouts/app', only: :action_with_layout
-        
+
         def action_with_layout; end
         def action_without_layout; end
       end
-      
-      ccall(LayoutFiltersSpec, :action_with_layout, format: 'html').should == "Layout html, content"  
+
+      ccall(LayoutFiltersSpec, :action_with_layout, format: 'html').should == "Layout html, content"
       ccall(LayoutFiltersSpec, :action_without_layout).should == "content"
     end
-    
+
     it "should apply formats to layout" do
       class LayoutSpec
         inherit Rad::Controller::Abstract
         layout '/layouts/app'
-      
-        def action; end      
+
+        def action; end
       end
-    
-      ccall(LayoutSpec, :action, format: 'html').should == "Layout html, content"  
+
+      ccall(LayoutSpec, :action, format: 'html').should == "Layout html, content"
       ccall(LayoutSpec, :action, format: 'js').should == "Layout js, content"
-    end  
-      
+    end
+
     it "should take layout: false or layout: '/another_layout'" do
       class AnotherLayout
         inherit Rad::Controller::Abstract
         layout '/layout/app'
-        
+
         def action; end
-        
+
         def without_layout
           render action: :action, layout: false
         end
-        
+
         def another_layout
           render action: :action, layout: '/layouts/admin'
-        end        
+        end
       end
-      
+
       ccall(AnotherLayout, :without_layout).should == "action"
       ccall(AnotherLayout, :another_layout).should == "Admin layout, action"
     end
-      
-    
+
+
     it "should take into account :layout when rendering template" do
       class ::ExplicitRenderSpec
         inherit Rad::Controller::Abstract
         layout '/layouts/app'
-        
+
         def with_layout
           render '/some_template'
         end
-        
+
         def without_layout
           render '/some_template', layout: false
         end
       end
-      
+
       ccall(ExplicitRenderSpec, :with_layout, format: 'html').should == "Layout html, some template"
       ccall(ExplicitRenderSpec, :without_layout, format: 'html').should == "some template"
-    end    
+    end
   end
-  
+
   it "should render template inside of controller" do
     class ::RenderInsideOfControllerSpec
       inherit Rad::Controller::Abstract
 
       def some_action
         render '/some_template'
-      end    
+      end
     end
 
-    ccall(RenderInsideOfControllerSpec, 'some_action').should == "some template"
+    ccall(RenderInsideOfControllerSpec, :some_action).should == "some template"
   end
-  
+
   it "should not allow to render partials as actions" do
     class ::ForbidPartialAsActionSpec
       inherit Rad::Controller::Abstract
@@ -109,21 +109,21 @@ describe "Controller render" do
 
     ccall(ForbidPartialAsActionSpec, :action).should == ''
   end
-  
+
   it "should render view with right format" do
     class FormatSpec
       inherit Rad::Controller::Abstract
       def action; end
     end
 
-    ccall(FormatSpec, :action, format: 'html').should == "html format"    
+    ccall(FormatSpec, :action, format: 'html').should == "html format"
     ccall(FormatSpec, :action, format: 'js').should == "js format"
   end
-  
+
   it "should be able to use rad.template.render for different purposes (mail for example)" do
     rad.template.render("/standalone", locals: {a: 'a'}).should == 'standalone usage, a'
   end
-  
+
   it "should not rener if already rendered in controller" do
     class ::AlreadyRenderedSpec
       inherit Rad::Controller::Abstract
@@ -135,93 +135,93 @@ describe "Controller render" do
 
     ccall(AlreadyRenderedSpec, :action).should == 'custom content'
   end
-  
+
   it "should handle serialization obj ('xml', 'json')" do
     class ::SpecialFormatSpec
       inherit Rad::Controller::Abstract
-      
+
       def json_action
         render json: {a: "b"}
       end
-      
+
       def xml_action
         render xml: {a: "b"}
       end
     end
-    
-    ccall(SpecialFormatSpec, :json_action, format: 'json').should == %({"a":"b"})      
-    ccall(SpecialFormatSpec, :xml_action, format: 'xml').should =~ /<a>b<\/a>/      
+
+    ccall(SpecialFormatSpec, :json_action, format: 'json').should == %({"a":"b"})
+    ccall(SpecialFormatSpec, :xml_action, format: 'xml').should =~ /<a>b<\/a>/
     -> {
       ccall(SpecialFormatSpec, :json_action, format: 'xml')
     }.should raise_error(/responing with 'json' to the 'xml'/)
   end
-  
+
   it "should render another action via action: :action_name" do
     class ::AnotherActionSpec
       inherit Rad::Controller::Abstract
-  
+
       def another_action; end
-      
-      def action          
+
+      def action
         render action: :another_action
       end
     end
-    
+
     ccall(AnotherActionSpec, :action).should == "another action (action_name: another_action)"
   end
-    
+
   it "should take :inline option" do
     class ::InlineRenderSpec
       inherit Rad::Controller::Abstract
-      
+
       def action
         render inline: "content"
       end
     end
-    
+
     ccall(InlineRenderSpec, :action).should == "content"
   end
-  
+
   # it ":inline option should render without layout" do
   #   class ::InlineWithLayoutSpec
   #     inherit Rad::Controller::Abstract
-  #     
+  #
   #     layout '/layouts/app'
-  #     
+  #
   #     def action
   #       render inline: "content"
   #     end
   #   end
-  #   
+  #
   #   ccall(InlineWithLayoutSpec, :action).should == "content"
   # end
-  
+
   it "should render correct action inside of special 'actions.xxx' template file" do
     class ::MultipleActions
       inherit Rad::Controller::Abstract
-      
+
       def increase; end
       def decrease; end
       def action_without_template; end
     end
-    
+
     ccall(MultipleActions, :increase).should == "plus\n"
     ccall(MultipleActions, :decrease).should == "minus\n"
     ccall(MultipleActions, :action_without_template).should == ''
   end
-  
+
   it "relative templates should be searched as: CurrentClass -> SuperClass -> SameDir" do
     module ::RelativeSpec
       class A
         inherit Rad::Controller::Abstract
-        
+
         def show; end
       end
-    
+
       class B < A
       end
     end
-    
+
     ccall(RelativeSpec::B, :show).should == 'form b'
   end
 end

data/spec/conveyors/conveyors_spec.rb

@@ -2,12 +2,12 @@ require "spec_helper"
 
 describe "Conveyor" do
   inject conveyors: :conveyors
-  
+
   def call_conveyor
     r = conveyors.web.call(result: [])
     r.result
   end
-  
+
   after :all do
     remove_constants %w(
       SmokeTestASpec
@@ -21,65 +21,65 @@ describe "Conveyor" do
       ErrorBubblingBSpec
     )
   end
-  
+
   isolate :conveyors
-  
+
   before :all do
     rad.mode = :development, true
   end
-  
+
   after :all do
     rad.mode = :test, true
   end
-  
+
   it "smoke test" do
-    class SmokeTestASpec < Rad::Conveyors::Processor      
+    class SmokeTestASpec < Rad::Conveyors::Processor
       def call
-        workspace.result << :a_before          
+        workspace.result << :a_before
         next_processor.call
         workspace.result << :a_after
       end
     end
 
-    class SmokeTestBSpec < Rad::Conveyors::Processor      
-      def call      
-        rad.workspace.result << :b_before      
+    class SmokeTestBSpec < Rad::Conveyors::Processor
+      def call
+        rad.workspace.result << :b_before
         next_processor.call
         rad.workspace.result << :b_after
       end
     end
-    
+
     conveyors.web.use SmokeTestASpec
     conveyors.web.use SmokeTestBSpec
     call_conveyor.should == [:a_before, :b_before, :b_after, :a_after]
   end
-  
+
   describe "error handling" do
     it "common case" do
       class CommonCaseASpec < Rad::Conveyors::Processor
         def call
           workspace.result << :a_before
-              
+
           begin
             next_processor.call
           rescue StandardError => e
             workspace.result << e.message
           end
         end
-      end    
-  
+      end
+
       class CommonCaseBSpec < Rad::Conveyors::Processor
         def call
           workspace.result << :b_before
           raise 'error before'
         end
       end
-  
+
       conveyors.web.use CommonCaseASpec
       conveyors.web.use CommonCaseBSpec
       call_conveyor.should == [:a_before, :b_before, "error before"]
     end
-  
+
     it "should raise error if not catched" do
       class NotCatchedErrorSpec < Rad::Conveyors::Processor
         def call
@@ -87,39 +87,39 @@ describe "Conveyor" do
           raise 'error before'
         end
       end
-            
+
       conveyors.web.use NotCatchedErrorSpec
       lambda{call_conveyor}.should raise_error(/error before/)
     end
-  
+
     it "in after block" do
       class ErrorInAfterBlockASpec < Rad::Conveyors::Processor
         def call
           workspace.result << :a_before
-  
+
           begin
             next_processor.call
           rescue StandardError => e
             workspace.result << e.message
           end
         end
-      end    
-  
-  
+      end
+
+
       class ErrorInAfterBlockBSpec < Rad::Conveyors::Processor
         def call
           workspace.result << :b_before
           next_processor.call
-          raise 'error after'          
+          raise 'error after'
         end
       end
-  
-  
+
+
       conveyors.web.use ErrorInAfterBlockASpec
       conveyors.web.use ErrorInAfterBlockBSpec
       call_conveyor.should == [:a_before, :b_before, "error after"]
     end
-  
+
     it "bubbling (from error)" do
       class ErrorBubblingASpec < Rad::Conveyors::Processor
         def call
@@ -130,16 +130,16 @@ describe "Conveyor" do
           end
         end
       end
-      
+
       class ErrorBubblingBSpec < Rad::Conveyors::Processor
         def call
           raise 'error'
         end
-      end      
-      
+      end
+
       conveyors.web.use ErrorBubblingASpec
       conveyors.web.use ErrorBubblingBSpec
-      
+
       call_conveyor.should == ['error']
     end
   end

data/spec/environment/config_spec.rb

@@ -3,20 +3,20 @@ require 'spec_helper'
 require 'rad'
 require 'rad/spec/environment'
 
-describe 'Config' do  
+describe 'Config' do
   before do
     rad.mode = :development, true
-    @c = Rad::Config.new key: 'value', key2: 'value2'    
+    @c = Rad::Config.new key: 'value', key2: 'value2'
   end
   after{rad.mode = :test, true}
-    
+
   it "clone" do
     c = Rad::Config.new a: {b: :c}
-    
-    c2 = c.clone    
+
+    c2 = c.clone
     c.a.delete :b
     c.delete :a
-    
+
     c2.a[:b].should == :c
   end
 end