@nx/gradle 21.2.0-beta.3 → 21.2.0-beta.5

package/package.json

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

package/src/executors/gradle/get-exclude-task.d.ts

@@ -1,4 +1,4 @@
-import { ProjectGraph } from 'nx/src/config/project-graph';
+import { ProjectGraphProjectNode } from 'nx/src/config/project-graph';
 /**
  * Returns Gradle CLI arguments to exclude dependent tasks
  * that are not part of the current execution set.
@@ -6,9 +6,6 @@ import { ProjectGraph } from 'nx/src/config/project-graph';
  * For example, if a project defines `dependsOn: ['lint']` for the `test` target,
  * and only `test` is running, this will return: ['lint']
  */
-export declare function getExcludeTasks(projectGraph: ProjectGraph, targets: {
-    project: string;
-    target: string;
-    excludeDependsOn: boolean;
-}[], runningTaskIds?: Set<string>): Set<string>;
-export declare function getAllDependsOn(projectGraph: ProjectGraph, projectName: string, targetName: string, visited?: Set<string>): string[];
+export declare function getExcludeTasks(taskIds: Set<string>, nodes: Record<string, ProjectGraphProjectNode>, runningTaskIds?: Set<string>): Set<string>;
+export declare function getGradleTaskNameWithNxTaskId(nxTaskId: string, nodes: Record<string, ProjectGraphProjectNode>): string | null;
+export declare function getAllDependsOn(nodes: Record<string, ProjectGraphProjectNode>, projectName: string, targetName: string): Set<string>;

package/src/executors/gradle/get-exclude-task.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExcludeTasks = getExcludeTasks;
+exports.getGradleTaskNameWithNxTaskId = getGradleTaskNameWithNxTaskId;
 exports.getAllDependsOn = getAllDependsOn;
 /**
  * Returns Gradle CLI arguments to exclude dependent tasks
@@ -9,38 +10,46 @@ exports.getAllDependsOn = getAllDependsOn;
  * For example, if a project defines `dependsOn: ['lint']` for the `test` target,
  * and only `test` is running, this will return: ['lint']
  */
-function getExcludeTasks(projectGraph, targets, runningTaskIds = new Set()) {
+function getExcludeTasks(taskIds, nodes, runningTaskIds = new Set()) {
     const excludes = new Set();
-    for (const { project, target, excludeDependsOn } of targets) {
-        if (!excludeDependsOn) {
-            continue;
-        }
-        const taskDeps = projectGraph.nodes[project]?.data?.targets?.[target]?.dependsOn ?? [];
+    for (const taskId of taskIds) {
+        const [project, target] = taskId.split(':');
+        const taskDeps = nodes[project]?.data?.targets?.[target]?.dependsOn ?? [];
         for (const dep of taskDeps) {
             const taskId = typeof dep === 'string' ? dep : dep?.target;
             if (taskId && !runningTaskIds.has(taskId)) {
-                const [projectName, targetName] = taskId.split(':');
-                const taskName = projectGraph.nodes[projectName]?.data?.targets?.[targetName]?.options
-                    ?.taskName;
-                if (taskName) {
-                    excludes.add(taskName);
+                const gradleTaskName = getGradleTaskNameWithNxTaskId(taskId, nodes);
+                if (gradleTaskName) {
+                    excludes.add(gradleTaskName);
                 }
             }
         }
     }
     return excludes;
 }
-function getAllDependsOn(projectGraph, projectName, targetName, visited = new Set()) {
-    const dependsOn = projectGraph[projectName]?.data?.targets?.[targetName]?.dependsOn ?? [];
-    const allDependsOn = [];
-    for (const dependency of dependsOn) {
-        if (!visited.has(dependency)) {
-            visited.add(dependency);
-            const [depProjectName, depTargetName] = dependency.split(':');
-            allDependsOn.push(dependency);
-            // Recursively get dependencies of the current dependency
-            allDependsOn.push(...getAllDependsOn(projectGraph, depProjectName, depTargetName, visited));
+function getGradleTaskNameWithNxTaskId(nxTaskId, nodes) {
+    const [projectName, targetName] = nxTaskId.split(':');
+    const gradleTaskName = nodes[projectName]?.data?.targets?.[targetName]?.options?.taskName;
+    return gradleTaskName;
+}
+function getAllDependsOn(nodes, projectName, targetName) {
+    const allDependsOn = new Set();
+    const stack = [`${projectName}:${targetName}`];
+    while (stack.length > 0) {
+        const currentTaskId = stack.pop();
+        if (currentTaskId && !allDependsOn.has(currentTaskId)) {
+            allDependsOn.add(currentTaskId);
+            const [currentProjectName, currentTargetName] = currentTaskId.split(':');
+            const directDependencies = nodes[currentProjectName]?.data?.targets?.[currentTargetName]
+                ?.dependsOn ?? [];
+            for (const dep of directDependencies) {
+                const depTaskId = typeof dep === 'string' ? dep : dep?.target;
+                if (depTaskId && !allDependsOn.has(depTaskId)) {
+                    stack.push(depTaskId);
+                }
+            }
         }
     }
+    allDependsOn.delete(`${projectName}:${targetName}`); // Exclude the starting task itself
     return allDependsOn;
 }

package/src/executors/gradle/gradle-batch.impl.d.ts

@@ -1,6 +1,14 @@
-import { ExecutorContext, TaskGraph } from '@nx/devkit';
+import { ExecutorContext, ProjectGraphProjectNode, TaskGraph } from '@nx/devkit';
 import { RunCommandsOptions } from 'nx/src/executors/run-commands/run-commands.impl';
 import { BatchResults } from 'nx/src/tasks-runner/batch/batch-messages';
 import { GradleExecutorSchema } from './schema';
 export declare const batchRunnerPath: string;
 export default function gradleBatch(taskGraph: TaskGraph, inputs: Record<string, GradleExecutorSchema>, overrides: RunCommandsOptions, context: ExecutorContext): Promise<BatchResults>;
+/**
+ * Get the gradlew task ids to run
+ */
+export declare function getGradlewTasksToRun(taskIds: string[], taskGraph: TaskGraph, inputs: Record<string, GradleExecutorSchema>, nodes: Record<string, ProjectGraphProjectNode>): {
+    gradlewTasksToRun: Record<string, GradleExecutorSchema>;
+    excludeTasks: Set<string>;
+    excludeTestTasks: Set<string>;
+};

package/src/executors/gradle/gradle-batch.impl.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.batchRunnerPath = void 0;
 exports.default = gradleBatch;
+exports.getGradlewTasksToRun = getGradlewTasksToRun;
 const devkit_1 = require("@nx/devkit");
 const run_commands_impl_1 = require("nx/src/executors/run-commands/run-commands.impl");
 const exec_gradle_1 = require("../../utils/exec-gradle");
@@ -27,42 +28,9 @@ async function gradleBatch(taskGraph, inputs, overrides, context) {
         if (overrides.__overrides_unparsed__.length) {
             args.push(...overrides.__overrides_unparsed__);
         }
-        const taskIdsWithExclude = [];
-        const taskIdsWithoutExclude = [];
         const taskIds = Object.keys(taskGraph.tasks);
-        for (const taskId of taskIds) {
-            if (inputs[taskId].excludeDependsOn) {
-                taskIdsWithExclude.push(taskId);
-            }
-            else {
-                taskIdsWithoutExclude.push(taskId);
-            }
-        }
-        const allDependsOn = new Set(taskIds);
-        taskIdsWithoutExclude.forEach((taskId) => {
-            const [projectName, targetName] = taskId.split(':');
-            const dependencies = (0, get_exclude_task_1.getAllDependsOn)(context.projectGraph, projectName, targetName);
-            dependencies.forEach((dep) => allDependsOn.add(dep));
-        });
-        const gradlewTasksToRun = taskIds.reduce((gradlewTasksToRun, taskId) => {
-            const task = taskGraph.tasks[taskId];
-            const gradlewTaskName = inputs[task.id].taskName;
-            const testClassName = inputs[task.id].testClassName;
-            gradlewTasksToRun[taskId] = {
-                taskName: gradlewTaskName,
-                testClassName: testClassName,
-            };
-            return gradlewTasksToRun;
-        }, {});
-        const excludeTasks = (0, get_exclude_task_1.getExcludeTasks)(context.projectGraph, taskIdsWithExclude.map((taskId) => {
-            const task = taskGraph.tasks[taskId];
-            return {
-                project: task?.target?.project,
-                target: task?.target?.target,
-                excludeDependsOn: inputs[taskId]?.excludeDependsOn,
-            };
-        }), allDependsOn);
-        const batchResults = await runTasksInBatch(gradlewTasksToRun, excludeTasks, args, root);
+        const { gradlewTasksToRun, excludeTasks, excludeTestTasks } = getGradlewTasksToRun(taskIds, taskGraph, inputs, context.projectGraph.nodes);
+        const batchResults = await runTasksInBatch(gradlewTasksToRun, excludeTasks, excludeTestTasks, args, root);
         taskIds.forEach((taskId) => {
             if (!batchResults[taskId]) {
                 batchResults[taskId] = {
@@ -84,13 +52,63 @@ async function gradleBatch(taskGraph, inputs, overrides, context) {
         }, {});
     }
 }
-async function runTasksInBatch(gradlewTasksToRun, excludeTasks, args, root) {
+/**
+ * Get the gradlew task ids to run
+ */
+function getGradlewTasksToRun(taskIds, taskGraph, inputs, nodes) {
+    const taskIdsWithExclude = new Set([]);
+    const testTaskIdsWithExclude = new Set([]);
+    const taskIdsWithoutExclude = new Set([]);
+    const gradlewTasksToRun = {};
+    for (const taskId of taskIds) {
+        const task = taskGraph.tasks[taskId];
+        const input = inputs[task.id];
+        gradlewTasksToRun[taskId] = input;
+        if (input.excludeDependsOn) {
+            if (input.testClassName) {
+                testTaskIdsWithExclude.add(taskId);
+            }
+            else {
+                taskIdsWithExclude.add(taskId);
+            }
+        }
+        else {
+            taskIdsWithoutExclude.add(taskId);
+        }
+    }
+    const allDependsOn = new Set(taskIds);
+    for (const taskId of taskIdsWithoutExclude) {
+        const [projectName, targetName] = taskId.split(':');
+        const dependencies = (0, get_exclude_task_1.getAllDependsOn)(nodes, projectName, targetName);
+        dependencies.forEach((dep) => allDependsOn.add(dep));
+    }
+    const excludeTasks = (0, get_exclude_task_1.getExcludeTasks)(taskIdsWithExclude, nodes, allDependsOn);
+    const allTestsDependsOn = new Set();
+    for (const taskId of testTaskIdsWithExclude) {
+        const [projectName, targetName] = taskId.split(':');
+        const taskDependsOn = (0, get_exclude_task_1.getAllDependsOn)(nodes, projectName, targetName);
+        taskDependsOn.forEach((dep) => allTestsDependsOn.add(dep));
+    }
+    const excludeTestTasks = new Set();
+    for (let taskId of allTestsDependsOn) {
+        const gradleTaskName = (0, get_exclude_task_1.getGradleTaskNameWithNxTaskId)(taskId, nodes);
+        if (gradleTaskName) {
+            excludeTestTasks.add(gradleTaskName);
+        }
+    }
+    return {
+        gradlewTasksToRun,
+        excludeTasks,
+        excludeTestTasks,
+    };
+}
+async function runTasksInBatch(gradlewTasksToRun, excludeTasks, excludeTestTasks, args, root) {
     const gradlewBatchStart = performance.mark(`gradlew-batch:start`);
     const usePseudoTerminal = process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
         pseudo_terminal_1.PseudoTerminal.isSupported();
     const command = `java -jar ${exports.batchRunnerPath} --tasks='${JSON.stringify(gradlewTasksToRun)}' --workspaceRoot=${root} --args='${args
         .join(' ')
-        .replaceAll("'", '"')}' --excludeTasks='${Array.from(excludeTasks).join(',')}' ${process.env.NX_VERBOSE_LOGGING === 'true' ? '' : '--quiet'}`;
+        .replaceAll("'", '"')}' --excludeTasks='${Array.from(excludeTasks).join(',')}' --excludeTestTasks='${Array.from(excludeTestTasks).join(',')}' ${process.env.NX_VERBOSE_LOGGING === 'true' ? '' : '--quiet'}`;
     let batchResults;
     if (usePseudoTerminal && process.env.NX_VERBOSE_LOGGING !== 'true') {
         const terminal = (0, pseudo_terminal_1.createPseudoTerminal)();

package/src/executors/gradle/gradle.impl.js

@@ -17,13 +17,7 @@ async function gradleExecutor(options, context) {
     if (options.testClassName) {
         args.push(`--tests`, options.testClassName);
     }
-    (0, get_exclude_task_1.getExcludeTasks)(context.projectGraph, [
-        {
-            project: context.projectName,
-            target: context.targetName,
-            excludeDependsOn: options.excludeDependsOn,
-        },
-    ]).forEach((task) => {
+    (0, get_exclude_task_1.getExcludeTasks)(new Set([`${context.projectName}:${context.targetName}`]), context.projectGraph.nodes).forEach((task) => {
         if (task) {
             args.push('--exclude-task', task);
         }

package/src/executors/gradle/schema.json

@@ -11,7 +11,7 @@
     },
     "testClassName": {
       "type": "string",
-      "description": "The test class name to run for test task."
+      "description": "The full test name to run for test task (package name and class name)."
     },
     "args": {
       "oneOf": [