actionview 5.2.4.4 → 6.1.1

data/lib/action_view/renderer/partial_renderer/collection_caching.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/enumerable"
+
 module ActionView
   module CollectionCaching # :nodoc:
     extend ActiveSupport::Concern
@@ -11,44 +13,87 @@ module ActionView
     end
 
     private
-      def cache_collection_render(instrumentation_payload)
-        return yield unless @options[:cached]
+      def will_cache?(options, view)
+        options[:cached] && view.controller.respond_to?(:perform_caching) && view.controller.perform_caching
+      end
+
+      def cache_collection_render(instrumentation_payload, view, template, collection)
+        return yield(collection) unless will_cache?(@options, view)
+
+        collection_iterator = collection
+
+        # Result is a hash with the key represents the
+        # key used for cache lookup and the value is the item
+        # on which the partial is being rendered
+        keyed_collection, ordered_keys = collection_by_cache_keys(view, template, collection)
 
-        keyed_collection = collection_by_cache_keys
-        cached_partials  = collection_cache.read_multi(*keyed_collection.keys)
+        # Pull all partials from cache
+        # Result is a hash, key matches the entry in
+        # `keyed_collection` where the cache was retrieved and the
+        # value is the value that was present in the cache
+        cached_partials = collection_cache.read_multi(*keyed_collection.keys)
         instrumentation_payload[:cache_hits] = cached_partials.size
 
-        @collection = keyed_collection.reject { |key, _| cached_partials.key?(key) }.values
-        rendered_partials = @collection.empty? ? [] : yield
+        # Extract the items for the keys that are not found
+        collection = keyed_collection.reject { |key, _| cached_partials.key?(key) }.values
+
+        rendered_partials = collection.empty? ? [] : yield(collection_iterator.from_collection(collection))
 
         index = 0
-        fetch_or_cache_partial(cached_partials, order_by: keyed_collection.each_key) do
+        keyed_partials = fetch_or_cache_partial(cached_partials, template, order_by: keyed_collection.each_key) do
+          # This block is called once
+          # for every cache miss while preserving order.
           rendered_partials[index].tap { index += 1 }
         end
+
+        ordered_keys.map do |key|
+          keyed_partials[key]
+        end
       end
 
       def callable_cache_key?
         @options[:cached].respond_to?(:call)
       end
 
-      def collection_by_cache_keys
+      def collection_by_cache_keys(view, template, collection)
         seed = callable_cache_key? ? @options[:cached] : ->(i) { i }
 
-        @collection.each_with_object({}) do |item, hash|
-          hash[expanded_cache_key(seed.call(item))] = item
+        digest_path = view.digest_path_from_template(template)
+
+        collection.each_with_object([{}, []]) do |item, (hash, ordered_keys)|
+          key = expanded_cache_key(seed.call(item), view, template, digest_path)
+          ordered_keys << key
+          hash[key] = item
         end
       end
 
-      def expanded_cache_key(key)
-        key = @view.combined_fragment_cache_key(@view.cache_fragment_name(key, virtual_path: @template.virtual_path))
+      def expanded_cache_key(key, view, template, digest_path)
+        key = view.combined_fragment_cache_key(view.cache_fragment_name(key, digest_path: digest_path))
         key.frozen? ? key.dup : key # #read_multi & #write may require mutability, Dalli 2.6.0.
       end
 
-      def fetch_or_cache_partial(cached_partials, order_by:)
-        order_by.map do |cache_key|
-          cached_partials.fetch(cache_key) do
+      # `order_by` is an enumerable object containing keys of the cache,
+      # all keys are  passed in whether found already or not.
+      #
+      # `cached_partials` is a hash. If the value exists
+      # it represents the rendered partial from the cache
+      # otherwise `Hash#fetch` will take the value of its block.
+      #
+      # This method expects a block that will return the rendered
+      # partial. An example is to render all results
+      # for each element that was not found in the cache and store it as an array.
+      # Order it so that the first empty cache element in `cached_partials`
+      # corresponds to the first element in `rendered_partials`.
+      #
+      # If the partial is not already cached it will also be
+      # written back to the underlying cache store.
+      def fetch_or_cache_partial(cached_partials, template, order_by:)
+        order_by.index_with do |cache_key|
+          if content = cached_partials[cache_key]
+            build_rendered_template(content, template)
+          else
             yield.tap do |rendered_partial|
-              collection_cache.write(cache_key, rendered_partial)
+              collection_cache.write(cache_key, rendered_partial.body)
             end
           end
         end

data/lib/action_view/renderer/renderer.rb

@@ -19,10 +19,14 @@ module ActionView
 
     # 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
 
@@ -41,16 +45,67 @@ module ActionView
 
     # 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

@@ -27,14 +27,13 @@ module ActionView
       end
 
       private
-
         # 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".dup
-          message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
+          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
@@ -43,19 +42,18 @@ module ActionView
     # 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, [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
@@ -64,7 +62,11 @@ module ActionView
         output  = ActionView::StreamingBuffer.new(buffer)
         yielder = lambda { |*name| view._layout_for(*name) }
 
-        instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) do
+        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

data/lib/action_view/renderer/template_renderer.rb

@@ -1,23 +1,17 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/object/try"
-
 module ActionView
   class TemplateRenderer < AbstractRenderer #:nodoc:
     def render(context, options)
-      @view    = context
       @details = extract_details(options)
       template = determine_template(options)
 
-      prepend_formats(template.formats)
-
-      @lookup_context.rendered_format ||= (template.formats.first || formats.first)
+      prepend_formats(template.format)
 
-      render_template(template, options[:layout], options[:locals])
+      render_template(context, template, options[:layout], options[:locals] || {})
     end
 
     private
-
       # Determine the template to be rendered using the given options.
       def determine_template(options)
         keys = options.has_key?(:locals) ? options[:locals].keys : []
@@ -29,15 +23,26 @@ module ActionView
         elsif options.key?(:html)
           Template::HTML.new(options[:html], formats.first)
         elsif options.key?(:file)
-          with_fallbacks { find_file(options[:file], nil, false, keys, @details) }
+          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")
-          Template.new(options[:inline], "inline template", handler, locals: keys)
+          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
-            find_template(options[:template], options[:prefixes], false, keys, @details)
+            @lookup_context.find_template(options[:template], options[:prefixes], false, keys, @details)
           end
         else
           raise ArgumentError, "You invoked render but did not give any of :partial, :template, :inline, :file, :plain, :html or :body option."
@@ -46,27 +51,30 @@ module ActionView
 
       # Renders the given template. A string representing the layout can be
       # supplied as well.
-      def render_template(template, layout_name = nil, locals = nil)
-        view, locals = @view, locals || {}
-
-        render_with_layout(layout_name, locals) do |layout|
-          instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) do
+      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
 
-      def render_with_layout(path, locals)
+      def render_with_layout(view, template, path, locals)
         layout  = path && find_layout(path, locals.keys, [formats.first])
-        content = yield(layout)
 
-        if layout
-          view = @view
-          view.view_flow.set(:layout, content)
-          layout.render(view, locals) { |*name| view._layout_for(*name) }
+        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
-          content
+          yield
         end
+        build_rendered_template(body, template)
       end
 
       # This is the method which actually finds the layout using details in the lookup
@@ -84,16 +92,16 @@ module ActionView
         when String
           begin
             if layout.start_with?("/")
-              with_fallbacks { find_template(layout, nil, false, [], details) }
+              raise ArgumentError, "Rendering layouts from an absolute path is not supported."
             else
-              find_template(layout, nil, false, [], details)
+              @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)
+            raise unless template_exists?(layout, nil, false, [], **all_details)
           end
         when Proc
-          resolve_layout(layout.call(formats), keys, formats)
+          resolve_layout(layout.call(@lookup_context, formats), keys, formats)
         else
           layout
         end

data/lib/action_view/rendering.rb

@@ -26,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
@@ -35,47 +42,59 @@ module ActionView
     end
 
     module ClassMethods
-      def view_context_class
-        @view_context_class ||= begin
-          supports_path = supports_path?
-          routes  = respond_to?(:_routes)  && _routes
-          helpers = respond_to?(:_helpers) && _helpers
-
-          Class.new(ActionView::Base) do
-            if routes
-              include routes.url_helpers(supports_path)
-              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.
     #
     # The view class must have the following methods:
-    # View.new[lookup_context, assigns, controller]
-    #   Create a new ActionView instance for a controller and we can also pass the arguments.
-    # View#render(option)
-    #   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.
     def view_renderer # :nodoc:
+      # Lifespan: Per controller
       @_view_renderer ||= ActionView::Renderer.new(lookup_context)
     end
 
@@ -84,12 +103,7 @@ module ActionView
       _render_template(options)
     end
 
-    def rendered_format
-      Template::Types[lookup_context.rendered_format]
-    end
-
     private
-
       # Find and render a template based on the options given.
       def _render_template(options)
         variant = options.delete(:variant)
@@ -97,17 +111,22 @@ module ActionView
         context = view_context
 
         context.assign assigns if assigns
-        lookup_context.rendered_format = nil if options[:formats]
         lookup_context.variants = variant if variant
 
-        view_renderer.render(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 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
@@ -125,6 +144,8 @@ module ActionView
         else
           if action.respond_to?(:permitted?) && action.permitted?
             options = action
+          elsif action.respond_to?(:render_in)
+            options[:renderable] = action
           else
             options[:partial] = action
           end