refactor: rewrote the logger

Simplifies the calls and renames methods to more intuitive names

Author: gnikit

src/extension.ts

@@ -12,11 +12,11 @@ import { FortlsClient } from './lsp/client';
 import { FortranHoverProvider } from './features/hover-provider';
 import { FortranLintingProvider } from './features/linter-provider';
 import { EXTENSION_ID, FortranDocumentSelector } from './lib/tools';
-import { LoggingService } from './services/logging-service';
+import { Logger } from './services/logging-service';
 import { WhatsNew } from './features/commands';
 
 // Make it global to catch errors when activation fails
-const loggingService = new LoggingService();
+const logger = new Logger(vscode.window.createOutputChannel('Modern Fortran'));
 
 export async function activate(context: vscode.ExtensionContext) {
   const config = vscode.workspace.getConfiguration(EXTENSION_ID);
@@ -27,34 +27,34 @@ export async function activate(context: vscode.ExtensionContext) {
   const symbolsType = config.get<string>('provide.symbols');
   detectDeprecatedOptions();
 
-  loggingService.logInfo(`Extension Name: ${pkg.displayName}`);
-  loggingService.logInfo(`Extension Version: ${pkg.version}`);
-  loggingService.logInfo(`Linter set to: ${linterType}`);
-  loggingService.logInfo(`Formatter set to: ${formatterType}`);
-  loggingService.logInfo(`Autocomplete set to: ${autocompleteType}`);
-  loggingService.logInfo(`Hover set to: ${hoverType}`);
-  loggingService.logInfo(`Symbols set to: ${symbolsType}`);
+  logger.info(`Extension Name: ${pkg.displayName}`);
+  logger.info(`Extension Version: ${pkg.version}`);
+  logger.info(`Linter set to: ${linterType}`);
+  logger.info(`Formatter set to: ${formatterType}`);
+  logger.info(`Autocomplete set to: ${autocompleteType}`);
+  logger.info(`Hover set to: ${hoverType}`);
+  logger.info(`Symbols set to: ${symbolsType}`);
 
   // Linter is always activated but will only lint if compiler !== Disabled
-  const linter = new FortranLintingProvider(loggingService);
+  const linter = new FortranLintingProvider(logger);
   linter.activate(context.subscriptions);
   vscode.languages.registerCodeActionsProvider(FortranDocumentSelector(), linter);
 
   if (formatterType !== 'Disabled') {
     const disposable: vscode.Disposable = vscode.languages.registerDocumentFormattingEditProvider(
       FortranDocumentSelector(),
-      new FortranFormattingProvider(loggingService)
+      new FortranFormattingProvider(logger)
     );
     context.subscriptions.push(disposable);
   }
 
   if (autocompleteType === 'Built-in') {
-    const completionProvider = new FortranCompletionProvider(loggingService);
+    const completionProvider = new FortranCompletionProvider(logger);
     vscode.languages.registerCompletionItemProvider(FortranDocumentSelector(), completionProvider);
   }
 
   if (hoverType === 'Built-in' || hoverType === 'Both') {
-    const hoverProvider = new FortranHoverProvider(loggingService);
+    const hoverProvider = new FortranHoverProvider(logger);
     vscode.languages.registerHoverProvider(FortranDocumentSelector(), hoverProvider);
   }
 
@@ -64,7 +64,7 @@ export async function activate(context: vscode.ExtensionContext) {
   }
 
   if (!config.get<boolean>('fortls.disabled')) {
-    new FortlsClient(loggingService, context).activate();
+    new FortlsClient(logger, context).activate();
   }
   // override VS Code's default implementation of the debug hover
   // here we match Fortran derived types and scope them appropriately
@@ -129,7 +129,7 @@ function detectDeprecatedOptions() {
         if (selected === 'Open Settings') {
           vscode.commands.executeCommand('workbench.action.openGlobalSettings');
         }
-        loggingService.logError(`The following deprecated options have been detected:\n${oldArgs}`);
+        logger.error(`The following deprecated options have been detected:\n${oldArgs}`);
       });
   }
 

src/features/completion-provider.ts

@@ -4,7 +4,7 @@ import * as vscode from 'vscode';
 import { isPositionInString, FORTRAN_KEYWORDS } from '../lib/helper';
 import { getDeclaredFunctions } from '../lib/functions';
 import { EXTENSION_ID } from '../lib/tools';
-import { LoggingService } from '../services/logging-service';
+import { Logger } from '../services/logging-service';
 import intrinsics from './intrinsics.json';
 
 class CaseCoverter {
@@ -35,7 +35,7 @@ class CaseCoverter {
 }
 
 export class FortranCompletionProvider implements vscode.CompletionItemProvider {
-  constructor(private loggingService: LoggingService) {}
+  constructor(private logger: Logger) {}
   public provideCompletionItems(
     document: vscode.TextDocument,
     position: vscode.Position,

src/features/formatting-provider.ts

@@ -6,7 +6,7 @@ import * as which from 'which';
 import * as vscode from 'vscode';
 import * as cp from 'child_process';
 
-import { LoggingService } from '../services/logging-service';
+import { Logger } from '../services/logging-service';
 import {
   FORMATTERS,
   EXTENSION_ID,
@@ -18,7 +18,7 @@ import {
 export class FortranFormattingProvider implements vscode.DocumentFormattingEditProvider {
   private readonly workspace = vscode.workspace.getConfiguration(EXTENSION_ID);
   private formatter: string | undefined;
-  constructor(private logger: LoggingService) {}
+  constructor(private logger: Logger) {}
 
   public async provideDocumentFormattingEdits(
     document: vscode.TextDocument,
@@ -32,7 +32,7 @@ export class FortranFormattingProvider implements vscode.DocumentFormattingEditP
     } else if (formatterName === 'findent') {
       return this.doFormatFindent(document);
     } else {
-      this.logger.logError('Cannot format document with formatter set to Disabled');
+      this.logger.error('Cannot format document with formatter set to Disabled');
     }
 
     return undefined;
@@ -46,7 +46,7 @@ export class FortranFormattingProvider implements vscode.DocumentFormattingEditP
   private async doFormatFprettify(document: vscode.TextDocument): Promise<vscode.TextEdit[]> {
     // fprettify can only do FortranFreeFrom
     if (document.languageId !== 'FortranFreeForm') {
-      this.logger.logError(`fprettify can only format FortranFreeForm, change
+      this.logger.error(`fprettify can only format FortranFreeForm, change
                             to findent for FortranFixedForm formatting`);
       return undefined;
     }
@@ -56,7 +56,7 @@ export class FortranFormattingProvider implements vscode.DocumentFormattingEditP
     const formatter: string = path.join(formatterPath, formatterName);
     // If no formatter is detected try and install it
     if (!which.sync(formatter, { nothrow: true })) {
-      this.logger.logWarning(`Formatter: ${formatterName} not detected in your system.
+      this.logger.warn(`Formatter: ${formatterName} not detected in your system.
                                 Attempting to install now.`);
       const msg = `Installing ${formatterName} through pip with --user option`;
       promptForMissingTool(formatterName, msg, 'Python', ['Install'], this.logger);
@@ -66,7 +66,7 @@ export class FortranFormattingProvider implements vscode.DocumentFormattingEditP
     const edits: vscode.TextEdit[] = [];
     const [stdout, stderr] = await spawnAsPromise(formatter, args, undefined, document.getText());
     edits.push(new vscode.TextEdit(getWholeFileRange(document), stdout));
-    if (stderr) this.logger.logInfo(`fprettify error output: ${stderr}`);
+    if (stderr) this.logger.info(`fprettify error output: ${stderr}`);
     return edits;
   }
 
@@ -81,7 +81,7 @@ export class FortranFormattingProvider implements vscode.DocumentFormattingEditP
     const formatter: string = path.join(formatterPath, formatterName);
     // If no formatter is detected try and install it
     if (!which.sync(formatter, { nothrow: true })) {
-      this.logger.logWarning(`Formatter: ${formatterName} not detected in your system.
+      this.logger.warn(`Formatter: ${formatterName} not detected in your system.
                                     Attempting to install now.`);
       const msg = `Installing ${formatterName} through pip with --user option`;
       promptForMissingTool(formatterName, msg, 'Python', ['Install'], this.logger);
@@ -91,7 +91,7 @@ export class FortranFormattingProvider implements vscode.DocumentFormattingEditP
     const edits: vscode.TextEdit[] = [];
     const [stdout, stderr] = await spawnAsPromise(formatter, args, undefined, document.getText());
     edits.push(new vscode.TextEdit(getWholeFileRange(document), stdout));
-    if (stderr) this.logger.logInfo(`findent error output: ${stderr}`);
+    if (stderr) this.logger.info(`findent error output: ${stderr}`);
     return edits;
   }
 
@@ -107,7 +107,7 @@ export class FortranFormattingProvider implements vscode.DocumentFormattingEditP
     this.formatter = this.workspace.get('formatting.formatter', 'Disabled');
 
     if (!FORMATTERS.includes(this.formatter)) {
-      this.logger.logError(`Unsupported formatter: ${this.formatter}`);
+      this.logger.error(`Unsupported formatter: ${this.formatter}`);
     }
     return this.formatter;
   }
@@ -130,7 +130,7 @@ export class FortranFormattingProvider implements vscode.DocumentFormattingEditP
   private getFormatterPath(): string {
     const formatterPath: string = this.workspace.get('formatting.path', '');
     if (formatterPath !== '') {
-      this.logger.logInfo(`Formatter located in: ${formatterPath}`);
+      this.logger.info(`Formatter located in: ${formatterPath}`);
     }
 
     return formatterPath;

src/features/hover-provider.ts

@@ -1,9 +1,9 @@
 import { CancellationToken, TextDocument, Position, Hover } from 'vscode';
-import { LoggingService } from '../services/logging-service';
+import { Logger } from '../services/logging-service';
 import intrinsics from './intrinsics.json';
 
 export class FortranHoverProvider {
-  constructor(private loggingService: LoggingService) {}
+  constructor(private logger: Logger) {}
   public provideHover(
     document: TextDocument,
     position: Position,

src/features/linter-provider.ts

@@ -5,15 +5,15 @@ import * as cp from 'child_process';
 import which from 'which';
 
 import * as vscode from 'vscode';
-import { LoggingService } from '../services/logging-service';
+import { Logger } from '../services/logging-service';
 import { FortranDocumentSelector, resolveVariables } from '../lib/tools';
 import * as fg from 'fast-glob';
 import { glob } from 'glob';
 import { arraysEqual } from '../lib/helper';
 import { RescanLint } from './commands';
 
 export class FortranLintingProvider {
-  constructor(private logger: LoggingService = new LoggingService()) {}
+  constructor(private logger: Logger = new Logger()) {}
 
   private diagnosticCollection: vscode.DiagnosticCollection;
   private compiler: string;
@@ -167,7 +167,7 @@ export class FortranLintingProvider {
     }
 
     modout = resolveVariables(modout);
-    this.logger.logInfo(`Linter.moduleOutput: ${modFlag} ${modout}`);
+    this.logger.info(`Linter.moduleOutput: ${modFlag} ${modout}`);
     return [modFlag, modout];
   }
 
@@ -195,7 +195,7 @@ export class FortranLintingProvider {
     // Update our cache input
     this.cache['includePaths'] = includePaths;
     // Output the original include paths
-    this.logger.logInfo(`Linter.include:\n${includePaths.join('\r\n')}`);
+    this.logger.info(`Linter.include:\n${includePaths.join('\r\n')}`);
     // Resolve internal variables and expand glob patterns
     const resIncludePaths = includePaths.map(e => resolveVariables(e));
     // fast-glob cannot work with Windows paths
@@ -212,12 +212,12 @@ export class FortranLintingProvider {
       // Try to recover from fast-glob failing due to EACCES using slower more
       // robust glob.
     } catch (eacces) {
-      this.logger.logWarning(`You lack read permissions for an include directory
+      this.logger.warn(`You lack read permissions for an include directory
           or more likely a glob match from the input 'includePaths' list. This can happen when
           using overly broad root level glob patters e.g. /usr/lib/** .
           No reason to worry. I will attempt to recover. 
           You should consider adjusting your 'includePaths' if linting performance is slow.`);
-      this.logger.logWarning(`${eacces.message}`);
+      this.logger.warn(`${eacces.message}`);
       try {
         const globIncPaths: string[] = [];
         for (const i of resIncludePaths) {
@@ -228,7 +228,7 @@ export class FortranLintingProvider {
         return globIncPaths;
         // if we failed again then our includes are somehow wrong. Abort
       } catch (error) {
-        this.logger.logError(`Failed to recover: ${error}`);
+        this.logger.error(`Failed to recover: ${error}`);
       }
     }
   }
@@ -243,7 +243,7 @@ export class FortranLintingProvider {
     this.compiler = config.get<string>('compiler', 'gfortran');
     this.compilerPath = config.get<string>('compilerPath', '');
     if (this.compilerPath === '') this.compilerPath = which.sync(this.compiler);
-    this.logger.logInfo(`using linter: ${this.compiler} located in: ${this.compilerPath}`);
+    this.logger.info(`using linter: ${this.compiler} located in: ${this.compilerPath}`);
     return this.compilerPath;
   }
 
@@ -287,7 +287,7 @@ export class FortranLintingProvider {
       const lnStr: string = ln === -1 ? 'none' : ln.toString();
       args.push(`-ffree-line-length-${lnStr}`, `-ffixed-line-length-${lnStr}`);
     }
-    this.logger.logInfo(`Linter.arguments:\n${args.join('\r\n')}`);
+    this.logger.info(`Linter.arguments:\n${args.join('\r\n')}`);
 
     // Resolve internal variables but do not apply glob pattern matching
     return args.map(e => resolveVariables(e));

src/lib/tools.ts

@@ -2,7 +2,7 @@ import * as os from 'os';
 import * as vscode from 'vscode';
 import * as assert from 'assert';
 import * as cp from 'child_process';
-import { LoggingService } from '../services/logging-service';
+import { Logger } from '../services/logging-service';
 import { isString, isArrayOfString } from './helper';
 
 export const LS_NAME = 'fortls';
@@ -106,7 +106,7 @@ export async function promptForMissingTool(
   msg: string,
   toolType: string,
   opts: string[],
-  logger?: LoggingService,
+  logger?: Logger,
   action?: () => void
 ) {
   const items = ['Install'];
@@ -118,14 +118,14 @@ export async function promptForMissingTool(
           break;
 
         case 'VSExt':
-          logger.logInfo(`Installing VS Marketplace Extension with id: ${tool}`);
+          logger.info(`Installing VS Marketplace Extension with id: ${tool}`);
           vscode.commands.executeCommand('extension.open', tool);
           vscode.commands.executeCommand('workbench.extensions.installExtension', tool);
-          logger.logInfo(`Extension ${tool} successfully installed`);
+          logger.info(`Extension ${tool} successfully installed`);
           break;
 
         default:
-          logger.logError(`Failed to install tool: ${tool}`);
+          logger.error(`Failed to install tool: ${tool}`);
           vscode.window.showErrorMessage(`Failed to install tool: ${tool}`);
           break;
       }
@@ -142,22 +142,22 @@ export async function promptForMissingTool(
  * @param pyPackage name of python package in PyPi
  * @param logger `optional` logging channel for output
  */
-export function installPythonTool(pyPackage: string, logger?: LoggingService) {
+export function installPythonTool(pyPackage: string, logger?: Logger) {
   const installProcess = cp.spawnSync(
     'pip',
     'install --user --upgrade '.concat(pyPackage).split(' ')
   );
   if (installProcess.error) {
-    logger.logError(
+    logger.error(
       `Python package ${pyPackage} failed to install with code: ${installProcess.error}`
     );
   }
   if (installProcess.stdout) {
     const sep = '-'.repeat(80);
-    logger.logInfo(
+    logger.info(
       `pip install --user --upgrade ${pyPackage}:\n${sep}\n${installProcess.stdout}${sep}`
     );
-    logger.logInfo(`pip install was successful`);
+    logger.info(`pip install was successful`);
   }
 }
 

src/lsp/client.ts

@@ -12,7 +12,7 @@ import {
   isFortran,
   getOuterMostWorkspaceFolder,
 } from '../lib/tools';
-import { LoggingService } from '../services/logging-service';
+import { Logger } from '../services/logging-service';
 import { RestartLS } from '../features/commands';
 
 // The clients are non member variables of the class because they need to be
@@ -21,8 +21,8 @@ import { RestartLS } from '../features/commands';
 export const clients: Map<string, LanguageClient> = new Map();
 
 export class FortlsClient {
-  constructor(private logger: LoggingService, private context?: vscode.ExtensionContext) {
-    this.logger.logInfo('Fortran Language Server');
+  constructor(private logger: Logger, private context?: vscode.ExtensionContext) {
+    this.logger.info('Fortran Language Server');
 
     // if context is present
     if (context !== undefined) {
@@ -109,7 +109,7 @@ export class FortlsClient {
     if (!folder) {
       const fileRoot: string = path.dirname(document.uri.fsPath);
       if (clients.has(fileRoot)) return; // already registered
-      this.logger.logInfo(
+      this.logger.info(
         'Initialising Language Server for file: ' +
           `${document.uri.fsPath} with command-line options: ${args.join(', ')}`
       );
@@ -133,7 +133,7 @@ export class FortlsClient {
     if (!clients.has(folder.uri.toString())) {
       folder = getOuterMostWorkspaceFolder(folder);
       if (clients.has(folder.uri.toString())) return; // already registered
-      this.logger.logInfo(
+      this.logger.info(
         'Initialising Language Server for workspace: ' +
           `${document.uri.fsPath} with command-line options: ${args.join(', ')}`
       );
@@ -317,7 +317,7 @@ export class FortlsClient {
               fortlsDisabled = true;
             }
             if (install.stdout) {
-              this.logger.logInfo(install.stdout.toString());
+              this.logger.info(install.stdout.toString());
               fortlsDisabled = false;
             }
           } else if (opt == 'Disable') {
@@ -336,7 +336,7 @@ export class FortlsClient {
    * Restart the language server
    */
   private async restartLS(): Promise<void> {
-    this.logger.logInfo('Restarting language server...');
+    this.logger.info('Restarting language server...');
     vscode.window.showInformationMessage('Restarting language server...');
     await this.deactivate();
     await this.activate();