feat: add logging via a logging channel (#236)

Author: krvajal

.vscode/tasks.json

@@ -8,23 +8,33 @@
 
 // A task runner that calls a custom npm script that compiles the extension.
 {
-    "version": "0.1.0",
+    "version": "2.0.0",
 
     // we want to run npm
     "command": "npm",
 
-    // the command is a shell script
-    "isShellCommand": true,
-
-    // show the output window only if unrecognized errors occur.
-    "showOutput": "silent",
-
     // we run the custom script "compile" as defined in package.json
     "args": ["run", "compile", "--loglevel", "silent"],
 
     // The tsc compiler is started in watching mode
     "isBackground": true,
 
     // use the standard tsc in watch mode problem matcher to find compile problems in the output.
-    "problemMatcher": "$tsc-watch"
+    "problemMatcher": "$tsc-watch",
+    "tasks": [
+        {
+            "label": "npm",
+            "type": "shell",
+            "command": "npm",
+            "args": [
+                "run",
+                "compile",
+                "--loglevel",
+                "silent"
+            ],
+            "isBackground": true,
+            "problemMatcher": "$tsc-watch",
+            "group": "build"
+        }
+    ]
 }

.vscode/tasks.json.old

@@ -0,0 +1,30 @@
+// Available variables which can be used inside of strings.
+// ${workspaceRoot}: the root folder of the team
+// ${file}: the current opened file
+// ${fileBasename}: the current opened file's basename
+// ${fileDirname}: the current opened file's dirname
+// ${fileExtname}: the current opened file's extension
+// ${cwd}: the current working directory of the spawned process
+
+// A task runner that calls a custom npm script that compiles the extension.
+{
+    "version": "0.1.0",
+
+    // we want to run npm
+    "command": "npm",
+
+    // the command is a shell script
+    "isShellCommand": true,
+
+    // show the output window only if unrecognized errors occur.
+    "showOutput": "silent",
+
+    // we run the custom script "compile" as defined in package.json
+    "args": ["run", "compile", "--loglevel", "silent"],
+
+    // The tsc compiler is started in watching mode
+    "isBackground": true,
+
+    // use the standard tsc in watch mode problem matcher to find compile problems in the output.
+    "problemMatcher": "$tsc-watch"
+}

package.json

@@ -183,7 +183,7 @@
     "@types/fs-extra": "0.0.35",
     "@types/glob": "^5.0.30",
     "@types/mocha": "^2.2.32",
-    "@types/node": "^6.0.40",
+    "@types/node": "^15.12.1",
     "decache": "^4.1.0",
     "fs-extra": "^1.0.0",
     "glob": "^7.1.1",

src/extension.ts

@@ -8,32 +8,39 @@ import { FortranDocumentSymbolProvider } from './features/document-symbol-provid
 
 import { FORTRAN_FREE_FORM_ID, EXTENSION_ID } from './lib/helper'
 import { FortranLangServer, checkForLangServer } from './lang-server'
-
+import { LoggingService } from './services/logging-service'
+import * as pkg from '../package.json'
 
 export function activate(context: vscode.ExtensionContext) {
-
+  const loggingService = new LoggingService()
   const extensionConfig = vscode.workspace.getConfiguration(EXTENSION_ID)
 
+  loggingService.logInfo(`Extension Name: ${pkg.displayName}`)
+  loggingService.logInfo(`Extension Version: ${pkg.version}`)
+
   if (extensionConfig.get('linterEnabled', true)) {
-    let linter = new FortranLintingProvider()
+    let linter = new FortranLintingProvider(loggingService)
     linter.activate(context.subscriptions)
     vscode.languages.registerCodeActionsProvider(FORTRAN_FREE_FORM_ID, linter)
+  } else {
+    loggingService.logInfo('Linter is not enabled')
   }
 
   if (extensionConfig.get('provideCompletion', true)) {
-    let completionProvider = new FortranCompletionProvider()
+    let completionProvider = new FortranCompletionProvider(loggingService)
     vscode.languages.registerCompletionItemProvider(
       FORTRAN_FREE_FORM_ID,
       completionProvider
     )
+  } else {
+    loggingService.logInfo('Completion Provider is not enabled')
   }
 
   if (extensionConfig.get('provideHover', true)) {
-    let hoverProvider = new FortranHoverProvider()
-    vscode.languages.registerHoverProvider(
-      FORTRAN_FREE_FORM_ID,
-      hoverProvider
-    )
+    let hoverProvider = new FortranHoverProvider(loggingService)
+    vscode.languages.registerHoverProvider(FORTRAN_FREE_FORM_ID, hoverProvider)
+  } else {
+    loggingService.logInfo('Hover Provider is not enabled')
   }
 
   if (extensionConfig.get('provideSymbols', true)) {
@@ -42,10 +49,11 @@ export function activate(context: vscode.ExtensionContext) {
       FORTRAN_FREE_FORM_ID,
       symbolProvider
     )
+  } else {
+    loggingService.logInfo('Symbol Provider is not enabled')
   }
 
   if (checkForLangServer(extensionConfig)) {
-
     const langServer = new FortranLangServer(context, extensionConfig)
     langServer.start()
     langServer.onReady().then(() => {

src/features/completion-provider.ts

@@ -1,40 +1,43 @@
-import { CancellationToken, TextDocument, Position, Hover } from 'vscode';
-import * as fs from 'fs';
-import * as vscode from 'vscode';
-import { isPositionInString, intrinsics, FORTRAN_KEYWORDS } from '../lib/helper';
-import { getDeclaredFunctions } from '../lib/functions';
+import { CancellationToken, TextDocument, Position, Hover } from 'vscode'
+import * as fs from 'fs'
+import * as vscode from 'vscode'
+import { isPositionInString, intrinsics, FORTRAN_KEYWORDS } from '../lib/helper'
+import { getDeclaredFunctions } from '../lib/functions'
 
-import { EXTENSION_ID } from '../lib/helper';
+import { EXTENSION_ID } from '../lib/helper'
+import { LoggingService } from '../services/logging-service'
 
 class CaseCoverter {
-  preferredCase: string;
-  static LOWER = 'lowercase';
-  static UPPER = 'uppercase';
+  preferredCase: string
+  static LOWER = 'lowercase'
+  static UPPER = 'uppercase'
 
   constructor(preferredCase: string = CaseCoverter.LOWER) {
-    this.preferredCase = preferredCase;
+    this.preferredCase = preferredCase
   }
 
   convert(word: string): string {
     if (this.preferredCase === CaseCoverter.LOWER) {
-      return this.toLower(word);
+      return this.toLower(word)
     } else if (this.preferredCase === CaseCoverter.UPPER) {
-      return this.toUpper(word);
+      return this.toUpper(word)
     }
 
-    throw new Error(`the provided case ${this.preferredCase} is not supported`);
+    throw new Error(`the provided case ${this.preferredCase} is not supported`)
   }
 
   toLower(word: string) {
-    return word.toLowerCase();
+    return word.toLowerCase()
   }
   toUpper(word: string) {
-    return word.toUpperCase();
+    return word.toUpperCase()
   }
 }
 
 export class FortranCompletionProvider
-  implements vscode.CompletionItemProvider {
+  implements vscode.CompletionItemProvider
+{
+  constructor(private loggingService: LoggingService) {}
   public provideCompletionItems(
     document: vscode.TextDocument,
     position: vscode.Position,
@@ -45,7 +48,7 @@ export class FortranCompletionProvider
       position,
       token,
       vscode.workspace.getConfiguration(EXTENSION_ID)
-    );
+    )
   }
 
   public provideCompletionItemsInternal(
@@ -55,105 +58,104 @@ export class FortranCompletionProvider
     config: vscode.WorkspaceConfiguration
   ): Thenable<vscode.CompletionItem[]> {
     return new Promise<vscode.CompletionItem[]>((resolve, reject) => {
-      let lineText = document.lineAt(position.line).text;
-      let lineTillCurrentPosition = lineText.substr(0, position.character);
+      let lineText = document.lineAt(position.line).text
+      let lineTillCurrentPosition = lineText.substr(0, position.character)
       // nothing to complete
       if (lineText.match(/^\s*\/\//)) {
-        return resolve([]);
+        return resolve([])
       }
 
-      let inString = isPositionInString(document, position);
+      let inString = isPositionInString(document, position)
       if (!inString && lineTillCurrentPosition.endsWith('"')) {
         // completing a string
-        return resolve([]);
+        return resolve([])
       }
 
-      let currentWord = this.getCurrentWord(document, position);
+      let currentWord = this.getCurrentWord(document, position)
 
       if (currentWord.match(/^\d+$/)) {
         // starts with a number
-        return resolve([]);
+        return resolve([])
       }
 
-      const caseConverter = new CaseCoverter(config.get('preferredCase'));
+      const caseConverter = new CaseCoverter(config.get('preferredCase'))
 
       if (currentWord.length === 0) {
-        resolve([]);
+        resolve([])
       }
 
       const intrinsicSuggestions = this.getIntrinsicSuggestions(
         currentWord,
         caseConverter
-      );
+      )
 
       // add keyword suggestions
-      const keywordSuggestions = this.getKeywordSuggestions(currentWord);
+      const keywordSuggestions = this.getKeywordSuggestions(currentWord)
 
       const functionSuggestions = this.getFunctionSuggestions(
         document,
         currentWord
-      );
+      )
 
       return resolve([
         ...intrinsicSuggestions,
         ...keywordSuggestions,
         ...functionSuggestions,
-      ]);
-    });
+      ])
+    })
   }
 
   private getIntrinsicSuggestions(
     currentWord: string,
     caseConverter: CaseCoverter
   ): vscode.CompletionItem[] {
     return intrinsics
-      .filter(i => i.startsWith(currentWord.toUpperCase()))
+      .filter((i) => i.startsWith(currentWord.toUpperCase()))
       .map((intrinsic: string) => {
         return new vscode.CompletionItem(
           caseConverter.convert(intrinsic),
           vscode.CompletionItemKind.Method
-        );
-      });
+        )
+      })
   }
 
   private getKeywordSuggestions(currentWord: string): vscode.CompletionItem[] {
-    return FORTRAN_KEYWORDS.filter(keyword =>
+    return FORTRAN_KEYWORDS.filter((keyword) =>
       keyword.startsWith(currentWord.toUpperCase())
-    ).map(keyword => {
+    ).map((keyword) => {
       return new vscode.CompletionItem(
         keyword.toLowerCase(),
         vscode.CompletionItemKind.Keyword
-      );
-    });
+      )
+    })
   }
 
   private getFunctionSuggestions(
     document: TextDocument,
     currentWord: string
   ): vscode.CompletionItem[] {
-    const functions = getDeclaredFunctions(document);
+    const functions = getDeclaredFunctions(document)
     // check for available functions
     return functions
-      .filter(fun => fun.name.startsWith(currentWord))
-      .map(fun => {
+      .filter((fun) => fun.name.startsWith(currentWord))
+      .map((fun) => {
         return new vscode.CompletionItem(
           `${fun.name}(`,
           vscode.CompletionItemKind.Function
-        );
-      });
+        )
+      })
   }
 
   private getCurrentWord(document: TextDocument, position: Position): string {
-    let wordAtPosition = document.getWordRangeAtPosition(position);
-    let currentWord = '';
+    let wordAtPosition = document.getWordRangeAtPosition(position)
+    let currentWord = ''
     if (wordAtPosition && wordAtPosition.start.character < position.character) {
-      let word = document.getText(wordAtPosition);
+      let word = document.getText(wordAtPosition)
       currentWord = word.substr(
         0,
         position.character - wordAtPosition.start.character
-      );
+      )
     }
-    return currentWord;
-
+    return currentWord
   }
 }