actionview 4.1.13 → 6.1.3.1

data/lib/action_view/renderer/renderer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   # This is the main entry point for rendering. It basically delegates
   # to other objects like TemplateRenderer and PartialRenderer which
@@ -15,12 +17,16 @@ module ActionView
       @lookup_context = lookup_context
     end
 
-    # Main render entry point shared by AV and AC.
+    # Main render entry point shared by Action View and Action Controller.
     def render(context, options)
+      render_to_object(context, options).body
+    end
+
+    def render_to_object(context, options) # :nodoc:
       if options.key?(:partial)
-        render_partial(context, options)
+        render_partial_to_object(context, options)
       else
-        render_template(context, options)
+        render_template_to_object(context, options)
       end
     end
 
@@ -37,14 +43,69 @@ module ActionView
       end
     end
 
-    # Direct accessor to template rendering.
+    # Direct access to template rendering.
     def render_template(context, options) #:nodoc:
-      TemplateRenderer.new(@lookup_context).render(context, options)
+      render_template_to_object(context, options).body
     end
 
     # Direct access to partial rendering.
     def render_partial(context, options, &block) #:nodoc:
-      PartialRenderer.new(@lookup_context).render(context, options, block)
+      render_partial_to_object(context, options, &block).body
+    end
+
+    def cache_hits # :nodoc:
+      @cache_hits ||= {}
     end
+
+    def render_template_to_object(context, options) #:nodoc:
+      TemplateRenderer.new(@lookup_context).render(context, options)
+    end
+
+    def render_partial_to_object(context, options, &block) #:nodoc:
+      partial = options[:partial]
+      if String === partial
+        collection = collection_from_options(options)
+
+        if collection
+          # Collection + Partial
+          renderer = CollectionRenderer.new(@lookup_context, options)
+          renderer.render_collection_with_partial(collection, partial, context, block)
+        else
+          if options.key?(:object)
+            # Object + Partial
+            renderer = ObjectRenderer.new(@lookup_context, options)
+            renderer.render_object_with_partial(options[:object], partial, context, block)
+          else
+            # Partial
+            renderer = PartialRenderer.new(@lookup_context, options)
+            renderer.render(partial, context, block)
+          end
+        end
+      else
+        collection = collection_from_object(partial) || collection_from_options(options)
+
+        if collection
+          # Collection + Derived Partial
+          renderer = CollectionRenderer.new(@lookup_context, options)
+          renderer.render_collection_derive_partial(collection, context, block)
+        else
+          # Object + Derived Partial
+          renderer = ObjectRenderer.new(@lookup_context, options)
+          renderer.render_object_derive_partial(partial, context, block)
+        end
+      end
+    end
+
+    private
+      def collection_from_options(options)
+        if options.key?(:collection)
+          collection = options[:collection]
+          collection || []
+        end
+      end
+
+      def collection_from_object(object)
+        object if object.respond_to?(:to_ary)
+      end
   end
 end

data/lib/action_view/renderer/streaming_template_renderer.rb

@@ -1,10 +1,11 @@
-require 'fiber'
+# frozen_string_literal: true
+
+require "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).
@@ -26,78 +27,81 @@ module ActionView
       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 = ActionView::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
+        # This is the same logging logic as in ShowExceptions middleware.
+        def log_error(exception)
+          logger = ActionView::Base.logger
+          return unless logger
+
+          message = +"\n#{exception.class} (#{exception.message}):\n"
+          message << exception.annotated_source_code.to_s if exception.respond_to?(:annotated_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?
+    def render_template(view, template, layout_name = nil, locals = {}) #:nodoc:
+      return [super.body] unless layout_name && template.supports_streaming?
 
       locals ||= {}
-      layout   = layout_name && find_layout(layout_name, locals.keys)
+      layout   = layout_name && find_layout(layout_name, locals.keys, [formats.first])
 
       Body.new do |buffer|
-        delayed_render(buffer, template, layout, @view, locals)
+        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, every time 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
+      def delayed_render(buffer, template, layout, view, locals)
+        # Wrap the given buffer in the StreamingBuffer and pass it to the
+        # underlying template handler. Now, every time 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) }
+
+        ActiveSupport::Notifications.instrument(
+          "render_template.action_view",
+          identifier: template.identifier,
+          layout: layout && layout.virtual_path
+        ) do
+          outer_config = I18n.config
+          fiber = Fiber.new do
+            I18n.config = outer_config
+            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
-        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)
+          # 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
+          # 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)
+          # 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)
+            # 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?
+            # 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
 end

data/lib/action_view/renderer/template_renderer.rb

@@ -1,102 +1,110 @@
-require 'active_support/core_ext/object/try'
+# frozen_string_literal: true
 
 module ActionView
   class TemplateRenderer < AbstractRenderer #:nodoc:
     def render(context, options)
-      @view    = context
       @details = extract_details(options)
       template = determine_template(options)
-      context  = @lookup_context
 
-      prepend_formats(template.formats)
+      prepend_formats(template.format)
 
-      unless context.rendered_format
-        context.rendered_format = template.formats.first || formats.first
-      end
-
-      render_template(template, options[:layout], options[:locals])
+      render_template(context, template, options[:layout], options[:locals] || {})
     end
 
-    # Determine the template to be rendered using the given options.
-    def determine_template(options) #:nodoc:
-      keys = options.fetch(:locals, {}).keys
+    private
+      # Determine the template to be rendered using the given options.
+      def determine_template(options)
+        keys = options.has_key?(:locals) ? options[:locals].keys : []
 
-      if options.key?(:body)
-        Template::Text.new(options[:body])
-      elsif options.key?(:text)
-        Template::Text.new(options[:text], formats.first)
-      elsif options.key?(:plain)
-        Template::Text.new(options[:plain])
-      elsif options.key?(:html)
-        Template::HTML.new(options[:html], formats.first)
-      elsif options.key?(:file)
-        with_fallbacks { find_template(options[:file], nil, false, keys, @details) }
-      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)
-        if options[:template].respond_to?(:render)
-          options[:template]
+        if options.key?(:body)
+          Template::Text.new(options[:body])
+        elsif options.key?(:plain)
+          Template::Text.new(options[:plain])
+        elsif options.key?(:html)
+          Template::HTML.new(options[:html], formats.first)
+        elsif options.key?(:file)
+          if File.exist?(options[:file])
+            Template::RawFile.new(options[:file])
+          else
+            raise ArgumentError, "`render file:` should be given the absolute path to a file. '#{options[:file]}' was given instead"
+          end
+        elsif options.key?(:inline)
+          handler = Template.handler_for_extension(options[:type] || "erb")
+          format = if handler.respond_to?(:default_format)
+            handler.default_format
+          else
+            @lookup_context.formats.first
+          end
+          Template::Inline.new(options[:inline], "inline template", handler, locals: keys, format: format)
+        elsif options.key?(:renderable)
+          Template::Renderable.new(options[:renderable])
+        elsif options.key?(:template)
+          if options[:template].respond_to?(:render)
+            options[:template]
+          else
+            @lookup_context.find_template(options[:template], options[:prefixes], false, keys, @details)
+          end
         else
-          find_template(options[:template], options[:prefixes], false, keys, @details)
+          raise ArgumentError, "You invoked render but did not give any of :partial, :template, :inline, :file, :plain, :html or :body option."
         end
-      else
-        raise ArgumentError, "You invoked render but did not give any of :partial, :template, :inline, :file, :plain, :text or :body option."
       end
-    end
 
-    # Renders the given template. A string representing the layout can be
-    # supplied as well.
-    def render_template(template, layout_name = nil, locals = nil) #: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) }
+      # Renders the given template. A string representing the layout can be
+      # supplied as well.
+      def render_template(view, template, layout_name, locals)
+        render_with_layout(view, template, layout_name, locals) do |layout|
+          ActiveSupport::Notifications.instrument(
+            "render_template.action_view",
+            identifier: template.identifier,
+            layout: layout && layout.virtual_path
+          ) do
+            template.render(view, locals) { |*name| view._layout_for(*name) }
+          end
         end
       end
-    end
 
-    def render_with_layout(path, locals) #:nodoc:
-      layout  = path && find_layout(path, locals.keys)
-      content = yield(layout)
+      def render_with_layout(view, template, path, locals)
+        layout  = path && find_layout(path, locals.keys, [formats.first])
 
-      if layout
-        view = @view
-        view.view_flow.set(:layout, content)
-        layout.render(view, locals){ |*name| view._layout_for(*name) }
-      else
-        content
+        body = if layout
+          ActiveSupport::Notifications.instrument("render_layout.action_view", identifier: layout.identifier) do
+            view.view_flow.set(:layout, yield(layout))
+            layout.render(view, locals) { |*name| view._layout_for(*name) }
+          end
+        else
+          yield
+        end
+        build_rendered_template(body, template)
       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)
-      with_layout_format { resolve_layout(layout, keys) }
-    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, formats)
+        resolve_layout(layout, keys, formats)
+      end
 
-    def resolve_layout(layout, keys)
-      case layout
-      when String
-        begin
-          if layout =~ /^\//
-            with_fallbacks { find_template(layout, nil, false, keys, @details) }
-          else
-            find_template(layout, nil, false, keys, @details)
+      def resolve_layout(layout, keys, formats)
+        details = @details.dup
+        details[:formats] = formats
+
+        case layout
+        when String
+          begin
+            if layout.start_with?("/")
+              raise ArgumentError, "Rendering layouts from an absolute path is not supported."
+            else
+              @lookup_context.find_template(layout, nil, false, [], details)
+            end
+          rescue ActionView::MissingTemplate
+            all_details = @details.merge(formats: @lookup_context.default_formats)
+            raise unless template_exists?(layout, nil, false, [], **all_details)
           end
-        rescue ActionView::MissingTemplate
-          all_details = @details.merge(:formats => @lookup_context.default_formats)
-          raise unless template_exists?(layout, nil, false, keys, all_details)
+        when Proc
+          resolve_layout(layout.call(@lookup_context, formats), keys, formats)
+        else
+          layout
         end
-      when Proc
-        resolve_layout(layout.call, keys)
-      when FalseClass
-        nil
-      else
-        layout
       end
-    end
   end
 end

data/lib/action_view/rendering.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "action_view/view_paths"
 
 module ActionView
@@ -24,7 +26,14 @@ module ActionView
     extend ActiveSupport::Concern
     include ActionView::ViewPaths
 
-    # Overwrite process to setup I18n proxy.
+    attr_reader :rendered_format
+
+    def initialize
+      @rendered_format = nil
+      super
+    end
+
+    # Overwrite process to set up I18n proxy.
     def process(*) #:nodoc:
       old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)
       super
@@ -33,47 +42,59 @@ module ActionView
     end
 
     module ClassMethods
-      def view_context_class
-        @view_context_class ||= begin
-          routes = respond_to?(:_routes) && _routes
-          helpers = respond_to?(:_helpers) && _helpers
-
-          Class.new(ActionView::Base) do
-            if routes
-              include routes.url_helpers
-              include routes.mounted_helpers
-            end
-
-            if helpers
-              include helpers
-            end
+      def _routes
+      end
+
+      def _helpers
+      end
+
+      def build_view_context_class(klass, supports_path, routes, helpers)
+        Class.new(klass) do
+          if routes
+            include routes.url_helpers(supports_path)
+            include routes.mounted_helpers
+          end
+
+          if helpers
+            include helpers
           end
         end
       end
-    end
 
-    attr_internal_writer :view_context_class
+      def view_context_class
+        klass = ActionView::LookupContext::DetailsKey.view_context_class(ActionView::Base)
+
+        @view_context_class ||= build_view_context_class(klass, supports_path?, _routes, _helpers)
+
+        if klass.changed?(@view_context_class)
+          @view_context_class = build_view_context_class(klass, supports_path?, _routes, _helpers)
+        end
+
+        @view_context_class
+      end
+    end
 
     def view_context_class
-      @_view_context_class ||= self.class.view_context_class
+      self.class.view_context_class
     end
 
-    # An instance of a view class. The default view class is ActionView::Base
+    # An instance of a view class. The default view class is ActionView::Base.
     #
     # The view class must have the following methods:
-    # View.new[lookup_context, assigns, controller]
-    #   Create a new ActionView instance for a controller
-    # View#render[options]
-    #   Returns String with the rendered template
+    #
+    # * <tt>View.new(lookup_context, assigns, controller)</tt> — Create a new
+    #   ActionView instance for a controller and we can also pass the arguments.
+    #
+    # * <tt>View#render(option)</tt> — Returns String with the rendered template.
     #
     # Override this method in a module to change the default behavior.
     def view_context
-      view_context_class.new(view_renderer, view_assigns, self)
+      view_context_class.new(lookup_context, view_assigns, self)
     end
 
     # Returns an object that is able to render templates.
-    # :api: private
-    def view_renderer
+    def view_renderer # :nodoc:
+      # Lifespan: Per controller
       @_view_renderer ||= ActionView::Renderer.new(lookup_context)
     end
 
@@ -82,34 +103,35 @@ module ActionView
       _render_template(options)
     end
 
-    def rendered_format
-      Mime[lookup_context.rendered_format]
-    end
-
     private
-
       # Find and render a template based on the options given.
-      # :api: private
-      def _render_template(options) #:nodoc:
-        variant = options[:variant]
+      def _render_template(options)
+        variant = options.delete(:variant)
+        assigns = options.delete(:assigns)
+        context = view_context
 
-        lookup_context.rendered_format = nil if options[:formats]
+        context.assign assigns if assigns
         lookup_context.variants = variant if variant
 
-        view_renderer.render(view_context, options)
+        rendered_template = context.in_rendering_context(options) do |renderer|
+          renderer.render_to_object(context, options)
+        end
+
+        rendered_format = rendered_template.format || lookup_context.formats.first
+        @rendered_format = Template::Types[rendered_format]
+
+        rendered_template.body
       end
 
-      # Assign the rendered format to lookup context.
-      def _process_format(format, options = {}) #:nodoc:
+      # Assign the rendered format to look up context.
+      def _process_format(format)
         super
-        lookup_context.formats = [format.to_sym]
-        lookup_context.rendered_format = lookup_context.formats.first
+        lookup_context.formats = [format.to_sym] if format.to_sym
       end
 
       # Normalize args by converting render "foo" to render :action => "foo" and
-      # render "foo/bar" to render :file => "foo/bar".
-      # :api: private
-      def _normalize_args(action=nil, options={})
+      # render "foo/bar" to render :template => "foo/bar".
+      def _normalize_args(action = nil, options = {})
         options = super(action, options)
         case action
         when NilClass
@@ -117,17 +139,22 @@ module ActionView
           options = action
         when String, Symbol
           action = action.to_s
-          key = action.include?(?/) ? :file : :action
+          key = action.include?(?/) ? :template : :action
           options[key] = action
         else
-          options[:partial] = action
+          if action.respond_to?(:permitted?) && action.permitted?
+            options = action
+          elsif action.respond_to?(:render_in)
+            options[:renderable] = action
+          else
+            options[:partial] = action
+          end
         end
 
         options
       end
 
       # Normalize options.
-      # :api: private
       def _normalize_options(options)
         options = super(options)
         if options[:partial] == true