actionview 7.0.8.1 → 7.2.2.1

data/lib/action_view/render_parser.rb

@@ -1,176 +1,19 @@
 # frozen_string_literal: true
 
-require "action_view/ripper_ast_parser"
-
 module ActionView
-  class RenderParser # :nodoc:
-    def initialize(name, code)
-      @name = name
-      @code = code
-      @parser = RipperASTParser
-    end
-
-    def render_calls
-      render_nodes = @parser.parse_render_nodes(@code)
-
-      render_nodes.map do |method, nodes|
-        nodes.map { |n| send(:parse_render, n) }
-      end.flatten.compact
-    end
+  module RenderParser # :nodoc:
+    ALL_KNOWN_KEYS = [:partial, :template, :layout, :formats, :locals, :object, :collection, :as, :status, :content_type, :location, :spacer_template]
+    RENDER_TYPE_KEYS = [:partial, :template, :layout]
 
-    private
-      def directory
-        File.dirname(@name)
-      end
-
-      def resolve_path_directory(path)
-        if path.include?("/")
-          path
-        else
-          "#{directory}/#{path}"
-        end
-      end
-
-      # Convert
-      #   render("foo", ...)
-      # into either
-      #   render(template: "foo", ...)
-      # or
-      #   render(partial: "foo", ...)
-      def normalize_args(string, options_hash)
-        if options_hash
-          { partial: string, locals: options_hash }
-        else
-          { partial: string }
-        end
-      end
-
-      def parse_render(node)
-        node = node.argument_nodes
-
-        if (node.length == 1 || node.length == 2) && !node[0].hash?
-          if node.length == 1
-            options = normalize_args(node[0], nil)
-          elsif node.length == 2
-            options = normalize_args(node[0], node[1])
-          end
-
-          return nil unless options
-
-          parse_render_from_options(options)
-        elsif node.length == 1 && node[0].hash?
-          options = parse_hash_to_symbols(node[0])
-
-          return nil unless options
-
-          parse_render_from_options(options)
-        else
-          nil
-        end
-      end
-
-      def parse_hash(node)
-        node.hash? && node.to_hash
-      end
-
-      def parse_hash_to_symbols(node)
-        hash = parse_hash(node)
-
-        return unless hash
-
-        hash.transform_keys do |key_node|
-          key = parse_sym(key_node)
-
-          return unless key
-
-          key
-        end
-      end
-
-      ALL_KNOWN_KEYS = [:partial, :template, :layout, :formats, :locals, :object, :collection, :as, :status, :content_type, :location, :spacer_template]
-
-      RENDER_TYPE_KEYS =
-        [:partial, :template, :layout]
-
-      def parse_render_from_options(options_hash)
-        renders = []
-        keys = options_hash.keys
-
-        if (keys & RENDER_TYPE_KEYS).size < 1
-          # Must have at least one of render keys
-          return nil
-        end
-
-        if (keys - ALL_KNOWN_KEYS).any?
-          # de-opt in case of unknown option
-          return nil
-        end
-
-        render_type = (keys & RENDER_TYPE_KEYS)[0]
-
-        node = options_hash[render_type]
-
-        if node.string?
-          template = resolve_path_directory(node.to_string)
-        else
-          if node.variable_reference?
-            dependency = node.variable_name.sub(/\A(?:\$|@{1,2})/, "")
-          elsif node.vcall?
-            dependency = node.variable_name
-          elsif node.call?
-            dependency = node.call_method_name
-          else
-            return
-          end
-
-          object_template = true
-          template = "#{dependency.pluralize}/#{dependency.singularize}"
-        end
-
-        return unless template
-
-        if spacer_template = render_template_with_spacer?(options_hash)
-          virtual_path = partial_to_virtual_path(:partial, spacer_template)
-          renders << virtual_path
-        end
-
-        if options_hash.key?(:object) || options_hash.key?(:collection) || object_template
-          return nil if options_hash.key?(:object) && options_hash.key?(:collection)
-          return nil unless options_hash.key?(:partial)
-        end
-
-        virtual_path = partial_to_virtual_path(render_type, template)
-        renders << virtual_path
-
-        # Support for rendering multiple templates (i.e. a partial with a layout)
-        if layout_template = render_template_with_layout?(render_type, options_hash)
-          virtual_path = partial_to_virtual_path(:layout, layout_template)
-
-          renders << virtual_path
-        end
-
-        renders
-      end
-
-      def parse_str(node)
-        node.string? && node.to_string
-      end
-
-      def parse_sym(node)
-        node.symbol? && node.to_symbol
+    class Base # :nodoc:
+      def initialize(name, code)
+        @name = name
+        @code = code
       end
 
       private
-        def render_template_with_layout?(render_type, options_hash)
-          if render_type != :layout && options_hash.key?(:layout)
-            parse_str(options_hash[:layout])
-          end
-        end
-
-        def render_template_with_spacer?(options_hash)
-          if options_hash.key?(:spacer_template)
-            parse_str(options_hash[:spacer_template])
-          end
+        def directory
+          File.dirname(@name)
         end
 
         def partial_to_virtual_path(render_type, partial_path)
@@ -180,9 +23,18 @@ module ActionView
             partial_path
           end
         end
+    end
 
-        def layout_to_virtual_path(layout_path)
-          "layouts/#{layout_path}"
-        end
+    # Check if prism is available. If it is, use it. Otherwise, use ripper.
+    begin
+      require "prism"
+    rescue LoadError
+      require "ripper"
+      require_relative "render_parser/ripper_render_parser"
+      Default = RipperRenderParser
+    else
+      require_relative "render_parser/prism_render_parser"
+      Default = PrismRenderParser
+    end
   end
 end

data/lib/action_view/renderer/abstract_renderer.rb

@@ -31,7 +31,7 @@ module ActionView
 
     module ObjectRendering # :nodoc:
       PREFIXED_PARTIAL_NAMES = Concurrent::Map.new do |h, k|
-        h[k] = Concurrent::Map.new
+        h.compute_if_absent(k) { Concurrent::Map.new }
       end
 
       def initialize(lookup_context, options)
@@ -79,7 +79,7 @@ module ActionView
           path = if object.respond_to?(:to_partial_path)
             object.to_partial_path
           else
-            raise ArgumentError.new("'#{object.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.")
+            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

data/lib/action_view/renderer/collection_renderer.rb

@@ -51,6 +51,10 @@ module ActionView
       def length
         @collection.respond_to?(:length) ? @collection.length : size
       end
+
+      def preload!
+        # no-op
+      end
     end
 
     class SameCollectionIterator < CollectionIterator # :nodoc:
@@ -84,9 +88,13 @@ module ActionView
 
       def each_with_info
         return super unless block_given?
-        @relation.preload_associations(@collection)
+        preload!
         super
       end
+
+      def preload!
+        @relation.preload_associations(@collection)
+      end
     end
 
     class MixedCollectionIterator < CollectionIterator # :nodoc:
@@ -186,7 +194,7 @@ module ActionView
 
           _template = (cache[path] ||= (template || find_template(path, @locals.keys + [as, counter, iteration])))
 
-          content = _template.render(view, locals)
+          content = _template.render(view, locals, implicit_locals: [counter, iteration])
           content = layout.render(view, locals) { content } if layout
           partial_iteration.iterate!
           build_rendered_template(content, _template)

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

@@ -59,6 +59,7 @@ module ActionView
         seed = callable_cache_key? ? @options[:cached] : ->(i) { i }
 
         digest_path = view.digest_path_from_template(template)
+        collection.preload! if callable_cache_key?
 
         collection.each_with_object([{}, []]) do |item, (hash, ordered_keys)|
           key = expanded_cache_key(seed.call(item), view, template, digest_path)
@@ -100,7 +101,7 @@ module ActionView
             # We want to cache buffers as raw strings. This both improve performance and
             # avoid creating forward compatibility issues with the internal representation
             # of these two types.
-            if body.is_a?(ActiveSupport::SafeBuffer)
+            if body.is_a?(ActionView::OutputBuffer) || body.is_a?(ActiveSupport::SafeBuffer)
               body = body.to_str
             end
 

data/lib/action_view/renderer/partial_renderer.rb

@@ -246,7 +246,8 @@ module ActionView
         ActiveSupport::Notifications.instrument(
           "render_partial.action_view",
           identifier: template.identifier,
-          layout: layout && layout.virtual_path
+          layout: layout && layout.virtual_path,
+          locals: locals
         ) do |payload|
           content = template.render(view, locals, add_to_stack: !block) do |*name|
             view._layout_for(*name, &block)

data/lib/action_view/renderer/renderer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActionView
+  # = Action View \Renderer
+  #
   # This is the main entry point for rendering. It basically delegates
   # to other objects like TemplateRenderer and PartialRenderer which
   # actually renders the template.
@@ -43,12 +45,6 @@ module ActionView
       end
     end
 
-    # Direct access to template rendering.
-    def render_template(context, options) # :nodoc:
-      render_template_to_object(context, options).body
-    end
-
-    # Direct access to partial rendering.
     def render_partial(context, options, &block) # :nodoc:
       render_partial_to_object(context, options, &block).body
     end
@@ -57,46 +53,46 @@ module ActionView
       @cache_hits ||= {}
     end
 
-    def render_template_to_object(context, options) # :nodoc:
-      TemplateRenderer.new(@lookup_context).render(context, options)
-    end
+    private
+      def render_template_to_object(context, options)
+        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)
+      def render_partial_to_object(context, options, &block)
+        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)
+          if collection
+            # Collection + Partial
+            renderer = CollectionRenderer.new(@lookup_context, options)
+            renderer.render_collection_with_partial(collection, partial, context, block)
           else
-            # Partial
-            renderer = PartialRenderer.new(@lookup_context, options)
-            renderer.render(partial, context, block)
+            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
-        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)
+          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
-    end
 
-    private
       def collection_from_options(options)
         if options.key?(:collection)
           collection = options[:collection]

data/lib/action_view/renderer/streaming_template_renderer.rb

@@ -46,7 +46,7 @@ module ActionView
       return [super.body] unless layout_name && template.supports_streaming?
 
       locals ||= {}
-      layout   = layout_name && find_layout(layout_name, locals.keys, [formats.first])
+      layout   = find_layout(layout_name, locals.keys, [formats.first])
 
       Body.new do |buffer|
         delayed_render(buffer, template, layout, view, locals)
@@ -65,7 +65,8 @@ module ActionView
         ActiveSupport::Notifications.instrument(
           "render_template.action_view",
           identifier: template.identifier,
-          layout: layout && layout.virtual_path
+          layout: layout && layout.virtual_path,
+          locals: locals
         ) do
           outer_config = I18n.config
           fiber = Fiber.new do

data/lib/action_view/renderer/template_renderer.rb

@@ -49,7 +49,7 @@ module ActionView
             @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."
+          raise ArgumentError, "You invoked render but did not give any of :body, :file, :html, :inline, :partial, :plain, :renderable, or :template option."
         end
       end
 
@@ -60,7 +60,8 @@ module ActionView
           ActiveSupport::Notifications.instrument(
             "render_template.action_view",
             identifier: template.identifier,
-            layout: layout && layout.virtual_path
+            layout: layout && layout.virtual_path,
+            locals: locals
           ) do
             template.render(view, locals) { |*name| view._layout_for(*name) }
           end

data/lib/action_view/rendering.rb

@@ -10,7 +10,8 @@ module ActionView
 
     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
+      @original_config = original_config
+      @lookup_context = lookup_context
     end
 
     def locale
@@ -26,10 +27,10 @@ module ActionView
     extend ActiveSupport::Concern
     include ActionView::ViewPaths
 
-    attr_reader :rendered_format
+    attr_internal_reader :rendered_format
 
     def initialize
-      @rendered_format = nil
+      @_rendered_format = nil
       super
     end
 
@@ -48,7 +49,18 @@ module ActionView
       def _helpers
       end
 
+      def inherit_view_context_class?
+        superclass.respond_to?(:view_context_class) &&
+          supports_path? == superclass.supports_path? &&
+          _routes.equal?(superclass._routes) &&
+          _helpers.equal?(superclass._helpers)
+      end
+
       def build_view_context_class(klass, supports_path, routes, helpers)
+        if inherit_view_context_class?
+          return superclass.view_context_class
+        end
+
         Class.new(klass) do
           if routes
             include routes.url_helpers(supports_path)
@@ -61,8 +73,14 @@ module ActionView
         end
       end
 
+      def eager_load!
+        super
+        view_context_class
+        nil
+      end
+
       def view_context_class
-        klass = ActionView::LookupContext::DetailsKey.view_context_class(ActionView::Base)
+        klass = ActionView::LookupContext::DetailsKey.view_context_class
 
         @view_context_class ||= build_view_context_class(klass, supports_path?, _routes, _helpers)
 
@@ -118,7 +136,7 @@ module ActionView
         end
 
         rendered_format = rendered_template.format || lookup_context.formats.first
-        @rendered_format = Template::Types[rendered_format]
+        @_rendered_format = Template::Types[rendered_format]
 
         rendered_template.body
       end
@@ -129,8 +147,8 @@ module ActionView
         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 :template => "foo/bar".
+      # 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
@@ -161,7 +179,7 @@ module ActionView
           options[:partial] = action_name
         end
 
-        if (options.keys & [:partial, :file, :template]).empty?
+        if !options.keys.intersect?([:partial, :file, :template])
           options[:prefixes] ||= _prefixes
         end
 

data/lib/action_view/template/error.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/enumerable"
+require "active_support/syntax_error_proxy"
 
 module ActionView
   # = Action View Errors
@@ -156,13 +157,25 @@ module ActionView
       # Override to prevent #cause resetting during re-raise.
       attr_reader :cause
 
+      attr_reader :template
+
       def initialize(template)
         super($!.message)
-        set_backtrace($!.backtrace)
         @cause = $!
+        if @cause.is_a?(SyntaxError)
+          @cause = ActiveSupport::SyntaxErrorProxy.new(@cause)
+        end
         @template, @sub_templates = template, nil
       end
 
+      def backtrace
+        @cause.backtrace
+      end
+
+      def backtrace_locations
+        @cause.backtrace_locations
+      end
+
       def file_name
         @template.identifier
       end

data/lib/action_view/template/handlers/builder.rb

@@ -7,10 +7,10 @@ module ActionView
 
       def call(template, source)
         require_engine
-        "xml = ::Builder::XmlMarkup.new(:indent => 2);" \
-          "self.output_buffer = xml.target!;" +
-          source +
-          ";xml.target!;"
+        # the double assignment is to silence "assigned but unused variable" warnings
+        "xml = xml = ::Builder::XmlMarkup.new(indent: 2, target: output_buffer.raw);" \
+          "#{source};" \
+          "output_buffer.to_s"
       end
 
       private

data/lib/action_view/template/handlers/erb/erubi.rb

@@ -16,22 +16,16 @@ module ActionView
 
             properties[:bufvar]     ||= "@output_buffer"
             properties[:preamble]   ||= ""
-            properties[:postamble]  ||= "#{properties[:bufvar]}.to_s"
+            properties[:postamble]  ||= "#{properties[:bufvar]}"
+
+            # Tell Eruby that whether template will be compiled with `frozen_string_literal: true`
+            properties[:freeze_template_literals] = !Template.frozen_string_literal
 
             properties[:escapefunc] = ""
 
             super
           end
 
-          def evaluate(action_view_erb_handler_context)
-            src = @src
-            view = Class.new(ActionView::Base) {
-              include action_view_erb_handler_context._routes.url_helpers
-              class_eval("define_method(:_template) { |local_assigns, output_buffer| #{src} }", defined?(@filename) ? @filename : "(erubi)", 0)
-            }.empty
-            view._run(:_template, nil, {}, ActionView::OutputBuffer.new)
-          end
-
         private
           def add_text(text)
             return if text.empty?
@@ -39,30 +33,32 @@ module ActionView
             if text == "\n"
               @newline_pending += 1
             else
-              src << bufvar << ".safe_append='"
-              src << "\n" * @newline_pending if @newline_pending > 0
-              src << text.gsub(/['\\]/, '\\\\\&')
-              src << "'.freeze;"
-
+              with_buffer do
+                src << ".safe_append='"
+                src << "\n" * @newline_pending if @newline_pending > 0
+                src << text.gsub(/['\\]/, '\\\\\&') << @text_end
+              end
               @newline_pending = 0
             end
           end
 
-          BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+          BLOCK_EXPR = /((\s|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
 
           def add_expression(indicator, code)
             flush_newline_if_pending(src)
 
-            if (indicator == "==") || @escape
-              src << bufvar << ".safe_expr_append="
-            else
-              src << bufvar << ".append="
-            end
-
-            if BLOCK_EXPR.match?(code)
-              src << " " << code
-            else
-              src << "(" << code << ");"
+            with_buffer do
+              if (indicator == "==") || @escape
+                src << ".safe_expr_append="
+              else
+                src << ".append="
+              end
+
+              if BLOCK_EXPR.match?(code)
+                src << " " << code
+              else
+                src << "(" << code << ")"
+              end
             end
           end
 
@@ -78,7 +74,7 @@ module ActionView
 
           def flush_newline_if_pending(src)
             if @newline_pending > 0
-              src << bufvar << ".safe_append='#{"\n" * @newline_pending}'.freeze;"
+              with_buffer { src << ".safe_append='#{"\n" * @newline_pending}" << @text_end }
               @newline_pending = 0
             end
           end