actionview 7.1.5.2 → 8.1.2.1

data/lib/action_view/{ripper_ast_parser.rb → render_parser/ripper_render_parser.rb}

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "ripper"
-
 module ActionView
-  class RenderParser
-    module RipperASTParser # :nodoc:
+  module RenderParser
+    class RipperRenderParser < Base # :nodoc:
       class Node < ::Array # :nodoc:
         attr_reader :type
 
@@ -68,7 +66,16 @@ module ActionView
 
         def to_string
           raise unless string?
-          self[0][0][0]
+
+          # s(:string_literal, s(:string_content, map))
+          self[0].map do |node|
+            case node.type
+            when :@tstring_content
+              node[0]
+            when :string_embexpr
+              "*"
+            end
+          end.join("")
         end
 
         def hash?
@@ -183,16 +190,161 @@ module ActionView
           end
       end
 
-      extend self
-
-      def parse_render_nodes(code)
-        parser = RenderCallExtractor.new(code)
+      def render_calls
+        parser = RenderCallExtractor.new(@code)
         parser.parse
 
         parser.render_calls.group_by(&:first).to_h do |method, nodes|
           [ method.to_sym, nodes.collect { |v| v[1] } ]
-        end
+        end.map do |method, nodes|
+          nodes.map { |n| parse_render(n) }
+        end.flatten.compact
       end
+
+      private
+        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
+
+        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
+        end
+
+        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
+        end
     end
   end
 end

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

@@ -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/partial_renderer.rb

@@ -48,6 +48,22 @@ module ActionView
   #
   #   <%= render partial: "account", locals: { user: @buyer } %>
   #
+  # == \Rendering variants of a partial
+  #
+  # The <tt>:variants</tt> option can be used to render a different template variant of a partial. For instance:
+  #
+  #   <%= render partial: "account", variants: :mobile %>
+  #
+  # This will render <tt>_account.html+mobile.erb</tt>. This option also accepts multiple variants
+  # like so:
+  #
+  #   <%= render partial: "account", variants: [:desktop, :mobile] %>
+  #
+  # This will look for the following templates and render the first one that exists:
+  # * <tt>_account.html+desktop.erb</tt>
+  # * <tt>_account.html+mobile.erb</tt>
+  # * <tt>_account.html.erb</tt>
+  #
   # == \Rendering a collection of partials
   #
   # The example of partial use describes a familiar pattern where a template needs to iterate over an array and
@@ -94,7 +110,7 @@ module ActionView
   #  # <%= render partial: "accounts/account", locals: { account: @account} %>
   #  <%= render partial: @account %>
   #
-  #  # @posts is an array of Post instances, so every post record returns 'posts/post' on +to_partial_path+,
+  #  # @posts is an array of Post instances, so every post record returns 'posts/post' on #to_partial_path,
   #  # that's why we can replace:
   #  # <%= render partial: "posts/post", collection: @posts %>
   #  <%= render partial: @posts %>
@@ -114,7 +130,7 @@ module ActionView
   #  # <%= render partial: "accounts/account", locals: { account: @account} %>
   #  <%= render @account %>
   #
-  #  # @posts is an array of Post instances, so every post record returns 'posts/post' on +to_partial_path+,
+  #  # @posts is an array of Post instances, so every post record returns 'posts/post' on #to_partial_path,
   #  # that's why we can replace:
   #  # <%= render partial: "posts/post", collection: @posts %>
   #  <%= render @posts %>

data/lib/action_view/renderer/renderer.rb

@@ -45,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
@@ -59,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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "fiber"
 
 module ActionView
   # == TODO
@@ -26,6 +25,13 @@ module ActionView
         self
       end
 
+      # Returns the complete body as a string.
+      def body
+        buffer = String.new
+        each { |part| buffer << part }
+        buffer
+      end
+
       private
         # This is the same logging logic as in ShowExceptions middleware.
         def log_error(exception)
@@ -43,7 +49,7 @@ module ActionView
     # object that responds to each. This object is initialized with a block
     # that knows how to render the template.
     def render_template(view, template, layout_name = nil, locals = {}) # :nodoc:
-      return [super.body] unless layout_name && template.supports_streaming?
+      return [super.body] unless template.supports_streaming?
 
       locals ||= {}
       layout   = find_layout(layout_name, locals.keys, [formats.first])

data/lib/action_view/renderer/template_renderer.rb

@@ -99,14 +99,14 @@ module ActionView
             if layout.start_with?("/")
               raise ArgumentError, "Rendering layouts from an absolute path is not supported."
             else
-              @lookup_context.find_template(layout, nil, false, [], details)
+              @lookup_context.find_template(layout, nil, false, keys, 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, keys, **all_details)
           end
         when Proc
-          resolve_layout(layout.call(@lookup_context, formats), keys, formats)
+          resolve_layout(layout.call(@lookup_context, formats, keys), keys, formats)
         else
           layout
         end

data/lib/action_view/rendering.rb

@@ -27,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
 
@@ -118,6 +118,7 @@ module ActionView
 
     def render_to_body(options = {})
       _process_options(options)
+      _process_render_template_options(options)
       _render_template(options)
     end
 
@@ -136,7 +137,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
@@ -173,18 +174,16 @@ module ActionView
       end
 
       # Normalize options.
-      def _normalize_options(options)
-        options = super(options)
+      def _process_render_template_options(options)
         if options[:partial] == true
           options[:partial] = action_name
         end
 
-        if (options.keys & [:partial, :file, :template]).empty?
+        if !options.keys.intersect?([:partial, :file, :template])
           options[:prefixes] ||= _prefixes
         end
 
         options[:template] ||= (options[:action] || action_name).to_s
-        options
       end
   end
 end