feat: Add toggle command

package.json

@@ -161,6 +161,10 @@
         "command": "coverage-gutters.displayCoverage",
         "title": "Coverage Gutters: Display Coverage"
       },
+      {
+        "command": "coverage-gutters.toggleCoverage",
+        "title": "Coverage Gutters: Toggle Coverage"
+      },
       {
         "command": "coverage-gutters.watchCoverageAndVisibleEditors",
         "title": "Coverage Gutters: Watch"
@@ -200,6 +204,11 @@
         "key": "ctrl+shift+0",
         "mac": "shift+cmd+0",
         "win": "ctrl+shift+backspace"
+      },
+      {
+        "command": "coverage-gutters.toggleCoverage",
+        "key": "ctrl+shift+5",
+        "mac": "shift+cmd+5"
       }
     ],
     "menus": {

src/coverage-system/coverageservice.ts

@@ -29,6 +29,7 @@ export class CoverageService {
     private outputChannel: OutputChannel;
     private filesLoader: FilesLoader;
     private renderer: Renderer;
+    private isCoverageDisplayed = false;
 
     private coverageParser: CoverageParser;
     private coverageWatcher: FileSystemWatcher | undefined;
@@ -68,6 +69,15 @@ export class CoverageService {
 
     public async displayForFile() {
         await this.loadCacheAndProcess();
+        this.isCoverageDisplayed = true;
+    }
+
+    public async toggleCoverage() {
+        if (this.isCoverageDisplayed) {
+            this.removeCoverageForCurrentEditor();
+        } else {
+            await this.displayForFile();
+        }
     }
 
     public async watchWorkspace() {
@@ -82,6 +92,7 @@ export class CoverageService {
             this.renderer.renderCoverage(new Map(), window.visibleTextEditors);
         } finally {
             this.statusBar.setLoading(false);
+            this.isCoverageDisplayed = false;
         }
     }
 

src/extension.ts

@@ -24,6 +24,10 @@ export function activate(context: vscode.ExtensionContext) {
         "coverage-gutters.displayCoverage",
         gutters.displayCoverageForActiveFile.bind(gutters),
     );
+    const toggle = vscode.commands.registerCommand(
+        "coverage-gutters.toggleCoverage",
+        gutters.toggleCoverageForActiveFile.bind(gutters),
+    );
     const watch = vscode.commands.registerCommand(
         "coverage-gutters.watchCoverageAndVisibleEditors",
         gutters.watchCoverageAndVisibleEditors.bind(gutters),
@@ -40,6 +44,7 @@ export function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(previewCoverageReport);
     context.subscriptions.push(remove);
     context.subscriptions.push(display);
+    context.subscriptions.push(toggle);
     context.subscriptions.push(watch);
     context.subscriptions.push(removeWatch);
     context.subscriptions.push(gutters);

src/extension/gutters.ts

@@ -76,6 +76,15 @@ export class Gutters {
         }
     }
 
+    public async toggleCoverageForActiveFile() {
+        try {
+            await this.coverageService.toggleCoverage();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        } catch (error: any) {
+            this.handleError("toggleCoverageForActiveFile", error);
+        }
+    }
+
     public async watchCoverageAndVisibleEditors() {
         try {
             this.statusBar.toggle(true);

test/extension.test.ts

@@ -90,6 +90,44 @@ suite("Extension Tests", function() {
             expect(cachedLines.none).to.have.lengthOf(3);
         });
 
+        await vscode.commands.executeCommand("coverage-gutters.removeCoverage");
+        decorationSpy.restore();
+    });
+
+    test("Run toggle coverage on python test file x2 @integration", async () => {
+        // Set up the spies to allow for detecting proper code flows
+        const decorationSpy = sinon.spy(Renderer.prototype, "setDecorationsForEditor");
+        const removalSpy = sinon.spy(Renderer.prototype, "removeDecorationsForEditor");
+        const extension = await vscode.extensions.getExtension("ryanluker.vscode-coverage-gutters");
+        if (!extension) {
+            throw new Error("Could not load extension");
+        }
+
+        const testCoverage = await vscode.workspace.findFiles("**/bar/a.py", "**/node_modules/**");
+        const testDocument = await vscode.workspace.openTextDocument(testCoverage[0]);
+        await vscode.window.showTextDocument(testDocument);
+
+        // Toggle coverage on
+        await vscode.commands.executeCommand("coverage-gutters.toggleCoverage");
+        await checkCoverage(() => {
+            // Look for exact coverage on the file
+            const cachedLines: ICoverageLines = decorationSpy.getCall(0).args[1];
+            expect(cachedLines.full).to.have.lengthOf(3);
+            expect(cachedLines.none).to.have.lengthOf(3);
+        });
+
+        // Toggle coverage off
+        await vscode.commands.executeCommand("coverage-gutters.toggleCoverage");
+        // Check that renderSections was called with empty Map
+        await checkCoverage(() => {
+            // Check for remove coverage being called twice
+            const coverageRemovalCalls = removalSpy.getCalls();
+            expect(coverageRemovalCalls).to.have.length(2);
+            // Check for the coverage display being called once
+            const coverageAdditionCalls = decorationSpy.getCalls();
+            expect(coverageAdditionCalls).to.have.length(1);
+        });
+
         decorationSpy.restore();
     });