@nx/gradle 21.0.0-beta.1 → 21.0.0-beta.11

package/src/migrations/19-4-0/add-project-report-all.js

@@ -1,10 +1,91 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = update;
-const init_1 = require("../../generators/init/init");
+exports.addBuildGradleFileNextToSettingsGradle = addBuildGradleFileNextToSettingsGradle;
+const devkit_1 = require("@nx/devkit");
+const node_path_1 = require("node:path");
 /**
  * This migration adds task `projectReportAll` to build.gradle files
  */
 async function update(tree) {
-    await (0, init_1.addBuildGradleFileNextToSettingsGradle)(tree);
+    await addBuildGradleFileNextToSettingsGradle(tree);
+}
+/**
+ * This function creates and populate build.gradle file next to the settings.gradle file.
+ */
+async function addBuildGradleFileNextToSettingsGradle(tree) {
+    const settingsGradleFiles = await (0, devkit_1.globAsync)(tree, [
+        '**/settings.gradle?(.kts)',
+    ]);
+    settingsGradleFiles.forEach((settingsGradleFile) => {
+        addProjectReportToBuildGradle(settingsGradleFile, tree);
+    });
+}
+/**
+ * - creates a build.gradle file next to the settings.gradle file if it does not exist.
+ * - adds the project-report plugin to the build.gradle file if it does not exist.
+ * - adds a task to generate project reports for all subprojects and included builds.
+ */
+function addProjectReportToBuildGradle(settingsGradleFile, tree) {
+    const filename = (0, node_path_1.basename)(settingsGradleFile);
+    let gradleFilePath = 'build.gradle';
+    if (filename.endsWith('.kts')) {
+        gradleFilePath = 'build.gradle.kts';
+    }
+    gradleFilePath = (0, node_path_1.join)((0, node_path_1.dirname)(settingsGradleFile), gradleFilePath);
+    let buildGradleContent = '';
+    if (!tree.exists(gradleFilePath)) {
+        tree.write(gradleFilePath, buildGradleContent); // create a build.gradle file near settings.gradle file if it does not exist
+    }
+    else {
+        buildGradleContent = tree.read(gradleFilePath).toString();
+    }
+    if (buildGradleContent.includes('allprojects')) {
+        if (!buildGradleContent.includes('"project-report"')) {
+            devkit_1.logger.warn(`Please add the project-report plugin to your ${gradleFilePath}:
+allprojects {
+  apply {
+      plugin("project-report")
+  }
+}`);
+        }
+    }
+    else {
+        buildGradleContent += `\n\rallprojects {
+  apply {
+      plugin("project-report")
+  }
+}`;
+    }
+    if (!buildGradleContent.includes(`tasks.register("projectReportAll")`)) {
+        if (gradleFilePath.endsWith('.kts')) {
+            buildGradleContent += `\n\rtasks.register("projectReportAll") {
+    // All project reports of subprojects
+    allprojects.forEach {
+        dependsOn(it.tasks.get("projectReport"))
+    }
+
+    // All projectReportAll of included builds
+    gradle.includedBuilds.forEach {
+        dependsOn(it.task(":projectReportAll"))
+    }
+}`;
+        }
+        else {
+            buildGradleContent += `\n\rtasks.register("projectReportAll") {
+        // All project reports of subprojects
+        allprojects.forEach {
+            dependsOn(it.tasks.getAt("projectReport"))
+        }
+    
+        // All projectReportAll of included builds
+        gradle.includedBuilds.forEach {
+            dependsOn(it.task(":projectReportAll"))
+        }
+    }`;
+        }
+    }
+    if (buildGradleContent) {
+        tree.write(gradleFilePath, buildGradleContent);
+    }
 }

package/src/migrations/21-0-0/change-plugin-to-v1.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): void;

package/src/migrations/21-0-0/change-plugin-to-v1.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const has_gradle_plugin_1 = require("../../utils/has-gradle-plugin");
+/* This function changes the plugin to v1
+ * Replace @nx/gradle with @nx/gradle/plugin-v1
+ */
+function update(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    if (!nxJson) {
+        return;
+    }
+    if (!(0, has_gradle_plugin_1.hasGradlePlugin)(tree)) {
+        return;
+    }
+    let gradlePluginIndex = nxJson.plugins.findIndex((p) => typeof p === 'string' ? p === '@nx/gradle' : p.plugin === '@nx/gradle');
+    let gradlePlugin = nxJson.plugins[gradlePluginIndex];
+    if (typeof gradlePlugin === 'string') {
+        nxJson.plugins[gradlePluginIndex] = '@nx/gradle/plugin-v1';
+    }
+    else {
+        gradlePlugin.plugin = '@nx/gradle/plugin-v1';
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}

package/src/plugin/dependencies.d.ts

@@ -1,2 +1,3 @@
 import { CreateDependencies } from '@nx/devkit';
-export declare const createDependencies: CreateDependencies;
+import { GradlePluginOptions } from './utils/gradle-plugin-options';
+export declare const createDependencies: CreateDependencies<GradlePluginOptions>;

package/src/plugin/dependencies.js

@@ -3,60 +3,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDependencies = void 0;
 const devkit_1 = require("@nx/devkit");
 const node_path_1 = require("node:path");
-const get_gradle_report_1 = require("../utils/get-gradle-report");
+const get_project_graph_from_gradle_plugin_1 = require("./utils/get-project-graph-from-gradle-plugin");
 const split_config_files_1 = require("../utils/split-config-files");
-const createDependencies = async (_, context) => {
-    const gradleFiles = findGradleFiles(context.filesToProcess);
-    if (gradleFiles.length === 0) {
-        return [];
-    }
-    const gradleDependenciesStart = performance.mark('gradleDependencies:start');
-    const { gradleFileToGradleProjectMap, gradleProjectNameToProjectRootMap, buildFileToDepsMap, gradleProjectToChildProjects, } = (0, get_gradle_report_1.getCurrentGradleReport)();
-    const dependencies = new Set();
-    for (const gradleFile of gradleFiles) {
-        const gradleProject = gradleFileToGradleProjectMap.get(gradleFile);
-        const projectName = Object.values(context.projects).find((project) => project.root === (0, node_path_1.dirname)(gradleFile))?.name;
-        const dependedProjects = buildFileToDepsMap.get(gradleFile);
-        if (projectName && dependedProjects?.size) {
-            dependedProjects?.forEach((dependedProject) => {
-                const targetProjectRoot = gradleProjectNameToProjectRootMap.get(dependedProject);
-                const targetProjectName = Object.values(context.projects).find((project) => project.root === targetProjectRoot)?.name;
-                const dependency = {
-                    source: projectName,
-                    target: targetProjectName,
-                    type: devkit_1.DependencyType.static,
-                    sourceFile: gradleFile,
-                };
-                (0, devkit_1.validateDependency)(dependency, context);
-                dependencies.add(dependency);
-            });
-        }
-        gradleProjectToChildProjects.get(gradleProject)?.forEach((childProject) => {
-            if (childProject) {
-                const dependency = {
-                    source: projectName,
-                    target: childProject,
-                    type: devkit_1.DependencyType.static,
-                    sourceFile: gradleFile,
-                };
-                (0, devkit_1.validateDependency)(dependency, context);
-                dependencies.add(dependency);
+const workspace_context_1 = require("nx/src/utils/workspace-context");
+const createDependencies = async (options, context) => {
+    const files = await (0, workspace_context_1.globWithWorkspaceContext)(devkit_1.workspaceRoot, Array.from(split_config_files_1.GRALDEW_FILES));
+    const { gradlewFiles } = (0, split_config_files_1.splitConfigFiles)(files);
+    await (0, get_project_graph_from_gradle_plugin_1.populateProjectGraph)(context.workspaceRoot, gradlewFiles.map((file) => (0, node_path_1.join)(devkit_1.workspaceRoot, file)), options);
+    const { dependencies: dependenciesFromReport } = (0, get_project_graph_from_gradle_plugin_1.getCurrentProjectGraphReport)();
+    const dependencies = [];
+    dependenciesFromReport.forEach((dependencyFromPlugin) => {
+        try {
+            const source = (0, node_path_1.relative)(devkit_1.workspaceRoot, dependencyFromPlugin.source) || '.';
+            const sourceProjectName = Object.values(context.projects).find((project) => source === project.root)?.name ?? dependencyFromPlugin.source;
+            const target = (0, node_path_1.relative)(devkit_1.workspaceRoot, dependencyFromPlugin.target) || '.';
+            const targetProjectName = Object.values(context.projects).find((project) => target === project.root)?.name ?? dependencyFromPlugin.target;
+            if (!sourceProjectName || !targetProjectName) {
+                return;
             }
-        });
-    }
-    const gradleDependenciesEnd = performance.mark('gradleDependencies:end');
-    performance.measure('gradleDependencies', gradleDependenciesStart.name, gradleDependenciesEnd.name);
-    return Array.from(dependencies);
+            const dependency = {
+                source: sourceProjectName,
+                target: targetProjectName,
+                type: devkit_1.DependencyType.static,
+                sourceFile: (0, devkit_1.normalizePath)((0, node_path_1.relative)(devkit_1.workspaceRoot, dependencyFromPlugin.sourceFile)),
+            };
+            (0, devkit_1.validateDependency)(dependency, context);
+            dependencies.push(dependency);
+        }
+        catch {
+            devkit_1.logger.warn(`Unable to parse dependency from gradle plugin: ${dependencyFromPlugin.source} -> ${dependencyFromPlugin.target}`);
+        }
+    });
+    return dependencies;
 };
 exports.createDependencies = createDependencies;
-function findGradleFiles(fileMap) {
-    const gradleFiles = [];
-    for (const [_, files] of Object.entries(fileMap.projectFileMap)) {
-        for (const file of files) {
-            if (split_config_files_1.GRADLE_BUILD_FILES.has((0, node_path_1.basename)(file.file))) {
-                gradleFiles.push(file.file);
-            }
-        }
-    }
-    return gradleFiles;
-}

package/src/plugin/nodes.d.ts

@@ -1,20 +1,7 @@
-import { CreateNodes, CreateNodesV2, ProjectConfiguration, CreateNodesFunction } from '@nx/devkit';
-import { GradleReport } from '../utils/get-gradle-report';
-export interface GradlePluginOptions {
-    includeSubprojectsTasks?: boolean;
-    ciTargetName?: string;
-    testTargetName?: string;
-    classesTargetName?: string;
-    buildTargetName?: string;
-    [taskTargetName: string]: string | undefined | boolean;
-}
+import { CreateNodesV2, ProjectConfiguration, CreateNodesFunction, ProjectGraphExternalNode } from '@nx/devkit';
+import { GradlePluginOptions } from './utils/gradle-plugin-options';
 type GradleTargets = Record<string, Partial<ProjectConfiguration>>;
 export declare function writeTargetsToCache(cachePath: string, results: GradleTargets): void;
 export declare const createNodesV2: CreateNodesV2<GradlePluginOptions>;
-export declare const makeCreateNodesForGradleConfigFile: (gradleReport: GradleReport, targetsCache?: GradleTargets, gradleProjectRootToTestFilesMap?: Record<string, string[]>) => CreateNodesFunction;
-/**
- @deprecated This is replaced with {@link createNodesV2}. Update your plugin to export its own `createNodesV2` function that wraps this one instead.
-  This function will change to the v2 function in Nx 20.
- */
-export declare const createNodes: CreateNodes<GradlePluginOptions>;
+export declare const makeCreateNodesForGradleConfigFile: (projects: Record<string, Partial<ProjectConfiguration>>, projectsCache?: GradleTargets, externalNodes?: Record<string, ProjectGraphExternalNode>) => CreateNodesFunction;
 export {};

package/src/plugin/nodes.js

@@ -1,32 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodes = exports.makeCreateNodesForGradleConfigFile = exports.createNodesV2 = void 0;
+exports.makeCreateNodesForGradleConfigFile = exports.createNodesV2 = void 0;
 exports.writeTargetsToCache = writeTargetsToCache;
 const devkit_1 = require("@nx/devkit");
 const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
-const devkit_internals_1 = require("nx/src/devkit-internals");
-const get_gradle_report_1 = require("../utils/get-gradle-report");
 const file_hasher_1 = require("nx/src/hasher/file-hasher");
 const split_config_files_1 = require("../utils/split-config-files");
-const exec_gradle_1 = require("../utils/exec-gradle");
-const cacheableTaskType = new Set(['Build', 'Verification']);
-const dependsOnMap = {
-    build: ['^build', 'classes', 'test'],
-    testClasses: ['classes'],
-    test: ['testClasses'],
-    classes: ['^classes'],
-};
-function normalizeOptions(options) {
-    options ??= {};
-    options.testTargetName ??= 'test';
-    options.classesTargetName ??= 'classes';
-    options.buildTargetName ??= 'build';
-    return options;
-}
-function readTargetsCache(cachePath) {
+const get_project_graph_from_gradle_plugin_1 = require("./utils/get-project-graph-from-gradle-plugin");
+const gradle_plugin_options_1 = require("./utils/gradle-plugin-options");
+function readProjectsCache(cachePath) {
     return (0, node_fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
 }
 function writeTargetsToCache(cachePath, results) {
@@ -35,232 +20,41 @@ function writeTargetsToCache(cachePath, results) {
 exports.createNodesV2 = [
     split_config_files_1.gradleConfigAndTestGlob,
     async (files, options, context) => {
-        const { buildFiles, projectRoots, gradlewFiles, testFiles } = (0, split_config_files_1.splitConfigFiles)(files);
+        const { buildFiles, gradlewFiles } = (0, split_config_files_1.splitConfigFiles)(files);
         const optionsHash = (0, file_hasher_1.hashObject)(options);
         const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `gradle-${optionsHash}.hash`);
-        const targetsCache = readTargetsCache(cachePath);
-        await (0, get_gradle_report_1.populateGradleReport)(context.workspaceRoot, gradlewFiles.map((f) => (0, node_path_1.join)(context.workspaceRoot, f)));
-        const gradleReport = (0, get_gradle_report_1.getCurrentGradleReport)();
-        const gradleProjectRootToTestFilesMap = getGradleProjectRootToTestFilesMap(testFiles, projectRoots);
+        const projectsCache = readProjectsCache(cachePath);
+        await (0, get_project_graph_from_gradle_plugin_1.populateProjectGraph)(context.workspaceRoot, gradlewFiles.map((f) => (0, node_path_1.join)(context.workspaceRoot, f)), options);
+        const { nodes, externalNodes } = (0, get_project_graph_from_gradle_plugin_1.getCurrentProjectGraphReport)();
         try {
-            return (0, devkit_1.createNodesFromFiles)((0, exports.makeCreateNodesForGradleConfigFile)(gradleReport, targetsCache, gradleProjectRootToTestFilesMap), buildFiles, options, context);
+            return (0, devkit_1.createNodesFromFiles)((0, exports.makeCreateNodesForGradleConfigFile)(nodes, projectsCache, externalNodes), buildFiles, options, context);
         }
         finally {
-            writeTargetsToCache(cachePath, targetsCache);
+            writeTargetsToCache(cachePath, projectsCache);
         }
     },
 ];
-const makeCreateNodesForGradleConfigFile = (gradleReport, targetsCache = {}, gradleProjectRootToTestFilesMap = {}) => async (gradleFilePath, options, context) => {
+const makeCreateNodesForGradleConfigFile = (projects, projectsCache = {}, externalNodes = {}) => async (gradleFilePath, options, context) => {
+    if (process.env.VERCEL) {
+        // Vercel does not allow JAVA_VERSION to be set
+        // skip on Vercel
+        return {};
+    }
     const projectRoot = (0, node_path_1.dirname)(gradleFilePath);
-    options = normalizeOptions(options);
+    options = (0, gradle_plugin_options_1.normalizeOptions)(options);
     const hash = await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options ?? {}, context);
-    targetsCache[hash] ??= await createGradleProject(gradleReport, gradleFilePath, options, context, gradleProjectRootToTestFilesMap[projectRoot]);
-    const project = targetsCache[hash];
+    projectsCache[hash] ??=
+        projects[projectRoot] ?? projects[(0, node_path_1.join)(devkit_1.workspaceRoot, projectRoot)];
+    const project = projectsCache[hash];
     if (!project) {
         return {};
     }
+    project.root = projectRoot;
     return {
         projects: {
             [projectRoot]: project,
         },
+        externalNodes: externalNodes,
     };
 };
 exports.makeCreateNodesForGradleConfigFile = makeCreateNodesForGradleConfigFile;
-/**
- @deprecated This is replaced with {@link createNodesV2}. Update your plugin to export its own `createNodesV2` function that wraps this one instead.
-  This function will change to the v2 function in Nx 20.
- */
-exports.createNodes = [
-    split_config_files_1.gradleConfigGlob,
-    async (buildFile, options, context) => {
-        devkit_1.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
-        const { gradlewFiles } = (0, split_config_files_1.splitConfigFiles)(context.configFiles);
-        await (0, get_gradle_report_1.populateGradleReport)(context.workspaceRoot, gradlewFiles);
-        const gradleReport = (0, get_gradle_report_1.getCurrentGradleReport)();
-        const internalCreateNodes = (0, exports.makeCreateNodesForGradleConfigFile)(gradleReport);
-        return await internalCreateNodes(buildFile, options, context);
-    },
-];
-async function createGradleProject(gradleReport, gradleFilePath, options, context, testFiles = []) {
-    try {
-        const { gradleProjectToTasksTypeMap, gradleProjectToTasksMap, gradleFileToOutputDirsMap, gradleFileToGradleProjectMap, gradleProjectToProjectName, } = gradleReport;
-        const gradleProject = gradleFileToGradleProjectMap.get(gradleFilePath);
-        const projectName = gradleProjectToProjectName.get(gradleProject);
-        if (!projectName) {
-            return;
-        }
-        const tasksTypeMap = gradleProjectToTasksTypeMap.get(gradleProject);
-        const tasksSet = gradleProjectToTasksMap.get(gradleProject);
-        let tasks = [];
-        tasksSet.forEach((taskName) => {
-            tasks.push({
-                type: tasksTypeMap?.get(taskName),
-                name: taskName,
-            });
-        });
-        if (options.includeSubprojectsTasks) {
-            tasksTypeMap.forEach((taskType, taskName) => {
-                if (!tasksSet.has(taskName)) {
-                    tasks.push({
-                        type: taskType,
-                        name: taskName,
-                    });
-                }
-            });
-        }
-        const outputDirs = gradleFileToOutputDirsMap.get(gradleFilePath);
-        const { targets, targetGroups } = await createGradleTargets(tasks, options, context, outputDirs, gradleProject, gradleFilePath, testFiles);
-        const project = {
-            name: projectName,
-            projectType: 'application',
-            targets,
-            metadata: {
-                targetGroups,
-                technologies: ['gradle'],
-            },
-        };
-        return project;
-    }
-    catch (e) {
-        console.error(e);
-        return undefined;
-    }
-}
-async function createGradleTargets(tasks, options, context, outputDirs, gradleProject, gradleBuildFilePath, testFiles = []) {
-    const inputsMap = createInputsMap(context);
-    const gradlewFileDirectory = (0, node_path_1.dirname)((0, exec_gradle_1.findGraldewFile)(gradleBuildFilePath, context.workspaceRoot));
-    const targets = {};
-    const targetGroups = {};
-    for (const task of tasks) {
-        const targetName = options?.[`${task.name}TargetName`] ?? task.name;
-        let outputs = [outputDirs.get(task.name)].filter(Boolean);
-        if (task.name === 'test') {
-            outputs = [
-                outputDirs.get('testReport'),
-                outputDirs.get('testResults'),
-            ].filter(Boolean);
-            getTestCiTargets(testFiles, gradleProject, targetName, options.ciTargetName, inputsMap['test'], outputs, task.type, targets, targetGroups, gradlewFileDirectory);
-        }
-        const taskCommandToRun = `${gradleProject ? gradleProject + ':' : ''}${task.name}`;
-        targets[targetName] = {
-            command: `${(0, exec_gradle_1.getGradleExecFile)()} ${taskCommandToRun}`,
-            options: {
-                cwd: gradlewFileDirectory,
-            },
-            cache: cacheableTaskType.has(task.type),
-            inputs: inputsMap[task.name],
-            dependsOn: dependsOnMap[task.name],
-            metadata: {
-                technologies: ['gradle'],
-                help: {
-                    command: `${(0, exec_gradle_1.getGradleExecFile)()} help --task ${taskCommandToRun}`,
-                    example: {
-                        options: {
-                            args: ['--rerun'],
-                        },
-                    },
-                },
-            },
-            ...(outputs && outputs.length ? { outputs } : {}),
-        };
-        if (task.type) {
-            if (!targetGroups[task.type]) {
-                targetGroups[task.type] = [];
-            }
-            targetGroups[task.type].push(targetName);
-        }
-    }
-    return { targetGroups, targets };
-}
-function createInputsMap(context) {
-    const namedInputs = context.nxJsonConfiguration.namedInputs;
-    return {
-        build: namedInputs?.production
-            ? ['production', '^production']
-            : ['default', '^default'],
-        test: ['default', namedInputs?.production ? '^production' : '^default'],
-        classes: namedInputs?.production
-            ? ['production', '^production']
-            : ['default', '^default'],
-    };
-}
-function getTestCiTargets(testFiles, gradleProject, testTargetName, ciTargetName, inputs, outputs, targetGroupName, targets, targetGroups, gradlewFileDirectory) {
-    if (!testFiles || testFiles.length === 0 || !ciTargetName) {
-        return;
-    }
-    const taskCommandToRun = `${gradleProject ? gradleProject + ':' : ''}test`;
-    if (!targetGroups[targetGroupName]) {
-        targetGroups[targetGroupName] = [];
-    }
-    const dependsOn = [];
-    testFiles.forEach((testFile) => {
-        const testName = (0, node_path_1.basename)(testFile).split('.')[0];
-        const targetName = ciTargetName + '--' + testName;
-        targets[targetName] = {
-            command: `${(0, exec_gradle_1.getGradleExecFile)()} ${taskCommandToRun} --tests ${testName}`,
-            options: {
-                cwd: gradlewFileDirectory,
-            },
-            cache: true,
-            inputs,
-            dependsOn: dependsOnMap['test'],
-            metadata: {
-                technologies: ['gradle'],
-                description: `Runs Gradle test ${testFile} in CI`,
-                help: {
-                    command: `${(0, exec_gradle_1.getGradleExecFile)()} help --task ${taskCommandToRun}`,
-                    example: {
-                        options: {
-                            args: ['--rerun'],
-                        },
-                    },
-                },
-            },
-            ...(outputs && outputs.length > 0 ? { outputs } : {}),
-        };
-        targetGroups[targetGroupName].push(targetName);
-        dependsOn.push({
-            target: targetName,
-            projects: 'self',
-            params: 'forward',
-        });
-    });
-    targets[ciTargetName] = {
-        executor: 'nx:noop',
-        cache: true,
-        inputs,
-        dependsOn: dependsOn,
-        ...(outputs && outputs.length > 0 ? { outputs } : {}),
-        metadata: {
-            technologies: ['gradle'],
-            description: 'Runs Gradle Tests in CI',
-            nonAtomizedTarget: testTargetName,
-            help: {
-                command: `${(0, exec_gradle_1.getGradleExecFile)()} help --task ${taskCommandToRun}`,
-                example: {
-                    options: {
-                        args: ['--rerun'],
-                    },
-                },
-            },
-        },
-    };
-    targetGroups[targetGroupName].push(ciTargetName);
-}
-function getGradleProjectRootToTestFilesMap(testFiles, projectRoots) {
-    if (testFiles.length === 0 || projectRoots.length === 0) {
-        return;
-    }
-    const roots = new Map(projectRoots.map((root) => [root, root]));
-    const testFilesToGradleProjectMap = {};
-    testFiles.forEach((testFile) => {
-        const projectRoot = (0, devkit_internals_1.findProjectForPath)(testFile, roots);
-        if (projectRoot) {
-            if (!testFilesToGradleProjectMap[projectRoot]) {
-                testFilesToGradleProjectMap[projectRoot] = [];
-            }
-            testFilesToGradleProjectMap[projectRoot].push(testFile);
-        }
-    });
-    return testFilesToGradleProjectMap;
-}

package/src/plugin/utils/__mocks__/gradle_composite.json

@@ -0,0 +1,38 @@
+{
+  "nodes": {
+    "nested/nested/proj": {
+      "targets": {
+        "buildEnvironment": {
+          "cache": true,
+          "metadata": {
+            "description": "Displays all buildscript dependencies declared in root project \u0027my-composite\u0027.",
+            "technologies": ["gradle"]
+          },
+          "command": "./gradlew :buildEnvironment",
+          "options": {
+            "cwd": "nested/nested/proj"
+          }
+        }
+      },
+      "metadata": {
+        "targetGroups": {
+          "help": ["buildEnvironment"]
+        },
+        "technologies": ["gradle"]
+      },
+      "name": "my-composite"
+    }
+  },
+  "dependencies": [
+    {
+      "source": "nested/nested/proj",
+      "target": "projectRoot/my-app",
+      "sourceFile": "projectRoot/build.gradle.kts"
+    },
+    {
+      "source": "nested/nested/proj",
+      "target": "projectRoot/my-utils",
+      "sourceFile": "projectRoot/build.gradle.kts"
+    }
+  ]
+}