rad_core 0.2.6 → 0.2.7

data/spec/support/filters_spec.rb

@@ -1,18 +1,16 @@
 require 'support/spec_helper'
-
-require "rad/_support/callbacks"
 require "rad/_support/filters"
 
 describe "Filters" do
   module ARemote
     inherit Rad::Filters
   end
-  
+
   class FiltersBasic
     inherit ARemote
-          
+
     before :set_user
-    
+
     def action
       'result'
     end
@@ -22,39 +20,39 @@ describe "Filters" do
       @user = 'some user'
     end
   end
-  
+
   class FilterInheritance < FiltersBasic
     before :set_model
-    
+
     attr_reader :model
     def set_model
       @model = 'some model'
-    end      
+    end
   end
-  
+
   class FilterOverrideAction < FiltersBasic
     def action
       'overriden result'
     end
   end
-  
+
   it 'basic' do
     r = FiltersBasic.new
     r.run_callbacks(:action){r.send :action}.should == 'result'
     r.user.should == 'some user'
   end
-  
+
   it 'inheritance' do
     r = FilterInheritance.new
     r.run_callbacks(:action){r.send :action}.should == 'result'
     r.user.should == 'some user'
     r.model.should == 'some model'
   end
-  
+
   it "overriding action" do
     r = FilterOverrideAction.new
     r.run_callbacks(:action){r.send :action}.should == 'overriden result'
     r.user.should == 'some user'
   end
-  
+
 end

data/spec/template/template_spec.rb

@@ -2,64 +2,64 @@ require 'spec_helper'
 
 describe "Template" do
   with_view_path "#{spec_dir}/views"
-  
-  before :all do      
+
+  before :all do
     class ::SomeObject
-      attr_accessor :ivariable      
+      attr_accessor :ivariable
     end
-  end    
+  end
   after :all do
     remove_constants %w(SomeObject)
   end
-  
+
   before do
     rad.mode = :development, true
     $render_result = OpenObject.new
-  end  
+  end
   after{rad.mode = :test, true}
-  
+
   inject template: :template
-  
+
   def render *a, &b
     template.render *a, &b
   end
-  
+
   describe 'special' do
     it "read" do
       template.read('/other/template').should == %{<% "ruby code" %> content}
     end
-    
+
     it "exist?" do
       template.should exist('/other/template')
       template.should_not exist('/other/non-existing-template')
     end
-    
+
     it "template prefixes" do
       template.exist?('/prefixes/underscored', prefixes: ['']).should be_false
       render('/prefixes/underscored', prefixes: ['_', '']).should == "underscored"
       render('/prefixes/underscored.erb', prefixes: ['_', '']).should == "underscored"
-      
+
       template.exist?('/prefixes/without_prefix', prefixes: ['_']).should be_false
       render('/prefixes/without_prefix', prefixes: ['']).should == "whthout prefix"
     end
-    
+
     it "should not use prefixes for :action" do
       template.exist?('/prefixes/underscored').should be_true
       template.exist?('/prefixes/underscored', prefixes: [''], exact_format: true).should be_false
     end
   end
-  
+
   describe 'basic' do
-    it "general" do    
+    it "general" do
       some_object = SomeObject.new
       some_object.ivariable = "instance variable value"
       options = {
         instance_variables: [some_object, {ivariable2: "instance variable value 2"}],
-        object: OpenObject.new.update(value: 'object value'), 
+        object: OpenObject.new.update(value: 'object value'),
         locals: {lvariable: 'local value'},
         format: 'html'
       }
-      
+
       result = render("/basic/general", options){|content_name| "content for :#{content_name}"}
 
       check = %{\
@@ -71,53 +71,53 @@ Yield: content for :content}
 
       result.should == check
     end
-    
+
     it "should not render wrong format if :action specified" do
       template.exist?('/basic/non_existing_format', format: 'html', prefixes: [''], exact_format: true).should be_true
       template.exist?('/basic/non_existing_format', format: :invalid, prefixes: [''], exact_format: true).should be_false
-      
+
       # from error
       template.exist?('non_existing_format', format: :invalid, prefixes: [''], exact_format: true, current_dir: "#{spec_dir}/views/basic").should be_false
     end
-    
+
     it "extension" do
       render('/basic/extension').should == "some content"
       render('/basic/extension.erb').should == "some content"
     end
-    
+
     it "must support custom context_class" do
       class CustomTemplateContext < Rad::Template::Context
         def custom_helper
           'custom helper'
         end
       end
-    
+
       render('/basic/custom_context', context: CustomTemplateContext.new).should == "content from custom helper"
     end
-    
+
     # it "must support explicit context, and it should overtake context_class" do
     #   class CustomTemplateContext < Rad::Template::Context
     #     def custom_helper
     #       'custom helper'
     #     end
     #   end
-    # 
+    #
     #   render(
-    #     '/basic/custom_context', 
-    #     context: CustomTemplateContext.new, 
+    #     '/basic/custom_context',
+    #     context: CustomTemplateContext.new,
     #     context_class: Object
     #   ).should == "content from custom helper"
     # end
-    
+
     it "no template" do
       lambda{render('/non-existing-template')}.should raise_error(/no template/)
     end
-    
+
     it "should render arbitrary file" do
       render(file: "#{spec_dir}/file.erb").should == "file template"
     end
   end
-  
+
   describe 'format' do
     it "basic" do
       render('/format/format', format: 'html', prefixes: [''], exact_format: true).should == "html format"
@@ -126,16 +126,16 @@ Yield: content for :content}
       render('/format/format.html', format: 'js', prefixes: [''], exact_format: true).should == "html format"
       render('/format/format.html.erb', format: 'js', prefixes: [''], exact_format: true).should == "html format"
     end
-    
+
     it "nesting different formats" do
       render('/nesting_format/dialog', format: 'js', prefixes: [''], exact_format: true).should == %(rad.dialog().show("dialog, dialog form"))
     end
-    
+
     it "should not force format for partials (if :action not specified)" do
       render('/format_for_partials/dialog', format: 'js', prefixes: [''], exact_format: true).should == %(rad.dialog().show("dialog form"))
     end
   end
-  
+
   describe 'nested' do
     it "should render relative templates" do
       render('/nested/relative/a').should == "template a, template b"
@@ -143,17 +143,17 @@ Yield: content for :content}
       current_dir = "#{spec_dir}/views/nested/relative"
       render('b', current_dir: current_dir).should == "template b"
     end
-    
+
     it "should render relative templates with complex path (../../xxx)" do
       render('/nested/relative/c').should == "template c, shared template"
     end
-    
+
     it "nested templates should use the same format" do
       render('/nested/format/a', format: 'js').should == "b.js"
       # render('/nested/format/a', format: 'html')
     end
   end
-  
+
   describe "layout" do
     def render_with_layout path, options, layout
       content, context = template.basic_render(template.parse_arguments(path, options))
@@ -168,23 +168,21 @@ Yield: content for :content}
         end
       end
     end
-    
+
     it "templates and layout must share the same context" do
       render_with_layout(
         '/layout/same_context/a', {instance_variables: {ivariable: "ivariable"}},
         '/layout/same_context/layout'
       ).should == "layout ivariable content a ivariable content b ivariable"
     end
-    
+
     it "content_for" do
       render_with_layout(
         '/layout/content_for/content', {},
         '/layout/content_for/layout'
       ).should == %{\
-head 
-
+head
 content
-
 bottom}
     end
 
@@ -194,7 +192,7 @@ bottom}
         '/layout/basic/layout'
       ).should == "layotu begin content end"
     end
-    
+
     it "layout with format" do
       render_with_layout(
         '/layout/format/content', {format: 'html'},
@@ -204,15 +202,15 @@ bottom}
       render_with_layout(
         '/layout/format/content', {format: 'js'},
         '/layout/format/layout'
-      ).should == "js layout begin js content end"    
+      ).should == "js layout begin js content end"
     end
-    
+
     it "layout should support yield in partials (from error)" do
       render_with_layout(
         '/layout/nested_yield/a', {},
         '/layout/nested_yield/layout'
       ).should == "some content"
-    end    
+    end
   end
-  
+
 end

data/spec/template/template_spec/views/layout/content_for/content.erb

@@ -1,3 +1,5 @@
-<% content_for :head do %>head<% end %>
+<% content_for :head do %>
+head
+<% end %>
 content
 <% content_for :bottom, 'bottom' %>

data/spec/template/template_spec/views/layout/content_for/layout.erb

@@ -1,3 +1,3 @@
-<%= yield :head %> 
+<%= yield :head %>
 <%= yield %>
 <%= yield :bottom %>

data/spec/template/tilt_spec.rb

@@ -3,95 +3,95 @@ require 'spec_helper'
 
 describe "Tilt" do
   with_view_path "#{spec_dir}/views"
-  
+
   inject template: :template
-  
+
   def render *a, &b
     template.render *a, &b
   end
-  
+
   before :all do
     class TemplateContextStub < Rad::Template::Context
-      def tag name, content = nil, &block      
+      def tag name, content = nil, &block
         if block_given?
           content = capture(&block)
           concat "<#{name}>#{content}</#{name}>"
         else
           content = content
           "<#{name}>#{content}</#{name}>"
-        end      
+        end
       end
     end
   end
-  
+
   before do
     $render_result = OpenObject.new
     rad.mode = :development, true
   end
   after{rad.mode = :test, true}
-  
+
   it "haml should be ugly" do
     render('/ugly.haml').should_not =~ /^\s/
   end
-  
+
   it "should correctly show error lines" do
     lambda{render('/errors.erb')}.should raise_error(/line with error/){|e| e.backtrace.first.should =~ /^.+errors\.erb:2.+$/}
     lambda{render('/errors.haml')}.should raise_error(/line with error/){|e| e.backtrace.first.should =~ /^.+errors\.haml:2.+$/}
   end
-  
-  it "concat & capture" do    
+
+  it "concat & capture" do
     render('/concat_and_capture.erb').should =~ /^text for concatenation.?$/
     $render_result.erb_capture.should =~ /^text for capturing.?$/
-    
+
     render('/concat_and_capture.haml').should =~ /^text for concatenation.?$/
     $render_result.haml_capture.should =~ /^text for capturing.?$/
   end
-  
+
   it "yield" do
     render('/yield.erb'){|variable| "content for :#{variable}"}.should == "Layout, content for :content"
-  end  
-  
+  end
+
   it "should render non-ASCII symbols (from error)" do
     render('/encoding/erb').should =~ /»/
-    render('/encoding/haml').should =~ /»/    
+    render('/encoding/haml').should =~ /»/
   end
-  
+
   describe "mixed template types" do
     it "broken haml concat (from error)" do
       render(
         '/mixed_templates/broken_haml_concat_haml',
         context: TemplateContextStub.new
       ).gsub("\n", "").should == "<div>some content</div>"
-      
+
       render(
         '/mixed_templates/broken_haml_concat_erb',
         context: TemplateContextStub.new
       ).gsub("\n", "").should == "<div>some content</div>"
     end
-  
+
     it "broken erb concat (from error)" do
       render(
-        '/mixed_templates/broken_erb_concat_erb', 
+        '/mixed_templates/broken_erb_concat_erb',
         context: TemplateContextStub.new
       ).gsub("\n", "").should == "haml content<div>\tsome content</div>"
     end
   end
-  
-  
+
+
   it "nested capture & concat (from error)" do
     class TestTC < TemplateContextStub
       def form_tag &block
         html = capture &block
         concat(tag(:form_tag, html))
       end
-      
+
       def form_field &block
         html = capture &block
         concat(tag(:form_field, html))
       end
     end
-    
-    render('/nested_capture_and_concat', context: TestTC.new).gsub("\n", '').should == 
+
+    render('/nested_capture_and_concat', context: TestTC.new).gsub("\n", '').should ==
       "<form_tag><form_field>some field</form_field></form_tag>"
   end
 end

data/spec/web/basic_spec.rb

@@ -1,30 +1,30 @@
 require 'spec_helper'
 
-describe "Core" do  
+describe "Core" do
   with_load_path spec_dir
   isolate :conveyors, :router, before: :all
-  
+
   before :all do
     rad.web
-    
+
     rad.router.routers = [
       [:simple_router, Rad::Router::SimpleRouter.new]
     ]
   end
-  
-  after :all do        
-    remove_constants %w(      
+
+  after :all do
+    remove_constants %w(
       SmokeTestSpec
       JsonFormatSpec
       RequestAndSessionSpec
       FullUrl
     )
   end
-  
-  it "smoke test" do    
+
+  it "smoke test" do
     class ::SmokeTestSpec
       inherit Rad::Controller::Http
-      
+
       def action
         respond_to do |format|
           format.json{render json: {a: 'b'}}
@@ -32,24 +32,24 @@ describe "Core" do
         end
       end
     end
-    
+
     wcall("/smoke_test_spec/action")
     response.body.should == %(some content)
-    
+
     wcall("/smoke_test_spec/action", format: 'json')
-    response.body.should == %({"a":"b"})        
+    response.body.should == %({"a":"b"})
   end
-  
+
   it "full url (from error)" do
     class ::FullUrl
       inherit Rad::Controller::Http
-      
+
       def action
         params.a.should == 'b'
         render inline: 'ok'
       end
     end
-    
+
     wcall "http://localhost/full_url/action?a=b" do |c|
       check = {
         'PATH_INFO'    => '/full_url/action',
@@ -60,42 +60,42 @@ describe "Core" do
     end
     response.body.should == %(ok)
   end
-  
+
   it "json" do
     class ::JsonFormatSpec
       inherit Rad::Controller::Http
-      
+
       def action
         render json: {a: 'b'}
       end
     end
-    
+
     wcall("/json_format_spec/action.json")
     response.body.should == %({"a":"b"})
     # response.rson.should == {'result' => 'value'}
   end
-  
+
   it "should have workspace, request, env, and session" do
     class ::RequestAndSessionSpec
       inherit Rad::Controller::Http
-            
+
       inject workspace: :workspace
       def action
         workspace.should_not == nil
         workspace.env.should_not == nil
         request.should_not == nil
-        request.session.should_not == nil        
-        
+        request.session.should_not == nil
+
         self.class.request_and_session_passed = true
-        
+
         render json: {a: 'b'}
       end
-      
+
       class << self
         attr_accessor :request_and_session_passed
       end
     end
-    
+
     wcall('/request_and_session_spec/action.json')
     RequestAndSessionSpec.request_and_session_passed.should be_true
   end