chore: code layout

Author: pd93

src/commands/index.ts

@@ -0,0 +1 @@
+export * from './runTask';

src/commands/runTask.ts

@@ -0,0 +1,16 @@
+import * as vscode from 'vscode';
+import * as services from '../services';
+import * as models from '../models';
+
+// RunTask will show a quick pick with all the tasks and run the selected one
+export function runTask(taskfile?: models.Taskfile) {
+    if (!taskfile || taskfile.tasks.length === 0) {
+        vscode.window.showInformationMessage('No tasks found');
+        return;
+    }
+    vscode.window.showQuickPick(taskfile.tasks.map(t => t.name)).then((taskName) => {
+        if (taskName) {
+            services.taskfile.runTask(taskName);
+        }
+    });
+}

src/extension.ts

@@ -1,73 +1,18 @@
-// The module 'vscode' contains the VS Code extensibility API
-// Import the module and reference it with the alias vscode in your code below
 import * as vscode from 'vscode';
-import * as cp from 'child_process';
+import { TaskExtension } from './task';
 
-var outputChannel: vscode.OutputChannel;
-var taskList: TaskList;
-
-// This method is called when your extension is activated
-// Your extension is activated the very first time the command is executed
 export function activate(context: vscode.ExtensionContext) {
 
-	// Create an output channel for the task output
-	outputChannel = vscode.window.createOutputChannel('task');
-
-	// Register commands
-	let disposable = vscode.commands.registerCommand('vscode-task.runTask', runTask);
-
-	// Initialise the task list
-	refreshTaskList();
-
-	context.subscriptions.push(disposable);
-}
-
-// This method is called when your extension is deactivated
-export function deactivate() { }
-
-function runTask() {
-	refreshTaskList();
+	// Create a new instance of Tagger
+	let taskExtension: TaskExtension = new TaskExtension();
 
-	// Show a quick pick with all the tasks
-	vscode.window.showQuickPick(taskList.tasks.map(t => t.name)).then((taskName) => {
+	// Registration
+	taskExtension.registerCommands(context);
 
-		// If the user selected a task, run it
-		if (taskName) {
-			cp.exec(`task ${taskName}`, (err: cp.ExecException | null, stdout: string, stderr: string) => {
-				if (err) {
-					console.log('error: ' + err);
-					return;
-				}
-				outputChannel.append(stderr);
-				outputChannel.append(stdout);
-				outputChannel.show();
-			});
-		}
+	// Refresh the tasks list
+	taskExtension.update().catch((err: string) => {
+		console.error(err);
 	});
 }
 
-async function refreshTaskList() {
-	return await new Promise((resolve, reject) => {
-		// Get a list of all tasks
-		cp.exec('task --list-all --json', (err: cp.ExecException | null, stdout: string, stderr: string) => {
-			if (err) {
-				console.log('error: ' + err);
-				return;
-			}
-			// Parse the JSON output
-			taskList = JSON.parse(stdout);
-			resolve(stdout);
-		});
-	});
-}
-
-interface Task {
-	name: string;
-	desc: string;
-	summary: string;
-	up_to_date: boolean;
-}
-
-interface TaskList {
-	tasks: Task[];
-}
+export function deactivate() { }

src/models/index.ts

@@ -0,0 +1 @@
+export * from './taskfile';

src/models/taskfile.ts

@@ -0,0 +1,10 @@
+export interface Taskfile {
+    tasks: Task[];
+}
+
+export interface Task {
+    name: string;
+    desc: string;
+    summary: string;
+    up_to_date: boolean;
+}

src/services/index.ts

@@ -0,0 +1 @@
+export * from './taskfile';

src/services/taskfile.ts

@@ -0,0 +1,50 @@
+import * as cp from 'child_process';
+import * as vscode from 'vscode';
+import * as models from '../models';
+
+class TaskfileService {
+    private static _instance: TaskfileService;
+    private static outputChannel: vscode.OutputChannel;
+
+    private constructor() {
+        TaskfileService.outputChannel = vscode.window.createOutputChannel('Task');
+    }
+
+    public static get Instance() {
+        return this._instance || (this._instance = new this());
+    }
+
+    public async read(): Promise<models.Taskfile> {
+        return await new Promise((resolve, reject) => {
+            let command = 'task --list-all --json';
+            cp.exec(command, (err: cp.ExecException | null, stdout: string, stderr: string) => {
+                if (err) {
+                    console.log('error: ' + err);
+                    reject();
+                    return;
+                }
+                var taskfile: models.Taskfile = JSON.parse(stdout);
+                resolve(taskfile);
+            });
+        });
+    }
+
+    public async runTask(taskName: string): Promise<void> {
+        return await new Promise((resolve, reject) => {
+            let command = `task ${taskName}`;
+            cp.exec(command, (err: cp.ExecException | null, stdout: string, stderr: string) => {
+                if (err) {
+                    console.log('error: ' + err);
+                    reject();
+                    return;
+                }
+                TaskfileService.outputChannel.append(stderr);
+                TaskfileService.outputChannel.append(stdout);
+                TaskfileService.outputChannel.show();
+                resolve();
+            });
+        });
+    }
+}
+
+export const taskfile = TaskfileService.Instance;

src/task.ts

@@ -0,0 +1,25 @@
+import * as vscode from 'vscode';
+import * as commands from './commands';
+import * as services from './services';
+import * as models from './models';
+
+export class TaskExtension {
+    private _taskfile?: models.Taskfile;
+
+    public async update(): Promise<void> {
+        await services.taskfile.read().then((taskfile: models.Taskfile) => {
+            this._taskfile = taskfile;
+        });
+    }
+
+    public registerCommands(context: vscode.ExtensionContext): void {
+        context.subscriptions.push(vscode.commands.registerCommand('vscode-task.runTask', () => {
+            commands.runTask(this._taskfile);
+        }));
+        context.subscriptions.push(vscode.commands.registerCommand('vscode-task.refreshTasks', () => {
+            this.update().catch((err: string) => {
+                console.error(err);
+            });
+        }));
+    }
+}