bounded file cache

Author: joetannenbaum

src/extension.ts

@@ -27,7 +27,11 @@ import {
 } from "./support/fileWatcher";
 import { info } from "./support/logger";
 import { clearParserCaches, setParserBinaryPath } from "./support/parser";
-import { clearDefaultPhpCommand, initVendorWatchers } from "./support/php";
+import {
+    clearDefaultPhpCommand,
+    clearPhpFileCache,
+    initVendorWatchers,
+} from "./support/php";
 import { hasWorkspace, projectPathExists } from "./support/project";
 import { cleanUpTemp } from "./support/util";
 
@@ -186,6 +190,7 @@ export function deactivate() {
 
     disposeWatchers();
     clearParserCaches();
+    clearPhpFileCache();
 
     if (client) {
         client.stop();

src/support/cache.ts

@@ -1,3 +1,5 @@
+import * as fs from "fs";
+
 export class Cache<K, V> {
     private maxSize: number;
     private cache: Map<K, V>;
@@ -44,3 +46,78 @@ export class Cache<K, V> {
         return this.cache.size;
     }
 }
+
+export class BoundedFileCache {
+    private cache = new Map<string, string>();
+    private maxSize: number;
+
+    constructor(maxSize: number) {
+        this.maxSize = maxSize;
+    }
+
+    get(key: string): string | undefined {
+        return this.cache.get(key);
+    }
+
+    set(key: string, filePath: string): void {
+        if (this.cache.has(key)) {
+            return;
+        }
+
+        if (this.cache.size >= this.maxSize) {
+            const oldestKey = this.cache.keys().next().value;
+            if (oldestKey !== undefined) {
+                const oldFilePath = this.cache.get(oldestKey);
+                if (oldFilePath && fs.existsSync(oldFilePath)) {
+                    try {
+                        fs.unlinkSync(oldFilePath);
+                    } catch (e) {
+                        // File might already be deleted, ignore
+                    }
+                }
+                this.cache.delete(oldestKey);
+            }
+        }
+
+        this.cache.set(key, filePath);
+    }
+
+    has(key: string): boolean {
+        return this.cache.has(key);
+    }
+
+    delete(key: string): void {
+        const filePath = this.cache.get(key);
+
+        if (filePath && fs.existsSync(filePath)) {
+            try {
+                fs.unlinkSync(filePath);
+            } catch (e) {
+                // File might already be deleted, ignore
+            }
+        }
+
+        this.cache.delete(key);
+    }
+
+    clear(): void {
+        for (const [key] of this.cache.entries()) {
+            this.delete(key);
+        }
+
+        this.cache.clear();
+    }
+
+    size(): number {
+        return this.cache.size;
+    }
+
+    deleteByFilePath(filePath: string): void {
+        for (const [key, value] of this.cache.entries()) {
+            if (value === filePath) {
+                this.cache.delete(key);
+                break;
+            }
+        }
+    }
+}

src/support/php.ts

@@ -2,6 +2,7 @@ import { getTemplate, TemplateName } from "@src/templates";
 import * as cp from "child_process";
 import * as fs from "fs";
 import * as vscode from "vscode";
+import { BoundedFileCache } from "./cache";
 import { config, PhpEnvironment } from "./config";
 import { registerWatcher } from "./fileWatcher";
 import { error, info } from "./logger";
@@ -24,7 +25,7 @@ const toTemplateVar = (str: string) => {
 
 let defaultPhpCommand: string | null = null;
 
-const discoverFiles = new Map<string, string>();
+const discoverFiles = new BoundedFileCache(50);
 
 let hasVendor = projectPathExists("vendor/autoload.php");
 const hasBootstrap = projectPathExists("bootstrap/app.php");
@@ -46,12 +47,7 @@ export const initVendorWatchers = () => {
     );
 
     watcher.onDidDelete((file) => {
-        for (const [key, value] of discoverFiles) {
-            if (value === file.fsPath) {
-                discoverFiles.delete(key);
-                break;
-            }
-        }
+        discoverFiles.deleteByFilePath(file.fsPath);
     });
 
     [internalVendorPath(), projectPath("vendor")].forEach((path) => {
@@ -173,6 +169,10 @@ export const clearDefaultPhpCommand = () => {
     defaultPhpCommand = null;
 };
 
+export const clearPhpFileCache = () => {
+    discoverFiles.clear();
+};
+
 const getDefaultPhpCommand = (): string => {
     defaultPhpCommand ??= getPhpCommand();