feat(blazebuild): task graph

Author: virtual-designer

blazebuild/src/main/typescript/core/Blaze.ts

@@ -19,7 +19,7 @@ class Blaze {
         this.taskManager,
         this.projectManager
     ];
-
+    private _taskNames: string[] = [];
     private static _instance: Blaze;
 
     private constructor() {
@@ -35,6 +35,10 @@ class Blaze {
         return this._instance;
     }
 
+    public get taskNames() {
+        return this._taskNames;
+    }
+
     public async boot() {
         process.on("uncaughtException", error => {
             IO.fatal(error);
@@ -65,11 +69,11 @@ class Blaze {
             IO.fatal(error);
         }
 
-        const taskNames =
+        this._taskNames =
             process.argv.length >= 3 ? process.argv.slice(2) : [Blaze.defaultTaskName];
 
         try {
-            for (const taskName of taskNames) {
+            for (const taskName of this._taskNames) {
                 await this.taskManager.executeTask(taskName);
             }
         } catch (error) {

blazebuild/src/main/typescript/framework/tasks/GraphTask.ts

@@ -0,0 +1,25 @@
+import IO from "../../io/IO";
+import AbstractTask from "../../tasks/AbstractTask";
+import { Task } from "../../tasks/Task";
+import { TaskAction } from "../../tasks/TaskAction";
+
+@Task({
+    description: "Graphs the project's dependencies.",
+    group: "Help"
+})
+class GraphTask extends AbstractTask {
+    @TaskAction
+    public override async run() {
+        this.blaze.taskNames.shift();
+        const taskName = this.blaze.taskNames.shift();
+
+        if (!taskName) {
+            IO.fatal("No task specified. Please specify a task to graph.");
+        }
+
+        const graph = await this.blaze.taskManager.getTaskGraph(taskName);
+        console.log("\n" + (await graph.toString()));
+    }
+}
+
+export default GraphTask;

blazebuild/src/main/typescript/tasks/TaskGraph.ts

@@ -0,0 +1,42 @@
+import chalk from "chalk";
+import Blaze from "../core/Blaze";
+import type { TaskDetails } from "./TaskManager";
+
+class TaskGraph {
+    public readonly taskDetails: TaskDetails<unknown>;
+
+    public constructor(task: TaskDetails<unknown>) {
+        this.taskDetails = task;
+    }
+
+    public async toString() {
+        const dependenciesOutput = await this.internalToString(this.taskDetails, 1);
+        return `${chalk.bold(dependenciesOutput === "" ? "-" : "+")} ${this.taskDetails.options?.name ?? this.taskDetails.task.name}\n${dependenciesOutput.trimEnd()}`;
+    }
+
+    private async internalToString(
+        taskDetails: TaskDetails<unknown>,
+        tabs = 0,
+        visited = new Map<string, number>()
+    ) {
+        const taskManager = Blaze.getInstance().taskManager;
+        let output = "";
+
+        for (const dependency of await taskManager.getTaskDependencies(
+            taskDetails.task,
+            undefined,
+            false
+        )) {
+            const dependenciesOutput = await this.internalToString(dependency, tabs + 1, visited);
+            const name = dependency.options?.name ?? dependency.task.name;
+            const appearance = visited.get(name) ?? 0;
+            output += `${`${chalk.gray.dim("|")}  `.repeat(tabs)}${chalk.bold(dependenciesOutput === "" ? "-" : "+")} ${name}${appearance === 0 ? "" : ` ${chalk.white.dim(`[${appearance}]`)}`}\n`;
+            output += dependenciesOutput;
+            visited.set(name, appearance + 1);
+        }
+
+        return output;
+    }
+}
+
+export default TaskGraph;

blazebuild/src/main/typescript/tasks/TaskManager.ts

@@ -5,19 +5,22 @@ import type Blaze from "../core/Blaze";
 import Manager from "../core/Manager";
 import TaskNotFoundError from "../errors/TaskNotFoundError";
 import BuildTask from "../framework/tasks/BuildTask";
+import GraphTask from "../framework/tasks/GraphTask";
 import TasksTask from "../framework/tasks/TasksTask";
 import IO from "../io/IO";
 import type { FileResolvable } from "../types/file";
 import type { Awaitable } from "../types/utils";
 import AbstractTask, { type TaskResolvable } from "./AbstractTask";
 import { ActionlessTask } from "./ActionlessTask";
 import { TASK_DEPENDENCY_GENERATOR_METADATA_KEY } from "./TaskDependencyGenerator";
+import TaskGraph from "./TaskGraph";
 import { TaskOutputGenerator } from "./TaskOutputGenerator";
 
 class TaskManager extends Manager {
     private static readonly builtInTasks: Array<new (blaze: Blaze) => AbstractTask<any>> = [
         TasksTask,
-        BuildTask
+        BuildTask,
+        GraphTask
     ];
     private readonly tasks = new Map<string, TaskDetails<any>>();
     private readonly classToTaskMap = new Map<typeof AbstractTask<any>, TaskDetails<any>>();
@@ -76,7 +79,10 @@ class TaskManager extends Manager {
         throw new Error("Invalid arguments passed to register method");
     }
 
-    public named<T extends AbstractTask<any>>(name: string, options: TaskRegisterOptions<unknown, T>) {
+    public named<T extends AbstractTask<any>>(
+        name: string,
+        options: TaskRegisterOptions<unknown, T>
+    ) {
         const task = this.resolveTask(name);
 
         task.options = {
@@ -302,7 +308,8 @@ class TaskManager extends Manager {
 
     public async getTaskDependencies(
         taskResolvable: string | AbstractTask<any>,
-        set = new Set<TaskDetails<unknown>>()
+        set = new Set<TaskDetails<unknown>>(),
+        deep = true
     ) {
         const { task, options } = this.resolveTask(
             typeof taskResolvable === "string"
@@ -321,7 +328,11 @@ class TaskManager extends Manager {
 
         for (const dependency of [...dependencies, ...(options?.dependsOn ?? [])]) {
             const details: TaskDetails<unknown> = this.blaze.taskManager.resolveTask(dependency);
-            await this.getTaskDependencies(details.task, set);
+
+            if (deep) {
+                await this.getTaskDependencies(details.task, set);
+            }
+
             set.add(details);
         }
 
@@ -431,6 +442,11 @@ class TaskManager extends Manager {
     public getActionableTaskCount() {
         return this.upToDateTasks.size + this.executedTasks.size;
     }
+
+    public async getTaskGraph<T>(resolvable: TaskResolvable<T>) {
+        const taskDetails = this.resolveTask(resolvable);
+        return new TaskGraph(taskDetails);
+    }
 }
 
 export type TaskRegisterOptions<R, T extends AbstractTask<R> = AbstractTask<R>> = {