chore(refactor): refactoring

src/calc.ts

@@ -5,6 +5,9 @@ import { NumberParser } from './parser';
 export class Calc {
     private statusBarItem: StatusBarItem | undefined;
     private numberParser = new NumberParser();
+    constructor() {
+        this.getStatusBar();
+    }
     public getStatusBar(): StatusBarItem | undefined {
         if ((this.statusBarItem === undefined) && (window)) {
             this.statusBarItem = window.createStatusBarItem(StatusBarAlignment.Left);

src/executor.ts

@@ -1,7 +1,7 @@
 import * as cp from 'child_process';
 import * as vscode from 'vscode';
 import * as path from 'path';
-import { statusManager, errorDiagnosticCollection, warningDiagnosticCollection } from './extension';
+import { ExtensionState } from './extensionState';
 
 export class ICheckResult {
     file: string = "";
@@ -27,7 +27,7 @@ export class Executor {
      * @param parser Parser for the output
      */
     runTool(args: string[], cwd: string | null, severity: string, useStdErr: boolean, cmd: string, env: any, printUnexpectedOutput: boolean, parser: ExecutorParser | null, token?: vscode.CancellationToken): Promise<ICheckResult[]> {
-        let outputChannel = statusManager.outputChannel;
+        let outputChannel = ExtensionState.getInstance().getStatusManager().outputChannel;
         let p: cp.ChildProcess;
         if (token) {
             token.onCancellationRequested(() => {
@@ -160,6 +160,8 @@ export class Executor {
 
         diagnosticMap.forEach((diagMap, file) => {
             const fileUri = vscode.Uri.parse(file);
+            let warningDiagnosticCollection = ExtensionState.getInstance().getWarningDiagnosticCollection();
+            let errorDiagnosticCollection = ExtensionState.getInstance().getErrorDiagnosticCollection();
             if (diagnosticSeverity === undefined || diagnosticSeverity === vscode.DiagnosticSeverity.Error) {
                 const newErrors = diagMap.get(vscode.DiagnosticSeverity.Error);
                 let existingWarnings = warningDiagnosticCollection.get(fileUri);

src/extension.ts

@@ -1,26 +1,20 @@
 // 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 { ExtensionState } from './extensionState';
 import { M68kFormatter } from './formatter';
 import { M68kHoverProvider } from './hover';
 import { M86kColorProvider } from './color';
-import { Calc, CalcController } from './calc';
-import { VASMCompiler, VASMController } from './vasm';
-import { StatusManager } from "./status";
+import { CalcController } from './calc';
+import { VASMController } from './vasm';
 import { FsUAEDebugSession } from './fsUAEDebug';
 import * as Net from 'net';
 import { RunFsUAENoDebugSession } from './runFsUAENoDebug';
-import { Disassembler } from './disassemble';
+
 import { M68kDefinitionProvider } from './definitionProvider';
 
 // Setting all the globals values
 export const AMIGA_ASM_MODE: vscode.DocumentFilter = { language: 'm68k', scheme: 'file' };
-export let errorDiagnosticCollection = vscode.languages.createDiagnosticCollection('m68k-error');
-export let warningDiagnosticCollection = vscode.languages.createDiagnosticCollection('m68k-warning');
-export let statusManager = new StatusManager();
-export let calc = new Calc();
-export let compiler: VASMCompiler;
-export let disassembler = new Disassembler();
 
 /*
  * Set the following compile time flag to true if the
@@ -32,7 +26,9 @@ const EMBED_DEBUG_ADAPTER = true;
 // 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) {
+    let state = ExtensionState.getInstance();
     // Preparing the status manager
+    let statusManager = state.getStatusManager();
     statusManager.showStatus("Build", 'amiga-assembly.build-vasm-workspace', "Build Workspace");
     vscode.window.onDidChangeActiveTextEditor(statusManager.showHideStatus, null, context.subscriptions);
     context.subscriptions.push(statusManager);
@@ -56,6 +52,7 @@ export function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(disposable);
 
     // create a new disassembler
+    let disassembler = state.getDisassembler();
     disposable = vscode.commands.registerCommand('amiga-assembly.disassemble-file', () => {
         return disassembler.showInputPanel().catch(err => {
             vscode.window.showErrorMessage(err);
@@ -64,6 +61,7 @@ export function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(disposable);
 
     // create a new calculator
+    let calc = state.getCalc();
     let controller = new CalcController(calc);
 
     // Add to a list of disposables which are disposed when this extension is deactivated.
@@ -91,11 +89,13 @@ export function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(vscode.languages.registerDefinitionProvider(AMIGA_ASM_MODE, new M68kDefinitionProvider()));
 
     // Diagnostics 
+    let errorDiagnosticCollection = state.getErrorDiagnosticCollection();
+    let warningDiagnosticCollection = state.getWarningDiagnosticCollection();
     context.subscriptions.push(errorDiagnosticCollection);
     context.subscriptions.push(warningDiagnosticCollection);
 
     // VASM Command
-    compiler = new VASMCompiler();
+    let compiler = state.getCompiler();
     // Build a file
     disposable = vscode.commands.registerCommand('amiga-assembly.build-vasm', () => {
         statusManager.onDefault();

src/extensionState.ts

@@ -0,0 +1,47 @@
+
+import * as vscode from 'vscode';
+import { Calc } from './calc';
+import { VASMCompiler } from './vasm';
+import { StatusManager } from "./status";
+import { Disassembler } from './disassemble';
+
+export class ExtensionState {
+    private compiler: VASMCompiler;
+    private errorDiagnosticCollection: vscode.DiagnosticCollection;
+    private warningDiagnosticCollection: vscode.DiagnosticCollection;
+    private statusManager: StatusManager;
+    private calc: Calc;
+    private disassembler: Disassembler;
+    public static getInstance() {
+        return INSTANCE;
+    }
+    public constructor() {
+        this.compiler = new VASMCompiler();
+        this.errorDiagnosticCollection = vscode.languages.createDiagnosticCollection('m68k-error');
+        this.warningDiagnosticCollection = vscode.languages.createDiagnosticCollection('m68k-warning');
+        this.statusManager = new StatusManager();
+        this.calc = new Calc();
+        this.disassembler = new Disassembler();
+    }
+    public getErrorDiagnosticCollection(): vscode.DiagnosticCollection {
+        return this.errorDiagnosticCollection;
+    }
+    public getWarningDiagnosticCollection(): vscode.DiagnosticCollection {
+        return this.warningDiagnosticCollection;
+    }
+    public getStatusManager(): StatusManager {
+        return this.statusManager;
+    }
+    public getCalc(): Calc {
+        return this.calc;
+    }
+    public getCompiler(): VASMCompiler {
+        return this.compiler;
+    }
+    public getDisassembler(): Disassembler {
+        return this.disassembler;
+    }
+}
+
+
+const INSTANCE = new ExtensionState();

src/test/executor.test.ts

@@ -3,15 +3,15 @@ import * as vscode from 'vscode';
 import * as cp from 'child_process';
 import { capture, spy, verify, anyString, instance, when, anything, mock, resetCalls } from 'ts-mockito/lib/ts-mockito';
 import { Executor, ExecutorParser, ICheckResult } from '../executor';
-import { statusManager, errorDiagnosticCollection, warningDiagnosticCollection } from '../extension';
+import { ExtensionState } from '../extensionState';
 import { DummyTextDocument } from './dummy';
 
 describe("Executor Tests", function () {
     let spiedOutputChannel: vscode.OutputChannel;
     before(() => {
         // Opening file to activate the extension
         const newFile = vscode.Uri.parse("untitled://./exe.s");
-        return vscode.window.showTextDocument(newFile).then(() => { spiedOutputChannel = spy(statusManager.outputChannel); });
+        return vscode.window.showTextDocument(newFile).then(() => { spiedOutputChannel = spy(ExtensionState.getInstance().getStatusManager().outputChannel); });
     });
     it("Should execute a command and parse stdout", async () => {
         resetCalls(spiedOutputChannel);
@@ -62,6 +62,8 @@ describe("Executor Tests", function () {
     });
     describe("Diagnostics handle", () => {
         let ex: Executor;
+        let errorDiagnosticCollection = ExtensionState.getInstance().getErrorDiagnosticCollection();
+        let warningDiagnosticCollection = ExtensionState.getInstance().getWarningDiagnosticCollection();
         let spiedErrorDiagnosticCollection: vscode.DiagnosticCollection;
         let spiedWarningDiagnosticCollection: vscode.DiagnosticCollection;
         let error: ICheckResult;

src/test/extension.test.ts

@@ -9,7 +9,7 @@ import * as vscode from 'vscode';
 import * as path from 'path';
 import * as fs from 'fs';
 import { spy, verify, anyString, capture, when, anything, resetCalls, mock, instance } from 'ts-mockito/lib/ts-mockito';
-import * as extension from '../extension';
+import { ExtensionState } from '../extensionState';
 import { Capstone } from '../capstone';
 
 // Defines a Mocha test suite to group tests of similar kind together
@@ -58,16 +58,17 @@ describe("Global Extension Tests", function () {
     });
     describe.only("Calc comand", function () {
         before(async () => {
+            this.timeout(60000);
             // activate the extension
             let ext = vscode.extensions.getExtension('prb28.amiga-assembly');
             if (ext) {
                 await ext.activate();
             }
             const newFile = vscode.Uri.parse("untitled:myfile.s");
-            return vscode.workspace.openTextDocument(newFile).then(document => {
+            await vscode.workspace.openTextDocument(newFile).then(async document => {
                 const edit = new vscode.WorkspaceEdit();
                 edit.insert(newFile, new vscode.Position(0, 0), "3+2");
-                return vscode.workspace.applyEdit(edit).then(async (success) => {
+                await vscode.workspace.applyEdit(edit).then(async (success) => {
                     if (success) {
                         await vscode.window.showTextDocument(document);
                         await vscode.commands.executeCommand("cursorMove", { to: 'right', by: 'character', value: 3, select: true });
@@ -78,6 +79,7 @@ describe("Global Extension Tests", function () {
             });
         });
         beforeEach(async () => {
+            this.timeout(60000);
             // Set the editor contents
             const editor = vscode.window.activeTextEditor;
             if (editor) {
@@ -91,18 +93,21 @@ describe("Global Extension Tests", function () {
             }
         });
         it.only("Should evaluate the selection in the status bar", () => {
+            this.timeout(60000);
+            let calc = ExtensionState.getInstance().getCalc();
             // Get the satus value
             // tslint:disable-next-line:no-unused-expression
-            expect(extension.calc).to.not.be.undefined;
-            let sb = extension.calc.getStatusBar();
+            expect(calc).to.not.be.undefined;
+            let sb = calc.getStatusBar();
             // tslint:disable-next-line:no-unused-expression
             expect(sb).to.not.be.undefined;
             if (sb) {
                 expect(sb.text).to.be.equal("3+2=#5/$5/%101");
             }
         });
         it("Should hide the status bar if it it not evaluable", async () => {
-            let sb = extension.calc.getStatusBar();
+            let calc = ExtensionState.getInstance().getCalc();
+            let sb = calc.getStatusBar();
             // tslint:disable-next-line:no-unused-expression
             expect(sb).to.not.be.undefined;
             if (sb) {
@@ -153,8 +158,9 @@ describe("Global Extension Tests", function () {
             verify(spiedWindow.showInputBox(anything())).once();
         });
         it("Should build the workspace on command", async () => {
-            let spiedCompiler = spy(extension.compiler);
-            let spiedStatus = spy(extension.statusManager);
+            let state = ExtensionState.getInstance();
+            let spiedCompiler = spy(state.getCompiler());
+            let spiedStatus = spy(state.getStatusManager());
             when(spiedCompiler.buildWorkspace()).thenCall(() => { return Promise.resolve(); });
             await vscode.commands.executeCommand("amiga-assembly.build-vasm-workspace");
             verify(spiedCompiler.buildWorkspace()).once();
@@ -171,8 +177,9 @@ describe("Global Extension Tests", function () {
             verify(spiedStatus.onError("nope")).once();
         });
         it("Should build the current document on command", async () => {
-            let spiedCompiler = spy(extension.compiler);
-            let spiedStatus = spy(extension.statusManager);
+            let state = ExtensionState.getInstance();
+            let spiedCompiler = spy(state.getCompiler());
+            let spiedStatus = spy(state.getStatusManager());
             when(spiedCompiler.buildCurrentEditorFile()).thenCall(() => { return Promise.resolve(); });
             await vscode.commands.executeCommand("amiga-assembly.build-vasm");
             verify(spiedCompiler.buildCurrentEditorFile()).once();
@@ -188,8 +195,9 @@ describe("Global Extension Tests", function () {
             verify(spiedStatus.onError("nope")).once();
         });
         it("Should clean the current workspace on command", async () => {
-            let spiedCompiler = spy(extension.compiler);
-            let spiedStatus = spy(extension.statusManager);
+            let state = ExtensionState.getInstance();
+            let spiedCompiler = spy(state.getCompiler());
+            let spiedStatus = spy(state.getStatusManager());
             when(spiedCompiler.cleanWorkspace()).thenCall(() => { return Promise.resolve(); });
             await vscode.commands.executeCommand("amiga-assembly.clean-vasm-workspace");
             verify(spiedCompiler.cleanWorkspace()).once();
@@ -206,7 +214,8 @@ describe("Global Extension Tests", function () {
         });
         describe("Disassemble comand", function () {
             it("Should disassemble a file", async () => {
-                let spiedDisassembler = spy(extension.disassembler);
+                let state = ExtensionState.getInstance();
+                let spiedDisassembler = spy(state.getDisassembler());
                 let mockedCapstone = mock(Capstone);
                 let capstone = instance(mockedCapstone);
                 when(spiedDisassembler.getCapstone()).thenCall(() => { return capstone; });

src/test/status.test.ts

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { statusManager } from '../extension';
+import { ExtensionState } from '../extensionState';
 import { spy, verify, anyString, when } from 'ts-mockito/lib/ts-mockito';
 import * as vscode from 'vscode';
 
@@ -11,6 +11,8 @@ describe("Status Tests", function () {
         return vscode.window.showTextDocument(newFile);
     });
     it("Should status show on command", () => {
+        let state = ExtensionState.getInstance();
+        let statusManager = state.getStatusManager();
         statusManager.diagnosticsStatusBarItem.show();
         // status is shown
         expect(statusManager.statusBarEntry).not.to.be.null;
@@ -46,6 +48,8 @@ describe("Status Tests", function () {
     });
     it("Should show react to an error", () => {
         let spiedWindow = spy(vscode.window);
+        let state = ExtensionState.getInstance();
+        let statusManager = state.getStatusManager();
         expect(statusManager.statusBarEntry).not.to.be.null;
         if (statusManager.statusBarEntry) {
             // onError
@@ -56,6 +60,8 @@ describe("Status Tests", function () {
         }
     });
     it("Should show react to a success", () => {
+        let state = ExtensionState.getInstance();
+        let statusManager = state.getStatusManager();
         expect(statusManager.statusBarEntry).not.to.be.null;
         if (statusManager.statusBarEntry) {
             // onError

src/test/vasm.test.ts

@@ -5,7 +5,7 @@ import { capture, spy, verify, anyString, when, anything, resetCalls } from 'ts-
 import { VASMCompiler, VASMParser, VASMController } from '../vasm';
 import { Executor, ICheckResult } from '../executor';
 import { DummyTextDocument } from './dummy';
-import { statusManager } from '../extension';
+import { ExtensionState } from '../extensionState';
 import { VLINKLinker } from '../vlink';
 
 describe("VASM Tests", function () {
@@ -158,7 +158,8 @@ describe("VASM Tests", function () {
         });
         it("Should clean the workspace", async function () {
             let spiedWorkspace = spy(vscode.workspace);
-            let spiedOutputChannel = spy(statusManager.outputChannel);
+            let state = ExtensionState.getInstance();
+            let spiedOutputChannel = spy(state.getStatusManager().outputChannel);
             when(spiedCompiler.unlink(anything())).thenCall(() => { });
             let file1 = vscode.Uri.parse("file:///build/file1.o");
             let file2 = vscode.Uri.parse("file:///build/file2.o");
@@ -170,8 +171,8 @@ describe("VASM Tests", function () {
             });
         });
         it("Should get an error when cleaning the workspace", async function () {
-            //let spiedWorkspace = spy(vscode.workspace);
-            let spiedOutputChannel = spy(statusManager.outputChannel);
+            let state = ExtensionState.getInstance();
+            let spiedOutputChannel = spy(state.getStatusManager().outputChannel);
             spiedCompiler = spy(compiler);
             when(spiedCompiler.getWorkspaceRootDir()).thenReturn(vscode.Uri.parse("file:///workdir"));
             when(spiedCompiler.mkdirSync(anything())).thenCall(() => { return Promise.resolve(); });
@@ -202,7 +203,8 @@ describe("VASM Tests", function () {
         it("Should build the current document on save", async () => {
             let compiler = new VASMCompiler();
             const spiedCompiler = spy(compiler);
-            const spiedStatus = spy(statusManager);
+            let state = ExtensionState.getInstance();
+            const spiedStatus = spy(state.getStatusManager());
             let controller = new VASMController(compiler);
             let document = new DummyTextDocument();