@nx/gradle 21.0.0-canary.20250423-16fc551 → 21.0.0-canary.20250424-e23b25f

package/src/plugin-v1/nodes.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = 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) {
+    return (0, node_fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
+}
+function writeTargetsToCache(cachePath, results) {
+    (0, devkit_1.writeJsonFile)(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 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);
+        try {
+            return (0, devkit_1.createNodesFromFiles)((0, exports.makeCreateNodesForGradleConfigFile)(gradleReport, targetsCache, gradleProjectRootToTestFilesMap), buildFiles, options, context);
+        }
+        finally {
+            writeTargetsToCache(cachePath, targetsCache);
+        }
+    },
+];
+const makeCreateNodesForGradleConfigFile = (gradleReport, targetsCache = {}, gradleProjectRootToTestFilesMap = {}) => async (gradleFilePath, options, context) => {
+    const projectRoot = (0, node_path_1.dirname)(gradleFilePath);
+    options = 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];
+    if (!project) {
+        return {};
+    }
+    return {
+        projects: {
+            [projectRoot]: project,
+        },
+    };
+};
+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.findGradlewFile)(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/{utils → plugin-v1/utils}/get-gradle-report.d.ts

@@ -1,7 +1,7 @@
 export interface GradleReport {
     gradleFileToGradleProjectMap: Map<string, string>;
-    buildFileToDepsMap: Map<string, Set<string>>;
     gradleFileToOutputDirsMap: Map<string, Map<string, string>>;
+    gradleProjectToDepsMap: Map<string, Set<string>>;
     gradleProjectToTasksTypeMap: Map<string, Map<string, string>>;
     gradleProjectToTasksMap: Map<string, Set<string>>;
     gradleProjectToProjectName: Map<string, string>;
@@ -11,7 +11,7 @@ export interface GradleReport {
 export interface GradleReportJSON {
     hash: string;
     gradleFileToGradleProjectMap: Record<string, string>;
-    buildFileToDepsMap: Record<string, Set<string>>;
+    gradleProjectToDepsMap: Record<string, Array<string>>;
     gradleFileToOutputDirsMap: Record<string, Record<string, string>>;
     gradleProjectToTasksTypeMap: Record<string, Record<string, string>>;
     gradleProjectToTasksMap: Record<string, Array<string>>;

package/src/{utils → plugin-v1/utils}/get-gradle-report.js

@@ -10,9 +10,10 @@ const node_path_1 = require("node:path");
 const devkit_1 = require("@nx/devkit");
 const workspace_context_1 = require("nx/src/utils/workspace-context");
 const path_1 = require("path");
-const split_config_files_1 = require("./split-config-files");
+const split_config_files_1 = require("../../utils/split-config-files");
 const get_project_report_lines_1 = require("./get-project-report-lines");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
+const exec_gradle_1 = require("../../utils/exec-gradle");
 function readGradleReportCache(cachePath, hash) {
     const gradleReportJson = (0, node_fs_1.existsSync)(cachePath)
         ? (0, devkit_1.readJsonFile)(cachePath)
@@ -22,7 +23,7 @@ function readGradleReportCache(cachePath, hash) {
     }
     let results = {
         gradleFileToGradleProjectMap: new Map(Object.entries(gradleReportJson['gradleFileToGradleProjectMap'])),
-        buildFileToDepsMap: new Map(Object.entries(gradleReportJson['buildFileToDepsMap'])),
+        gradleProjectToDepsMap: new Map(Object.entries(gradleReportJson['gradleProjectToDepsMap']).map(([key, value]) => [key, new Set(value)])),
         gradleFileToOutputDirsMap: new Map(Object.entries(gradleReportJson['gradleFileToOutputDirsMap']).map(([key, value]) => [key, new Map(Object.entries(value))])),
         gradleProjectToTasksTypeMap: new Map(Object.entries(gradleReportJson['gradleProjectToTasksTypeMap']).map(([key, value]) => [key, new Map(Object.entries(value))])),
         gradleProjectToTasksMap: new Map(Object.entries(gradleReportJson['gradleProjectToTasksMap']).map(([key, value]) => [key, new Set(value)])),
@@ -36,7 +37,10 @@ function writeGradleReportToCache(cachePath, results) {
     let gradleReportJson = {
         hash: gradleCurrentConfigHash,
         gradleFileToGradleProjectMap: Object.fromEntries(results.gradleFileToGradleProjectMap),
-        buildFileToDepsMap: Object.fromEntries(results.buildFileToDepsMap),
+        gradleProjectToDepsMap: Object.fromEntries(Array.from(results.gradleProjectToDepsMap).map(([key, value]) => [
+            key,
+            Array.from(value),
+        ])),
         gradleFileToOutputDirsMap: Object.fromEntries(Array.from(results.gradleFileToOutputDirsMap).map(([key, value]) => [
             key,
             Object.fromEntries(value),
@@ -105,7 +109,7 @@ function processProjectReports(projectReportLines) {
      * Map of Gradle File path to Gradle Project Name
      */
     const gradleFileToGradleProjectMap = new Map();
-    const dependenciesMap = new Map();
+    const gradleProjectToDepsMap = new Map();
     /**
      * Map of Gradle Build File to tasks type map
      */
@@ -113,10 +117,6 @@ function processProjectReports(projectReportLines) {
     const gradleProjectToTasksMap = new Map();
     const gradleProjectToProjectName = new Map();
     const gradleProjectNameToProjectRootMap = new Map();
-    /**
-     * Map of buildFile to dependencies report path
-     */
-    const buildFileToDepsMap = new Map();
     /**
      * Map fo possible output files of each gradle file
      * e.g. {build.gradle.kts: { projectReportDir: '' testReportDir: '' }}
@@ -133,21 +133,21 @@ function processProjectReports(projectReportLines) {
             if (line.endsWith(':dependencyReport')) {
                 const gradleProject = line.substring('> Task '.length, line.length - ':dependencyReport'.length);
                 while (index < projectReportLines.length &&
-                    !projectReportLines[index].includes(get_project_report_lines_1.fileSeparator)) {
+                    !projectReportLines[index].includes(exec_gradle_1.fileSeparator)) {
                     index++;
                 }
-                const [_, file] = projectReportLines[index].split(get_project_report_lines_1.fileSeparator);
-                dependenciesMap.set(gradleProject, file);
+                const [_, file] = projectReportLines[index].split(exec_gradle_1.fileSeparator);
+                gradleProjectToDepsMap.set(gradleProject, processGradleDependencies(file));
             }
             if (line.endsWith('propertyReport')) {
                 const gradleProject = line.substring('> Task '.length, line.length - ':propertyReport'.length);
                 while (index < projectReportLines.length &&
-                    !projectReportLines[index].includes(get_project_report_lines_1.fileSeparator)) {
+                    !projectReportLines[index].includes(exec_gradle_1.fileSeparator)) {
                     index++;
                 }
-                const [_, file] = projectReportLines[index].split(get_project_report_lines_1.fileSeparator);
+                const [_, file] = projectReportLines[index].split(exec_gradle_1.fileSeparator);
                 const propertyReportLines = (0, node_fs_1.existsSync)(file)
-                    ? (0, node_fs_1.readFileSync)(file).toString().split(get_project_report_lines_1.newLineSeparator)
+                    ? (0, node_fs_1.readFileSync)(file).toString().split(exec_gradle_1.newLineSeparator)
                     : [];
                 let projectName, absBuildFilePath, absBuildDirPath;
                 const outputDirMap = new Map();
@@ -185,10 +185,6 @@ function processProjectReports(projectReportLines) {
                 }
                 const buildFile = (0, devkit_1.normalizePath)((0, node_path_1.relative)(devkit_1.workspaceRoot, absBuildFilePath));
                 const buildDir = (0, node_path_1.relative)(devkit_1.workspaceRoot, absBuildDirPath);
-                const depsFile = dependenciesMap.get(gradleProject);
-                if (depsFile) {
-                    buildFileToDepsMap.set(buildFile, processGradleDependencies(depsFile));
-                }
                 outputDirMap.set('build', `{workspaceRoot}/${buildDir}`);
                 outputDirMap.set('classes', `{workspaceRoot}/${(0, node_path_1.join)(buildDir, 'classes')}`);
                 gradleFileToOutputDirsMap.set(buildFile, outputDirMap);
@@ -200,13 +196,13 @@ function processProjectReports(projectReportLines) {
             if (line.endsWith('taskReport')) {
                 const gradleProject = line.substring('> Task '.length, line.length - ':taskReport'.length);
                 while (index < projectReportLines.length &&
-                    !projectReportLines[index].includes(get_project_report_lines_1.fileSeparator)) {
+                    !projectReportLines[index].includes(exec_gradle_1.fileSeparator)) {
                     index++;
                 }
-                const [_, file] = projectReportLines[index].split(get_project_report_lines_1.fileSeparator);
+                const [_, file] = projectReportLines[index].split(exec_gradle_1.fileSeparator);
                 const taskTypeMap = new Map();
                 const tasksFileLines = (0, node_fs_1.existsSync)(file)
-                    ? (0, node_fs_1.readFileSync)(file).toString().split(get_project_report_lines_1.newLineSeparator)
+                    ? (0, node_fs_1.readFileSync)(file).toString().split(exec_gradle_1.newLineSeparator)
                     : [];
                 let i = 0;
                 while (i < tasksFileLines.length) {
@@ -233,9 +229,9 @@ function processProjectReports(projectReportLines) {
     }
     return {
         gradleFileToGradleProjectMap,
-        buildFileToDepsMap,
         gradleFileToOutputDirsMap,
         gradleProjectToTasksTypeMap,
+        gradleProjectToDepsMap,
         gradleProjectToTasksMap,
         gradleProjectToProjectName,
         gradleProjectNameToProjectRootMap,
@@ -244,7 +240,7 @@ function processProjectReports(projectReportLines) {
 }
 function processGradleDependencies(depsFile) {
     const dependedProjects = new Set();
-    const lines = (0, node_fs_1.readFileSync)(depsFile).toString().split(get_project_report_lines_1.newLineSeparator);
+    const lines = (0, node_fs_1.readFileSync)(depsFile).toString().split(exec_gradle_1.newLineSeparator);
     let inDeps = false;
     for (const line of lines) {
         if (line.startsWith('implementationDependenciesMetadata') ||

package/src/{utils → plugin-v1/utils}/get-project-report-lines.d.ts

@@ -1,5 +1,3 @@
-export declare const fileSeparator: string;
-export declare const newLineSeparator: string;
 /**
  * This function executes the gradle projectReportAll task and returns the output as an array of lines.
  * @param gradlewFile the absolute path to the gradlew file

package/src/{utils → plugin-v1/utils}/get-project-report-lines.js

@@ -1,15 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.newLineSeparator = exports.fileSeparator = void 0;
 exports.getProjectReportLines = getProjectReportLines;
 const devkit_1 = require("@nx/devkit");
-const exec_gradle_1 = require("./exec-gradle");
-exports.fileSeparator = process.platform.startsWith('win')
-    ? 'file:///'
-    : 'file://';
-exports.newLineSeparator = process.platform.startsWith('win')
-    ? '\r\n'
-    : '\n';
+const exec_gradle_1 = require("../../utils/exec-gradle");
 /**
  * This function executes the gradle projectReportAll task and returns the output as an array of lines.
  * @param gradlewFile the absolute path to the gradlew file
@@ -17,7 +10,6 @@ exports.newLineSeparator = process.platform.startsWith('win')
  */
 async function getProjectReportLines(gradlewFile) {
     let projectReportBuffer;
-    // Attempt to run projectReport or projectReportAll task, regardless of build.gradle or build.gradle.kts location
     try {
         projectReportBuffer = await (0, exec_gradle_1.execGradleAsync)(gradlewFile, [
             'projectReportAll',
@@ -62,7 +54,7 @@ async function getProjectReportLines(gradlewFile) {
     }
     const projectReportLines = projectReportBuffer
         .toString()
-        .split(exports.newLineSeparator)
+        .split(exec_gradle_1.newLineSeparator)
         .filter((line) => line.trim() !== '');
     if (process.env.NX_VERBOSE_LOGGING === 'true') {
         devkit_1.output.log({

package/src/utils/exec-gradle.d.ts

@@ -1,4 +1,6 @@
 import { ExecFileOptions } from 'node:child_process';
+export declare const fileSeparator: string;
+export declare const newLineSeparator: string;
 /**
  * For gradle command, it needs to be run from the directory of the gradle binary
  * @returns gradle binary file name
@@ -14,10 +16,10 @@ export declare function getGradleExecFile(): string;
 export declare function execGradleAsync(gradleBinaryPath: string, args: ReadonlyArray<string>, execOptions?: ExecFileOptions): Promise<Buffer>;
 /**
  * This function recursively finds the nearest gradlew file in the workspace
- * @param originalFileToSearch the original file to search for
+ * @param originalFileToSearch the original file to search for, relative to workspace root, file path not directory path
  * @param wr workspace root
  * @param currentSearchPath the path to start searching for gradlew file
  * @returns the relative path of the gradlew file to workspace root, throws an error if gradlew file is not found
- * It will return gradlew.bat file on windows and gradlew file on other platforms
+ * It will return relative path to workspace root of gradlew.bat file on windows and gradlew file on other platforms
  */
-export declare function findGraldewFile(originalFileToSearch: string, wr?: string, currentSearchPath?: string): string;
+export declare function findGradlewFile(originalFileToSearch: string, wr?: string, currentSearchPath?: string): string;

package/src/utils/exec-gradle.js

@@ -1,13 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.newLineSeparator = exports.fileSeparator = void 0;
 exports.getGradleExecFile = getGradleExecFile;
 exports.execGradleAsync = execGradleAsync;
-exports.findGraldewFile = findGraldewFile;
+exports.findGradlewFile = findGradlewFile;
 const devkit_1 = require("@nx/devkit");
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const run_commands_impl_1 = require("nx/src/executors/run-commands/run-commands.impl");
+exports.fileSeparator = process.platform.startsWith('win')
+    ? 'file:///'
+    : 'file://';
+exports.newLineSeparator = process.platform.startsWith('win')
+    ? '\r\n'
+    : '\n';
 /**
  * For gradle command, it needs to be run from the directory of the gradle binary
  * @returns gradle binary file name
@@ -51,13 +58,13 @@ function execGradleAsync(gradleBinaryPath, args, execOptions = {}) {
 }
 /**
  * This function recursively finds the nearest gradlew file in the workspace
- * @param originalFileToSearch the original file to search for
+ * @param originalFileToSearch the original file to search for, relative to workspace root, file path not directory path
  * @param wr workspace root
  * @param currentSearchPath the path to start searching for gradlew file
  * @returns the relative path of the gradlew file to workspace root, throws an error if gradlew file is not found
- * It will return gradlew.bat file on windows and gradlew file on other platforms
+ * It will return relative path to workspace root of gradlew.bat file on windows and gradlew file on other platforms
  */
-function findGraldewFile(originalFileToSearch, wr = devkit_1.workspaceRoot, currentSearchPath) {
+function findGradlewFile(originalFileToSearch, wr = devkit_1.workspaceRoot, currentSearchPath) {
     currentSearchPath ??= originalFileToSearch;
     const parent = (0, node_path_1.dirname)(currentSearchPath);
     if (currentSearchPath === parent) {
@@ -80,5 +87,5 @@ function findGraldewFile(originalFileToSearch, wr = devkit_1.workspaceRoot, curr
             return gradlewPath;
         }
     }
-    return findGraldewFile(originalFileToSearch, wr, parent);
+    return findGradlewFile(originalFileToSearch, wr, parent);
 }

package/src/utils/split-config-files.js

@@ -11,6 +11,8 @@ exports.GRADLE_TEST_FILES = [
     '**/src/test/kotlin/**/*Test.kt',
     '**/src/test/java/**/*Tests.java',
     '**/src/test/kotlin/**/*Tests.kt',
+    '**/src/test/groovy/**/*Test.groovy',
+    '**/src/test/groovy/**/*Tests.groovy',
 ];
 exports.gradleConfigGlob = (0, globs_1.combineGlobPatterns)(...Array.from(exports.GRADLE_BUILD_FILES).map((file) => `**/${file}`));
 exports.gradleConfigAndTestGlob = (0, globs_1.combineGlobPatterns)(...Array.from(exports.GRADLE_BUILD_FILES), ...Array.from(exports.GRALDEW_FILES), ...Array.from(exports.GRADLE_BUILD_FILES).map((file) => `**/${file}`), ...Array.from(exports.GRALDEW_FILES).map((file) => `**/${file}`), ...exports.GRADLE_TEST_FILES);

package/src/utils/versions.d.ts

@@ -1 +1,3 @@
 export declare const nxVersion: any;
+export declare const gradleProjectGraphPluginName = "dev.nx.gradle.project-graph";
+export declare const gradleProjectGraphVersion = "0.0.2";

package/src/utils/versions.js

@@ -1,4 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nxVersion = void 0;
+exports.gradleProjectGraphVersion = exports.gradleProjectGraphPluginName = exports.nxVersion = void 0;
 exports.nxVersion = require('../../package.json').version;
+exports.gradleProjectGraphPluginName = 'dev.nx.gradle.project-graph';
+exports.gradleProjectGraphVersion = '0.0.2';