template_streaming 0.0.11 → 0.1.0

data/lib/template_streaming/templates/errors.erb

@@ -0,0 +1,37 @@
+<style>
+  #uncaught_exceptions {
+    position: absolute;
+    top: 0px;
+    left: 0px;
+    margin: 8px;
+    background-color: #fff; color: #333;
+  }
+
+  #uncaught_exceptions,
+  #uncaught_exceptions p,
+  #uncaught_exceptions ol,
+  #uncaught_exceptions ul,
+  #uncaught_exceptions td {
+    font-family: verdana, arial, helvetica, sans-serif;
+    font-size:   13px;
+    line-height: 18px;
+  }
+
+  #uncaught_exceptions h1 {
+    margin-top: 0px;
+  }
+
+  #uncaught_exceptions pre {
+    background-color: #eee;
+    padding: 10px;
+    font-size: 11px;
+  }
+
+  #uncaught_exceptions a { color: #000; }
+  #uncaught_exceptions a:visited { color: #666; }
+  #uncaught_exceptions a:hover { color: #fff; background-color:#000; }
+</style>
+
+<div id="uncaught_exceptions">
+  <%= @content %>
+</div>

data/lib/template_streaming/version.rb

@@ -1,5 +1,5 @@
 module TemplateStreaming
-  VERSION = [0, 0, 11]
+  VERSION = [0, 1, 0]
 
   class << VERSION
     include Comparable

data/rails/init.rb

@@ -0,0 +1,3 @@
+require 'template_streaming'
+require 'template_streaming/error_recovery'
+require 'template_streaming/new_relic' if defined?(NewRelic)

data/spec/autoflushing_spec.rb

@@ -0,0 +1,75 @@
+require 'spec/spec_helper'
+
+describe TemplateStreaming::Autoflushing do
+  include StreamingApp
+
+  describe "when streaming" do
+    describe "when autoflushing is on" do
+      use_attribute_value TemplateStreaming, :autoflush, 0
+
+      it "should automatically flush" do
+        layout "[<%= yield %>]"
+        view "(<%= render :partial => 'partial' %>)"
+        partial 'partial'
+        action { render :stream => true, :layout => 'layout' }
+        run
+        received.should == chunks('[', '(', 'partial', ')', ']', :end => true)
+      end
+
+      it "should autoflush correctly for partials with layouts where the partial is given as an option" do
+        layout "[<%= yield %>]"
+        view "(<%= render :partial => 'partial' %>)"
+        partial "{<%= render :layout => 'subpartial_layout', :partial => 'subpartial' %>}"
+        template 'test/_subpartial_layout', '<<%= yield %>>'
+        template 'test/_subpartial', 'subpartial'
+        action { render :stream => true, :layout => 'layout' }
+        run
+        received.should == chunks('[', '(', '{', '<', 'subpartial', '>', '}', ')', ']', :end => true)
+      end
+
+      it "should autoflush correctly for partials with layouts where the partial is given as a block" do
+        layout "[<%= yield %>]"
+        view "(<%= render :partial => 'partial' %>)"
+        partial "{<% render :layout => 'subpartial_layout' do %>`<%= render :partial => 'subpartial' %>'<% end %>}"
+        template 'test/_subpartial_layout', '<<%= yield %>>'
+        template 'test/_subpartial', 'subpartial'
+        action { render :stream => true, :layout => 'layout' }
+        run
+        received.should == chunks('[', '(', '{', '<', '`', 'subpartial', '\'', '>', '}', ')', ']', :end => true)
+      end
+
+      it "should autoflush correctly for views with multiple partials" do
+        layout "[<%= yield %>][<%= yield %>]"
+        view "(<%= render :partial => 'partial' %>)(<%= render :partial => 'partial' %>)"
+        partial 'partial'
+        action { render :stream => true, :layout => 'layout' }
+        run
+        received.should == chunks('[', '(', 'partial', ')(', 'partial', ')', '][', '(', 'partial', ')(', 'partial', ')', ']', :end => true)
+      end
+
+      it "should flush correctly when some of the automatic flushes are throttled" do
+        with_attribute_value TemplateStreaming, :autoflush, 0.2 do
+          data.t = Time.now
+          Time.stub(:now).and_return(data.t)
+          view <<-EOS.gsub(/^ *\|/, '')
+            |<%= 1 -%>
+            |<%= Time.stub(:now).and_return(data.t + 0.1); render :partial => 'a' -%>
+            |<%= 2 -%>
+            |<%= Time.stub(:now).and_return(data.t + 0.2); render :partial => 'b' -%>
+            |<%= 3 -%>
+            |<%= Time.stub(:now).and_return(data.t + 0.3); render :partial => 'c' -%>
+            |<%= 4 -%>
+          EOS
+          action { render :stream => true, :layout => nil }
+          template 'test/_a', 'a'
+          template 'test/_b', 'b'
+          template 'test/_c', 'c'
+          template 'test/_d', 'd'
+          action { render :stream => true, :layout => nil }
+          run
+          received.should == chunks('1', 'a2b3', 'c4', :end => true)
+        end
+      end
+    end
+  end
+end

data/spec/caching_spec.rb

@@ -0,0 +1,126 @@
+require 'spec/spec_helper'
+
+describe TemplateStreaming::Caching do
+  include StreamingApp
+
+  describe "page caching" do
+    use_attribute_value ActionController::Base, :page_cache_directory, "#{TMP}/page_cache"
+    use_attribute_value ActionController::Base, :perform_caching, true
+
+    before do
+      controller.caches_page :action
+      action { render :stream => true }
+      view "a<% flush %>b"
+    end
+
+    it "should render and cache the page correctly" do
+      run
+      received.should == chunks('a', 'b', :end => true)
+      File.read("#{controller.page_cache_directory}/index.html").should == 'ab'
+    end
+  end
+
+  describe "action caching" do
+    before do
+      push_attribute_value ActionController::Base, :cache_store, ActiveSupport::Cache::MemoryStore.new
+    end
+
+    after do
+      pop_attribute_value ActionController::Base, :cache_store
+    end
+
+    describe "when streaming" do
+      describe "when no layout is used" do
+        before do
+          controller.caches_action :action
+        end
+
+        it "should render the page correctly" do
+          view "a<% flush %>b"
+          action { render :stream => true, :layout => nil }
+          run
+          received.should == chunks('a', 'b', :end => true)
+        end
+
+        it "should use the cached copy if it exists" do
+          view "<% data.render_count += 1 %>a<% flush %>b"
+          action { render :stream => true, :layout => nil }
+          data.render_count = 0
+          run
+          run
+          received.should == 'ab'
+          data.render_count.should == 1
+        end
+      end
+    end
+
+    describe "when not streaming" do
+      describe "when no layout is used" do
+        before do
+          controller.caches_action :action
+          action { render :stream => false, :layout => nil }
+        end
+
+        it "should render the page correctly" do
+          view "a<% flush %>b"
+          run
+          received.should == 'ab'
+        end
+
+        it "should use the cached copy if it exists" do
+          view "<% data.render_count += 1 %>a<% flush %>b"
+          data.render_count = 0
+          run
+          run
+          received.should == 'ab'
+          data.render_count.should == 1
+        end
+      end
+
+      describe "when the layout is cached" do
+        before do
+          controller.caches_action :action, :layout => true
+          action { render :stream => false, :layout => 'layout' }
+        end
+
+        it "should cache the layout" do
+          layout "<% data.render_count += 1 %>[<%= yield %>]"
+          view "view"
+          data.render_count = 0
+
+          run
+          received.should == '[view]'
+          data.render_count.should == 1
+
+          run
+          received.should == '[view]'
+          data.render_count.should == 1
+        end
+      end
+
+      describe "when the layout is not cached" do
+        before do
+          controller.caches_action :action, :layout => false
+          # AC always does render(:layout => true) to render the layout when the
+          # body is cached, even if an explicit layout name is given. Hence, our
+          # layout name must match the controller name.
+          action { render :stream => false, :layout => 'test' }
+        end
+
+        it "should not cache the layout" do
+          template 'layouts/test', "<% data.render_count += 1 %>[<%= yield %>]"
+          view "view"
+          data.render_count = 0
+
+          run
+          received.should == '[view]'
+          data.render_count.should == 1
+
+          run
+          received.should == '[view]'
+          data.render_count.should == 2
+        end
+      end
+    end
+  end
+end

data/spec/error_recovery_spec.rb

@@ -0,0 +1,261 @@
+require 'spec/spec_helper'
+
+describe TemplateStreaming::ErrorRecovery do
+  include StreamingApp
+
+  describe "when there is an error during rendering" do
+    before do
+      class TestController
+        def rescue_action(exception)
+          # Run the default handler.
+          ActionController::Base.instance_method(:rescue_action).bind(self).call(exception)
+        end
+      end
+    end
+
+    describe "when not streaming" do
+      it "should show the standard error page" do
+        view "<% raise 'test exception' %>"
+        run
+        received.should include("Action Controller: Exception caught")
+        received.should include('test exception')
+      end
+    end
+
+    describe "when streaming" do
+      before do
+        controller.render_streaming_errors_with do |view, exceptions|
+          messages = exceptions.map { |e| e.original_exception.message }
+          "(#{messages.join(',')})"
+        end
+      end
+
+      describe "for local requests" do
+        before do
+          controller.class_eval do
+            def local_request?
+              true
+            end
+          end
+        end
+
+        it "should run the error callback for each error raised" do
+          messages = []
+          controller.on_streaming_error do |error|
+            messages << error.original_exception.message
+          end
+          view "<% render :partial => 'a' %><% render :partial => 'b' %>"
+          template 'test/_a', "<% raise 'a' %>"
+          template 'test/_b', "<% raise 'b' %>"
+          action { render :stream => true, :layout => nil }
+          run
+          messages.should == ['a', 'b']
+        end
+
+        describe "when a structurally-complete response is rendered" do
+          before do
+            view "<% raise 'x' %>"
+            action { render :stream => true, :layout => 'layout' }
+          end
+
+          it "should inject errors correctly when the error occurs before the doctype" do
+            layout "<%= yield %><!DOCTYPE html><html><head></head><body></body></html>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head><body>(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors correctly when the error occurs before the opening html tag" do
+            layout "<!DOCTYPE html><% flush %><% yield %><html><head></head><body></body></html>"
+            run
+            received.should == chunks("<!DOCTYPE html>", "<html><head></head><body>(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors correctly when the error occurs before the beginning of the head" do
+            layout "<!DOCTYPE html><html><% flush %><% yield %><head></head><body></body></html>"
+            run
+            received.should == chunks("<!DOCTYPE html><html>", "<head></head><body>(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors correctly when the error occurs during the head" do
+            layout "<!DOCTYPE html><html><head><% flush %><% yield %></head><body></body></html>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head>", "</head><body>(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors correctly when the error occurs between the head and body" do
+            layout "<!DOCTYPE html><html><head></head><% flush %><% yield %><body></body></html>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head>", "<body>(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors correctly when the error occurs during the body" do
+            layout "<!DOCTYPE html><html><head></head><body><% flush %><% yield %></body></html>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head><body>", "(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors correctly when the error occurs after the body" do
+            layout "<!DOCTYPE html><html><head></head><body></body><% flush %><% yield %></html>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head><body></body>", "</html>", "(x)", :end => true)
+          end
+
+          it "should inject errors correctly when the error occurs after the closing html tag" do
+            layout "<!DOCTYPE html><html><head></head><body></body></html><% flush %><% yield %>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head><body></body></html>", "(x)", :end => true)
+          end
+        end
+
+        describe "when an structurally-incomplete response is rendered" do
+          before do
+            action { render :stream => true, :layout => nil }
+          end
+
+          it "should inject errors correctly when nothing is rendered" do
+            view "<% flush %><% raise 'x' %>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head><title>Unhandled Exception</title></head><body>(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors correctly when just the doctype is rendered" do
+            view "<!DOCTYPE html><% flush %><% raise 'x' %>"
+            run
+            received.should == chunks("<!DOCTYPE html>", "<html><head><title>Unhandled Exception</title></head><body>(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors correctly when just the doctype and opening html tag are rendered" do
+            view "<!DOCTYPE html><html><% flush %><% raise 'x' %>"
+            run
+            received.should == chunks("<!DOCTYPE html><html>", "<head><title>Unhandled Exception</title></head><body>(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors correctly when only half the head is rendered" do
+            view "<!DOCTYPE html><html><head><% flush %><% raise 'x' %>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head>", "</head><body>(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors correctly when only a head is rendered" do
+            view "<!DOCTYPE html><html><head></head><% flush %><% raise 'x' %>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head>", "<body>(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors correctly when the closing body tag is missing" do
+            view "<!DOCTYPE html><html><head></head><body><% flush %><% raise 'x' %>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head><body>", "(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors correctly when the closing html tag is missing" do
+            view "<!DOCTYPE html><html><head></head><body></body><% flush %><% raise 'x' %>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head><body></body>", "(x)</html>", :end => true)
+          end
+        end
+
+        describe "when the response consists of multiple templates" do
+          before do
+            action { render :stream => true, :layout => 'layout' }
+          end
+
+          it "should inject errors when there is an error in the toplevel layout" do
+            layout "<!DOCTYPE html><html><head></head><body><% flush %><%= raise 'x' %></body></html>"
+            view ''
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head><body>", "(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors when there is an error in the toplevel view" do
+            layout "<!DOCTYPE html><html><head></head><body><% flush %>[<%= yield %>]</body></html>"
+            view "<% raise 'x' %>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head><body>", "[](x)</body></html>", :end => true)
+          end
+
+          it "should inject errors when there is an error in a partial" do
+            layout "<!DOCTYPE html><html><head></head><body><% flush %>[<%= yield %>]</body></html>"
+            view "view{<%= render :partial => 'partial' %>}"
+            partial "<% raise 'x' %>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head><body>", "[view{}](x)</body></html>", :end => true)
+          end
+
+          it "should inject errors when there is an error in a subpartial" do
+            layout "<!DOCTYPE html><html><head></head><body><% flush %><%= yield %></body></html>"
+            view "view{<%= render :partial => 'partial' %>}"
+            partial "partial`<%= render :partial => 'subpartial' %>'"
+            template 'test/_subpartial', "<% raise 'x' %>"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head><body>", "view{partial`'}(x)</body></html>", :end => true)
+          end
+
+          it "should inject errors from all partials which raised an unhandled exception" do
+            layout "<!DOCTYPE html><html><head></head><body><% flush %><%= yield %></body></html>"
+            view "view[<%= render :partial => 'x' %><%= render :partial => 'ok' %><%= render :partial => 'y' %>]"
+            template 'test/_x', "<% raise 'x' %>"
+            template 'test/_y', "<% raise 'y' %>"
+            template 'test/_ok', "ok"
+            run
+            received.should == chunks("<!DOCTYPE html><html><head></head><body>", "view[ok](x,y)</body></html>", :end => true)
+          end
+        end
+      end
+
+      describe "for nonlocal requests" do
+        before do
+          controller.class_eval do
+            def local_request?
+              false
+            end
+          end
+        end
+
+        it "should run the error callback for each error raised" do
+          messages = []
+          controller.on_streaming_error do |error|
+            messages << error.original_exception.message
+          end
+          view "<% render :partial => 'a' %><% render :partial => 'b' %>"
+          template 'test/_a', "<% raise 'a' %>"
+          template 'test/_b', "<% raise 'b' %>"
+          action { render :stream => true, :layout => nil }
+          run
+          messages.should == ['a', 'b']
+        end
+
+        it "should not inject any error information" do
+          layout "<!DOCTYPE html><html><head></head><body><% flush %><%= yield %></body></html>"
+          view "...<% raise 'x' %>..."
+          action { render :stream => true, :layout => 'layout' }
+          run
+          received.should == chunks("<!DOCTYPE html><html><head></head><body>", "</body></html>", :end => true)
+        end
+      end
+    end
+  end
+
+  describe "the default error rendering callback" do
+    before do
+      TestController.class_eval do
+        def rescue_action(exception)
+          # Run the default handler.
+          ActionController::Base.instance_method(:rescue_action).bind(self).call(exception)
+        end
+
+        def local_request?
+          true
+        end
+      end
+    end
+
+    it "should render the standard error information" do
+      view "<% raise 'test exception' %>"
+      action { render :stream => true }
+      run
+      received.should include('test exception')
+      received.should include('#uncaught_exceptions')
+    end
+  end
+end