Hover Provider (#202)

Hover Provider (#202)

Author: JD-Howard

extension/src/commands.ts

@@ -1,22 +1,33 @@
 import * as vscode from "vscode";
 import * as nls from 'vscode-nls';
-import { AutoLispExt } from './extension';
-import { openWebHelp } from './help/openWebHelp';
+import { AutoLispExt } from './context';
 import { generateDocumentationSnippet, getDefunArguments, getDefunAtPosition } from './help/userDocumentation';
 import { showErrorMessage } from './project/projectCommands';
 import { AutoLispExtProvideDefinition } from './providers/gotoProvider';
 import { AutoLispExtProvideReferences } from './providers/referenceProvider';
 import { AutoLispExtPrepareRename, AutoLispExtProvideRenameEdits } from './providers/renameProvider';
 import { SymbolManager } from './symbols';
+import {AutoLispExtProvideHover} from "./providers/hoverProvider";
+import { DocumentServices } from './services/documentServices';
 
 const localize = nls.loadMessageBundle();
 
 export function registerCommands(context: vscode.ExtensionContext){
 
-	// Associated with the right click "Open Online Help" menu item
 	context.subscriptions.push(vscode.commands.registerCommand('autolisp.openWebHelp', async () => {
+		// Note: this function is directly referenced by the package.json contributes (commands & menus) section.
+		// 		 Associated with the right click "Open Online Help" menu item.
 		try {
-			await openWebHelp();
+			const editor: vscode.TextEditor = vscode.window.activeTextEditor;
+			let selected: string = editor.document.getText(editor.selection);
+			if (selected === "") {
+				await vscode.commands.executeCommand('editor.action.addSelectionToNextFindMatch');
+				selected = editor.document.getText(editor.selection);
+			}
+			let urlPath: string = AutoLispExt.WebHelpLibrary.getWebHelpUrlBySymbolName(selected, editor.document.fileName);
+			if (urlPath.trim() !== ""){
+				vscode.env.openExternal(vscode.Uri.parse(urlPath));
+			}
 		}
 		catch (err) {
 			if (err){
@@ -50,9 +61,12 @@ export function registerCommands(context: vscode.ExtensionContext){
 			const vsDoc = vscode.window.activeTextEditor.document;
 			const lf = vsDoc.eol === vscode.EndOfLine.LF ? '\n' : '\r\n';
 			const doc = AutoLispExt.Documents.getDocument(vsDoc);
+			if (!doc.isLSP) {
+				return;
+			}
 
 			// find the root LispContainer of the current cursor position
-			const exp = doc.atomsForest.find(p => p.contains(pos));
+			const exp = doc.documentContainer.atoms.find(p => p.contains(pos));
 
 			// Locate the Defun to decorate
 			const def = await getDefunAtPosition(exp, pos);
@@ -73,7 +87,7 @@ export function registerCommands(context: vscode.ExtensionContext){
 		}
 	}));
 
-	AutoLispExt.Subscriptions.push(vscode.languages.registerDefinitionProvider([ 'autolisp', 'lisp'], {
+	AutoLispExt.Subscriptions.push(vscode.languages.registerDefinitionProvider([DocumentServices.Selectors.LSP, 'lisp'], {
 		provideDefinition: function (document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken)
 						 			: vscode.ProviderResult<vscode.Definition | vscode.LocationLink[]> {
 			// Purpose: locate potential source definitions of the underlying symbol
@@ -91,7 +105,7 @@ export function registerCommands(context: vscode.ExtensionContext){
 	}));
 
 	const msgRenameFail = localize("autolispext.providers.rename.failed", "The symbol was invalid for renaming operations");
-	AutoLispExt.Subscriptions.push(vscode.languages.registerRenameProvider(['autolisp', 'lisp'], {
+	AutoLispExt.Subscriptions.push(vscode.languages.registerRenameProvider([DocumentServices.Selectors.LSP, 'lisp'], {
 		prepareRename: function (document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken)
 							    : vscode.ProviderResult<vscode.Range | { range: vscode.Range; placeholder: string; }> 
 		{
@@ -133,7 +147,7 @@ export function registerCommands(context: vscode.ExtensionContext){
 	}));
 
 
-	AutoLispExt.Subscriptions.push(vscode.languages.registerReferenceProvider([ 'autolisp', 'lisp'], {
+	AutoLispExt.Subscriptions.push(vscode.languages.registerReferenceProvider([ DocumentServices.Selectors.LSP, 'lisp'], {
 		provideReferences: function (document: vscode.TextDocument, position: vscode.Position, context: vscode.ReferenceContext, token: vscode.CancellationToken)
 									: vscode.ProviderResult<vscode.Location[]> 
 		{
@@ -152,4 +166,16 @@ export function registerCommands(context: vscode.ExtensionContext){
 		}
 	}));
 
+	AutoLispExt.Subscriptions.push(vscode.languages.registerHoverProvider([DocumentServices.Selectors.LSP, DocumentServices.Selectors.DCL], {
+		provideHover(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): vscode.ProviderResult<vscode.Hover> {
+			try {
+				// offload all meaningful work to something that can be tested.
+				const roDoc = AutoLispExt.Documents.getDocument(document);
+				return AutoLispExtProvideHover(roDoc, position);
+			} catch (err) {
+				return;	// No localized error since VSCode has a default "no results" response
+			}
+		}
+	}));
+
 }

extension/src/completion/autocompletionProvider.ts

@@ -1,15 +1,15 @@
 import * as vscode from 'vscode';
 import * as os from 'os';
 import { isCursorInDoubleQuoteExpr } from "../format/autoIndent";
-import { allCmdsAndSysvars, internalDclKeys, internalLispFuncs, winOnlyListFuncPrefix  } from "../resources";
+import { AutoLispExt} from "../context";
 
 
 export function isInternalAutoLispOp(item: string): boolean {
     if (!item)
         return false;
 
-    for (let i = 0; i < internalLispFuncs.length; i++) {
-        if (internalLispFuncs[i] === item)
+    for (let i = 0; i < AutoLispExt.Resources.internalLispFuncs.length; i++) {
+        if (AutoLispExt.Resources.internalLispFuncs[i] === item)
             return true;
     }
     return false;
@@ -117,9 +117,9 @@ export function getMatchingWord(document: vscode.TextDocument, position: vscode.
 export function getLispAndDclCompletions(document: vscode.TextDocument, word: string, isupper: boolean): vscode.CompletionItem[] {
     let currentLSPDoc = document.fileName;
     let ext = currentLSPDoc.substring(currentLSPDoc.length - 4, currentLSPDoc.length).toUpperCase();
-    let candidatesItems = internalLispFuncs;
+    let candidatesItems = AutoLispExt.Resources.internalLispFuncs;
     if (ext === ".DCL") {
-        candidatesItems = internalDclKeys;
+        candidatesItems = AutoLispExt.Resources.internalDclKeys;
     }
     let allSuggestions: Array<vscode.CompletionItem> = [];
     allSuggestions = getCompletionCandidates(candidatesItems, word, isupper);
@@ -129,7 +129,7 @@ export function getLispAndDclCompletions(document: vscode.TextDocument, word: st
     }
     else {
         return allSuggestions.filter(function(suggestion) {
-            for (var prefix of winOnlyListFuncPrefix) {
+            for (var prefix of AutoLispExt.Resources.winOnlyListFuncPrefix) {
                 if (suggestion.label.toString().startsWith(prefix)) {
                     return false;
                 }
@@ -158,7 +158,7 @@ export function registerAutoCompletionProviders() {
 
                 var isInDoubleQuote = isCursorInDoubleQuoteExpr(document, position);
                 if (isInDoubleQuote) {
-                    var cmds = getCmdAndVarsCompletionCandidates(allCmdsAndSysvars, inputword, userInputIsUpper);
+                    var cmds = getCmdAndVarsCompletionCandidates(AutoLispExt.Resources.allCmdsAndSysvars, inputword, userInputIsUpper);
                     return cmds;
                 }
 

extension/src/context.ts

@@ -1,40 +1,68 @@
 import * as vscode from "vscode";
-import * as nls from "vscode-nls";
-import * as Resources from "./resources";
+import * as resources from "./resources";
 import { Disposable } from 'vscode-languageclient';
 import { DocumentManager } from './documents';
+import {DocumentServices} from "./services/documentServices";
+import { WebHelpLibrarySingleton } from './help/documentationLibrary';
 
+let _instance: ContextManager;
 
 export class ContextManager{
 	private _ctx: vscode.ExtensionContext;
 	private _docManager: DocumentManager;
-	
+	private _init: boolean;
+	private readonly _temp: Disposable[];
+
+	private constructor() {
+		this._init = false;
+		this._temp = [];
+	}
+
+	static get Instance(): ContextManager {
+		if (_instance) {
+			return _instance;
+		}
+		return _instance = new ContextManager();
+	}
 
 	get Context(): vscode.ExtensionContext { 
 		return this._ctx; 
 	}
 	get Documents(): DocumentManager { 
-		return this._docManager; 
+		return this._docManager;
 	}
-	get Selectors(): typeof DocumentManager.Selectors { 
-		return DocumentManager.Selectors; 
+	get Selectors(): typeof DocumentServices.Selectors {
+		return DocumentServices.Selectors;
 	}
 	get AllSelectors(): string[] { 
-		return [DocumentManager.Selectors.lsp, DocumentManager.Selectors.dcl, DocumentManager.Selectors.prj]; 
+		return [DocumentServices.Selectors.LSP, DocumentServices.Selectors.DCL, DocumentServices.Selectors.PRJ];
 	}
-	get Subscriptions(): Disposable[] { 
-		return this._ctx ? this._ctx.subscriptions : null; 
+	get Subscriptions(): Disposable[] {
+		if (this._temp.length > 0 && this._ctx){
+			this._ctx.subscriptions.push(...this._temp);
+			this._temp.length = 0;
+		}
+		return this._ctx ? this._ctx.subscriptions : this._temp;
 	}
 	get ExtPath(): string { 
 		return this._ctx ? this._ctx.extensionPath : ""; 
 	}
 	get Resources() { 
-		return Resources; 
+		return resources;
+	}
+	get WebHelpLibrary() {
+		return WebHelpLibrarySingleton.Instance;
 	}
 
 
 	initialize(context: vscode.ExtensionContext): void {
-		this._ctx = context;
-		this._docManager = new DocumentManager();
+		if (!this._init) {
+			this._ctx = context;
+		}
+		this._docManager = DocumentManager.Instance;
+		if (!resources.isLoaded)
+			resources.loadAllResources();
 	}
-}
+}
+
+export const AutoLispExt: ContextManager = ContextManager.Instance;