actionpack 3.0.20 → 3.1.0.beta1

data/lib/action_view/renderer/renderer.rb

@@ -0,0 +1,54 @@
+module ActionView
+  # This is the main entry point for rendering. It basically delegates
+  # to other objects like TemplateRenderer and PartialRenderer which
+  # actually renders the template.
+  class Renderer
+    attr_accessor :lookup_context
+
+    def initialize(lookup_context)
+      @lookup_context = lookup_context
+    end
+
+    # Main render entry point shared by AV and AC.
+    def render(context, options)
+      if options.key?(:partial)
+        render_partial(context, options)
+      else
+        render_template(context, options)
+      end
+    end
+
+    # Render but returns a valid Rack body. If fibers are defined, we return
+    # a streaming body that renders the template piece by piece.
+    #
+    # Note that partials are not supported to be rendered with streaming,
+    # so in such cases, we just wrap them in an array.
+    def render_body(context, options)
+      if options.key?(:partial)
+        [render_partial(context, options)]
+      else
+        StreamingTemplateRenderer.new(@lookup_context).render(context, options)
+      end
+    end
+
+    # Direct accessor to template rendering.
+    def render_template(context, options) #:nodoc:
+      _template_renderer.render(context, options)
+    end
+
+    # Direct access to partial rendering.
+    def render_partial(context, options, &block) #:nodoc:
+      _partial_renderer.render(context, options, block)
+    end
+
+    private
+
+    def _template_renderer #:nodoc:
+      @_template_renderer ||= TemplateRenderer.new(@lookup_context)
+    end
+
+    def _partial_renderer #:nodoc:
+      @_partial_renderer ||= PartialRenderer.new(@lookup_context)
+    end
+  end
+end

data/lib/action_view/renderer/streaming_template_renderer.rb

@@ -0,0 +1,106 @@
+# 1.9 ships with Fibers but we need to require the extra
+# methods explicitly. We only load those extra methods if
+# Fiber is available in the first place.
+require 'fiber' if defined?(Fiber)
+
+module ActionView
+  # == TODO
+  #
+  # * Support streaming from child templates, partials and so on.
+  # * Integrate exceptions with exceptron
+  # * Rack::Cache needs to support streaming bodies
+  class StreamingTemplateRenderer < TemplateRenderer #:nodoc:
+    # A valid Rack::Body (i.e. it responds to each).
+    # It is initialized with a block that, when called, starts
+    # rendering the template.
+    class Body #:nodoc:
+      def initialize(&start)
+        @start = start
+      end
+
+      def each(&block)
+        begin
+          @start.call(block)
+        rescue Exception => exception
+          log_error(exception)
+          block.call ActionView::Base.streaming_completion_on_exception
+        end
+        self
+      end
+
+      private
+
+      # This is the same logging logic as in ShowExceptions middleware.
+      # TODO Once "exceptron" is in, refactor this piece to simply re-use exceptron.
+      def log_error(exception) #:nodoc:
+        logger = ActionController::Base.logger
+        return unless logger
+
+        message = "\n#{exception.class} (#{exception.message}):\n"
+        message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
+        message << "  " << exception.backtrace.join("\n  ")
+        logger.fatal("#{message}\n\n")
+      end
+    end
+
+    # For streaming, instead of rendering a given a template, we return a Body
+    # object that responds to each. This object is initialized with a block
+    # that knows how to render the template.
+    def render_template(template, layout_name = nil, locals = {}) #:nodoc:
+      return [super] unless layout_name && template.supports_streaming?
+
+      locals ||= {}
+      layout   = layout_name && find_layout(layout_name, locals.keys)
+
+      Body.new do |buffer|
+        delayed_render(buffer, template, layout, @view, locals)
+      end
+    end
+
+    private
+
+    def delayed_render(buffer, template, layout, view, locals)
+      # Wrap the given buffer in the StreamingBuffer and pass it to the
+      # underlying template handler. Now, everytime something is concatenated
+      # to the buffer, it is not appended to an array, but streamed straight
+      # to the client.
+      output  = ActionView::StreamingBuffer.new(buffer)
+      yielder = lambda { |*name| view._layout_for(*name) }
+
+      instrument(:template, :identifier => template.identifier, :layout => layout.try(:virtual_path)) do
+        fiber = Fiber.new do
+          if layout
+            layout.render(view, locals, output, &yielder)
+          else
+            # If you don't have a layout, just render the thing
+            # and concatenate the final result. This is the same
+            # as a layout with just <%= yield %>
+            output.safe_concat view._layout_for
+          end
+        end
+
+        # Set the view flow to support streaming. It will be aware
+        # when to stop rendering the layout because it needs to search
+        # something in the template and vice-versa.
+        view.view_flow = StreamingFlow.new(view, fiber)
+
+        # Yo! Start the fiber!
+        fiber.resume
+
+        # If the fiber is still alive, it means we need something
+        # from the template, so start rendering it. If not, it means
+        # the layout exited without requiring anything from the template.
+        if fiber.alive?
+          content = template.render(view, locals, &yielder)
+
+          # Once rendering the template is done, sets its content in the :layout key.
+          view.view_flow.set(:layout, content)
+
+          # In case the layout continues yielding, we need to resume
+          # the fiber until all yields are handled.
+          fiber.resume while fiber.alive?
+        end
+      end
+    end
+  end
+end

data/lib/action_view/renderer/template_renderer.rb

@@ -0,0 +1,74 @@
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/array/wrap'
+
+module ActionView
+  class TemplateRenderer < AbstractRenderer #:nodoc:
+    def render(context, options)
+      @view = context
+
+      wrap_formats(options[:template] || options[:file]) do
+        template = determine_template(options)
+        freeze_formats(template.formats, true)
+        render_template(template, options[:layout], options[:locals])
+      end
+    end
+
+    # Determine the template to be rendered using the given options.
+    def determine_template(options) #:nodoc:
+      keys = options[:locals].try(:keys) || []
+
+      if options.key?(:text)
+        Template::Text.new(options[:text], formats.try(:first))
+      elsif options.key?(:file)
+        with_fallbacks { find_template(options[:file], nil, false, keys) }
+      elsif options.key?(:inline)
+        handler = Template.handler_for_extension(options[:type] || "erb")
+        Template.new(options[:inline], "inline template", handler, :locals => keys)
+      elsif options.key?(:template)
+        options[:template].respond_to?(:render) ?
+          options[:template] : find_template(options[:template], options[:prefixes], false, keys)
+      end
+    end
+
+    # Renders the given template. An string representing the layout can be
+    # supplied as well.
+    def render_template(template, layout_name = nil, locals = {}) #:nodoc:
+      view, locals = @view, locals || {}
+
+      render_with_layout(layout_name, locals) do |layout|
+        instrument(:template, :identifier => template.identifier, :layout => layout.try(:virtual_path)) do
+          template.render(view, locals) { |*name| view._layout_for(*name) }
+        end
+      end
+    end
+
+    def render_with_layout(path, locals) #:nodoc:
+      layout  = path && find_layout(path, locals.keys)
+      content = yield(layout)
+
+      if layout
+        view = @view
+        view.view_flow.set(:layout, content)
+        layout.render(view, locals){ |*name| view._layout_for(*name) }
+      else
+        content
+      end
+    end
+
+    # This is the method which actually finds the layout using details in the lookup
+    # context object. If no layout is found, it checks if at least a layout with
+    # the given name exists across all details before raising the error.
+    def find_layout(layout, keys)
+      begin
+        with_layout_format do
+          layout =~ /^\// ?
+            with_fallbacks { find_template(layout, nil, false, keys) } : find_template(layout, nil, false, keys)
+        end
+      rescue ActionView::MissingTemplate => e
+        update_details(:formats => nil) do
+          raise unless template_exists?(layout)
+        end
+      end
+    end
+  end
+end

data/lib/action_view/template.rb

@@ -98,9 +98,12 @@ module ActionView
 
     extend Template::Handlers
 
-    attr_reader :source, :identifier, :handler, :virtual_path, :formats,
-                :original_encoding
+    attr_accessor :locals, :formats, :virtual_path
 
+    attr_reader :source, :identifier, :handler, :original_encoding, :updated_at
+
+    # This finalizer is needed (and exactly with a proc inside another proc)
+    # otherwise templates leak in development.
     Finalizer = proc do |method_name, mod|
       proc do
         mod.module_eval do
@@ -110,61 +113,88 @@ module ActionView
     end
 
     def initialize(source, identifier, handler, details)
-      @source             = source
-      @identifier         = identifier
-      @handler            = handler
-      @original_encoding  = nil
-      @method_names       = {}
+      format = details[:format] || (handler.default_format if handler.respond_to?(:default_format))
 
-      format   = details[:format] || :html
+      @source            = source
+      @identifier        = identifier
+      @handler           = handler
+      @compiled          = false
+      @original_encoding = nil
+      @locals            = details[:locals] || []
+      @virtual_path      = details[:virtual_path]
+      @updated_at        = details[:updated_at] || Time.now
       @formats = Array.wrap(format).map { |f| f.is_a?(Mime::Type) ? f.ref : f }
-      @virtual_path = details[:virtual_path].try(:sub, ".#{format}", "")
     end
 
-    def render(view, locals, &block)
-      # Notice that we use a bang in this instrumentation because you don't want to
-      # consume this in production. This is only slow if it's being listened to.
-      ActiveSupport::Notifications.instrument("!render_template.action_view", :virtual_path => @virtual_path) do
-        if view.is_a?(ActionView::CompiledTemplates)
-          mod = ActionView::CompiledTemplates
-        else
-          mod = view.singleton_class
-        end
+    # Returns if the underlying handler supports streaming. If so,
+    # a streaming buffer *may* be passed when it start rendering.
+    def supports_streaming?
+      handler.respond_to?(:supports_streaming?) && handler.supports_streaming?
+    end
 
-        method_name = compile(locals, view, mod)
-        view.send(method_name, locals, &block)
+    # Render a template. If the template was not compiled yet, it is done
+    # exactly before rendering.
+    #
+    # This method is instrumented as "!render_template.action_view". Notice that
+    # we use a bang in this instrumentation because you don't want to
+    # consume this in production. This is only slow if it's being listened to.
+    def render(view, locals, buffer=nil, &block)
+      ActiveSupport::Notifications.instrument("!render_template.action_view", :virtual_path => @virtual_path) do
+        compile!(view)
+        view.send(method_name, locals, buffer, &block)
       end
     rescue Exception => e
-      if e.is_a?(Template::Error)
-        e.sub_template_of(self)
-        raise e
-      else
-        raise Template::Error.new(self, view.respond_to?(:assigns) ? view.assigns : {}, e)
-      end
+      handle_render_error(view, e)
     end
 
     def mime_type
       @mime_type ||= Mime::Type.lookup_by_extension(@formats.first.to_s) if @formats.first
     end
 
-    def variable_name
-      @variable_name ||= @virtual_path[%r'_?(\w+)(\.\w+)*$', 1].to_sym
+    # Receives a view object and return a template similar to self by using @virtual_path.
+    #
+    # This method is useful if you have a template object but it does not contain its source
+    # anymore since it was already compiled. In such cases, all you need to do is to call
+    # refresh passing in the view object.
+    #
+    # Notice this method raises an error if the template to be refreshed does not have a
+    # virtual path set (true just for inline templates).
+    def refresh(view)
+      raise "A template needs to have a virtual path in order to be refreshed" unless @virtual_path
+      lookup  = view.lookup_context
+      pieces  = @virtual_path.split("/")
+      name    = pieces.pop
+      partial = !!name.sub!(/^_/, "")
+      lookup.disable_cache do
+        lookup.find_template(name, [ pieces.join('/') ], partial, @locals)
+      end
     end
 
-    def counter_name
-      @counter_name ||= "#{variable_name}_counter".to_sym
+    def inspect
+      @inspect ||= defined?(Rails.root) ? identifier.sub("#{Rails.root}/", '') : identifier
     end
 
-    def inspect
-      @inspect ||=
-        if defined?(Rails.root)
-          identifier.sub("#{Rails.root}/", '')
+    protected
+
+      # Compile a template. This method ensures a template is compiled
+      # just once and removes the source after it is compiled.
+      def compile!(view) #:nodoc:
+        return if @compiled
+
+        if view.is_a?(ActionView::CompiledTemplates)
+          mod = ActionView::CompiledTemplates
         else
-          identifier
+          mod = view.singleton_class
         end
-    end
 
-    private
+        compile(view, mod)
+
+        # Just discard the source if we have a virtual path. This
+        # means we can get the template back.
+        @source = nil if @virtual_path
+        @compiled = true
+      end
+
       # Among other things, this method is responsible for properly setting
       # the encoding of the source. Until this point, we assume that the
       # source is BINARY data. If no additional information is supplied,
@@ -185,16 +215,10 @@ module ActionView
       # encode the source into Encoding.default_internal. In general,
       # this means that templates will be UTF-8 inside of Rails,
       # regardless of the original source encoding.
-      def compile(locals, view, mod)
-        method_name = build_method_name(locals)
-        return method_name if view.respond_to?(method_name)
-
-        locals_code = locals.keys.map! { |key| "#{key} = local_assigns[:#{key}];" }.join
+      def compile(view, mod) #:nodoc:
+        method_name = self.method_name
 
         if source.encoding_aware?
-          # Avoid performing in-place mutation for SafeBuffer
-          @source = source.to_str if source.html_safe?
-
           # Look for # encoding: *. If we find one, we'll encode the
           # String in that encoding, otherwise, we'll use the
           # default external encoding.
@@ -231,10 +255,10 @@ module ActionView
         # Make sure that the resulting String to be evalled is in the
         # encoding of the code
         source = <<-end_src
-          def #{method_name}(local_assigns)
-            _old_virtual_path, @_virtual_path = @_virtual_path, #{@virtual_path.inspect};_old_output_buffer = @output_buffer;#{locals_code};#{code}
+          def #{method_name}(local_assigns, output_buffer)
+            _old_virtual_path, @virtual_path = @virtual_path, #{@virtual_path.inspect};_old_output_buffer = @output_buffer;#{locals_code};#{code}
           ensure
-            @_virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
+            @virtual_path, @output_buffer = _old_virtual_path, _old_output_buffer
           end
         end_src
 
@@ -257,8 +281,6 @@ module ActionView
         begin
           mod.module_eval(source, identifier, 0)
           ObjectSpace.define_finalizer(self, Finalizer[method_name, mod])
-
-          method_name
         rescue Exception => e # errors from template code
           if logger = (view && view.logger)
             logger.debug "ERROR: compiling #{method_name} RAISED #{e}"
@@ -270,12 +292,27 @@ module ActionView
         end
       end
 
-      def build_method_name(locals)
-        @method_names[locals.keys.hash] ||= "_#{identifier_method_name}__#{@identifier.hash}_#{__id__}_#{locals.keys.hash}".gsub('-', "_")
+      def handle_render_error(view, e) #:nodoc:
+        if e.is_a?(Template::Error)
+          e.sub_template_of(self)
+          raise e
+        else
+          assigns  = view.respond_to?(:assigns) ? view.assigns : {}
+          template = @virtual_path ? refresh(view) : self
+          raise Template::Error.new(template, assigns, e)
+        end
+      end
+
+      def locals_code #:nodoc:
+        @locals.map { |key| "#{key} = local_assigns[:#{key}];" }.join
+      end
+
+      def method_name #:nodoc:
+        @method_name ||= "_#{identifier_method_name}__#{@identifier.hash}_#{__id__}".gsub('-', "_")
       end
 
-      def identifier_method_name
-        @identifier_method_name ||= inspect.gsub(/[^a-z_]/, '_')
+      def identifier_method_name #:nodoc:
+        inspect.gsub(/[^a-z_]/, '_')
       end
   end
 end

data/lib/action_view/template/error.rb

@@ -27,7 +27,7 @@ module ActionView
   class MissingTemplate < ActionViewError #:nodoc:
     attr_reader :path
 
-    def initialize(paths, path, details, partial)
+    def initialize(paths, path, prefixes, partial, details, *)
       @path = path
       display_paths = paths.compact.map{ |p| p.to_s.inspect }.join(", ")
       template_type = if partial
@@ -38,20 +38,27 @@ module ActionView
         'template'
       end
 
-      super("Missing #{template_type} #{path} with #{details.inspect} in view paths #{display_paths}")
+      searched_paths = prefixes.map { |prefix| [prefix, path].join("/") }
+
+      out  = "Missing #{template_type} #{searched_paths.join(", ")} with #{details.inspect}. Searched in:\n"
+      out += paths.compact.map { |p| "  * #{p.to_s.inspect}\n" }.join
+      super out
     end
   end
 
   class Template
-    # The Template::Error exception is raised when the compilation of the template fails. This exception then gathers a
-    # bunch of intimate details and uses it to report a very precise exception message.
+    # The Template::Error exception is raised when the compilation or rendering of the template
+    # fails. This exception then gathers a bunch of intimate details and uses it to report a
+    # precise exception message.
     class Error < ActionViewError #:nodoc:
       SOURCE_CODE_RADIUS = 3
 
       attr_reader :original_exception, :backtrace
 
       def initialize(template, assigns, original_exception)
+        super(original_exception.message)
         @template, @assigns, @original_exception = template, assigns.dup, original_exception
+        @sub_templates = nil
         @backtrace = original_exception.backtrace
       end
 
@@ -59,10 +66,6 @@ module ActionView
         @template.identifier
       end
 
-      def message
-        ActiveSupport::Deprecation.silence { original_exception.message }
-      end
-
       def sub_template_message
         if @sub_templates
           "Trace of template inclusion: " +