Intrinsics case auto-complete. (#83)

pedro-ricardo · krvajal · commit ff2620c23cdf · 2018-10-14T12:41:04.000+02:00
* Add new configuration option for intrinsics case auto-complete.

* Refactor code

* Fix README spelling mistakes
diff --git a/README.md b/README.md
@@ -6,16 +6,16 @@
 [![Installs](https://vsmarketplacebadge.apphb.com/installs/krvajalm.linter-gfortran.svg)](https://marketplace.visualstudio.com/items?itemName=krvajalm.linter-gfortran)
 [![GitHub release](https://img.shields.io/github/release/krvajal/vscode-fortran-support.svg)](https://GitHub.com/krvajal/vscode-fortran-support/releases/)
 
-> This extension provides support for the Fortran programming language. It includes syntax highlighting, code snippets and a linting based on gfortran. You can download the Visual Estudio Code editor from [here](https://code.visualstudio.com/download).
+> This extension provides support for the Fortran programming language. It includes syntax highlighting, code snippets and a linting based on `gfortran`. You can download the Visual Studio Code editor from [here](https://code.visualstudio.com/download).
 
 ## Features
 
-* Syntax highlighting
-* Code Snippets
-* Documentation on hover for intrisic functions
-* Code linting based on `gfortran` to show errors swiggles in your code
-* Code autocompletion (beta)
-* Symbols provider
+- Syntax highlighting
+- Code Snippets
+- Documentation on hover for intrinsic functions
+- Code linting based on `gfortran` to show errors wiggles in your code
+- Code autocompletion (beta)
+- Symbols provider
 
 ![symbol_nav](./doc/symbol_nav.png)
 
@@ -58,17 +58,25 @@ You can configure what kind of symbols will appear in the symbol list by using
 
 The available options are
 
-* "function"
-* "subroutine"
-* "variable"
-* "module" (not supported yet)
-* "program" (not supported yet)
+- "function"
+- "subroutine"
+- "variable"
+- "module" (not supported yet)
+- "program" (not supported yet)
 
 and by default only functions and subroutines are shown
 
+You can also configure the case for fortran intrinsics auto-complete by using
+
+```
+{
+    "fortran.preferredCase": "lowercase" | "uppercase"
+}
+```
+
 ## Snippets
 
-This is a list of some of the snippets included, if you like to include some additionals snippets please let me know and I will add them.
+This is a list of some of the snippets included, if you like to include additional snippets please let me know and I will add them.
 
 #### Program skeleton
 
@@ -78,7 +86,7 @@ This is a list of some of the snippets included, if you like to include some add
 
 ![module snippet](https://media.giphy.com/media/3ohzdUNRuio5FfyF1u/giphy.gif)
 
-## Error swiggles
+## Error wiggles
 
 To trigger code validations you must save the file first.
 
@@ -88,13 +96,13 @@ For the linter to work you need to have `gfortran` on your path, or wherever you
 
 ## Issues
 
-Please report any issues and feature request on the github repo [here](https://github.com/krvajalmiguelangel/vscode-fortran-support/issues/new)
+Please report any issues and feature request on the GitHub repo [here](https://github.com/krvajalmiguelangel/vscode-fortran-support/issues/new)
 
 ## Notice
 
 The syntax highlight support was imported from [TextMate bundle](https://github.com/textmate/fortran.tmbundle)
 
-The idea of using gfortran cames from this awesome [fortran plugin](https://github.com/315234/SublimeFortran) for Sublime Text.
+The idea of using `gfortran` comes from this awesome [fortran plugin](https://github.com/315234/SublimeFortran) for Sublime Text.
 
 ## LICENSE
 
diff --git a/package.json b/package.json
@@ -128,6 +128,15 @@
             "subroutine"
           ],
           "description": "Specify what kind of symbols should be shown by the symbols' provider"
+        },
+        "fortran.preferredCase": {
+          "type": "string",
+          "default": "lowercase",
+          "enum": [
+            "lowercase",
+            "uppercase"
+          ],
+          "description": "Scpecify the word case to use when suggesting autocomplete options (One of 'lowercase' or 'upercase')"
         }
       }
     }
diff --git a/src/extension.ts b/src/extension.ts
@@ -1,32 +1,34 @@
 // src/extension.ts
-import * as vscode from "vscode";
+import * as vscode from 'vscode'
 
-import FortranLintingProvider from "./features/linter-provider";
-import FortranHoverProvider from "./features/hover-provider";
-import { FortranCompletionProvider } from "./features/completion-provider";
-import { FortranDocumentSymbolProvider } from "./features/document-symbol-provider";
-import { LANGUAGE_ID  } from './lib/helper';
+import FortranLintingProvider from './features/linter-provider'
+import FortranHoverProvider from './features/hover-provider'
+import { FortranCompletionProvider } from './features/completion-provider'
+import { FortranDocumentSymbolProvider } from './features/document-symbol-provider'
+import { LANGUAGE_ID } from './lib/helper'
 
-const FORTRAN_FREE_FORM_ID = { language: LANGUAGE_ID, scheme: "file" };
+const FORTRAN_FREE_FORM_ID = { language: LANGUAGE_ID, scheme: 'file' }
 
 export function activate(context: vscode.ExtensionContext) {
-  let hoverProvider = new FortranHoverProvider();
-  let completionProvider = new FortranCompletionProvider();
-  let symbolProvider = new FortranDocumentSymbolProvider();
+  let hoverProvider = new FortranHoverProvider()
+  let completionProvider = new FortranCompletionProvider()
+  let symbolProvider = new FortranDocumentSymbolProvider()
+  const extensionConfig = vscode.workspace.getConfiguration('LANGUAGE_ID')
 
-  if (vscode.workspace.getConfiguration("fortran").get("linterEnabled", true)) {
-    let linter = new FortranLintingProvider();
-    linter.activate(context.subscriptions);
-    vscode.languages.registerCodeActionsProvider(FORTRAN_FREE_FORM_ID, linter);
+  if (extensionConfig.get('linterEnabled', true)) {
+    let linter = new FortranLintingProvider()
+    linter.activate(context.subscriptions)
+    vscode.languages.registerCodeActionsProvider(FORTRAN_FREE_FORM_ID, linter)
   }
 
   vscode.languages.registerCompletionItemProvider(
     FORTRAN_FREE_FORM_ID,
     completionProvider
-  );
-  vscode.languages.registerHoverProvider(FORTRAN_FREE_FORM_ID, hoverProvider);
+  )
+  vscode.languages.registerHoverProvider(FORTRAN_FREE_FORM_ID, hoverProvider)
+
   vscode.languages.registerDocumentSymbolProvider(
     FORTRAN_FREE_FORM_ID,
     symbolProvider
-  );
+  )
 }
diff --git a/src/features/completion-provider.ts b/src/features/completion-provider.ts
@@ -1,12 +1,36 @@
-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'
+
+class CaseCoverter {
+  preferredCase: string
+  static LOWER = 'lowercase'
+  static UPPER = 'uppercase'
+
+  constructor(preferredCase: string = CaseCoverter.LOWER) {
+    this.preferredCase = preferredCase
+  }
+
+  convert(word: string): string {
+    if (this.preferredCase == CaseCoverter.LOWER) {
+      return this.toLower(word)
+    } else if (this.preferredCase == CaseCoverter.UPPER) {
+      return this.toUpper(word)
+    }
+
+    throw new Error(`the provided case ${this.preferredCase} is not supported`)
+  }
+
+  toLower(word: string) {
+    return word.toLowerCase()
+  }
+  toUpper(word: string) {
+    return word.toUpperCase()
+  }
+}
 
 export class FortranCompletionProvider
   implements vscode.CompletionItemProvider {
@@ -19,87 +43,115 @@ export class FortranCompletionProvider
       document,
       position,
       token,
-      vscode.workspace.getConfiguration("go")
-    );
+      vscode.workspace.getConfiguration(EXTENSION_ID)
+    )
   }
+
   public provideCompletionItemsInternal(
     document: vscode.TextDocument,
     position: vscode.Position,
     token: vscode.CancellationToken,
     config: vscode.WorkspaceConfiguration
   ): Thenable<vscode.CompletionItem[]> {
     return new Promise<vscode.CompletionItem[]>((resolve, reject) => {
-      let filename = document.fileName;
-      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([])
       }
 
-      // get current word
-      let wordAtPosition = document.getWordRangeAtPosition(position);
-      let currentWord = "";
-      if (
-        wordAtPosition &&
-        wordAtPosition.start.character < position.character
-      ) {
-        let word = document.getText(wordAtPosition);
-        currentWord = word.substr(
-          0,
-          position.character - wordAtPosition.start.character
-        );
-      }
+      let currentWord = this.getCurrentWord(document, position)
 
       if (currentWord.match(/^\d+$/)) {
         // starts with a number
-        return resolve([]);
+        return resolve([])
       }
 
-      let suggestions = [];
-
-      if (currentWord.length > 0) {
-        intrinsics.forEach(intrinsic => {
-          if (intrinsic.startsWith(currentWord.toUpperCase())) {
-            suggestions.push(
-              new vscode.CompletionItem(
-                intrinsic,
-                vscode.CompletionItemKind.Method
-              )
-            );
-          }
-        });
-
-        // add keyword suggestions
-        FORTRAN_KEYWORDS.forEach(keyword => {
-          if (keyword.startsWith(currentWord.toUpperCase())) {
-            suggestions.push(
-              new vscode.CompletionItem(
-                keyword.toLowerCase(),
-                vscode.CompletionItemKind.Keyword
-              )
-            );
-          }
-        });
+      const caseConverter = new CaseCoverter(config.get('preferredCase'))
+
+      if (currentWord.length === 0) {
+        resolve([])
       }
-      const functions = getDeclaredFunctions(document);
-      // check for available functions
-      functions.filter(fun => fun.name.startsWith(currentWord)).forEach(fun => {
-        suggestions.push(
-          new vscode.CompletionItem(
-            fun.name,
-            vscode.CompletionItemKind.Function
-          )
-        );
-      });
-
-      return resolve(suggestions);
-    });
+
+      const intrinsicSuggestions = this.getIntrinsicSuggestions(
+        currentWord,
+        caseConverter
+      )
+
+      // add keyword suggestions
+      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()))
+      .map((intrinsic: string) => {
+        return new vscode.CompletionItem(
+          caseConverter.convert(intrinsic),
+          vscode.CompletionItemKind.Method
+        )
+      })
+  }
+
+  private getKeywordSuggestions(currentWord: string): vscode.CompletionItem[] {
+    return FORTRAN_KEYWORDS.filter(keyword =>
+      keyword.startsWith(currentWord.toUpperCase())
+    ).map(keyword => {
+      return new vscode.CompletionItem(
+        keyword.toLowerCase(),
+        vscode.CompletionItemKind.Keyword
+      )
+    })
+  }
+
+  private getFunctionSuggestions(
+    document: TextDocument,
+    currentWord: string
+  ): vscode.CompletionItem[] {
+    const functions = getDeclaredFunctions(document)
+    // check for available functions
+    return functions
+      .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 = ''
+    if (wordAtPosition && wordAtPosition.start.character < position.character) {
+      let word = document.getText(wordAtPosition)
+      currentWord = word.substr(
+        0,
+        position.character - wordAtPosition.start.character
+      )
+    }
+    return currentWord
   }
 }
diff --git a/src/lib/helper.ts b/src/lib/helper.ts
@@ -5,6 +5,8 @@ import * as vscode from 'vscode'
 // on the package.json otherwise the extension won't
 // work at all
 export const LANGUAGE_ID = 'FortranFreeForm'
+export const EXTENSION_ID = 'fortran'
+
 
 export const intrinsics = [
   'ABORT',

Original file line number	Diff line number	Diff line change
`@@ -128,6 +128,15 @@`
`128`	`128`	`"subroutine"`
`129`	`129`	`],`
`130`	`130`	`"description": "Specify what kind of symbols should be shown by the symbols' provider"`
	`131`	`+ },`
	`132`	`+ "fortran.preferredCase": {`
	`133`	`+ "type": "string",`
	`134`	`+ "default": "lowercase",`
	`135`	`+ "enum": [`
	`136`	`+ "lowercase",`
	`137`	`+ "uppercase"`
	`138`	`+ ],`
	`139`	`+ "description": "Scpecify the word case to use when suggesting autocomplete options (One of 'lowercase' or 'upercase')"`
`131`	`140`	`}`
`132`	`141`	`}`
`133`	`142`	`}`