Restore recipe hierarchy rows in SourcesFileResults (#6764)

* Restore recipe hierarchy rows in SourcesFileResults

PR #6022 removed the recursive hierarchy recording in RecipeRunCycle to
fix non-summable estimatedTimeSaving values. This had the side effect of
breaking the Sankey visualization, which needs (parentRecipe, recipe)
rows at every level to draw the full drill-down from top-level recipes
through to leaf recipes that made changes.

Restore the recursive recordSourceFileResult() method but pass 0 for
estimatedTimeSaving on hierarchy rows, so that only leaf recipes carry
effort values and the column remains summable.

* Document the purpose of the test

* Record why we show zero time savings

---------

Co-authored-by: Tim te Beek <tim@mac.home>

Author: timtebeek

rewrite-core/src/main/java/org/openrewrite/scheduling/RecipeRunCycle.java

@@ -261,6 +261,33 @@ protected void recordSourceFileResultAndSearchResults(@Nullable SourceFile befor
         for (SearchResults.Row searchResult : searchMarkers) {
             searchResults.insertRow(ctx, searchResult);
         }
+
+        if (hierarchical) {
+            recordSourceFileResult(beforePath, afterPath, recipeStack.subList(0, recipeStack.size() - 1), ctx);
+        }
+    }
+
+    private void recordSourceFileResult(@Nullable String beforePath, @Nullable String afterPath, List<Recipe> recipeStack, ExecutionContext ctx) {
+        if (recipeStack.size() <= 1) {
+            // No reason to record the synthetic root recipe which contains the recipe run
+            return;
+        }
+        String parentName;
+        if (recipeStack.size() == 2) {
+            // Record the parent name as blank rather than CompositeRecipe when the parent is the synthetic root recipe
+            parentName = "";
+        } else {
+            parentName = recipeStack.get(recipeStack.size() - 2).getName();
+        }
+        Recipe recipe = recipeStack.get(recipeStack.size() - 1);
+        sourcesFileResults.insertRow(ctx, new SourcesFileResults.Row(
+                beforePath,
+                afterPath,
+                parentName,
+                recipe.getName(),
+                0L, // Zero here, as we later sum only the recipes that themselves made changes
+                cycle));
+        recordSourceFileResult(beforePath, afterPath, recipeStack.subList(0, recipeStack.size() - 1), ctx);
     }
 
     private @Nullable SourceFile handleError(Recipe recipe, SourceFile sourceFile, @Nullable SourceFile after,

rewrite-core/src/test/java/org/openrewrite/table/SourceFileResultsTest.java

@@ -54,4 +54,49 @@ void hierarchical() {
           )
         );
     }
+
+    @Test
+    void deepHierarchyRecordsAllLevels() {
+        // Our Sankey visualization of recipe execution relies on the data table recording all levels of the hierarchy,
+        // not just the leaf recipes. This test ensures that the data table includes rows for both the parent and leaf
+        // recipes, even when the parent recipe doesn't directly perform any transformations (i.e., it has zero
+        // estimated time saving).
+        rewriteRun(
+          spec -> spec
+            .recipeFromYaml(
+                //language=yml
+                """
+                  type: specs.openrewrite.org/v1beta/recipe
+                  name: test.GrandParent
+                  displayName: Grand parent recipe
+                  description: Three-level hierarchy.
+                  recipeList:
+                    - test.Parent
+                  ---
+                  type: specs.openrewrite.org/v1beta/recipe
+                  name: test.Parent
+                  displayName: Parent recipe
+                  description: Middle level.
+                  recipeList:
+                    - org.openrewrite.text.ChangeText:
+                        toText: Hello!
+                  """,
+              "test.GrandParent"
+            ).dataTable(SourcesFileResults.Row.class, rows -> {
+                // Leaf recipe row + one hierarchy row for the parent recipe.
+                // The root recipe (GrandParent) doesn't get its own row but appears
+                // as the parent in production runs where a synthetic root wraps it.
+                assertThat(rows).hasSize(2);
+                assertThat(rows.get(0).getParentRecipe()).isEqualTo("test.Parent");
+                assertThat(rows.get(0).getRecipe()).isEqualTo("org.openrewrite.text.ChangeText");
+                // Hierarchy row with zero effort so the column remains summable
+                assertThat(rows.get(1).getRecipe()).isEqualTo("test.Parent");
+                assertThat(rows.get(1).getEstimatedTimeSaving()).isEqualTo(0L);
+            }),
+          text(
+            "Hi",
+            "Hello!"
+          )
+        );
+    }
 }