Enable DependencyTracker to evaluate interpolated paths (rails#50944)

* Enable RubyTracker to evaluate interpolated paths

Previously, neither the PrismRenderParser nor the RipperRenderParser
would consider an interpolated string as a dependency. The RubyTracker
even included a line to explcitly filter out interpolated paths returned
from the RipperRenderParser since they would end in a "/". However, the
RubyTracker does include the ability to evaluate explicit "Template
Dependency" comments with wildcard nodes.

This commit extends the RipperRenderParser and PrismRenderParser to
convert interpolated strings into wildcard globs. Additionally, it
changes the RubyTracker to evaluate wildcards the same for both implicit
and explicit dependencies. This enables the RubyTracker to identify
potential dependencies for interpolated renders, which it was previously
unable to do.

* Enable ERBTracker to evaluate interpolated paths

This ensures all three implementations (ERBTracker, RipperRenderParser,
and PrismRenderParser) are consistent in their ability to evaluate
interpolated paths.

* Extract WildcardResolver to remove duplication

Since both the ERBTracker and RubyTracker now support resolving
interpolated template paths against the view_paths, the logic for this
resolution can be extracted to its own class.

* Update CHANGELOG.md

---------

Co-authored-by: John Hawthorn <[email protected]>

Author: skipkayhil

actionview/CHANGELOG.md

@@ -1,3 +1,15 @@
+*   Enable DependencyTracker to evaluate renders with trailing interpolation.
+
+    ```erb
+    <%= render "maintenance_tasks/runs/info/#{run.status}" %>
+    ```
+
+    Previously, the DependencyTracker would ignore this render, but now it will
+    mark all partials in the "maintenance_tasks/runs/info" folder as
+    dependencies.
+
+    *Hartley McGuire*
+
 *   Rename `text_area` methods into `textarea`
 
     Old names are still available as aliases.

actionview/lib/action_view/dependency_tracker.rb

@@ -10,6 +10,7 @@ class DependencyTracker # :nodoc:
 
     autoload :ERBTracker
     autoload :RubyTracker
+    autoload :WildcardResolver
 
     @trackers = Concurrent::Map.new
 

actionview/lib/action_view/dependency_tracker/erb_tracker.rb

@@ -74,7 +74,7 @@ def initialize(name, template, view_paths = nil)
       end
 
       def dependencies
-        render_dependencies + explicit_dependencies
+        WildcardResolver.new(@view_paths, render_dependencies + explicit_dependencies).resolve
       end
 
       attr_reader :name, :template
@@ -90,15 +90,15 @@ def directory
         end
 
         def render_dependencies
-          render_dependencies = []
+          dependencies = []
           render_calls = source.split(/\brender\b/).drop(1)
 
           render_calls.each do |arguments|
-            add_dependencies(render_dependencies, arguments, LAYOUT_DEPENDENCY)
-            add_dependencies(render_dependencies, arguments, RENDER_ARGUMENTS)
+            add_dependencies(dependencies, arguments, LAYOUT_DEPENDENCY)
+            add_dependencies(dependencies, arguments, RENDER_ARGUMENTS)
           end
 
-          render_dependencies.uniq
+          dependencies
         end
 
         def add_dependencies(render_dependencies, arguments, pattern)
@@ -116,12 +116,33 @@ def add_dynamic_dependency(dependencies, dependency)
         end
 
         def add_static_dependency(dependencies, dependency, quote_type)
-          if quote_type == '"'
-            # Ignore if there is interpolation
-            return if dependency.include?('#{')
-          end
+          if quote_type == '"' && dependency.include?('#{')
+            scanner = StringScanner.new(dependency)
 
-          if dependency
+            wildcard_dependency = +""
+
+            while !scanner.eos?
+              next unless scanner.scan_until(/\#{/)
+
+              unmatched_brackets = 1
+              wildcard_dependency << scanner.pre_match
+
+              while unmatched_brackets > 0 && !scanner.eos?
+                scanner.scan_until(/[{}]/)
+
+                case scanner.matched
+                when "{"
+                  unmatched_brackets += 1
+                when "}"
+                  unmatched_brackets -= 1
+                end
+              end
+
+              wildcard_dependency << "*"
+            end
+
+            dependencies << wildcard_dependency
+          elsif dependency
             if dependency.include?("/")
               dependencies << dependency
             else
@@ -130,24 +151,8 @@ def add_static_dependency(dependencies, dependency, quote_type)
           end
         end
 
-        def resolve_directories(wildcard_dependencies)
-          return [] unless @view_paths
-          return [] if wildcard_dependencies.empty?
-
-          # Remove trailing "/*"
-          prefixes = wildcard_dependencies.map { |query| query[0..-3] }
-
-          @view_paths.flat_map(&:all_template_paths).uniq.filter_map { |path|
-            path.to_s if prefixes.include?(path.prefix)
-          }.sort
-        end
-
         def explicit_dependencies
-          dependencies = source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
-
-          wildcards, explicits = dependencies.partition { |dependency| dependency.end_with?("/*") }
-
-          (explicits + resolve_directories(wildcards)).uniq
+          source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
         end
     end
   end

actionview/lib/action_view/dependency_tracker/ruby_tracker.rb

@@ -10,7 +10,7 @@ def self.call(name, template, view_paths = nil)
       end
 
       def dependencies
-        render_dependencies + explicit_dependencies
+        WildcardResolver.new(view_paths, render_dependencies + explicit_dependencies).resolve
       end
 
       def self.supports_view_paths? # :nodoc:
@@ -31,29 +31,12 @@ def render_dependencies
           compiled_source = template.handler.call(template, template.source)
 
           @parser_class.new(@name, compiled_source).render_calls.filter_map do |render_call|
-            next if render_call.end_with?("/_")
             render_call.gsub(%r|/_|, "/")
           end
         end
 
         def explicit_dependencies
-          dependencies = template.source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
-
-          wildcards, explicits = dependencies.partition { |dependency| dependency.end_with?("/*") }
-
-          (explicits + resolve_directories(wildcards)).uniq
-        end
-
-        def resolve_directories(wildcard_dependencies)
-          return [] unless view_paths
-          return [] if wildcard_dependencies.empty?
-
-          # Remove trailing "/*"
-          prefixes = wildcard_dependencies.map { |query| query[0..-3] }
-
-          view_paths.flat_map(&:all_template_paths).uniq.filter_map { |path|
-            path.to_s if prefixes.include?(path.prefix)
-          }.sort
+          template.source.scan(EXPLICIT_DEPENDENCY).flatten.uniq
         end
     end
   end

actionview/lib/action_view/dependency_tracker/wildcard_resolver.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActionView
+  class DependencyTracker # :nodoc:
+    class WildcardResolver # :nodoc:
+      def initialize(view_paths, dependencies)
+        @view_paths = view_paths
+
+        @wildcard_dependencies, @explicit_dependencies =
+          dependencies.partition { |dependency| dependency.end_with?("/*") }
+      end
+
+      def resolve
+        return explicit_dependencies.uniq if !view_paths || wildcard_dependencies.empty?
+
+        (explicit_dependencies + resolved_wildcard_dependencies).uniq
+      end
+
+      private
+        attr_reader :explicit_dependencies, :wildcard_dependencies, :view_paths
+
+        def resolved_wildcard_dependencies
+          # Remove trailing "/*"
+          prefixes = wildcard_dependencies.map { |query| query[0..-3] }
+
+          view_paths.flat_map(&:all_template_paths).uniq.filter_map { |path|
+            path.to_s if prefixes.include?(path.prefix)
+          }.sort
+        end
+    end
+  end
+end

actionview/lib/action_view/helpers/cache_helper.rb

@@ -93,6 +93,14 @@ class UncacheableFragmentError < StandardError; end
       #   render partial: 'attachments/attachment', collection: group_of_attachments
       #   render partial: 'documents/document', collection: @project.documents.where(published: true).order('created_at')
       #
+      # One last type of dependency can be determined implicitly:
+      #
+      #   render "maintenance_tasks/runs/info/#{run.status}"
+      #
+      # Because the value passed to render ends in interpolation, Action View
+      # will mark all partials within the "maintenace_tasks/runs/info" folder as
+      # dependencies.
+      #
       # === Explicit dependencies
       #
       # Sometimes you'll have template dependencies that can't be derived at all. This is typically

actionview/lib/action_view/render_parser/prism_render_parser.rb

@@ -97,9 +97,21 @@ def render_call_options(node)
         def render_call_template(node)
           object_template = false
           template =
-            if node.is_a?(Prism::StringNode)
+            case node.type
+            when :string_node
               path = node.unescaped
               path.include?("/") ? path : "#{directory}/#{path}"
+            when :interpolated_string_node
+              node.parts.map do |node|
+                case node.type
+                when :string_node
+                  node.unescaped
+                when :embedded_statements_node
+                  "*"
+                else
+                  return
+                end
+              end.join("")
             else
               dependency =
                 case node.type

actionview/lib/action_view/render_parser/ripper_render_parser.rb

@@ -66,7 +66,16 @@ def call_method_name
 
         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?

actionview/test/template/dependency_tracker_test.rb

@@ -223,19 +223,31 @@ def test_dependencies_with_interpolation
 
     assert_equal ["single/\#{quote}"], tracker.dependencies
   end
+
+  def test_dependencies_with_interpolation_are_resolved_with_view_paths
+    view_paths = ActionView::PathSet.new([File.expand_path("../fixtures/digestor", __dir__)])
+
+    template = FakeTemplate.new(%q{
+      <%= render "events/#{quote}" %>
+    }, :erb)
+
+    tracker = make_tracker("interpolation/_string", template, view_paths)
+
+    assert_equal ["events/_completed", "events/_event", "events/index"], tracker.dependencies
+  end
 end
 
 class ERBTrackerTest < ActiveSupport::TestCase
   include SharedTrackerTests
 
-  def make_tracker(name, template)
-    ActionView::DependencyTracker::ERBTracker.new(name, template)
+  def make_tracker(name, template, view_paths = nil)
+    ActionView::DependencyTracker::ERBTracker.new(name, template, view_paths)
   end
 end
 
 module RubyTrackerTests
-  def make_tracker(name, template)
-    ActionView::DependencyTracker::RubyTracker.new(name, template, parser_class: parser_class)
+  def make_tracker(name, template, view_paths = nil)
+    ActionView::DependencyTracker::RubyTracker.new(name, template, view_paths, parser_class: parser_class)
   end
 
   def test_dependencies_skip_unknown_options