actionview 5.2.8.1 → 6.0.6.1

data/lib/action_view/railtie.rb

@@ -6,9 +6,13 @@ require "rails"
 module ActionView
   # = Action View Railtie
   class Railtie < Rails::Engine # :nodoc:
+    NULL_OPTION = Object.new
+
     config.action_view = ActiveSupport::OrderedOptions.new
     config.action_view.embed_authenticity_token_in_remote_forms = nil
     config.action_view.debug_missing_translation = true
+    config.action_view.default_enforce_utf8 = nil
+    config.action_view.finalize_compiled_template_methods = NULL_OPTION
 
     config.eager_load_namespaces << ActionView
 
@@ -35,6 +39,25 @@ module ActionView
       end
     end
 
+    initializer "action_view.default_enforce_utf8" do |app|
+      ActiveSupport.on_load(:action_view) do
+        default_enforce_utf8 = app.config.action_view.delete(:default_enforce_utf8)
+        unless default_enforce_utf8.nil?
+          ActionView::Helpers::FormTagHelper.default_enforce_utf8 = default_enforce_utf8
+        end
+      end
+    end
+
+    initializer "action_view.finalize_compiled_template_methods" do |app|
+      ActiveSupport.on_load(:action_view) do
+        option = app.config.action_view.delete(:finalize_compiled_template_methods)
+
+        if option != NULL_OPTION
+          ActiveSupport::Deprecation.warn "action_view.finalize_compiled_template_methods is deprecated and has no effect"
+        end
+      end
+    end
+
     initializer "action_view.logger" do
       ActiveSupport.on_load(:action_view) { self.logger ||= Rails.logger }
     end
@@ -58,7 +81,7 @@ module ActionView
     initializer "action_view.per_request_digest_cache" do |app|
       ActiveSupport.on_load(:action_view) do
         unless ActionView::Resolver.caching?
-          app.executor.to_run ActionView::Digestor::PerExecutionDigestCacheExpiry
+          app.executor.to_run ActionView::CacheExpiry::Executor.new(watcher: app.config.file_watcher)
         end
       end
     end

data/lib/action_view/record_identifier.rb

@@ -59,8 +59,8 @@ module ActionView
 
     include ModelNaming
 
-    JOIN = "_".freeze
-    NEW = "new".freeze
+    JOIN = "_"
+    NEW = "new"
 
     # The DOM class convention is to use the singular form of an object or class.
     #
@@ -95,7 +95,6 @@ module ActionView
     end
 
   private
-
     # Returns a string representation of the key attribute(s) that is suitable for use in an HTML DOM id.
     # This can be overwritten to customize the default generated string representation if desired.
     # If you need to read back a key from a dom_id in order to query for the underlying database record,

data/lib/action_view/renderer/abstract_renderer.rb

@@ -17,7 +17,7 @@ module ActionView
   # that new object is called in turn. This abstracts the setup and rendering
   # into a separate classes for partials and templates.
   class AbstractRenderer #:nodoc:
-    delegate :find_template, :find_file, :template_exists?, :any_templates?, :with_fallbacks, :with_layout_format, :formats, to: :@lookup_context
+    delegate :template_exists?, :any_templates?, :formats, to: :@lookup_context
 
     def initialize(lookup_context)
       @lookup_context = lookup_context
@@ -27,8 +27,54 @@ module ActionView
       raise NotImplementedError
     end
 
-    private
+    class RenderedCollection # :nodoc:
+      def self.empty(format)
+        EmptyCollection.new format
+      end
+
+      attr_reader :rendered_templates
+
+      def initialize(rendered_templates, spacer)
+        @rendered_templates = rendered_templates
+        @spacer = spacer
+      end
+
+      def body
+        @rendered_templates.map(&:body).join(@spacer.body).html_safe
+      end
+
+      def format
+        rendered_templates.first.format
+      end
+
+      class EmptyCollection
+        attr_reader :format
+
+        def initialize(format)
+          @format = format
+        end
+
+        def body; nil; end
+      end
+    end
+
+    class RenderedTemplate # :nodoc:
+      attr_reader :body, :layout, :template
+
+      def initialize(body, layout, template)
+        @body = body
+        @layout = layout
+        @template = template
+      end
+
+      def format
+        template.format
+      end
+
+      EMPTY_SPACER = Struct.new(:body).new
+    end
 
+    private
       def extract_details(options) # :doc:
         @lookup_context.registered_details.each_with_object({}) do |key, details|
           value = options[key]
@@ -38,8 +84,6 @@ module ActionView
       end
 
       def instrument(name, **options) # :doc:
-        options[:identifier] ||= (@template && @template.identifier) || @path
-
         ActiveSupport::Notifications.instrument("render_#{name}.action_view", options) do |payload|
           yield payload
         end
@@ -51,5 +95,13 @@ module ActionView
 
         @lookup_context.formats = formats | @lookup_context.formats
       end
+
+      def build_rendered_template(content, template, layout = nil)
+        RenderedTemplate.new content, layout, template
+      end
+
+      def build_rendered_collection(templates, spacer)
+        RenderedCollection.new templates, spacer
+      end
   end
 end

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

@@ -11,47 +11,93 @@ module ActionView
     end
 
     private
-      def cache_collection_render(instrumentation_payload)
-        return yield unless @options[:cached]
+      def cache_collection_render(instrumentation_payload, view, template)
+        return yield unless @options[:cached] && view.controller.respond_to?(:perform_caching) && view.controller.perform_caching
 
-        keyed_collection = collection_by_cache_keys
-        cached_partials  = collection_cache.read_multi(*keyed_collection.keys)
+        # 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)
+
+        # 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
 
+        # Extract the items for the keys that are not found
+        # Set the uncached values to instance variable @collection
+        # which is used by the caller
         @collection = keyed_collection.reject { |key, _| cached_partials.key?(key) }.values
+
+        # If all elements are already in cache then
+        # rendered partials will be an empty array
+        #
+        # If the cache is missing elements then
+        # the block will be called against the remaining items
+        # in the @collection.
         rendered_partials = @collection.empty? ? [] : yield
 
         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)
         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, virtual_path: template.virtual_path, 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
-            yield.tap do |rendered_partial|
-              collection_cache.write(cache_key, rendered_partial)
-            end
+      # `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.each_with_object({}) do |cache_key, hash|
+            hash[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.body)
+                end
+              end
           end
-        end
       end
   end
 end

data/lib/action_view/renderer/partial_renderer.rb

@@ -105,9 +105,6 @@ module ActionView
   #
   #   <%= render(partial: "ad", collection: @advertisements) || "There's no ad to be displayed" %>
   #
-  # NOTE: Due to backwards compatibility concerns, the collection can't be one of hashes. Normally you'd also
-  # just keep domain objects, like Active Records, in there.
-  #
   # == \Rendering shared partials
   #
   # Two controllers can share a set of partials and render them like this:
@@ -295,43 +292,59 @@ module ActionView
     end
 
     def render(context, options, block)
-      setup(context, options, block)
-      @template = find_partial
+      as = as_variable(options)
+      setup(context, options, as, block)
 
-      @lookup_context.rendered_format ||= begin
-        if @template && @template.formats.present?
-          @template.formats.first
+      if @path
+        if @has_object || @collection
+          @variable, @variable_counter, @variable_iteration = retrieve_variable(@path, as)
+          @template_keys = retrieve_template_keys(@variable)
         else
-          formats.first
+          @template_keys = @locals.keys
         end
+        template = find_partial(@path, @template_keys)
+        @variable ||= template.variable
+      else
+        if options[:cached]
+          raise NotImplementedError, "render caching requires a template. Please specify a partial when rendering"
+        end
+        template = nil
       end
 
       if @collection
-        render_collection
+        render_collection(context, template)
       else
-        render_partial
+        render_partial(context, template)
       end
     end
 
     private
-
-      def render_collection
-        instrument(:collection, count: @collection.size) do |payload|
-          return nil if @collection.blank?
-
-          if @options.key?(:spacer_template)
-            spacer = find_template(@options[:spacer_template], @locals.keys).render(@view, @locals)
+      def render_collection(view, template)
+        identifier = (template && template.identifier) || @path
+        instrument(:collection, identifier: identifier, count: @collection.size) do |payload|
+          return RenderedCollection.empty(@lookup_context.formats.first) if @collection.blank?
+
+          spacer = if @options.key?(:spacer_template)
+            spacer_template = find_template(@options[:spacer_template], @locals.keys)
+            build_rendered_template(spacer_template.render(view, @locals), spacer_template)
+          else
+            RenderedTemplate::EMPTY_SPACER
           end
 
-          cache_collection_render(payload) do
-            @template ? collection_with_template : collection_without_template
-          end.join(spacer).html_safe
+          collection_body = if template
+            cache_collection_render(payload, view, template) do
+              collection_with_template(view, template)
+            end
+          else
+            collection_without_template(view)
+          end
+          build_rendered_collection(collection_body, spacer)
         end
       end
 
-      def render_partial
-        instrument(:partial) do |payload|
-          view, locals, block = @view, @locals, @block
+      def render_partial(view, template)
+        instrument(:partial, identifier: template.identifier) do |payload|
+          locals, block = @locals, @block
           object, as = @object, @variable
 
           if !block && (layout = @options[:layout])
@@ -341,13 +354,13 @@ module ActionView
           object = locals[as] if object.nil? # Respect object when object is false
           locals[as] = object if @has_object
 
-          content = @template.render(view, locals) do |*name|
+          content = template.render(view, locals) do |*name|
             view._layout_for(*name, &block)
           end
 
           content = layout.render(view, locals) { content } if layout
-          payload[:cache_hit] = view.view_renderer.cache_hits[@template.virtual_path]
-          content
+          payload[:cache_hit] = view.view_renderer.cache_hits[template.virtual_path]
+          build_rendered_template(content, template, layout)
         end
       end
 
@@ -358,16 +371,13 @@ module ActionView
       # If +options[:partial]+ is a string, then the <tt>@path</tt> instance variable is
       # set to that string. Otherwise, the +options[:partial]+ object must
       # respond to +to_partial_path+ in order to setup the path.
-      def setup(context, options, block)
-        @view = context
+      def setup(context, options, as, block)
         @options = options
         @block   = block
 
         @locals  = options[:locals] || {}
         @details = extract_details(options)
 
-        prepend_formats(options[:formats])
-
         partial = options[:partial]
 
         if String === partial
@@ -381,26 +391,26 @@ module ActionView
           @collection = collection_from_object || collection_from_options
 
           if @collection
-            paths = @collection_data = @collection.map { |o| partial_path(o) }
-            @path = paths.uniq.one? ? paths.first : nil
+            paths = @collection_data = @collection.map { |o| partial_path(o, context) }
+            if paths.uniq.length == 1
+              @path = paths.first
+            else
+              paths.map! { |path| retrieve_variable(path, as).unshift(path) }
+              @path = nil
+            end
           else
-            @path = partial_path
+            @path = partial_path(@object, context)
           end
         end
 
+        self
+      end
+
+      def as_variable(options)
         if as = options[:as]
           raise_invalid_option_as(as) unless /\A[a-z_]\w*\z/.match?(as.to_s)
-          as = as.to_sym
+          as.to_sym
         end
-
-        if @path
-          @variable, @variable_counter, @variable_iteration = retrieve_variable(@path, as)
-          @template_keys = retrieve_template_keys
-        else
-          paths.map! { |path| retrieve_variable(path, as).unshift(path) }
-        end
-
-        self
       end
 
       def collection_from_options
@@ -414,8 +424,8 @@ module ActionView
         @object.to_ary if @object.respond_to?(:to_ary)
       end
 
-      def find_partial
-        find_template(@path, @template_keys) if @path
+      def find_partial(path, template_keys)
+        find_template(path, template_keys)
       end
 
       def find_template(path, locals)
@@ -423,8 +433,8 @@ module ActionView
         @lookup_context.find_template(path, prefixes, true, locals, @details)
       end
 
-      def collection_with_template
-        view, locals, template = @view, @locals, @template
+      def collection_with_template(view, template)
+        locals = @locals
         as, counter, iteration = @variable, @variable_counter, @variable_iteration
 
         if layout = @options[:layout]
@@ -441,12 +451,12 @@ module ActionView
           content = template.render(view, locals)
           content = layout.render(view, locals) { content } if layout
           partial_iteration.iterate!
-          content
+          build_rendered_template(content, template, layout)
         end
       end
 
-      def collection_without_template
-        view, locals, collection_data = @view, @locals, @collection_data
+      def collection_without_template(view)
+        locals, collection_data = @locals, @collection_data
         cache = {}
         keys  = @locals.keys
 
@@ -463,7 +473,7 @@ module ActionView
           template = (cache[path] ||= find_template(path, keys + [as, counter, iteration]))
           content = template.render(view, locals)
           partial_iteration.iterate!
-          content
+          build_rendered_template(content, template)
         end
       end
 
@@ -474,7 +484,7 @@ module ActionView
       #
       # If +prefix_partial_path_with_controller_namespace+ is true, then this
       # method will prefix the partial paths with a namespace.
-      def partial_path(object = @object)
+      def partial_path(object, view)
         object = object.to_model if object.respond_to?(:to_model)
 
         path = if object.respond_to?(:to_partial_path)
@@ -483,7 +493,7 @@ module ActionView
           raise ArgumentError.new("'#{object.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.")
         end
 
-        if @view.prefix_partial_path_with_controller_namespace
+        if view.prefix_partial_path_with_controller_namespace
           prefixed_partial_names[path] ||= merge_prefix_into_object_path(@context_prefix, path.dup)
         else
           path
@@ -511,9 +521,9 @@ module ActionView
         end
       end
 
-      def retrieve_template_keys
+      def retrieve_template_keys(variable)
         keys = @locals.keys
-        keys << @variable if @has_object || @collection
+        keys << variable
         if @collection
           keys << @variable_counter
           keys << @variable_iteration
@@ -523,7 +533,7 @@ module ActionView
 
       def retrieve_variable(path, as)
         variable = as || begin
-          base = path[-1] == "/".freeze ? "".freeze : File.basename(path)
+          base = path[-1] == "/" ? "" : File.basename(path)
           raise_invalid_identifier(path) unless base =~ /\A_?(.*?)(?:\.\w+)*\z/
           $1.to_sym
         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,24 @@ 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:
+      PartialRenderer.new(@lookup_context).render(context, options, block)
+    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