@profile-psl/psl-parser 0.1.0

package/utilities.d.ts

@@ -0,0 +1,43 @@
+import { FinderPaths } from "./config";
+import { Member, Method, ParsedDocument } from "./parser";
+import { Position, Token } from "./tokenizer";
+export interface FinderResult {
+    fsPath: string;
+    member?: Member;
+}
+export declare const dummyPosition: Position;
+export declare class ParsedDocFinder {
+    parsedDocument: ParsedDocument;
+    paths: FinderPaths;
+    procName: string;
+    private hierarchy;
+    constructor(parsedDocument: ParsedDocument, paths: FinderPaths, getWorkspaceDocumentText?: (fsPath: string) => Promise<string>);
+    resolveResult(callTokens: Token[]): Promise<FinderResult>;
+    newFinder(routineName: string): Promise<ParsedDocFinder>;
+    /**
+     * Search the parsed document and parents for a particular member
+     */
+    searchParser(queriedToken: Token): Promise<FinderResult>;
+    searchInDocument(queriedId: string): Promise<FinderResult>;
+    findAllInDocument(results?: FinderResult[]): Promise<FinderResult[]>;
+    resolveFileDefinitionDirectory(tableName: string): Promise<string>;
+    private searchForParent;
+    private searchInMethod;
+    private findActiveMethod;
+    private getWorkspaceDocumentText;
+}
+/**
+ * Get the tokens on the line of position, as well as the specific index of the token at position
+ */
+export declare function searchTokens(tokens: Token[], position: Position): {
+    tokensOnLine: Token[];
+    index: number;
+};
+export declare function getCallTokens(tokensOnLine: Token[], index: number): Token[];
+export declare function resolve(tokens: Token[]): number;
+export declare function findCallable(tokensOnLine: Token[], index: number): {
+    callTokens: Token[];
+    parameterIndex: number;
+};
+export declare function getLineAfter(method: Method): number;
+export declare function getCommentsOnLine(parsedDocument: ParsedDocument, lineNumber: number): Token[];

package/utilities.js

@@ -0,0 +1,427 @@
+import * as fs from "fs";
+import * as fsx from "fs-extra";
+import * as jsonc from "jsonc-parser";
+import * as path from "path";
+import { MemberClass, parseText } from "./parser";
+import { Position, Token } from "./tokenizer";
+export const dummyPosition = new Position(0, 0);
+export class ParsedDocFinder {
+    parsedDocument;
+    paths;
+    procName;
+    hierarchy = [];
+    constructor(parsedDocument, paths, getWorkspaceDocumentText) {
+        this.parsedDocument = parsedDocument;
+        this.paths = paths;
+        if (getWorkspaceDocumentText)
+            this.getWorkspaceDocumentText = getWorkspaceDocumentText;
+        this.procName = path.basename(this.paths.activeRoutine).split(".")[0];
+    }
+    async resolveResult(callTokens) {
+        // TODO: (Mischa Reitsma) Reset the finder a few times. Most of them can be a local const finder = this.newFinder(), but not all. Not going to change it now
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let finder = this;
+        if (callTokens.length === 1) {
+            const result = await finder.searchParser(callTokens[0]);
+            // check for core class or tables
+            if (!result) {
+                const pslClsNames = await getPslClsNames(this.paths.corePsl);
+                if (pslClsNames.indexOf(callTokens[0].value) >= 0) {
+                    const finder = await this.newFinder(callTokens[0].value);
+                    return {
+                        fsPath: finder.paths.activeRoutine,
+                    };
+                }
+                const tableName = callTokens[0].value.replace("Record", "");
+                const fileDefinitionDirectory = await this.resolveFileDefinitionDirectory(tableName);
+                if (fileDefinitionDirectory) {
+                    return {
+                        fsPath: path.join(fileDefinitionDirectory, tableName.toUpperCase() + ".TBL"),
+                    };
+                }
+                else if (callTokens[0] === this.parsedDocument.extending) {
+                    finder = await finder.newFinder(callTokens[0].value);
+                    return {
+                        fsPath: finder.paths.activeRoutine,
+                    };
+                }
+                else if (callTokens[0].value === "this" ||
+                    callTokens[0].value === this.procName) {
+                    return {
+                        fsPath: this.paths.activeRoutine,
+                    };
+                }
+            }
+            // handle static types
+            else if (result.member.types[0] === callTokens[0]) {
+                finder = await finder.newFinder(result.member.id.value);
+                return {
+                    fsPath: finder.paths.activeRoutine,
+                };
+            }
+            return result;
+        }
+        else {
+            let result;
+            for (let index = 0; index < callTokens.length; index++) {
+                const token = callTokens[index];
+                if (index === 0) {
+                    // handle core class
+                    const pslClsNames = await getPslClsNames(this.paths.corePsl);
+                    if (pslClsNames.indexOf(token.value) >= 0) {
+                        finder = await finder.newFinder(token.value);
+                        continue;
+                    }
+                    // skip over "this"
+                    else if (token.value === "this" ||
+                        token.value === this.procName) {
+                        result = {
+                            fsPath: this.paths.activeRoutine,
+                        };
+                        continue;
+                    }
+                    else {
+                        result = await finder.searchParser(token);
+                    }
+                }
+                if (!result || (result.fsPath === this.paths.activeRoutine
+                    && !result.member)) {
+                    result = await finder.searchInDocument(token.value);
+                }
+                if (!result)
+                    return null;
+                if (!callTokens[index + 1])
+                    return result;
+                let type = result.member.types[0].value;
+                if (type === "void")
+                    type = "Primitive"; // TODO whack hack
+                finder = await finder.newFinder(type);
+                result = undefined;
+            }
+        }
+        return null;
+    }
+    async newFinder(routineName) {
+        if (routineName.startsWith("Record") && routineName !== "Record") {
+            const tableName = routineName.replace("Record", "");
+            const tableDirectory = await this.resolveFileDefinitionDirectory(tableName.toLowerCase());
+            if (!tableDirectory)
+                return null;
+            const columns = (await fsx.readdir(tableDirectory))
+                .filter(file => file.endsWith(".COL"))
+                .map(col => {
+                const colName = col
+                    .replace(`${tableName}-`, "")
+                    .replace(".COL", "")
+                    .toLowerCase();
+                const ret = {
+                    id: new Token(1 /* Type.Alphanumeric */, colName, dummyPosition),
+                    memberClass: MemberClass.column,
+                    modifiers: [],
+                    types: [new Token(1 /* Type.Alphanumeric */, "String", dummyPosition)],
+                };
+                return ret;
+            });
+            const text = await this.getWorkspaceDocumentText(path.join(tableDirectory, `${tableName.toUpperCase()}.TBL`));
+            const parsed = jsonc.parse(text);
+            const parentFileId = parsed.PARFID;
+            const extendingValue = parentFileId ? `Record${parentFileId}` : "Record";
+            const parsedDocument = {
+                comments: [],
+                declarations: [],
+                extending: new Token(1 /* Type.Alphanumeric */, extendingValue, dummyPosition),
+                methods: [],
+                properties: columns,
+                pslPackage: "",
+                tokens: [],
+            };
+            const newPaths = Object.create(this.paths);
+            newPaths.activeRoutine = "";
+            newPaths.activeTable = tableDirectory;
+            return new ParsedDocFinder(parsedDocument, newPaths, this.getWorkspaceDocumentText);
+        }
+        const pathsWithoutExtensions = this.paths.projectPsl
+            .map(pslPath => path.join(pslPath, routineName));
+        for (const pathWithoutExtension of pathsWithoutExtensions) {
+            for (const extension of [".PROC", ".psl", ".PSL"]) {
+                const possiblePath = pathWithoutExtension + extension;
+                const routineText = await this.getWorkspaceDocumentText(possiblePath);
+                if (!routineText)
+                    continue;
+                const newPaths = Object.create(this.paths);
+                newPaths.activeRoutine = possiblePath;
+                return new ParsedDocFinder(parseText(routineText), newPaths, this.getWorkspaceDocumentText);
+            }
+        }
+        return null;
+    }
+    /**
+     * Search the parsed document and parents for a particular member
+     */
+    async searchParser(queriedToken) {
+        const activeMethod = this.findActiveMethod(queriedToken);
+        if (activeMethod) {
+            const variable = this.searchInMethod(activeMethod, queriedToken);
+            if (variable)
+                return { member: variable, fsPath: this.paths.activeRoutine };
+        }
+        return this.searchInDocument(queriedToken.value);
+    }
+    async searchInDocument(queriedId) {
+        let foundProperty;
+        if (this.paths.activeTable) {
+            foundProperty = this.parsedDocument.properties
+                .find(p => p.id.value.toLowerCase() === queriedId.toLowerCase());
+            if (foundProperty) {
+                const tableName = path.basename(this.paths.activeTable)
+                    .toUpperCase();
+                return {
+                    fsPath: path.join(this.paths.activeTable, `${tableName}-` +
+                        foundProperty.id.value.toUpperCase() +
+                        ".COL"),
+                    member: foundProperty,
+                };
+            }
+        }
+        foundProperty = this.parsedDocument.properties.find(p => p.id.value === queriedId);
+        if (foundProperty)
+            return { member: foundProperty, fsPath: this.paths.activeRoutine };
+        const foundMethod = this.parsedDocument.methods.find(p => p.id.value === queriedId);
+        if (foundMethod)
+            return { member: foundMethod, fsPath: this.paths.activeRoutine };
+        if (this.parsedDocument.extending) {
+            const parentRoutineName = this.parsedDocument.extending.value;
+            if (this.hierarchy.indexOf(parentRoutineName) > -1)
+                return null;
+            const parentFinder = await this.searchForParent(parentRoutineName);
+            if (!parentFinder)
+                return null;
+            return parentFinder.searchInDocument(queriedId);
+        }
+        return null;
+    }
+    async findAllInDocument(results) {
+        if (!results)
+            results = [];
+        const addToResults = (result) => {
+            if (!results.find(r => r.member.id.value === result.member.id.value)) {
+                results.push(result);
+            }
+        };
+        if (this.paths.activeTable) {
+            this.parsedDocument.properties.forEach(property => {
+                const tableName = path.basename(this.paths.activeTable)
+                    .toUpperCase();
+                addToResults({
+                    member: property,
+                    fsPath: path.join(this.paths.activeTable, `${tableName}-` +
+                        property.id.value.toUpperCase() +
+                        ".COL")
+                });
+            });
+        }
+        this.parsedDocument.properties.forEach(property => {
+            addToResults({ member: property, fsPath: this.paths.activeRoutine });
+        });
+        this.parsedDocument.methods.forEach(method => {
+            addToResults({ member: method, fsPath: this.paths.activeRoutine });
+        });
+        if (this.parsedDocument.extending) {
+            const parentRoutineName = this.parsedDocument.extending.value;
+            if (this.hierarchy.indexOf(parentRoutineName) > -1)
+                return results;
+            const parentFinder = await this.searchForParent(parentRoutineName);
+            if (!parentFinder)
+                return results;
+            return parentFinder.findAllInDocument(results);
+        }
+        return results;
+    }
+    async resolveFileDefinitionDirectory(tableName) {
+        for (const tableSource of this.paths.tables) {
+            const directory = path.join(tableSource, tableName.toLowerCase());
+            if (await fsx.pathExists(directory)) {
+                return directory;
+            }
+        }
+        return "";
+    }
+    async searchForParent(parentRoutineName) {
+        const parentFinder = await this.newFinder(parentRoutineName);
+        if (!parentFinder)
+            return null;
+        parentFinder.hierarchy = this.hierarchy.concat(this.paths.activeRoutine);
+        return parentFinder;
+    }
+    searchInMethod(activeMethod, queriedToken) {
+        for (const variable of activeMethod.declarations.reverse()) {
+            if (queriedToken.position.line < variable.id.position.line)
+                continue;
+            if (queriedToken.value === variable.id.value)
+                return variable;
+        }
+        for (const parameter of activeMethod.parameters) {
+            if (queriedToken.value === parameter.id.value)
+                return parameter;
+        }
+        return null;
+    }
+    findActiveMethod(queriedToken) {
+        const methods = this.parsedDocument.methods
+            .filter(method => queriedToken.position.line >= method.id.position.line);
+        return methods ? methods.at(-1) : null;
+    }
+    async getWorkspaceDocumentText(fsPath) {
+        return new Promise((resolve) => {
+            fs.readFile(fsPath, (err, data) => {
+                if (err)
+                    resolve("");
+                resolve(data.toString());
+            });
+        });
+    }
+}
+async function getPslClsNames(dir) {
+    try {
+        const names = await fsx.readdir(dir);
+        return names.map(name => name.split(".")[0]);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get the tokens on the line of position, as well as the specific index of the token at position
+ */
+export function searchTokens(tokens, position) {
+    const tokensOnLine = tokens.filter(t => t.position.line === position.line);
+    if (tokensOnLine.length === 0)
+        return undefined;
+    const index = tokensOnLine.findIndex(t => {
+        if (t.isNewLine() || t.isSpace() || t.isTab())
+            return null;
+        const start = t.position;
+        const end = {
+            line: t.position.line,
+            character: t.position.character + t.value.length
+        };
+        return isBetween(start, position, end);
+    });
+    return { tokensOnLine, index };
+}
+function isBetween(lb, t, ub) {
+    return lb.line <= t.line &&
+        lb.character <= t.character &&
+        ub.line >= t.line &&
+        ub.character >= t.character;
+}
+export function getCallTokens(tokensOnLine, index) {
+    const ret = [];
+    let current = getChildNode(tokensOnLine, index);
+    if (!current)
+        return ret;
+    while (current.parent && current.token) {
+        ret.unshift(current.token);
+        current = current.parent;
+    }
+    if (current.token)
+        ret.unshift(current.token);
+    return ret;
+}
+function getChildNode(tokensOnLine, index) {
+    const currentToken = tokensOnLine[index];
+    if (!currentToken)
+        return { token: undefined };
+    const previousToken = tokensOnLine[index - 1];
+    const nextToken = tokensOnLine[index + 1];
+    let routine = false;
+    if (previousToken) {
+        let newIndex = -1;
+        if (currentToken.isPeriod()) {
+            newIndex = resolve(tokensOnLine.slice(0, index));
+        }
+        else if (previousToken.isCaret()) {
+            routine = true;
+        }
+        else if (currentToken.isAlphanumeric() && previousToken.isPeriod()) {
+            newIndex = resolve(tokensOnLine.slice(0, index - 1));
+        }
+        if (newIndex >= 0) {
+            const parent = getChildNode(tokensOnLine, newIndex);
+            return { parent, token: currentToken };
+        }
+    }
+    if (nextToken && nextToken.isCaret()) {
+        const routineToken = tokensOnLine[index + 2];
+        if (!routineToken)
+            return undefined;
+        return { parent: { token: routineToken, routine: true }, token: currentToken };
+    }
+    if (currentToken.isAlphanumeric()) {
+        return { token: currentToken, routine };
+    }
+    return undefined;
+}
+export function resolve(tokens) {
+    const length = tokens.length;
+    let parenCount = 0;
+    if (length === 0)
+        return -1;
+    if (tokens[length - 1].isAlphanumeric())
+        return length - 1;
+    for (let index = tokens.length - 1; index >= 0; index--) {
+        const token = tokens[index];
+        if (token.isCloseParen())
+            parenCount++;
+        else if (token.isOpenParen())
+            parenCount--;
+        if (parenCount === 0) {
+            if (index > 0 && tokens[index - 1].isAlphanumeric())
+                return index - 1;
+            else
+                return -1;
+        }
+    }
+    return -1;
+}
+export function findCallable(tokensOnLine, index) {
+    const callables = [];
+    for (let tokenBufferIndex = 0; tokenBufferIndex <= index; tokenBufferIndex++) {
+        const token = tokensOnLine[tokenBufferIndex];
+        if (!tokenBufferIndex && !token.isTab() && !token.isSpace())
+            return null;
+        if (token.isOpenParen()) {
+            callables.push({
+                tokenBufferIndex: tokenBufferIndex - 1,
+                parameterIndex: 0
+            });
+        }
+        else if (token.isCloseParen()) {
+            if (callables.length)
+                callables.pop();
+            else
+                return null;
+        }
+        else if (token.isComma() && callables.length) {
+            callables[callables.length - 1].parameterIndex += 1;
+        }
+    }
+    if (!callables.length)
+        return null;
+    const activeCallable = callables.at(-1);
+    return {
+        callTokens: getCallTokens(tokensOnLine, activeCallable.tokenBufferIndex),
+        parameterIndex: activeCallable.parameterIndex,
+    };
+}
+export function getLineAfter(method) {
+    return method.closeParen ?
+        method.closeParen.position.line + 1 :
+        method.id.position.line + 1;
+}
+export function getCommentsOnLine(parsedDocument, lineNumber) {
+    return parsedDocument.comments.filter(t => {
+        return t.position.line === lineNumber;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utilities.js","sourceRoot":"","sources":["../src/utilities.ts"],"names":[],"mappings":"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"}