feat: prettier cancellation

discopop-project · Nov 14, 2023 · 73e82d2 · 73e82d2
1 parent ba51ce2
commit 73e82d2
Show file tree

Hide file tree

Showing 4 changed files with 69 additions and 14 deletions.
diff --git a/src/DiscoPoP/DiscoPoPRunner.ts b/src/DiscoPoP/DiscoPoPRunner.ts
@@ -16,6 +16,7 @@ import { getDefaultErrorHandler } from '../Utils/ErrorHandler'
 import { LineMapping } from '../LineMapping/LineMapping'
 import { Suggestion } from './classes/Suggestion/Suggestion'
 import { DiscoPoPAppliedSuggestionsWatcher } from './DiscoPoPAppliedSuggestionsWatcher'
+import { UserCancellationError } from '../Utils/CancellationError'
 
 export interface DiscoPoPRunnerRunArguments {
     fullConfiguration: DefaultConfiguration // TODO replace with only the necessary fields
@@ -68,7 +69,9 @@ export abstract class DiscoPoPRunner {
         )
         return runningFinishedSuccessfully
             ? DiscoPoPRunner.parse(dpRunnerArgs)
-            : Promise.reject(new Error('DiscoPoP run was cancelled.'))
+            : Promise.reject(
+                  new UserCancellationError('DiscoPoP run was cancelled.')
+              )
     }
 
     public static async run(

diff --git a/src/DiscoPoPExtension.ts b/src/DiscoPoPExtension.ts
@@ -24,6 +24,7 @@ import {
     HotspotDetectionRunnerResults,
 } from './HotspotDetection/HotspotDetectionRunner'
 import { getDefaultErrorHandler } from './Utils/ErrorHandler'
+import { UserCancellationError } from './Utils/CancellationError'
 
 function _removeDecorations(
     editor: vscode.TextEditor,
@@ -116,14 +117,23 @@ export class DiscoPoPExtension {
                 async (configuration: Configuration) => {
                     const fullConfig = configuration.getFullConfiguration()
 
-                    // DiscoPoP
-                    this.dpResults.finalize()
-                    this.dpResults = await fullConfig.runDiscoPoP()
-                    await this.showDiscoPoPResults(fullConfig)
+                    try {
+                        // DiscoPoP
+                        this.dpResults?.finalize()
+                        this.dpResults = await fullConfig.runDiscoPoP()
+                        await this.showDiscoPoPResults(fullConfig)
 
-                    // HotspotDetection
-                    this.hsResults = await configuration.runHotspotDetection()
-                    await this.showHotspotDetectionResults(this.hsResults)
+                        // HotspotDetection
+                        this.hsResults =
+                            await configuration.runHotspotDetection()
+                        await this.showHotspotDetectionResults(this.hsResults)
+                    } catch (error) {
+                        if (error instanceof UserCancellationError) {
+                            error.showErrorMessageNotification()
+                        } else {
+                            throw error
+                        }
+                    }
                 }
             )
         )
@@ -132,9 +142,18 @@ export class DiscoPoPExtension {
             vscode.commands.registerCommand(
                 Commands.runDiscoPoP,
                 async (configuration: Configuration) => {
-                    const fullConfig = configuration.getFullConfiguration()
-                    this.dpResults = await fullConfig.runDiscoPoP()
-                    await this.showDiscoPoPResults(fullConfig)
+                    try {
+                        const fullConfig = configuration.getFullConfiguration()
+                        this.dpResults?.finalize()
+                        this.dpResults = await fullConfig.runDiscoPoP()
+                        await this.showDiscoPoPResults(fullConfig)
+                    } catch (error) {
+                        if (error instanceof UserCancellationError) {
+                            error.showErrorMessageNotification()
+                        } else {
+                            throw error
+                        }
+                    }
                 }
             )
         )
@@ -143,8 +162,17 @@ export class DiscoPoPExtension {
             vscode.commands.registerCommand(
                 Commands.runHotspotDetection,
                 async (configuration: Configuration) => {
-                    const results = await configuration.runHotspotDetection()
-                    this.showHotspotDetectionResults(results)
+                    try {
+                        const results =
+                            await configuration.runHotspotDetection()
+                        this.showHotspotDetectionResults(results)
+                    } catch (error) {
+                        if (error instanceof UserCancellationError) {
+                            error.showErrorMessageNotification()
+                        } else {
+                            throw error
+                        }
+                    }
                 }
             )
         )

diff --git a/src/HotspotDetection/HotspotDetectionRunner.ts b/src/HotspotDetection/HotspotDetectionRunner.ts
@@ -14,6 +14,7 @@ import { FileMapping } from '../FileMapping/FileMapping'
 import { HotspotDetectionResults } from './HotspotDetectionResults'
 import { HotspotDetectionParser } from './HotspotDetectionParser'
 import { HotspotTree } from './HotspotTree'
+import { UserCancellationError } from '../Utils/CancellationError'
 
 export interface HotspotDetectionRunnerRunArguments {
     configuration: Configuration // TODO only the relevent properties
@@ -42,7 +43,9 @@ export abstract class HotspotDetectionRunner {
         )
         return runningFinishedSuccessfully
             ? HotspotDetectionRunner.parse(args)
-            : Promise.reject(new Error('Hotspot Detection was cancelled.'))
+            : Promise.reject(
+                  new UserCancellationError('Hotspot Detection was cancelled.')
+              )
     }
 
     public static async run(

diff --git a/src/Utils/CancellationError.ts b/src/Utils/CancellationError.ts
@@ -0,0 +1,21 @@
+import * as vscode from 'vscode'
+
+export class UserCancellationError extends Error {
+    constructor(message?: string) {
+        super(message)
+    }
+
+    public showErrorMessageNotification(timeout = 3000) {
+        vscode.window.withProgress(
+            {
+                location: vscode.ProgressLocation.Notification,
+                title: this.message,
+                cancellable: false,
+            },
+            async (progress, token) => {
+                progress.report({ increment: 100 })
+                await new Promise((resolve) => setTimeout(resolve, timeout))
+            }
+        )
+    }
+}