Merge pull request #25 from faissaloux/pnpm-support-all-versions

[pnpm] support all pnpm lockfile versions

Author: faissaloux

src/interfaces/lock_parser.ts

@@ -1,3 +1,4 @@
 export interface LockParser {
     dependencies(): {[key: string]: any}
+    lockVersion(): number | null
 }

src/package_manager/package_managers/javascript.ts

@@ -9,23 +9,31 @@ type JavascriptDependenciesLockFile = 'package-lock.json' | 'yarn.lock' | 'pnpm-
 
 export class Javascript extends LanguagePackageManager implements PackageManager {
     packageManager: JavascriptPackageManager = 'npm';
+    lockVersion: number | null = null;
     locks: {[key in JavascriptPackageManager]: JavascriptDependenciesLockFile} = {
         'npm': 'package-lock.json',
         'yarn': 'yarn.lock',
         'pnpm': 'pnpm-lock.yaml',
         'bun': 'bun.lock',
     };
-    startsWith: {[key in JavascriptPackageManager]: string} = {
+    startsWith: {[key: string]: string | {[version: string | number]: string}} = {
         'npm': 'packageName',
         'yarn': 'packageName@',
-        'pnpm': '/packageName/',
+        'pnpm': {
+            /* eslint-disable @typescript-eslint/naming-convention */
+            '5.3': '/packageName/',
+            '6': '/packageName@',
+            '9': 'packageName@',
+            /* eslint-enable */
+        },
         'bun': 'packageName',
     };
 
     async getInstalled(packageName: string): Promise<any> {
         this.packageManager = await this.getPackageManager();
-
-        const installedPackages = new Parser(this.packageManager).parse(await this.lockFileContent());
+        const lockFileParsed = new Parser(this.packageManager).parse(await this.lockFileContent());
+        const installedPackages = lockFileParsed['dependencies'];
+        this.lockVersion = lockFileParsed['lockVersion'];
 
         if (!vscode.workspace.getConfiguration().get(`package-manager-intellisense.${this.packageManager}.enable`)) {
             return null;
@@ -53,6 +61,30 @@ export class Javascript extends LanguagePackageManager implements PackageManager
     }
 
     lockPackageStartsWith(packageName: string): string {
-        return this.startsWith[this.packageManager].replace('packageName', packageName);
+        const pattern =  this.startsWith[this.packageManager];
+
+        if (typeof pattern === 'object' && this.lockVersion) {
+            const lockVersion = Number(this.lockVersion);
+
+            if (pattern[lockVersion]) {
+                return pattern[lockVersion].replace('packageName', packageName);
+            }
+
+            let lastVersion = Object.keys(pattern).sort().at(0);
+
+            if (lastVersion !== undefined) {
+                for (const version of Object.keys(pattern).sort()) {
+                    if (Number(version) > lockVersion ) {
+                        return pattern[lastVersion].replace('packageName', packageName);
+                    }
+
+                    lastVersion = version;
+                }
+
+                return pattern[lastVersion].replace('packageName', packageName);
+            }
+        }
+
+        return (pattern as string).replace('packageName', packageName);
     }
 }

src/package_manager/package_managers/php.ts

@@ -6,7 +6,7 @@ import { LanguagePackageManager } from '../language_package_manager';
 
 export class Php extends LanguagePackageManager implements PackageManager {
     async getInstalled(packageName: string): Promise<any> {
-        const installedPackages = new Parser("composer").parse(await this.lockFileContent());
+        const installedPackages = new Parser("composer").parse(await this.lockFileContent())['dependencies'];
 
         return installedPackages.find((pkg: types.ComposerInstalledPackage) => pkg.name === packageName);
     }

src/package_manager/package_managers/ruby.ts

@@ -5,7 +5,7 @@ import { LanguagePackageManager } from '../language_package_manager';
 
 export class Ruby extends LanguagePackageManager implements PackageManager {
     async getInstalled(packageName: string): Promise<{[key: string]: string}| undefined> {
-        const installedPackages = new Parser("rubygems").parse(await this.lockFileContent());
+        const installedPackages = new Parser("rubygems").parse(await this.lockFileContent())['dependencies'];
 
         const packageFound = Object.keys(installedPackages.GEM.specs).find((pkg: string) => pkg.startsWith(packageName));
 

src/parser/BunLock.ts

@@ -15,6 +15,10 @@ export class BunLock implements LockParser {
         return this.content.packages;
     }
 
+    lockVersion(): null {
+        return null;
+    }
+
     removeTrailingCommas(content: string): string {
         const regex = /\,(?!\s*?[\{\[\"\'\w])/g;
 

src/parser/composerLock.ts

@@ -12,4 +12,8 @@ export class ComposerLock implements LockParser {
     dependencies(): {[key: string]: any} {
         return this.content.packages;
     }
+
+    lockVersion(): null {
+        return null;
+    }
 }

src/parser/gemfileLock.ts

@@ -13,4 +13,8 @@ export class GemfileLock implements LockParser {
     dependencies(): {[key: string]: any} {
         return this.content;
     }
+
+    lockVersion(): null {
+        return null;
+    }
 }

src/parser/npmLock.ts

@@ -20,4 +20,8 @@ export class NpmLock implements LockParser {
 
         return new NpmLockV2(this.content).dependencies();
     }
+
+    lockVersion(): number {
+        return this.lockfileVersion;
+    }
 }

src/parser/npmLockV2.ts

@@ -8,4 +8,8 @@ export class NpmLockV2 implements LockParser {
     dependencies(): {[key: string]: any} {
         return this.content.dependencies;
     }
+
+    lockVersion(): number {
+        return 2;
+    }
 }

src/parser/npmLockV3.ts

@@ -14,4 +14,8 @@ export class NpmLockV3 implements LockParser {
 
         return dependencies;
     }
+
+    lockVersion(): number {
+        return 3;
+    }
 }

src/parser/parser.ts

@@ -19,8 +19,13 @@ export class Parser {
         return this;
     }
 
-    parse(content: string): {[key: string]: any} {
+    parse(content: string): {'lockVersion': number | null, 'dependencies': any} {
         // @ts-ignore
-        return new this.parsers[this.packageManager](content).dependencies();
+        const lockParser = new this.parsers[this.packageManager](content);
+
+        return {
+            'lockVersion': lockParser.lockVersion(),
+            'dependencies': lockParser.dependencies(),
+        };
     }
 }

src/parser/pnpmLock.ts

@@ -3,10 +3,12 @@ import { LockParser } from '../interfaces/lock_parser';
 
 export class PnpmLock implements LockParser {
     private content: {[key: string]: any};
+    private lockfileVersion: number;
 
     constructor(content: string) {
         // @ts-ignore
         this.content = jsYaml.load(content);
+        this.lockfileVersion = this.content.lockfileVersion;
         this.appendVersions();
 
         return this;
@@ -16,6 +18,10 @@ export class PnpmLock implements LockParser {
         return this.content.packages;
     }
 
+    lockVersion(): number {
+        return this.lockfileVersion;
+    }
+
     appendVersions(): void {
         Object.keys(this.content.packages).map(pkg => {
             let version = pkg.match(/\d+(\.\d+)+/);

src/parser/yarnLock.ts

@@ -13,4 +13,8 @@ export class YarnLock implements LockParser {
     dependencies(): {[key: string]: any} {
         return this.content.object;
     }
+
+    lockVersion(): null {
+        return null;
+    }
 }