feat: use --nested flag

pd93 · pd93 · commit 1edc61323793 · 2025-09-11T14:26:14.000Z
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
@@ -5,7 +5,7 @@
 	"tasks": [
 		{
 			"type": "npm",
-			"script": "bundle",
+			"script": "compile",
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
 			"presentation": {
diff --git a/src/elements/activityBar.ts b/src/elements/activityBar.ts
@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 import { TaskTreeDataProvider } from '../providers/taskTreeDataProvider.js';
-import { Taskfile } from '../models/taskfile.js';
+import { Namespace } from '../models/models.js';
 
 export class ActivityBar {
     private _provider: TaskTreeDataProvider;
@@ -16,12 +16,7 @@ export class ActivityBar {
         });
     }
 
-    public setTreeNesting(enabled: boolean) {
-        this._provider.setTreeNesting(enabled);
-        this._provider.refresh();
-    }
-
-    public refresh(taskfiles?: Taskfile[]) {
-        this._provider.refresh(taskfiles);
+    public refresh(taskfiles?: Namespace[], nesting?: boolean): void {
+        this._provider.refresh(taskfiles, nesting);
     }
 }
diff --git a/src/elements/quickPickItem.ts b/src/elements/quickPickItem.ts
@@ -1,24 +1,24 @@
 import * as vscode from 'vscode';
-import { Taskfile, Task } from '../models/taskfile.js';
+import { Namespace, Task } from '../models/models.js';
 
 export class QuickPickTaskItem implements vscode.QuickPickItem {
-    constructor(taskfile: Taskfile, task: Task) {
-        this.taskfile = taskfile;
+    constructor(namespace: Namespace, task: Task) {
+        this.namespace = namespace;
         this.task = task;
         this.label = task.name;
         this.description = task.desc;
         this.kind = vscode.QuickPickItemKind.Default;
     }
-    taskfile: Taskfile;
+    namespace: Namespace;
     task: Task;
     label: string;
     description: string;
     kind: vscode.QuickPickItemKind;
 }
 
 export class QuickPickTaskSeparator implements vscode.QuickPickItem {
-    constructor(taskfile: Taskfile) {
-        this.label = taskfile.location;
+    constructor(namespace: Namespace) {
+        this.label = namespace.location;
         this.kind = vscode.QuickPickItemKind.Separator;
     }
     label: string;
diff --git a/src/elements/treeItem.ts b/src/elements/treeItem.ts
@@ -1,13 +1,13 @@
 import * as vscode from 'vscode';
-import { Task } from '../models/taskfile.js';
+import { Namespace, Task } from '../models/models.js';
 
 export type TreeItem = WorkspaceTreeItem | NamespaceTreeItem | TaskTreeItem;
 
 export class WorkspaceTreeItem extends vscode.TreeItem {
     constructor(
         readonly label: string,
         readonly workspace: string,
-        readonly tasks: Task[],
+        readonly namespace: Namespace,
         readonly collapsibleState: vscode.TreeItemCollapsibleState,
         readonly command?: vscode.Command
     ) {
@@ -22,8 +22,7 @@ export class NamespaceTreeItem extends vscode.TreeItem {
     constructor(
         readonly label: string,
         readonly workspace: string,
-        readonly namespaceMap: any,
-        readonly tasks: Task[],
+        readonly namespace: Namespace,
         readonly collapsibleState: vscode.TreeItemCollapsibleState,
         readonly command?: vscode.Command
     ) {
diff --git a/src/models/models.ts b/src/models/models.ts
@@ -1,9 +1,6 @@
-export type TaskMapping = {
-    [key: string]: TaskMapping | null;
-};
-
-export interface Taskfile {
+export interface Namespace {
     tasks: Task[];
+    namespaces: Map<string, Namespace>;
     location: string; // The location of the actual Taskfile
     // The vscode workspace directory where the command was executed to find this taskfile
     // This is where tasks in this taskfile will be executed from.
diff --git a/src/providers/taskTreeDataProvider.ts b/src/providers/taskTreeDataProvider.ts
@@ -1,31 +1,29 @@
 import * as path from 'path';
 import * as vscode from 'vscode';
 import { TreeItem, TaskTreeItem, NamespaceTreeItem, WorkspaceTreeItem } from '../elements/treeItem.js';
-import { Taskfile, Task, TaskMapping } from '../models/taskfile.js';
+import { Namespace, Task } from '../models/models.js';
 
 const namespaceSeparator = ':';
 
 export class TaskTreeDataProvider implements vscode.TreeDataProvider<TreeItem> {
     private _onDidChangeTreeData: vscode.EventEmitter<TaskTreeItem | undefined> = new vscode.EventEmitter<TaskTreeItem | undefined>();
     readonly onDidChangeTreeData: vscode.Event<TaskTreeItem | undefined> = this._onDidChangeTreeData.event;
-    private _taskfiles?: Taskfile[];
-    private _treeViewMap: TaskMapping = {};
+    private _namespaces?: Namespace[];
+    private _nesting: boolean = false;
 
-    constructor(
-        private nestingEnabled: boolean = false
-    ) { }
-
-    setTreeNesting(enabled: boolean) {
-        this.nestingEnabled = enabled;
+    refresh(namespaces?: Namespace[], nesting?: boolean): void {
+        if (namespaces) {
+            this._namespaces = namespaces;
+        }
+        this._nesting = nesting ?? this._nesting;
+        this._onDidChangeTreeData.fire(undefined);
     }
 
     getTreeItem(element: TreeItem): vscode.TreeItem {
         return element;
     }
 
     getChildren(parent?: TreeItem): Thenable<TreeItem[]> {
-        var treeItems: TreeItem[] = [];
-
         // If there are no workspace folders, return an empty array
         if (vscode.workspace.workspaceFolders === undefined || vscode.workspace.workspaceFolders.length === 0) {
             return Promise.resolve([]);
@@ -38,51 +36,56 @@ export class TaskTreeDataProvider implements vscode.TreeDataProvider<TreeItem> {
             return Promise.resolve(workspaces);
         }
 
-        // If there are no taskfiles, return an empty array
-        if (!this._taskfiles || this._taskfiles.length === 0) {
+        // If there are no namespaces, return an empty array
+        if (!this._namespaces || this._namespaces.length === 0) {
             return Promise.resolve([]);
         }
 
-        var tasks: Task[] | undefined;
-        var parentNamespace = "";
-        var namespaceMap = this._treeViewMap;
-        var workspace = "";
-
         // If there is no parent and exactly one workspace folder or if the parent is a workspace
         if (!parent && vscode.workspace.workspaceFolders.length === 1) {
-            tasks = this._taskfiles[0].tasks;
-            workspace = this._taskfiles[0].workspace ?? "";
+            return Promise.resolve(this.createTreeItems(
+                this._namespaces[0].workspace ?? "",
+                this._namespaces[0].namespaces,
+                this._namespaces[0].tasks
+            ));
         }
 
-        // If there is a parent and it is a workspace
-        if (parent instanceof WorkspaceTreeItem) {
-            tasks = parent.tasks;
-            workspace = parent.workspace;
+        // If there is a parent and it is a workspace or namespace
+        if (parent instanceof WorkspaceTreeItem || parent instanceof NamespaceTreeItem) {
+            return Promise.resolve(this.createTreeItems(
+                parent.workspace,
+                parent.namespace.namespaces,
+                parent.namespace.tasks
+            ));
         }
 
-        // If there is a parent and it is a namespace
-        if (parent instanceof NamespaceTreeItem) {
-            tasks = parent.tasks;
-            parentNamespace = parent.label;
-            namespaceMap = parent.namespaceMap;
-            workspace = parent.workspace;
-        }
+        return Promise.resolve([]);
+    }
 
+    createTreeItems(
+        workspace: string,
+        namespaces: Map<string, Namespace>,
+        tasks: Task[]
+    ): TreeItem[] {
+        var treeItems: TreeItem[] = [];
 
-        if (tasks === undefined) {
-            return Promise.resolve([]);
+        // Add each namespace to the tree
+        if (namespaces) {
+            for (const [key, namespace] of Object.entries(namespaces)){
+                treeItems = treeItems.concat(new NamespaceTreeItem(
+                    key,
+                    workspace,
+                    namespace,
+                    vscode.TreeItemCollapsibleState.Collapsed
+                ));
+            }
         }
 
-        let namespaceTreeItems = new Map<string, NamespaceTreeItem>();
-        let taskTreeItems: TaskTreeItem[] = [];
-        tasks.forEach(task => {
-            let taskName = task.name.split(":").pop() ?? task.name;
-            let namespacePath = trimParentNamespace(task.name, parentNamespace);
-            let namespaceName = getNamespaceName(namespacePath);
-
-            if (taskName in namespaceMap) {
-                let item = new TaskTreeItem(
-                    task.name.split(namespaceSeparator).pop() ?? task.name,
+        // Add each task to the tree
+        if (tasks) {
+            for (const task of tasks) {
+                treeItems = treeItems.concat(new TaskTreeItem(
+                    this._nesting ? task.name.split(namespaceSeparator).pop() ?? task.name : task.name,
                     workspace,
                     task,
                     vscode.TreeItemCollapsibleState.None,
@@ -91,119 +94,25 @@ export class TaskTreeDataProvider implements vscode.TreeDataProvider<TreeItem> {
                         title: 'Go to Definition',
                         arguments: [task, true]
                     }
-                );
-                taskTreeItems = taskTreeItems.concat(item);
-            }
-
-            if (namespaceName in namespaceMap && namespaceMap[namespaceName] !== null) {
-                let namespaceTreeItem = namespaceTreeItems.get(namespaceName);
-
-                if (namespaceTreeItem === undefined) {
-                    namespaceTreeItem = new NamespaceTreeItem(
-                        namespaceName,
-                        workspace,
-                        namespaceMap[namespaceName],
-                        [],
-                        vscode.TreeItemCollapsibleState.Collapsed
-                    );
-                }
-                namespaceTreeItem.tasks.push(task);
-                namespaceTreeItems.set(namespaceName, namespaceTreeItem);
+                ));
             }
+        }
 
-        });
-
-        // Add the namespace and tasks to the tree
-        namespaceTreeItems.forEach(namespace => {
-            treeItems = treeItems.concat(namespace);
-        });
-        treeItems = treeItems.concat(taskTreeItems);
-
-        return Promise.resolve(treeItems);
+        return treeItems;
     }
 
     getWorkspaces(): WorkspaceTreeItem[] {
         let workspaceTreeItems: WorkspaceTreeItem[] = [];
-        this._taskfiles?.forEach(taskfile => {
-            let dir = path.dirname(taskfile.location);
+        this._namespaces?.forEach(namespace => {
+            let dir = path.dirname(namespace.location);
             let workspaceTreeItem = new WorkspaceTreeItem(
                 path.basename(dir),
                 dir,
-                taskfile.tasks,
+                namespace,
                 vscode.TreeItemCollapsibleState.Expanded
             );
             workspaceTreeItems = workspaceTreeItems.concat(workspaceTreeItem);
         });
         return workspaceTreeItems;
     }
-
-    refresh(taskfiles?: Taskfile[]): void {
-        if (taskfiles) {
-            this._taskfiles = taskfiles;
-            this._treeViewMap = {};
-
-            // loop over all of the tasks in all of the task files and map their names into a set
-            const taskNames = Array.from(new Set(
-                taskfiles.flatMap(taskfile =>
-                    taskfile.tasks.flatMap(task => task.name)
-                )
-                // and sort desc so we know that the namespace reduction sets child objects correctly.
-            )).sort((a, b) => (a > b ? -1 : 1));
-
-            taskNames.reduce((acc: any, key: string) => {
-                const parts = key.split(':');
-                let currentLevel = acc;
-
-                parts.forEach((part, index) => {
-                    if (part === "") {
-                        return;
-                    };
-
-                    if (!(part in currentLevel)) {
-                        currentLevel[part] = {};
-                        if (index === parts.length - 1) {
-                            currentLevel[part] = null;
-                        }
-                    }
-
-                    currentLevel = currentLevel[part] as TaskMapping;
-                });
-
-                return acc;
-            }, this._treeViewMap);
-        }
-        this._onDidChangeTreeData.fire(undefined);
-    }
-}
-
-function getFullNamespacePath(task: Task): string {
-    // If the task has no namespace, return undefined
-    if (!task.name.includes(namespaceSeparator)) {
-        return "";
-    }
-    // Return the task's namespace by removing the last element
-    return task.name.substring(0, task.name.lastIndexOf(namespaceSeparator));
-}
-
-function trimParentNamespace(namespace: string, parentNamespace: string): string {
-    if (parentNamespace === "") {
-        return namespace;
-    }
-
-    const index = namespace.indexOf(parentNamespace + namespaceSeparator);
-
-    if (index === -1) {
-        return namespace;
-    }
-
-    return namespace.substring(index + parentNamespace.length + 1);
-}
-
-function getNamespaceName(namespacePath: string): string {
-    // If the namespace has no separator, return the namespace
-    if (!namespacePath.includes(namespaceSeparator)) {
-        return namespacePath;
-    }
-    // Return the first element of the namespace
-    return namespacePath.substring(0, namespacePath.indexOf(namespaceSeparator));
 }
diff --git a/src/services/taskfile.ts b/src/services/taskfile.ts
@@ -5,7 +5,7 @@ import { Octokit } from 'octokit';
 import * as path from 'path';
 import * as semver from 'semver';
 import * as vscode from 'vscode';
-import { Taskfile, Task } from '../models/taskfile.js';
+import { Namespace, Task } from '../models/models.js';
 import { OutputTo, TerminalClose, TerminalPer, TreeSort, settings } from '../utils/settings.js';
 import { log } from '../utils/log.js';
 import stripAnsi from 'strip-ansi';
@@ -177,14 +177,17 @@ class TaskfileService {
         }
     }
 
-    public async read(dir: string): Promise<Taskfile | undefined> {
+    public async read(dir: string, nesting: boolean): Promise<Namespace | undefined> {
         log.info(`Searching for taskfile in: "${dir}"`);
         return await new Promise((resolve, reject) => {
             let additionalFlags = "";
             // Sorting
             if (settings.tree.sort !== TreeSort.default) {
                 additionalFlags = ` --sort ${settings.tree.sort}`;
             }
+            if (nesting) {
+                additionalFlags = ` --nested`;
+            }
             let command = this.command(`--list-all --json${additionalFlags}`);
             cp.exec(command, { cwd: dir }, (err: cp.ExecException | null, stdout: string, stderr: string) => {
                 if (err) {
@@ -209,7 +212,7 @@ class TaskfileService {
                     }
                     return resolve(undefined);
                 }
-                var taskfile: Taskfile = JSON.parse(stdout);
+                var taskfile: Namespace = JSON.parse(stdout);
                 if (path.dirname(taskfile.location) !== dir) {
                     log.info(`Ignoring taskfile: "${taskfile.location}" (outside of workspace)`);
                     return reject();
diff --git a/src/task.ts b/src/task.ts

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`"tasks": [`
`6`	`6`	`{`
`7`	`7`	`"type": "npm",`
`8`		`- "script": "bundle",`
	`8`	`+ "script": "compile",`
`9`	`9`	`"problemMatcher": "$tsc-watch",`
`10`	`10`	`"isBackground": true,`
`11`	`11`	`"presentation": {`