actionview 5.2.3

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActionView
+  module CollectionCaching # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      # Fallback cache store if Action View is used without Rails.
+      # Otherwise overridden in Railtie to use Rails.cache.
+      mattr_accessor :collection_cache, default: ActiveSupport::Cache::MemoryStore.new
+    end
+
+    private
+      def cache_collection_render(instrumentation_payload)
+        return yield unless @options[:cached]
+
+        keyed_collection = collection_by_cache_keys
+        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
+
+        index = 0
+        fetch_or_cache_partial(cached_partials, order_by: keyed_collection.each_key) do
+          rendered_partials[index].tap { index += 1 }
+        end
+      end
+
+      def callable_cache_key?
+        @options[:cached].respond_to?(:call)
+      end
+
+      def collection_by_cache_keys
+        seed = callable_cache_key? ? @options[:cached] : ->(i) { i }
+
+        @collection.each_with_object({}) do |item, hash|
+          hash[expanded_cache_key(seed.call(item))] = item
+        end
+      end
+
+      def expanded_cache_key(key)
+        key = @view.combined_fragment_cache_key(@view.cache_fragment_name(key, virtual_path: @template.virtual_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
+            yield.tap do |rendered_partial|
+              collection_cache.write(cache_key, rendered_partial)
+            end
+          end
+        end
+      end
+  end
+end

data/lib/action_view/renderer/renderer.rb

@@ -0,0 +1,56 @@
+# 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
+  # actually renders the template.
+  #
+  # The Renderer will parse the options from the +render+ or +render_body+
+  # method and render a partial or a template based on the options. The
+  # +TemplateRenderer+ and +PartialRenderer+ objects are wrappers which do all
+  # the setup and logic necessary to render a view and a new object is created
+  # each time +render+ is called.
+  class Renderer
+    attr_accessor :lookup_context
+
+    def initialize(lookup_context)
+      @lookup_context = lookup_context
+    end
+
+    # Main render entry point shared by Action View and Action Controller.
+    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 access to template rendering.
+    def render_template(context, options) #:nodoc:
+      TemplateRenderer.new(@lookup_context).render(context, options)
+    end
+
+    # Direct access to partial rendering.
+    def render_partial(context, options, &block) #:nodoc:
+      PartialRenderer.new(@lookup_context).render(context, options, block)
+    end
+
+    def cache_hits # :nodoc:
+      @cache_hits ||= {}
+    end
+  end
+end

data/lib/action_view/renderer/streaming_template_renderer.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "fiber"
+
+module ActionView
+  # == TODO
+  #
+  # * Support streaming from child templates, partials and so on.
+  # * 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.
+        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 << "  " << 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, [formats.first])
+
+      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, 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
+          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
+
+          # 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,102 @@
+# 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)
+
+      render_template(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 : []
+
+        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)
+          with_fallbacks { find_file(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]
+          else
+            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."
+        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)
+        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)
+        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) }
+        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, formats)
+        resolve_layout(layout, keys, formats)
+      end
+
+      def resolve_layout(layout, keys, formats)
+        details = @details.dup
+        details[:formats] = formats
+
+        case layout
+        when String
+          begin
+            if layout.start_with?("/")
+              with_fallbacks { find_template(layout, nil, false, [], details) }
+            else
+              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
+        when Proc
+          resolve_layout(layout.call(formats), keys, formats)
+        else
+          layout
+        end
+      end
+  end
+end

data/lib/action_view/rendering.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "action_view/view_paths"
+
+module ActionView
+  # This is a class to fix I18n global state. Whenever you provide I18n.locale during a request,
+  # it will trigger the lookup_context and consequently expire the cache.
+  class I18nProxy < ::I18n::Config #:nodoc:
+    attr_reader :original_config, :lookup_context
+
+    def initialize(original_config, lookup_context)
+      original_config = original_config.original_config if original_config.respond_to?(:original_config)
+      @original_config, @lookup_context = original_config, lookup_context
+    end
+
+    def locale
+      @original_config.locale
+    end
+
+    def locale=(value)
+      @lookup_context.locale = value
+    end
+  end
+
+  module Rendering
+    extend ActiveSupport::Concern
+    include ActionView::ViewPaths
+
+    # Overwrite process to setup I18n proxy.
+    def process(*) #:nodoc:
+      old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)
+      super
+    ensure
+      I18n.config = old_config
+    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
+          end
+        end
+      end
+    end
+
+    attr_internal_writer :view_context_class
+
+    def view_context_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
+    #
+    # Override this method in a module to change the default behavior.
+    def view_context
+      view_context_class.new(view_renderer, view_assigns, self)
+    end
+
+    # Returns an object that is able to render templates.
+    def view_renderer # :nodoc:
+      @_view_renderer ||= ActionView::Renderer.new(lookup_context)
+    end
+
+    def render_to_body(options = {})
+      _process_options(options)
+      _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)
+        assigns = options.delete(:assigns)
+        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)
+      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
+      end
+
+      # Normalize args by converting render "foo" to render :action => "foo" and
+      # render "foo/bar" to render :template => "foo/bar".
+      def _normalize_args(action = nil, options = {})
+        options = super(action, options)
+        case action
+        when NilClass
+        when Hash
+          options = action
+        when String, Symbol
+          action = action.to_s
+          key = action.include?(?/) ? :template : :action
+          options[key] = action
+        else
+          if action.respond_to?(:permitted?) && action.permitted?
+            options = action
+          else
+            options[:partial] = action
+          end
+        end
+
+        options
+      end
+
+      # Normalize options.
+      def _normalize_options(options)
+        options = super(options)
+        if options[:partial] == true
+          options[:partial] = action_name
+        end
+
+        if (options.keys & [:partial, :file, :template]).empty?
+          options[:prefixes] ||= _prefixes
+        end
+
+        options[:template] ||= (options[:action] || action_name).to_s
+        options
+      end
+  end
+end