actionview 7.1.5.1 → 7.2.3

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

@@ -94,7 +94,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 +114,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/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
 
@@ -136,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
@@ -179,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

@@ -27,6 +27,17 @@ module ActionView
     end
   end
 
+  class StrictLocalsError < ArgumentError # :nodoc:
+    def initialize(argument_error, template)
+      message = argument_error.message.
+                  gsub("unknown keyword:", "unknown local:").
+                  gsub("missing keyword:", "missing local:").
+                  gsub("no keywords accepted", "no locals accepted").
+                  concat(" for #{template.short_identifier}")
+      super(message)
+    end
+  end
+
   class MissingTemplate < ActionViewError # :nodoc:
     attr_reader :path, :paths, :prefixes, :partial
 

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

@@ -42,7 +42,9 @@ module ActionView
         # source location inside the template.
         def translate_location(spot, backtrace_location, source)
           # Tokenize the source line
-          tokens = ::ERB::Util.tokenize(source.lines[backtrace_location.lineno - 1])
+          source_lines = source.lines
+          return nil if source_lines.size < backtrace_location.lineno
+          tokens = ::ERB::Util.tokenize(source_lines[backtrace_location.lineno - 1])
           new_first_column = find_offset(spot[:snippet], tokens, spot[:first_column])
           lineno_delta = spot[:first_lineno] - backtrace_location.lineno
           spot[:first_lineno] -= lineno_delta
@@ -51,7 +53,7 @@ module ActionView
           column_delta = spot[:first_column] - new_first_column
           spot[:first_column] -= column_delta
           spot[:last_column] -= column_delta
-          spot[:script_lines] = source.lines
+          spot[:script_lines] = source_lines
 
           spot
         rescue NotImplementedError, LocationParsingError
@@ -105,51 +107,57 @@ module ActionView
           raise WrongEncodingError.new(string, string.encoding)
         end
 
+        # Find which token in the source template spans the byte range that
+        # contains the error_column, then return the offset compared to the
+        # original source template.
+        #
+        # Iterate consecutive pairs of CODE or TEXT tokens, requiring
+        # a match of the first token before matching either token.
+        #
+        # For example, if we want to find tokens A, B, C, we do the following:
+        # 1. Find a match for A: test error_column or advance scanner.
+        # 2. Find a match for B or A:
+        #   a. If B: start over with next token set (B, C).
+        #   b. If A: test error_column or advance scanner.
+        #   c. Otherwise: Advance 1 byte
+        #
+        # Prioritize matching the next token over the current token once
+        # a match for the current token has been found. This is to prevent
+        # the current token from looping past the next token if they both
+        # match (i.e. if the current token is a single space character).
         def find_offset(compiled, source_tokens, error_column)
           compiled = StringScanner.new(compiled)
+          offset_source_tokens(source_tokens).each_cons(2) do |(name, str, offset), (_, next_str, _)|
+            matched_str = false
 
-          passed_tokens = []
+            until compiled.eos?
+              if matched_str && next_str && compiled.match?(next_str)
+                break
+              elsif compiled.match?(str)
+                matched_str = true
 
-          while tok = source_tokens.shift
-            tok_name, str = *tok
-            case tok_name
-            when :TEXT
-              loop do
-                break if compiled.match?(str)
-                compiled.getch
-              end
-              raise LocationParsingError unless compiled.scan(str)
-            when :CODE
-              if compiled.pos > error_column
-                raise LocationParsingError, "We went too far"
-              end
+                if name == :CODE && compiled.pos <= error_column && compiled.pos + str.bytesize >= error_column
+                  return error_column - compiled.pos + offset
+                end
 
-              if compiled.pos + str.bytesize >= error_column
-                offset = error_column - compiled.pos
-                return passed_tokens.map(&:last).join.bytesize + offset
+                compiled.pos += str.bytesize
               else
-                unless compiled.scan(str)
-                  raise LocationParsingError, "Couldn't find code snippet"
-                end
-              end
-            when :OPEN
-              next_tok = source_tokens.first.last
-              loop do
-                break if compiled.match?(next_tok)
-                compiled.getch
+                compiled.pos += 1
               end
-            when :CLOSE
-              next_tok = source_tokens.first.last
-              loop do
-                break if compiled.match?(next_tok)
-                compiled.getch
-              end
-            else
-              raise LocationParsingError, "Not implemented: #{tok.first}"
             end
+          end
+
+          raise LocationParsingError, "Couldn't find code snippet"
+        end
 
-            passed_tokens << tok
+        def offset_source_tokens(source_tokens)
+          source_offset = 0
+          with_offset = source_tokens.filter_map do |(name, str)|
+            result = [name, str, source_offset] if name == :CODE || name == :TEXT
+            source_offset += str.bytesize
+            result
           end
+          with_offset << [:EOS, nil, source_offset]
         end
       end
     end

data/lib/action_view/template/renderable.rb

@@ -14,10 +14,16 @@ module ActionView
 
       def render(context, *args)
         @renderable.render_in(context)
+      rescue NoMethodError
+        if !@renderable.respond_to?(:render_in)
+          raise ArgumentError, "'#{@renderable.inspect}' is not a renderable object. It must implement #render_in."
+        else
+          raise
+        end
       end
 
       def format
-        @renderable.format
+        @renderable.try(:format)
       end
     end
   end

data/lib/action_view/template/resolver.rb

@@ -10,8 +10,6 @@ require "concurrent/map"
 module ActionView
   # = Action View Resolver
   class Resolver
-    include ActiveSupport::Deprecation::DeprecatedConstantAccessor
-
     class PathParser # :nodoc:
       ParsedPath = Struct.new(:path, :details)
 

data/lib/action_view/template.rb

@@ -148,6 +148,20 @@ module ActionView
     #     <p><%= alert %></p>
     #   <% end %>
     #
+    # By default, templates will accept any <tt>locals</tt> as keyword arguments
+    # and make them available to <tt>local_assigns</tt>. To restrict what
+    # <tt>local_assigns</tt> a template will accept, add a <tt>locals:</tt> magic comment:
+    #
+    #   <%# locals: (headline:, alerts: []) %>
+    #
+    #   <h1><%= headline %></h1>
+    #
+    #   <% alerts.each do |alert| %>
+    #     <p><%= alert %></p>
+    #   <% end %>
+    #
+    # Read more about strict locals in {Action View Overview}[https://guides.rubyonrails.org/action_view_overview.html#strict-locals]
+    # in the guides.
 
     eager_autoload do
       autoload :Error
@@ -216,11 +230,21 @@ module ActionView
     end
 
     def spot(location) # :nodoc:
-      ast = RubyVM::AbstractSyntaxTree.parse(compiled_source, keep_script_lines: true)
       node_id = RubyVM::AbstractSyntaxTree.node_id_for_backtrace_location(location)
-      node = find_node_by_id(ast, node_id)
+      found =
+        if RubyVM::InstructionSequence.compile("").to_a[4][:parser] == :prism
+          require "prism"
 
-      ErrorHighlight.spot(node)
+          if Prism::VERSION >= "1.0.0"
+            result = Prism.parse(compiled_source).value
+            result.breadth_first_search { |node| node.node_id == node_id }
+          end
+        else
+          node = RubyVM::AbstractSyntaxTree.parse(compiled_source, keep_script_lines: true)
+          find_node_by_id(node, node_id)
+        end
+
+      ErrorHighlight.spot(found) if found
     end
 
     # Translate an error location returned by ErrorHighlight to the correct
@@ -425,9 +449,9 @@ module ActionView
         method_arguments =
           if set_strict_locals
             if set_strict_locals.include?("&")
-              "output_buffer, #{set_strict_locals}"
+              "local_assigns, output_buffer, #{set_strict_locals}"
             else
-              "output_buffer, #{set_strict_locals}, &_"
+              "local_assigns, output_buffer, #{set_strict_locals}, &_"
             end
           else
             "local_assigns, output_buffer, &_"
@@ -486,11 +510,12 @@ module ActionView
 
         return unless strict_locals?
 
-        parameters = mod.instance_method(method_name).parameters - [[:req, :output_buffer]]
+        parameters = mod.instance_method(method_name).parameters
+        parameters -= [[:req, :local_assigns], [:req, :output_buffer]]
+
         # Check compiled method parameters to ensure that only kwargs
         # were provided as strict locals, preventing `locals: (foo, *foo)` etc
         # and allowing `locals: (foo:)`.
-
         non_kwarg_parameters = parameters.select do |parameter|
           ![:keyreq, :key, :keyrest, :nokey].include?(parameter[0])
         end
@@ -531,12 +556,15 @@ module ActionView
         end
       end
 
+      RUBY_RESERVED_KEYWORDS = ::ActiveSupport::Delegation::RUBY_RESERVED_KEYWORDS
+      private_constant :RUBY_RESERVED_KEYWORDS
+
       def locals_code
         return "" if strict_locals?
 
         # Only locals with valid variable names get set directly. Others will
         # still be available in local_assigns.
-        locals = @locals - Module::RUBY_RESERVED_KEYWORDS
+        locals = @locals - RUBY_RESERVED_KEYWORDS
 
         locals = locals.grep(/\A(?![A-Z0-9])(?:[[:alnum:]_]|[^\0-\177])+\z/)