Extract js package functions to PackageReader and add js-specific module path to uri converter

Author: Noam Kfir

src/services/languages/javascript/languageExtractor.ts

@@ -4,12 +4,16 @@ import { IMethodExtractor, ISpanExtractor } from '../extractors';
 import { LanguageExtractor } from '../languageExtractor';
 import { IMethodPositionSelector } from '../methodPositionSelector';
 import { JSMethodPositionSelector } from './methodPositionSelector';
-import { IModulePathToUriConverter, LogicalModulePathToUriConverter, PhysicalModulePathToUriConverter } from '../modulePathToUriConverters';
+import { IModulePathToUriConverter } from '../modulePathToUriConverters';
 import { JSMethodExtractor } from './methodExtractor';
 import { JSSpanExtractor } from './spanExtractor';
+import { JSPackageReader } from './packageReader';
+import { JSPackageToUriConverter } from './modulePathToUriConverters';
 
 export class JSLanguageExtractor extends LanguageExtractor 
 {
+
+    private packageReader: JSPackageReader = new JSPackageReader();
     public requiredExtensionLoaded: boolean = false;
 
     public get requiredExtensionId(): string {
@@ -22,7 +26,7 @@ export class JSLanguageExtractor extends LanguageExtractor
 
     public get methodExtractors(): IMethodExtractor[] {
         return [
-            new JSMethodExtractor()
+            new JSMethodExtractor(this.packageReader),
         ];
     }
 
@@ -37,9 +41,9 @@ export class JSLanguageExtractor extends LanguageExtractor
     }
 
     public async getModulePathToUriConverters(): Promise<IModulePathToUriConverter[]> {
+        const packagesMap = await this.packageReader.loadPackagesMap();
         return [
-            new LogicalModulePathToUriConverter(),
-            new PhysicalModulePathToUriConverter(),
+            new JSPackageToUriConverter(packagesMap),
         ];
     }
 }

src/services/languages/javascript/methodExtractor.ts

@@ -2,7 +2,6 @@ import * as vscode from 'vscode';
 import * as path from 'path';
 import { DocumentSymbol } from 'vscode-languageclient';
 import { IMethodExtractor, SymbolInfo } from '../extractors';
-import { Logger } from '../../logger';
 import { Token, TokenType } from '../tokens';
 import {
     MethodSymbolInfoExtractor,
@@ -11,20 +10,23 @@ import {
     AnonymousExpressRequestHandlerSymbolInfoExtractor,
     VariableFunctionSymbolInfoExtractor,
 } from './symbolInfoExtractors';
+import { JSPackageReader } from './packageReader';
 
 export class JSMethodExtractor implements IMethodExtractor {
 
+    constructor(
+        private packageReader: JSPackageReader,
+    ) {
+    }
+
     public async extractMethods(document: vscode.TextDocument, docSymbols: DocumentSymbol[], tokens: Token[]): Promise<SymbolInfo[]> {
-        const packages = await vscode.workspace.findFiles('**/package.json');
-        const packageFile = packages.find(f => document.uri.fsPath.startsWith(path.dirname(f.fsPath)));
+        const packageFile = await this.packageReader.findPackage(document.uri);
         if (!packageFile) {
-            Logger.warn(`Could not resolve package file for '${document.uri.path}'`);
             return [];
         }
 
-        let packageName = await this.getPackageName(packageFile);
-        if (packageName === undefined || packageName === "") {
-            Logger.warn(`Could not find package name in '${packageFile.path}'`);
+        let packageName = await this.packageReader.getPackageName(packageFile);
+        if (packageName === undefined) {
             return [];
         }
 
@@ -46,12 +48,6 @@ export class JSMethodExtractor implements IMethodExtractor {
         return this.extractFunctions(document, codeObjectPath, '', docSymbols, tokens);
     }
 
-    private async getPackageName(packageFile: vscode.Uri): Promise<string | undefined> {
-        const modDocument = await vscode.workspace.openTextDocument(packageFile);
-        const pkgjson = JSON.parse(modDocument.getText());
-        return pkgjson.name;
-    }
-
     private extractFunctions(document: vscode.TextDocument, codeObjectPath: string, parentSymbolPath: string, symbols: DocumentSymbol[], tokens: Token[]): SymbolInfo[] {
         const symbolInfos: SymbolInfo[] = [];
 

src/services/languages/javascript/modulePathToUriConverters.ts

@@ -0,0 +1,55 @@
+import { dirname, join } from 'path';
+import * as vscode from 'vscode';
+import { IModulePathToUriConverter, ModulePathInfo } from '../modulePathToUriConverters';
+
+export class JSPackageToUriConverter implements IModulePathToUriConverter {
+
+    private codeObjectIdParser = new JSCodeObjectIdParser();
+
+    constructor(
+        private packagesMap: Map<string, vscode.Uri>,
+    ) {
+    }
+
+    async convert(pathInfo: ModulePathInfo): Promise<vscode.Uri | undefined> {
+        const { codeObjectId, modulePhysicalPath } = pathInfo;
+        if(codeObjectId && modulePhysicalPath) {
+            const info = this.codeObjectIdParser.parse(codeObjectId);
+            const { packageName } = info;
+            const packageUri = this.packagesMap.get(packageName);
+            if(packageUri) {
+                const basePath = dirname(packageUri.fsPath);
+                const path = join(basePath, modulePhysicalPath);
+                const uri = vscode.Uri.file(path);
+                return uri;
+            }
+        }
+    }
+}
+
+interface JSCodeObjectInfo {
+    packageName: string
+    modulePath: string
+    symbol: string
+}
+
+class JSCodeObjectIdParser {
+    parse(codeObjectId: string): JSCodeObjectInfo {
+        const pattern = /([\w\@/-]+):(?:.)+\$_\$(?:.)*/;
+        const matches = codeObjectId.match(pattern);
+        if(matches) {
+            const [ , packageName, modulePath, symbol ] = matches;
+            return {
+                packageName,
+                modulePath,
+                symbol,
+            };
+        }
+
+        return {
+            packageName: '',
+            modulePath: '',
+            symbol: '',
+        };
+    }
+}

src/services/languages/javascript/packageReader.ts

@@ -0,0 +1,57 @@
+import * as vscode from 'vscode';
+import { dirname } from 'path';
+import { Logger } from '../../logger';
+
+type PackagesMap = Map<string, vscode.Uri>;
+
+export class JSPackageReader {
+    private packagesMap: PackagesMap = new Map<string, vscode.Uri>();
+
+    public async findAllPackagesInWorkspace() {
+        const packages = await vscode.workspace.findFiles('**/package.json');
+        return packages;
+    }
+    
+    public async findPackage(uri: vscode.Uri): Promise<vscode.Uri | undefined> {
+        const packages = await this.findAllPackagesInWorkspace();
+        const packageFile = packages.find(f => uri.fsPath.startsWith(dirname(f.fsPath)));
+        if (!packageFile) {
+            Logger.warn(`Could not resolve package file for '${uri.path}'`);
+            return undefined;
+        }
+        return packageFile;
+    }
+
+    public async getPackageName(packageFile: vscode.Uri): Promise<string | undefined> {
+        const modDocument = await vscode.workspace.openTextDocument(packageFile);
+        const pkgjson = JSON.parse(modDocument.getText());
+        const packageName = pkgjson.name;
+        if (packageName === undefined || packageName === '') {
+            Logger.warn(`Could not find package name in '${packageFile.path}'`);
+            return undefined;
+        }
+        return packageName;
+    }
+
+    public async loadPackagesMap(force: boolean = false): Promise<PackagesMap> {
+        if(force) {
+            this.packagesMap.clear();
+        }
+        if(this.packagesMap.size === 0) {
+            const packages = await this.findAllPackagesInWorkspace();
+            for await (const packageFile of packages) {
+                try {
+                    const packageName = await this.getPackageName(packageFile);
+                    if(packageName) {
+                        this.packagesMap.set(packageName, packageFile);
+                    }
+                    console.log(packageName, packageFile.fsPath);
+                }
+                catch(err) {
+                    console.error('failed to parse package name for', packageFile);
+                }
+            }
+        }
+        return this.packagesMap;
+    }
+}