@nx/gradle 19.4.1 → 19.5.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/gradle",
-  "version": "19.4.1",
+  "version": "19.5.0-beta.0",
   "private": false,
   "description": "The Nx Plugin for Gradle allows Gradle tasks to be run through Nx",
   "repository": {
@@ -34,7 +34,7 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
-    "@nx/devkit": "19.4.1"
+    "@nx/devkit": "19.5.0-beta.0"
   },
   "publishConfig": {
     "access": "public"

package/src/plugin/dependencies.js

@@ -26,12 +26,11 @@ const createDependencies = async (_, context) => {
     return Array.from(dependencies);
 };
 exports.createDependencies = createDependencies;
-const gradleConfigFileNames = new Set(['build.gradle', 'build.gradle.kts']);
 function findGradleFiles(fileMap) {
     const gradleFiles = [];
     for (const [_, files] of Object.entries(fileMap.projectFileMap)) {
         for (const file of files) {
-            if (gradleConfigFileNames.has((0, node_path_1.basename)(file.file))) {
+            if (get_gradle_report_1.GRADLE_BUILD_FILES.has((0, node_path_1.basename)(file.file))) {
                 gradleFiles.push(file.file);
             }
         }

package/src/plugin/nodes.d.ts

@@ -1,6 +1,7 @@
 import { CreateNodes, CreateNodesV2, ProjectConfiguration, TargetConfiguration, CreateNodesFunction } from '@nx/devkit';
 import { GradleReport } from '../utils/get-gradle-report';
 export interface GradlePluginOptions {
+    ciTargetName?: string;
     testTargetName?: string;
     classesTargetName?: string;
     buildTargetName?: string;
@@ -13,7 +14,7 @@ type GradleTargets = Record<string, {
 }>;
 export declare function writeTargetsToCache(cachePath: string, results: GradleTargets): void;
 export declare const createNodesV2: CreateNodesV2<GradlePluginOptions>;
-export declare const makeCreateNodes: (gradleReport: GradleReport, targetsCache: GradleTargets) => CreateNodesFunction;
+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.

package/src/plugin/nodes.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodes = exports.makeCreateNodes = exports.createNodesV2 = exports.writeTargetsToCache = void 0;
+exports.createNodes = exports.makeCreateNodesForGradleConfigFile = exports.createNodesV2 = exports.writeTargetsToCache = void 0;
 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 exec_gradle_1 = require("../utils/exec-gradle");
 const get_gradle_report_1 = require("../utils/get-gradle-report");
 const file_hasher_1 = require("nx/src/hasher/file-hasher");
@@ -15,6 +16,13 @@ const dependsOnMap = {
     test: ['classes'],
     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) : {};
 }
@@ -23,25 +31,28 @@ function writeTargetsToCache(cachePath, results) {
 }
 exports.writeTargetsToCache = writeTargetsToCache;
 exports.createNodesV2 = [
-    get_gradle_report_1.gradleConfigGlob,
-    async (configFiles, options, context) => {
+    get_gradle_report_1.gradleConfigAndTestGlob,
+    async (files, options, context) => {
+        const { configFiles, projectRoots, testFiles } = 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);
         const gradleReport = (0, get_gradle_report_1.getCurrentGradleReport)();
+        const gradleProjectRootToTestFilesMap = getGradleProjectRootToTestFilesMap(testFiles, projectRoots);
         try {
-            return await (0, devkit_1.createNodesFromFiles)((0, exports.makeCreateNodes)(gradleReport, targetsCache), configFiles, options, context);
+            return (0, devkit_1.createNodesFromFiles)((0, exports.makeCreateNodesForGradleConfigFile)(gradleReport, targetsCache, gradleProjectRootToTestFilesMap), configFiles, options, context);
         }
         finally {
             writeTargetsToCache(cachePath, targetsCache);
         }
     },
 ];
-const makeCreateNodes = (gradleReport, targetsCache) => async (gradleFilePath, options, context) => {
+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] ??= createGradleProject(gradleReport, gradleFilePath, options, context);
+    targetsCache[hash] ??= await createGradleProject(gradleReport, gradleFilePath, options, context, gradleProjectRootToTestFilesMap[projectRoot]);
     const project = targetsCache[hash];
     if (!project) {
         return {};
@@ -52,7 +63,7 @@ const makeCreateNodes = (gradleReport, targetsCache) => async (gradleFilePath, o
         },
     };
 };
-exports.makeCreateNodes = makeCreateNodes;
+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.
@@ -63,11 +74,11 @@ exports.createNodes = [
         devkit_1.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
         await (0, get_gradle_report_1.populateGradleReport)(context.workspaceRoot);
         const gradleReport = (0, get_gradle_report_1.getCurrentGradleReport)();
-        const internalCreateNodes = (0, exports.makeCreateNodes)(gradleReport, {});
+        const internalCreateNodes = (0, exports.makeCreateNodesForGradleConfigFile)(gradleReport);
         return await internalCreateNodes(configFile, options, context);
     },
 ];
-function createGradleProject(gradleReport, gradleFilePath, options, context) {
+async function createGradleProject(gradleReport, gradleFilePath, options, context, testFiles = []) {
     try {
         const { gradleProjectToTasksTypeMap, gradleFileToOutputDirsMap, gradleFileToGradleProjectMap, gradleProjectToProjectName, } = gradleReport;
         const gradleProject = gradleFileToGradleProjectMap.get(gradleFilePath);
@@ -84,7 +95,7 @@ function createGradleProject(gradleReport, gradleFilePath, options, context) {
             });
         }
         const outputDirs = gradleFileToOutputDirsMap.get(gradleFilePath);
-        const { targets, targetGroups } = createGradleTargets(tasks, options, context, outputDirs, gradleProject);
+        const { targets, targetGroups } = await createGradleTargets(tasks, options, context, outputDirs, gradleProject, gradleFilePath, testFiles);
         const project = {
             name: projectName,
             targets,
@@ -100,29 +111,35 @@ function createGradleProject(gradleReport, gradleFilePath, options, context) {
         return undefined;
     }
 }
-function createGradleTargets(tasks, options, context, outputDirs, gradleProject) {
+async function createGradleTargets(tasks, options, context, outputDirs, gradleProject, gradleFilePath, testFiles = []) {
     const inputsMap = createInputsMap(context);
     const targets = {};
     const targetGroups = {};
     for (const task of tasks) {
         const targetName = options?.[`${task.name}TargetName`] ?? task.name;
-        const outputs = outputDirs.get(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);
+        }
+        const taskCommandToRun = `${gradleProject ? gradleProject + ':' : ''}${task.name}`;
         targets[targetName] = {
-            command: `${(0, exec_gradle_1.getGradleExecFile)()} ${gradleProject ? gradleProject + ':' : ''}${task.name}`,
+            command: `${(0, exec_gradle_1.getGradleExecFile)()} ${taskCommandToRun}`,
             cache: cacheableTaskType.has(task.type),
             inputs: inputsMap[task.name],
             dependsOn: dependsOnMap[task.name],
             metadata: {
                 technologies: ['gradle'],
             },
+            ...(outputs && outputs.length ? { outputs } : {}),
         };
-        if (outputs) {
-            targets[targetName].outputs = [outputs];
-        }
         if (!targetGroups[task.type]) {
             targetGroups[task.type] = [];
         }
-        targetGroups[task.type].push(task.name);
+        targetGroups[task.type].push(targetName);
     }
     return { targetGroups, targets };
 }
@@ -138,3 +155,79 @@ function createInputsMap(context) {
             : ['default', '^default'],
     };
 }
+function getTestCiTargets(testFiles, gradleProject, testTargetName, ciTargetName, inputs, outputs, targetGroupName, targets, targetGroups) {
+    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}`,
+            cache: true,
+            inputs,
+            dependsOn: dependsOnMap['test'],
+            metadata: {
+                technologies: ['gradle'],
+                description: `Runs Gradle test ${testFile} in CI`,
+            },
+            ...(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,
+        },
+    };
+    targetGroups[targetGroupName].push(ciTargetName);
+}
+function splitConfigFiles(files) {
+    const configFiles = [];
+    const testFiles = [];
+    const projectRoots = new Set();
+    files.forEach((file) => {
+        if (get_gradle_report_1.GRADLE_BUILD_FILES.has((0, node_path_1.basename)(file))) {
+            configFiles.push(file);
+            projectRoots.add((0, node_path_1.dirname)(file));
+        }
+        else {
+            testFiles.push(file);
+        }
+    });
+    return { configFiles, testFiles, projectRoots: Array.from(projectRoots) };
+}
+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/get-gradle-report.d.ts

@@ -7,7 +7,10 @@ export interface GradleReport {
     gradleProjectToTasksTypeMap: Map<string, Map<string, string>>;
     gradleProjectToProjectName: Map<string, string>;
 }
-export declare const gradleConfigGlob = "**/build.{gradle.kts,gradle}";
+export declare const GRADLE_BUILD_FILES: Set<string>;
+export declare const GRADLE_TEST_FILES: string[];
+export declare const gradleConfigGlob: string;
+export declare const gradleConfigAndTestGlob: string;
 export declare function getCurrentGradleReport(): GradleReport;
 export declare function populateGradleReport(workspaceRoot: string): Promise<void>;
 export declare function processProjectReports(projectReportLines: string[]): GradleReport;

package/src/utils/get-gradle-report.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processProjectReports = exports.populateGradleReport = exports.getCurrentGradleReport = exports.gradleConfigGlob = exports.newLineSeparator = exports.fileSeparator = void 0;
+exports.processProjectReports = exports.populateGradleReport = exports.getCurrentGradleReport = exports.gradleConfigAndTestGlob = exports.gradleConfigGlob = exports.GRADLE_TEST_FILES = exports.GRADLE_BUILD_FILES = exports.newLineSeparator = exports.fileSeparator = void 0;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const devkit_1 = require("@nx/devkit");
+const globs_1 = require("nx/src/utils/globs");
 const exec_gradle_1 = require("./exec-gradle");
 const workspace_context_1 = require("nx/src/utils/workspace-context");
 exports.fileSeparator = process.platform.startsWith('win')
@@ -14,7 +15,13 @@ exports.newLineSeparator = process.platform.startsWith('win')
     : '\n';
 let gradleReportCache;
 let gradleCurrentConfigHash;
-exports.gradleConfigGlob = '**/build.{gradle.kts,gradle}';
+exports.GRADLE_BUILD_FILES = new Set(['build.gradle', 'build.gradle.kts']);
+exports.GRADLE_TEST_FILES = [
+    '**/src/test/java/**/*.java',
+    '**/src/test/kotlin/**/*.kt',
+];
+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).map((file) => `**/${file}`), ...exports.GRADLE_TEST_FILES);
 function getCurrentGradleReport() {
     if (!gradleReportCache) {
         throw new Error('Expected cached gradle report. Please open an issue at https://github.com/nrwl/nx/issues/new/choose');