template_streaming 0.0.11 → 0.1.0

data/lib/template_streaming/autoflushing.rb

@@ -0,0 +1,88 @@
+module TemplateStreaming
+  class << self
+    #
+    # If non-nil, #flush will automatically be called when streaming
+    # before and after each render call.
+    #
+    # The value of this attribute should be a number, which is the
+    # number of milliseconds since the last flush that should elapse
+    # for the autoflush to occur. 0 means force a flush every time.
+    #
+    attr_accessor :autoflush
+  end
+
+  module Autoflushing
+    module View
+      def self.included(base)
+        base.alias_method_chain :render, :template_streaming_autoflushing
+      end
+
+      def render_with_template_streaming_autoflushing(*args, &block)
+        with_autoflushing do
+          render_without_template_streaming_autoflushing(*args, &block)
+        end
+      end
+
+      def capture(*args, &block)
+        if block == @_proc_for_layout
+          # Rendering the content of a streamed layout - inject autoflushing.
+          with_autoflushing do
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def with_autoflushing
+        controller.flush if TemplateStreaming.autoflush
+        fragment = yield
+        if TemplateStreaming.autoflush
+          controller.push(fragment)
+          ''
+        else
+          fragment
+        end
+      end
+    end
+
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        response = @app.call(env)
+        if env[STREAMING_KEY] && TemplateStreaming.autoflush
+          response[2] = BodyProxy.new(response[2])
+        end
+        response
+      end
+
+      class BodyProxy
+        def initialize(body)
+          @body = body
+        end
+
+        def each
+          buffered_chunks = []
+          autoflush_due_at = Time.now.to_f
+          @body.each do |chunk|
+            buffered_chunks << chunk
+            if Time.now.to_f >= autoflush_due_at
+              yield buffered_chunks.join
+              buffered_chunks.clear
+              autoflush_due_at = Time.now.to_f + TemplateStreaming.autoflush
+            end
+          end
+          unless buffered_chunks.empty?
+            yield buffered_chunks.join
+          end
+        end
+      end
+    end
+
+    ActionView::Base.send :include, View
+    ActionController::Dispatcher.middleware.use Middleware
+  end
+end

data/lib/template_streaming/caching.rb

@@ -0,0 +1,68 @@
+module TemplateStreaming
+  module Caching
+    CACHER_KEY = 'template_streaming.caching.cacher'.freeze
+
+    module Controller
+      def cache_page(content = nil, options = nil)
+        if content
+          super
+        else
+          request.env[CACHER_KEY] = lambda { |c| super(c, options) }
+        end
+      end
+    end
+
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        response = @app.call(env)
+        path = env[CACHER_KEY] and
+          response[2] = CachingBodyProxy.new(response[2], env[CACHER_KEY])
+        response
+      end
+
+      class CachingBodyProxy
+        def initialize(body, cacher)
+          @body = body
+          @cacher = cacher
+        end
+
+        def each
+          chunks = []
+          @body.each do |chunk|
+            chunks << chunk
+            yield chunk
+          end
+          @cacher.call(chunks.join)
+        end
+      end
+    end
+
+    module ActionCacheFilter
+      def self.included(base)
+        base.alias_method_chain :after, :template_streaming_caching
+      end
+
+      def after_with_template_streaming_caching(controller)
+        if controller.streaming_template?
+          # This flag is ass-backwards to me. It really means *don't* cache the layout...
+          cache_layout? and
+            raise NotImplementedError, "sorry, using caches_action with :layout => false is not yet supported by Template Streaming"
+          controller.request.env[CACHER_KEY] = lambda do |content|
+            # This is what the standard method does.
+            controller.write_fragment(controller.action_cache_path.path, content, @options[:store_options])
+          end
+        else
+          after_without_template_streaming_caching(controller)
+        end
+      end
+    end
+
+    ActionController::Base.send :include, Controller
+    ActionController::Dispatcher.middleware.use Middleware
+    ActionController::Caching::Actions::ActionCacheFilter.send :include, ActionCacheFilter
+  end
+end

data/lib/template_streaming/error_recovery.rb

@@ -1,119 +1,233 @@
 module TemplateStreaming
   module ErrorRecovery
-    ENV_EXCEPTIONS   = 'template_streaming.error_recovery.exceptions'.freeze
-    ENV_SHOW_DETAILS = 'template_streaming.error_recovery.exceptions'.freeze
-
-    module Rendering
-      def uncaught_errors_html(errors)
-        content = errors.map do |error|
-          "<pre>#{uncaught_error_string(error)}</pre>"
-        end.join
-        <<-EOS.gsub(/^ *\|/, '')
-        |<div style='position: absolute; left: 0px; top: 0px; background-color: #fff; z-index: 999'>
-        |  <h2 style="margin: 20px; font-weight: bold; border-bottom: 1px solid red">Rails Application Error</h2>
-        |  #{content}
-        |</div>
-      EOS
-      end
+    CONTROLLER_KEY = 'template_streaming.error_recovery.controller'.freeze
+    EXCEPTIONS_KEY = 'template_streaming.error_recovery.exceptions'.freeze
 
-      def uncaught_error_string(error)
-        details = "#{error.class}: #{error.message}"
-        backtrace = error.backtrace.join("\n").gsub(/^/, '  ')
-        "<span style='font-weight: bold; margin: 20px'>#{h details}</span>\n#{h backtrace}"
+    class Middleware
+      def initialize(app)
+        @app = app
       end
-    end
 
-    module Controller
-      def self.included(base)
-        base.when_streaming_template :recover_from_errors
-        base.helper Helper
-        base.helper_method :recover_from_errors?
+      def call(env)
+        response = *@app.call(env)
+        if env[TemplateStreaming::STREAMING_KEY]
+          response[2] = BodyProxy.new(env, response[2])
+          response
+        else
+          response
+        end
       end
 
-      def recover_from_errors
-        @recover_from_errors = true
-      end
+      class BodyProxy
+        def initialize(env, body)
+          @env = env
+          @body = body
+          @controller = @env[CONTROLLER_KEY]
+        end
 
-      def recover_from_errors?
-        @recover_from_errors
-      end
-    end
+        def each(&block)
+          if @controller && @controller.show_errors?
+            exceptions = @env[EXCEPTIONS_KEY] = []
+            @state = :start
+            @body.each do |chunk|
+              advance_state(chunk)
+              if !exceptions.empty?
+                try_to_insert_errors(chunk, exceptions)
+              end
+              yield chunk
+            end
+            if !exceptions.empty?
+              yield uninserted_errors(exceptions)
+            end
+          else
+            @body.each(&block)
+          end
+        end
 
-    module Helper
-      def render(*)
-        begin
-          super
-        rescue ActionView::MissingTemplate => e
-          # ActionView uses this as a signal to try another template engine.
-          raise e
-        rescue Exception => e
-          raise e if !recover_from_errors?
-          if HoptoadNotifier.configuration[:api_key]
-            Rails.logger.error("#{e.class}: #{e.message}")
-            Rails.logger.error(e.backtrace.join("\n").gsub(/^/, '  '))
-            HoptoadNotifier.notify(e)
+        def advance_state(chunk, cursor=0)
+          case @state
+          when :start
+            if index = chunk.index(%r'<!doctype\b.*?>'i, cursor)
+              @state = :before_html
+              advance_state(chunk, index)
+            end
+          when :before_html
+            if index = chunk.index(%r'<html\b'i, cursor)
+              @state = :before_head
+              advance_state(chunk, index)
+            end
+          when :before_head
+            if index = chunk.index(%r'<head\b'i, cursor)
+              @state = :in_head
+              advance_state(chunk, index)
+            end
+          when :in_head
+            if index = chunk.index(%r'</head\b.*?>'i, cursor)
+              @state = :between_head_and_body
+              advance_state(chunk, index)
+            end
+          when :between_head_and_body
+            if index = chunk.index(%r'<body\b'i, cursor)
+              @state = :in_body
+              advance_state(chunk, index)
+            end
+          when :in_body
+            if index = chunk.index(%r'</body\b.*?>'i, cursor)
+              @state = :after_body
+              advance_state(chunk, index)
+            end
+          when :after_body
+            if index = chunk.index(%r'</html\b.*?>'i, cursor)
+              @state = :after_html
+              advance_state(chunk, index)
+            end
           end
+        end
 
-          request.env[ENV_SHOW_DETAILS] = consider_all_requests_local || local_request?
+        def try_to_insert_errors(chunk, exceptions)
+          if (index = chunk =~ %r'</body\s*>\s*(?:</html\s*>\s*)?\z'im)
+            chunk.insert(index, render_exceptions(exceptions))
+            exceptions.clear
+          end
+        end
 
-          # TODO: Find a way to make this suck less.
-          is_template_error = e.is_a?(ActionView::TemplateError)
-          if is_template_error && e.file_name =~ %r'\Aapp/views/prelayouts/'
-            # Error in prelayout - no head or body rendered yet.
-            head = "<head><title>Rails Application Error</title></head>"
-            body = "<body>#{uncaught_errors_html([e])}</body>"
+        def uninserted_errors(exceptions)
+          html = render_exceptions(exceptions)
+          exceptions.clear
+          case @state
+          when :start
+            head = "<head><title>Unhandled Exception</title></head>"
+            body = "<body>#{html}</body>"
             "<!DOCTYPE html><html>#{head}#{body}</html>"
-          elsif is_template_error && e.file_name =~ %r'\Aapp/views/layouts/'
-            # Error in layout - unclosed head tag has been rendered.
-            head = "<title>Rails Application Error</title></head>"
-            body = "<body>#{uncaught_errors_html([e])}</body>"
+          when :before_html
+            head = "<head><title>Unhandled Exception</title></head>"
+            body = "<body>#{html}</body>"
+            "<html>#{head}#{body}</html>"
+          when :before_head
+            head = "<head><title>Unhandled Exception</title></head>"
+            body = "<body>#{html}</body>"
             "#{head}#{body}</html>"
-          else
-            # Body is being rendered - return nothing for this render
-            # call, and render the exception in the middleware.
-            request.env[ENV_EXCEPTIONS] << e
-            ''
+          when :in_head
+            "</head><body>#{html}</body></html>"
+          when :between_head_and_body
+            "<body>#{html}</body></html>"
+          when :in_body
+            "#{html}</body></html>"
+          when :after_body
+            # Errors aren't likely to happen at this point, as after the body
+            # there should only be "</html>". Just stick our error html in there
+            # - it's invalid HTML no matter what we do.
+            "#{html}</html>"
+          when :after_html
+            html
           end
         end
-      end
 
-      include Rendering
+        def render_exceptions(exceptions)
+          template = @controller.response.template
+          template.render_streaming_exceptions(exceptions)
+        end
+      end
     end
 
-    class Middleware
-      def initialize(app)
-        @app = app
+    module Controller
+      def self.included(base)
+        base.when_streaming_template :set_template_streaming_controller
+        base.class_inheritable_accessor :streaming_error_callbacks
+        base.class_inheritable_accessor :streaming_error_renderer
+        base.streaming_error_callbacks = []
+        base.extend ClassMethods
       end
 
-      def call(env)
-        @env = env
-        env[ENV_EXCEPTIONS] = []
-        status, headers, @body = *@app.call(env)
-        [status, headers, self]
+      module ClassMethods
+        #
+        # Call the given block when an error occurs while streaming.
+        #
+        # The block is called with the controller instance and exception object.
+        #
+        # Hook in your exception notification system here.
+        #
+        def on_streaming_error(&block)
+          streaming_error_callbacks << block
+        end
+
+        #
+        # Call the give block to render errors injected into the page, when
+        # uncaught exceptions are raised while streaming.
+        #
+        # The block is called with the view instance an list of exception
+        # objects. It should return the HTML to inject into the page.
+        #
+        def render_streaming_errors_with(&block)
+          self.streaming_error_renderer = block
+        end
+      end
+
+      def set_template_streaming_controller
+        request.env[CONTROLLER_KEY] = self
+      end
+
+      def show_errors?
+        local_request?
+      end
+    end
+
+    module View
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :render, :template_streaming_error_recovery
+        end
       end
 
-      def each
-        # Assume there are no faux occurrences of </body>.
-        @body.each do |chunk|
-          if render_errors? && (chunk =~ %r'</body\b')
-            errors = @env[ENV_EXCEPTIONS]
-            chunk.insert($~.begin(0), uncaught_errors_html(errors))
+      def render_with_template_streaming_error_recovery(*args, &block)
+        if streaming_template?
+          begin
+            render_without_template_streaming_error_recovery(*args, &block)
+          rescue ActionView::MissingTemplate => e
+            # ActionView uses this as a signal to try another template format.
+            raise e
+          rescue Exception => e
+            logger.error "#{e.class}: #{e.message}"
+            logger.error e.backtrace.join("\n").gsub(/^/, '  ')
+            controller.streaming_error_callbacks.each{|c| c.call(e)}
+            exceptions = controller.request.env[EXCEPTIONS_KEY] and
+              exceptions << e
+            ''
           end
-          yield chunk
+        else
+          render_without_template_streaming_error_recovery(*args, &block)
         end
       end
 
-      private
+      def render_streaming_exceptions(exceptions)
+        controller.streaming_error_renderer.call(self, exceptions)
+      end
 
-      def render_errors?
-        !Rails.env.production? && !@env[ENV_EXCEPTIONS].empty?
+      def render_default_streaming_exceptions(exceptions)
+        # Ensure errors in the error rendering don't recurse.
+        @rendering_default_streaming_exceptions = true
+        begin
+          @content = exceptions.map do |exception|
+            template_path = ActionController::Rescue::RESCUES_TEMPLATE_PATH
+            @exception = exception
+            @rescues_path = template_path
+            render :file => "#{template_path}/rescues/template_error.erb"
+          end.join
+          render :file => "#{File.dirname(__FILE__)}/templates/errors.erb"
+        ensure
+          @rendering_default_streaming_exceptions = false
+        end
       end
+    end
 
-      include Rendering
+    DEFAULT_ERROR_RENDERER = lambda do |view, exceptions|
+      view.render_default_streaming_exceptions(exceptions)
     end
 
-    ActionController::Base.send(:include, Controller)
-    ActionView::Base.send(:include, Helper)
-    ActionController::Dispatcher.middleware.insert_after('ActionController::Failsafe', Middleware)
+    ActionController::Dispatcher.middleware.insert_after ActionController::Failsafe, Middleware
+    ActionController::Base.send :include, Controller
+    ActionView::Base.send :include, View
+
+    ActionController::Base.streaming_error_renderer = DEFAULT_ERROR_RENDERER
   end
 end