actionview 5.2.8.1 → 6.0.0.beta2

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

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.
     #

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,6 +27,53 @@ module ActionView
       raise NotImplementedError
     end
 
+    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:
@@ -38,8 +85,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 +96,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,18 +11,38 @@ module ActionView
     end
 
     private
-      def cache_collection_render(instrumentation_payload)
+      def cache_collection_render(instrumentation_payload, view, template)
         return yield unless @options[:cached]
 
-        keyed_collection = collection_by_cache_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 = 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
+        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
       end
@@ -31,24 +51,43 @@ module ActionView
         @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 }
 
+        digest_path = view.digest_path_from_template(template)
+
         @collection.each_with_object({}) do |item, hash|
-          hash[expanded_cache_key(seed.call(item))] = item
+          hash[expanded_cache_key(seed.call(item), view, template, digest_path)] = 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` 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.map do |cache_key|
-          cached_partials.fetch(cache_key) do
+          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/partial_renderer.rb

@@ -295,43 +295,60 @@ 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?
+      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?
 
-          if @options.key?(:spacer_template)
-            spacer = find_template(@options[:spacer_template], @locals.keys).render(@view, @locals)
+          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 +358,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 +375,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 +395,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
-        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) }
+          as.to_sym
         end
-
-        self
       end
 
       def collection_from_options
@@ -414,8 +428,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 +437,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 +455,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 +477,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 +488,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 +497,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 +525,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 +537,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

@@ -33,7 +33,7 @@ module ActionView
           logger = ActionView::Base.logger
           return unless logger
 
-          message = "\n#{exception.class} (#{exception.message}):\n".dup
+          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")
@@ -43,14 +43,14 @@ 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
 

data/lib/action_view/renderer/template_renderer.rb

@@ -5,15 +5,12 @@ 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)
+      prepend_formats(template.format)
 
-      @lookup_context.rendered_format ||= (template.formats.first || formats.first)
-
-      render_template(template, options[:layout], options[:locals])
+      render_template(context, template, options[:layout], options[:locals] || {})
     end
 
     private
@@ -29,15 +26,20 @@ 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) }
+          @lookup_context.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)
+          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?(: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 +48,25 @@ 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|
+      def render_template(view, template, layout_name, locals)
+        render_with_layout(view, layout_name, template, 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)
+      def render_with_layout(view, path, template, locals)
         layout  = path && find_layout(path, locals.keys, [formats.first])
         content = yield(layout)
 
-        if layout
-          view = @view
+        body = if layout
           view.view_flow.set(:layout, content)
           layout.render(view, locals) { |*name| view._layout_for(*name) }
         else
           content
         end
+        build_rendered_template(body, template, layout)
       end
 
       # This is the method which actually finds the layout using details in the lookup
@@ -84,16 +84,16 @@ module ActionView
         when String
           begin
             if layout.start_with?("/")
-              with_fallbacks { find_template(layout, nil, false, [], details) }
+              @lookup_context.with_fallbacks.find_template(layout, nil, false, [], details)
             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)
           end
         when Proc
-          resolve_layout(layout.call(formats), keys, formats)
+          resolve_layout(layout.call(@lookup_context, formats), keys, formats)
         else
           layout
         end