Refactor completions for objects

Author: vetlek

server/src/language-service/completionProvider.ts

@@ -35,6 +35,7 @@ import { isAlphaNumeric } from "../util";
 import { CompletionSettings, SettingsManager } from '../settings';
 
 const threeLettersOrLessWordsRegex = /\b[\w]{1,3}\b/;
+
 export class CompletionProvider {
     private readonly cnfgProvider: ISepticConfigProvider;
     private readonly settingsManager: SettingsManager;
@@ -207,78 +208,29 @@ export function getObjectCompletion(
 ): CompletionItem[] {
     cnfg.updateObjectParents(SepticMetaInfoProvider.getInstance().getObjectHierarchy());
     refProvider.updateObjectParents(SepticMetaInfoProvider.getInstance().getObjectHierarchy());
-    const snippets: CompletionItem[] = getRelevantSnippets(offset, refProvider, doc, settings.onlySuggestValidSnippets);
-    const references: CompletionItem[] = [];
+    const objectSnippets: CompletionItem[] = getRelevantObjectSnippets(offset, refProvider, doc, settings.onlySuggestValidSnippets);
     const obj = cnfg.getObjectFromOffset(offset);
     if (!obj) {
-        return snippets;
+        return objectSnippets;
     }
-    const ref = cnfg.getXvrRefFromOffset(offset);
+    const range = findCompletionRange(offset, cnfg, doc)
     if (isIdentifierCompletion(offset, obj)) {
-        const range: Range = ref
-            ? {
-                start: doc.positionAt(ref.location.start),
-                end: doc.positionAt(ref.location.end),
-            }
-            : {
-                start: doc.positionAt(offset),
-                end: doc.positionAt(offset),
-            };
-        return getRelevantXvrsIdentifier(
-            obj,
-            refProvider.getAllXvrObjects()
-        ).map((obj) => xvrToCompletionItem(obj, range));
+        return getIdentifierCompletion(obj, refProvider, range);
     }
-    const currentAttr = getCurrentAttr(offset, obj);
+    const currentAttr = findCurrentAttr(offset, obj);
     if (!currentAttr.attr) {
-        return [...snippets, ...getObjectAttributeCompletion(obj, offset, doc)];
-    }
-    if (isReferenceAttribute(obj, currentAttr.attr)) {
-        const range: Range = ref
-            ? {
-                start: doc.positionAt(ref.location.start),
-                end: doc.positionAt(ref.location.end),
-            }
-            : {
-                start: doc.positionAt(offset),
-                end: doc.positionAt(offset),
-            };
-
-        references.push(
-            ...getRelevantXvrsAttributes(
-                currentAttr.attr,
-                refProvider.getAllXvrObjects()
-            ).map((obj) => xvrToCompletionItem(obj, range))
-        );
+        return [...objectSnippets, ...getObjectAttributeCompletion(obj, offset, doc)];
     }
-    const enums = getEnumCompletions(obj, currentAttr.attr);
-    const completions = [...enums, ...references];
+    const completions = getAttributeValueCompletion(obj, currentAttr.attr, refProvider, range);
     if (isEndAttribute(offset, currentAttr.attr)) {
         completions.push(...getObjectAttributeCompletion(obj, offset, doc));
         if (currentAttr.last) {
-            completions.push(...snippets);
+            completions.push(...objectSnippets);
         }
     }
     return completions;
 }
 
-function getCurrentAttr(
-    offset: number,
-    obj: SepticObject
-): { attr: Attribute | undefined; last: boolean } {
-    if (!obj.attributes.length) {
-        return { attr: undefined, last: false };
-    }
-    let index = 1;
-    while (index < obj.attributes.length) {
-        if (obj.attributes[index].start >= offset) {
-            return { attr: obj.attributes[index - 1], last: false };
-        }
-        index += 1;
-    }
-    return { attr: obj.attributes[obj.attributes.length - 1], last: true };
-}
-
 function getObjectAttributeCompletion(
     obj: SepticObject,
     offset: number,
@@ -291,7 +243,7 @@ function getObjectAttributeCompletion(
         return [];
     }
     const compItems: CompletionItem[] = [];
-    const rangeNewLine = getRangeAttrTextEdit(offset, doc);
+    const rangeNewLine = findRangeAttrTextEdit(offset, doc);
     for (const attr of objDoc.attributes) {
         if (obj.getAttribute(attr.name)) {
             continue;
@@ -316,6 +268,51 @@ function getObjectAttributeCompletion(
     return compItems;
 }
 
+function getIdentifierCompletion(obj: SepticObject, refProvider: SepticReferenceProvider, range: Range): CompletionItem[] {
+    return getRelevantXvrsIdentifier(
+        obj,
+        refProvider.getAllXvrObjects()
+    ).map((obj) => xvrToCompletionItem(obj, range))
+}
+
+function getAttributeValueCompletion(obj: SepticObject, attr: Attribute, refProvider: SepticReferenceProvider, range: Range): CompletionItem[] {
+    const references = getReferenceCompletions(obj, attr, refProvider, range);
+    const enums = getEnumCompletions(obj, attr);
+    return [...references, ...enums];
+}
+
+function getReferenceCompletions(obj: SepticObject, attr: Attribute, refProvider: SepticReferenceProvider, range: Range): CompletionItem[] {
+    if (!isReferenceAttribute(obj, attr)) {
+        return [];
+    }
+    return getRelevantXvrsAttributes(
+        attr,
+        refProvider.getAllXvrObjects()
+    ).map((obj) => xvrToCompletionItem(obj, range))
+}
+
+function getEnumCompletions(obj: SepticObject, attr: Attribute): CompletionItem[] {
+    const objectInfo = SepticMetaInfoProvider.getInstance().getObjectDocumentation(obj.type);
+    if (!objectInfo) {
+        return [];
+    }
+    let attrDoc = objectInfo.attributes.find((a) => a.name === attr.key);
+    if (!attrDoc) {
+        return [];
+    }
+    if (attrDoc.dataType !== "enum") {
+        return [];
+    }
+    return attrDoc.enums.map((value) => {
+        return {
+            label: value,
+            kind: CompletionItemKind.EnumMember,
+            detail: `Enum member of ${attrDoc.name}`,
+            sortText: `1${value}`,
+        };
+    });
+}
+
 function isIdentifierCompletion(offset: number, obj: SepticObject) {
     const objectInfo = SepticMetaInfoProvider.getInstance().getObject(obj.type);
     if (!objectInfo?.refs.identifier) {
@@ -347,28 +344,6 @@ function isReferenceAttribute(obj: SepticObject, attr: Attribute): boolean {
     return objectInfo.refs.attributes.includes(attr.key);
 }
 
-function getEnumCompletions(obj: SepticObject, attr: Attribute): CompletionItem[] {
-    const objectInfo = SepticMetaInfoProvider.getInstance().getObjectDocumentation(obj.type);
-    if (!objectInfo) {
-        return [];
-    }
-    let attrDoc = objectInfo.attributes.find((a) => a.name === attr.key);
-    if (!attrDoc) {
-        return [];
-    }
-    if (attrDoc.dataType !== "enum") {
-        return [];
-    }
-    return attrDoc.enums.map((value) => {
-        return {
-            label: value,
-            kind: CompletionItemKind.EnumMember,
-            detail: `Enum member of ${attrDoc.name}`,
-            sortText: `1${value}`,
-        };
-    });
-}
-
 function isEndAttribute(offset: number, attr: Attribute): boolean {
     return offset >= attr.end;
 }
@@ -386,7 +361,7 @@ function getTextAttrTextEdit(attr: SepticAttributeDocumentation) {
     return attrFormatted;
 }
 
-function getRangeAttrTextEdit(
+function findRangeAttrTextEdit(
     offset: number,
     doc: ITextDocument
 ): { range: Range; addNewLine: boolean } {
@@ -497,7 +472,7 @@ function getRelevantXvrsAttributes(
     }
 }
 
-function getRelevantSnippets(offset: number, refProvider: SepticReferenceProvider, doc: ITextDocument, onlySuggestValidSnippets: boolean): CompletionItem[] {
+function getRelevantObjectSnippets(offset: number, refProvider: SepticReferenceProvider, doc: ITextDocument, onlySuggestValidSnippets: boolean): CompletionItem[] {
     const snippets = SepticMetaInfoProvider.getInstance().getSnippets().slice();
     if (!onlySuggestValidSnippets) {
         return snippets;
@@ -535,4 +510,35 @@ function getObjectsSnippets(objectHierarchy: SepticObjectHierarchy, obj: SepticO
     }
 
     return relevantObjects.map((val) => val.toLowerCase());
+}
+
+function findCompletionRange(offset: number, cnfg: SepticCnfg, doc: ITextDocument) {
+    const ref = cnfg.getXvrRefFromOffset(offset);
+    const range: Range = ref
+        ? {
+            start: doc.positionAt(ref.location.start),
+            end: doc.positionAt(ref.location.end),
+        }
+        : {
+            start: doc.positionAt(offset),
+            end: doc.positionAt(offset),
+        };
+    return range;
+}
+
+function findCurrentAttr(
+    offset: number,
+    obj: SepticObject
+): { attr: Attribute | undefined; last: boolean } {
+    if (!obj.attributes.length) {
+        return { attr: undefined, last: false };
+    }
+    let index = 1;
+    while (index < obj.attributes.length) {
+        if (obj.attributes[index].start >= offset) {
+            return { attr: obj.attributes[index - 1], last: false };
+        }
+        index += 1;
+    }
+    return { attr: obj.attributes[obj.attributes.length - 1], last: true };
 }