Merge pull request #2770 from ViewComponent/joelhawksley-fix-interpolated-render-dependencies

Fix unresolvable interpolated render dependencies

Author: joelhawksley

docs/CHANGELOG.md

@@ -10,6 +10,10 @@ nav_order: 6
 
 ## main
 
+* Avoid missing-template digest errors for unresolvable interpolated render paths in components and included helpers.
+
+    *Joel Hawksley*
+
 * Cover shared helper dependencies in the boot benchmark and add a cold cache digest benchmark to the CI performance check.
 
     *Joel Hawksley*

lib/view_component/cache_digest.rb

@@ -457,20 +457,29 @@ def partial_paths_in(source, name)
       # Dynamic renders can return components without naming their classes,
       # such as `render UI.button`. Keep Action View's guess only if it resolves,
       # without executing application methods to discover what they return.
+      # Interpolated paths are discarded if Rails cannot expand their wildcards.
       def unresolved_partials_rendered_by(calls, name, view_paths)
-        return [] unless view_paths
-
         targets = calls.flat_map { |call| render_targets(call) }
         literal, dynamic = targets.partition do |target|
           target.is_a?(Prism::StringNode) || target.is_a?(Prism::InterpolatedStringNode)
         end
-        return [] if dynamic.empty?
+        interpolated = literal.grep(Prism::InterpolatedStringNode)
+        unresolved = []
+        if interpolated.any?
+          paths = partial_paths_in(interpolated.map { |target| "render(#{target.slice})" }.join("\n"), name)
+          # Rails expands only directory wildcards with a literal prefix.
+          # Older parsers can return truncated paths without any wildcard.
+          unresolved = paths.reject { |path| path.match?(%r{\A[^*]+/\*\z}) }
+          static = literal.grep(Prism::StringNode)
+          unresolved -= partial_paths_in(static.map { |target| "render(#{target.slice})" }.join("\n"), name)
+        end
+        return unresolved unless view_paths && dynamic.any?
 
         inferred = partial_paths_in(dynamic.map { |target| "render(#{target.slice})" }.join("\n"), name)
         declared = partial_paths_in(literal.map { |target| "render(#{target.slice})" }.join("\n"), name)
         finder = ActionView::LookupContext.new(view_paths, variants: :any, locale: I18n.available_locales)
 
-        inferred.reject do |path|
+        unresolved | inferred.reject do |path|
           declared.include?(path) || finder.exists?(path, [], true)
         end
       end

lib/view_component/cache_digest/dependency_tracking.rb

@@ -35,6 +35,8 @@ def find_dependencies(name, template, view_paths = nil)
 
           component_paths, inferred_partials =
             CacheDigest.template_renders_in(CacheDigest.compiled_source(template), name, view_paths: view_paths)
+          # Older ERB trackers omit the underscore on unqualified partial paths.
+          inferred_partials |= inferred_partials.map { |path| path.delete_prefix("_") }
           declared = source.scan(CacheDigest::EXPLICIT_DEPENDENCY).flatten
 
           (dependencies - (inferred_partials - declared) + component_paths).uniq

test/sandbox/test/cacheable_test.rb

@@ -1137,6 +1137,40 @@ def test_existing_dynamic_partial_dependencies_are_kept
     )
   end
 
+  def test_unresolvable_interpolated_partial_dependencies_are_discarded
+    sources = [
+      "render(\"\#{path}/\#{association}_fields\")",
+      "render partial: \"\#{path}/\#{association}_fields\"",
+      "render_to_string \"\#{path}/\#{association}_fields\"",
+      "render \"buttons/\#{kind}_fields\"",
+      "render \"\#{path}/\#{name}\"",
+      "render \"\#{kind}_fields\""
+    ]
+
+    each_render_tracker do
+      sources.each do |source|
+        dependencies = ActionView::DependencyTracker.find_dependencies(
+          "test/template", build_template("<%= #{source} %>"), []
+        )
+
+        # Older ERB trackers leave interpolation markers, which the digestor skips.
+        assert_empty dependencies.reject { |path| path.include?("#") }, source
+        [nil, []].each do |view_paths|
+          assert_equal [[], []], ViewComponent::CacheDigest.renders_in(source, "test/template", view_paths: view_paths), source
+        end
+      end
+    end
+  end
+
+  def test_literal_wildcards_are_not_discarded_with_matching_interpolated_paths
+    source = "render \"buttons/*_fields\"; render \"buttons/\#{kind}_fields\""
+
+    assert_equal(
+      [[], ["buttons/*_fields"]],
+      ViewComponent::CacheDigest.renders_in(source, "test/template", view_paths: [])
+    )
+  end
+
   def test_existing_dynamic_partials_still_change_the_digest
     digests = %w[before after].map do |content|
       clear_digest_cache

test/sandbox/test/template_regression_test.rb

@@ -170,6 +170,62 @@ def test_render_parent_preserves_child_fragment_cache_identity
     end
   end
 
+  def test_precomputation_does_not_log_unresolvable_interpolated_helper_dependencies
+    with_component_files(
+      "interpolated_helper.rb" => <<~'RUBY',
+        module TemplateRegressionFixtures::InterpolatedHelper
+          def nested_fields(path, association)
+            render("#{path}/#{association}_fields")
+          end
+        end
+      RUBY
+      "base_component.rb" => <<~RUBY,
+        class TemplateRegressionFixtures::BaseComponent < ViewComponent::Base
+          include TemplateRegressionFixtures::InterpolatedHelper
+        end
+      RUBY
+      "greeting_component.rb" => "class TemplateRegressionFixtures::GreetingComponent < TemplateRegressionFixtures::BaseComponent; end",
+      "greeting_component.html.erb" => "<p>Hello</p>",
+      "control_component.rb" => "class TemplateRegressionFixtures::ControlComponent < ViewComponent::Base; end",
+      "control_component.html.erb" => "<%= render TemplateRegressionFixtures::GreetingComponent.new %>"
+    ) do
+      components = [TemplateRegressionFixtures::GreetingComponent, TemplateRegressionFixtures::ControlComponent]
+      components.each(&:__vc_compile)
+
+      ActionView::Digestor.logger.stub(:error, ->(message) { flunk message }) do
+        ViewComponent::CacheDigest.precompute!(components)
+      end
+
+      refute_includes components.first.__vc_cache_digest_source, "*/*_fields"
+      assert_includes components.last.__vc_cache_digest_source,
+        ViewComponent::CacheDigest.virtual_path_for(components.first)
+    end
+  end
+
+  def test_supported_interpolated_partial_edits_change_component_digest
+    parser = ViewComponent::CacheDigest::RENDER_PARSER.new("test/template", "render \"buttons/\#{kind}\"")
+    unless parser.render_calls.any? { |path| path.gsub(%r{/_}, "/") == "buttons/*" }
+      skip "Action View's render parser does not support interpolated directory wildcards"
+    end
+
+    with_component_files(
+      "wildcard_component.rb" => "class TemplateRegressionFixtures::WildcardComponent < ViewComponent::Base; end",
+      "wildcard_component.html.erb" => "<%= render \"buttons/\#{kind}\" %>",
+      "views/buttons/_button.html.erb" => "original partial"
+    ) do |directory|
+      component = TemplateRegressionFixtures::WildcardComponent
+      component.__vc_cache_digest_source = ViewComponent::CacheDigest::Resolver.instance.source_for(component).freeze
+      resolver = ActionView::FileSystemResolver.new(File.join(directory, "views"))
+      before = component.cache_digest(finder: ActionView::LookupContext.new([resolver]))
+
+      File.write(File.join(directory, "views/buttons/_button.html.erb"), "changed partial")
+      resolver.clear_cache
+      clear_digest_cache
+
+      refute_equal before, component.cache_digest(finder: ActionView::LookupContext.new([resolver]))
+    end
+  end
+
   def test_view_fragments_track_components_assigned_to_locals
     with_component_files(
       "leaf_component.rb" => "class TemplateRegressionFixtures::LeafComponent < ViewComponent::Base; end",