Rearranges routines from helper to tools

The helper.ts file was cluttered, filled with routines and variables
that belonged to the tools file. This have now been moved.

In addition, the old interface with the language server has been removed
in preparation for the new interface that will be added.

Author: gnikit

src/extension.ts

@@ -7,12 +7,12 @@ import FortranHoverProvider from './features/hover-provider';
 import { FortranCompletionProvider } from './features/completion-provider';
 import { FortranDocumentSymbolProvider } from './features/document-symbol-provider';
 
-import { FortranLangServer } from './lang-server';
-import { FORTRAN_DOCUMENT_SELECTOR, EXTENSION_ID, promptForMissingTool } from './lib/helper';
 import { LoggingService } from './services/logging-service';
 import * as pkg from '../package.json';
 import { LANG_SERVER_TOOL_ID } from './lib/tools';
 import { FortranFormattingProvider } from './features/formatting-provider';
+import FortranLanguageServer from './fortls-interface';
+import { EXTENSION_ID, FortranDocumentSelector, promptForMissingTool } from './lib/tools';
 
 // Make it global to catch errors when activation fails
 const loggingService = new LoggingService();
@@ -26,15 +26,15 @@ export function activate(context: vscode.ExtensionContext) {
   if (extensionConfig.get('linterEnabled', true)) {
     const linter = new FortranLintingProvider(loggingService);
     linter.activate(context.subscriptions);
-    vscode.languages.registerCodeActionsProvider(FORTRAN_DOCUMENT_SELECTOR, linter);
+    vscode.languages.registerCodeActionsProvider(FortranDocumentSelector(), linter);
     loggingService.logInfo('Linter is enabled');
   } else {
     loggingService.logInfo('Linter is not enabled');
   }
 
   if (extensionConfig.get('formatter') !== 'Disabled') {
     const disposable: vscode.Disposable = vscode.languages.registerDocumentFormattingEditProvider(
-      FORTRAN_DOCUMENT_SELECTOR,
+      FortranDocumentSelector(),
       new FortranFormattingProvider(loggingService)
     );
     context.subscriptions.push(disposable);
@@ -45,22 +45,22 @@ export function activate(context: vscode.ExtensionContext) {
 
   if (extensionConfig.get('provideCompletion', true)) {
     const completionProvider = new FortranCompletionProvider(loggingService);
-    vscode.languages.registerCompletionItemProvider(FORTRAN_DOCUMENT_SELECTOR, completionProvider);
+    vscode.languages.registerCompletionItemProvider(FortranDocumentSelector(), completionProvider);
   } else {
     loggingService.logInfo('Completion Provider is not enabled');
   }
 
   if (extensionConfig.get('provideHover', true)) {
     const hoverProvider = new FortranHoverProvider(loggingService);
-    vscode.languages.registerHoverProvider(FORTRAN_DOCUMENT_SELECTOR, hoverProvider);
+    vscode.languages.registerHoverProvider(FortranDocumentSelector(), hoverProvider);
     loggingService.logInfo('Hover Provider is enabled');
   } else {
     loggingService.logInfo('Hover Provider is not enabled');
   }
 
   if (extensionConfig.get('provideSymbols', true)) {
     const symbolProvider = new FortranDocumentSymbolProvider();
-    vscode.languages.registerDocumentSymbolProvider(FORTRAN_DOCUMENT_SELECTOR, symbolProvider);
+    vscode.languages.registerDocumentSymbolProvider(FortranDocumentSelector(), symbolProvider);
     loggingService.logInfo('Symbol Provider is enabled');
   } else {
     loggingService.logInfo('Symbol Provider is not enabled');
@@ -74,30 +74,4 @@ export function activate(context: vscode.ExtensionContext) {
               https://github.com/hansec/fortran-language-server`;
     promptForMissingTool(LANG_SERVER_TOOL_ID, msg, 'Python', loggingService);
   }
-
-  // Check that Fortran Intellisense is installed and if not prompt to install
-  if (!vscode.extensions.getExtension('hansec.fortran-ls')) {
-    const msg = `It is highly recommended to install the Fortran IntelliSense 
-              extension. The extension is used to interface with the 
-              fortran-language-server.
-              For a full list of features provided by the extension see:
-              https://github.com/hansec/vscode-fortran-ls`;
-    promptForMissingTool('hansec.fortran-ls', msg, 'VSExt', loggingService);
-  }
-
-  // Our interface with `fortls` has been disabled in favour of the @hansec's
-  // VS Code extension Fortran IntelliSense
-  const useInternalFLInterface = false;
-  if (useInternalFLInterface) {
-    const langServer = new FortranLangServer(context, extensionConfig);
-    langServer.start();
-    langServer.onReady().then(() => {
-      const capabilities = langServer.getCapabilities();
-      if (!capabilities) {
-        return vscode.window.showErrorMessage(
-          'The language server is not able to serve any features at the moment.'
-        );
-      }
-    });
-  }
 }

src/features/completion-provider.ts

@@ -4,7 +4,7 @@ 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/tools';
 import { LoggingService } from '../services/logging-service';
 
 class CaseCoverter {

src/features/formatting-provider.ts

@@ -6,9 +6,8 @@ import * as which from 'which';
 import * as vscode from 'vscode';
 import * as cp from 'child_process';
 
-import { FORMATTERS } from '../lib/tools';
 import { LoggingService } from '../services/logging-service';
-import { EXTENSION_ID, promptForMissingTool } from '../lib/helper';
+import { FORMATTERS, EXTENSION_ID, promptForMissingTool } from '../lib/tools';
 
 export class FortranFormattingProvider implements vscode.DocumentFormattingEditProvider {
   constructor(private logger: LoggingService) {}

src/features/linter-provider.ts

@@ -2,11 +2,10 @@
 
 import * as path from 'path';
 import * as cp from 'child_process';
-import { FORTRAN_DOCUMENT_SELECTOR, getIncludeParams } from '../lib/helper';
 
 import * as vscode from 'vscode';
 import { LoggingService } from '../services/logging-service';
-import { resolveVariables } from '../lib/tools';
+import { FortranDocumentSelector, resolveVariables } from '../lib/tools';
 import * as fg from 'fast-glob';
 import { glob } from 'glob';
 
@@ -21,8 +20,8 @@ export default class FortranLintingProvider {
 
     // Only lint Fortran (free, fixed) format files
     if (
-      !FORTRAN_DOCUMENT_SELECTOR.some(e => e.scheme === textDocument.uri.scheme) ||
-      !FORTRAN_DOCUMENT_SELECTOR.some(e => e.language === textDocument.languageId)
+      !FortranDocumentSelector().some(e => e.scheme === textDocument.uri.scheme) ||
+      !FortranDocumentSelector().some(e => e.language === textDocument.languageId)
     ) {
       return;
     }
@@ -111,7 +110,7 @@ export default class FortranLintingProvider {
     const fileNameWithoutExtension = textDocument.fileName.substring(0, extensionIndex);
     const argList = [
       ...args,
-      ...getIncludeParams(includePaths), // include paths
+      ...this.getIncludeParams(includePaths), // include paths
       textDocument.fileName,
       `-o ${fileNameWithoutExtension}.mod`,
     ];
@@ -222,4 +221,8 @@ export default class FortranLintingProvider {
     this.loggingService.logInfo(`Linter.arguments:\n${args.join('\r\n')}`);
     return args.map(e => resolveVariables(e));
   }
+
+  private getIncludeParams = (paths: string[]) => {
+    return paths.map(path => `-I${path}`);
+  };
 }

src/lang-server.ts

@@ -4,15 +4,7 @@ import { installPythonTool } from './tools';
 import intrinsics from './fortran-intrinsics';
 import { LoggingService } from '../services/logging-service';
 
-// IMPORTANT: this should match the value
-// on the package.json otherwise the extension won't
-// work at all
-export const FORTRAN_DOCUMENT_SELECTOR = [
-  { scheme: 'file', language: 'FortranFreeForm' },
-  { scheme: 'file', language: 'FortranFixedForm' },
-];
 export { intrinsics };
-export const EXTENSION_ID = 'fortran';
 
 export const FORTRAN_KEYWORDS = [
   'FUNCTION',
@@ -84,10 +76,6 @@ export const _loadDocString = (keyword: string) => {
   return docText;
 };
 
-export const getIncludeParams = (paths: string[]) => {
-  return paths.map(path => `-I${path}`);
-};
-
 export function isPositionInString(
   document: vscode.TextDocument,
   position: vscode.Position
@@ -112,52 +100,6 @@ const saveKeywordToJson = keyword => {
   });
 };
 
-/**
- * Install a package either a Python pip package or a VS Marketplace Extension.
- *
- * For the Python install supply the name of the package in PyPi
- * e.g. fortran-language-server
- *
- * For the VS Extension to be installed supply the id of the extension
- * e.g 'hansec.fortran-ls'
- *
- * @param tool name of the tool e.g. fortran-language-server
- * @param msg optional message for installing said package
- * @param toolType type of tool, supports `Python` (through pip) and 'VSExt'
- */
-export function promptForMissingTool(
-  tool: string,
-  msg: string,
-  toolType: string,
-  logger?: LoggingService
-) {
-  const items = ['Install'];
-  return new Promise((resolve, reject) => {
-    resolve(
-      vscode.window.showInformationMessage(msg, ...items).then(selected => {
-        if (selected === 'Install') {
-          switch (toolType) {
-            case 'Python':
-              installPythonTool(tool, logger);
-              break;
-
-            case 'VSExt':
-              logger.logInfo(`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`);
-              break;
-
-            default:
-              logger.logError(`Failed to install tool: ${tool}`);
-              break;
-          }
-        }
-      })
-    );
-  });
-}
-
 export function isUri(input: any): input is vscode.Uri {
   return input && input instanceof vscode.Uri;
 }

src/lib/helper.ts

@@ -1,16 +1,95 @@
-export const LANG_SERVER_TOOL_ID = 'fortran-language-server';
-export const FORMATTERS = ['Disabled', 'findent', 'fprettify'];
-
 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 { isString, isArrayOfString } from './helper';
 
+export const EXTENSION_ID = 'fortran';
+export const LANG_SERVER_TOOL_ID = 'fortran-language-server';
+export const FORMATTERS = ['Disabled', 'findent', 'fprettify'];
+
 // Platform-specific environment variable delimiter
 export const envDelimiter: string = process.platform === 'win32' ? ';' : ':';
 
+/**
+ * Generates a document selector for the supported file and languages
+ * if the folder is present then a glob pattern for all the files in the workspace
+ * is included
+ *
+ * @warning this should match the value on the package.json otherwise the extension
+ * won't work at all
+ *
+ * @param folder `optional` WorkspaceFolder to search
+ * @returns tuple of DocumentSelector
+ */
+export function FortranDocumentSelector(folder?: vscode.WorkspaceFolder) {
+  if (folder) {
+    return [
+      { scheme: 'file', language: 'FortranFreeForm', pattern: `${folder.uri.fsPath}/**/*` },
+      { scheme: 'file', language: 'FortranFixedForm', pattern: `${folder.uri.fsPath}/**/*` },
+    ];
+  } else {
+    return [
+      { scheme: 'file', language: 'FortranFreeForm' },
+      { scheme: 'file', language: 'FortranFixedForm' },
+    ];
+  }
+}
+
+/**
+ * Install a package either a Python pip package or a VS Marketplace Extension.
+ *
+ * For the Python install supply the name of the package in PyPi
+ * e.g. fortran-language-server
+ *
+ * For the VS Extension to be installed supply the id of the extension
+ * e.g 'hansec.fortran-ls'
+ *
+ * @param tool name of the tool e.g. fortran-language-server
+ * @param msg optional message for installing said package
+ * @param toolType type of tool, supports `Python` (through pip) and 'VSExt'
+ */
+export function promptForMissingTool(
+  tool: string,
+  msg: string,
+  toolType: string,
+  logger?: LoggingService
+) {
+  const items = ['Install'];
+  return new Promise((resolve, reject) => {
+    resolve(
+      vscode.window.showInformationMessage(msg, ...items).then(selected => {
+        if (selected === 'Install') {
+          switch (toolType) {
+            case 'Python':
+              installPythonTool(tool, logger);
+              break;
+
+            case 'VSExt':
+              logger.logInfo(`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`);
+              break;
+
+            default:
+              logger.logError(`Failed to install tool: ${tool}`);
+              break;
+          }
+        }
+      })
+    );
+  });
+}
+
+/**
+ * A wrapper around a call to `pip` for installing external tools.
+ * Does not explicitly check if `pip` is installed.
+ *
+ * @param pyPackage name of python package in PyPi
+ * @param logger `optional` logging channel for output
+ */
 export function installPythonTool(pyPackage: string, logger?: LoggingService) {
   const installProcess = cp.spawn('pip', 'install --user --upgrade '.concat(pyPackage).split(' '));
   installProcess.stdout.on('data', data => {