refactor: Support url based cache entries (#7639)

Author: Jason3S

packages/cspell/src/util/cache/DiskCache.test.ts

@@ -1,4 +1,4 @@
-import * as path from 'node:path';
+import { pathToFileURL } from 'node:url';
 
 import { afterEach, beforeEach, describe, expect, type Mock, test, vi } from 'vitest';
 
@@ -56,14 +56,14 @@ describe('DiskCache', () => {
     }
 
     beforeEach(async () => {
-        diskCache = await createDiskCache('.foobar', false, 'version', false);
+        diskCache = await createDiskCache(pathToFileURL('.foobar'), false, 'version', false);
         _fileEntryCache = mockCreateFileEntryCache.mock.results[0].value;
     });
 
     describe('constructor', () => {
         test('creates file-entry-cache in specified location', () => {
             expect(mockCreateFileEntryCache).toHaveBeenCalledTimes(1);
-            expect(mockCreateFileEntryCache).toHaveBeenCalledWith(path.resolve('.foobar'), false, undefined);
+            expect(mockCreateFileEntryCache).toHaveBeenCalledWith(pathToFileURL('.foobar'), false, undefined);
         });
     });
 

packages/cspell/src/util/cache/DiskCache.ts

@@ -1,13 +1,19 @@
 import assert from 'node:assert';
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
-import { dirname, isAbsolute as isAbsolutePath, relative as relativePath, resolve as resolvePath } from 'node:path';
+import {
+    isAbsolute as isAbsolutePath,
+    relative as relativePath,
+    resolve as resolvePath,
+    sep as pathSep,
+} from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 import { readFileInfo } from '../../util/fileHelper.js';
 import type { LintFileResult } from '../../util/LintFileResult.js';
 import type { CSpellLintResultCache } from './CSpellLintResultCache.js';
 import type { FileDescriptor, FileEntryCache } from './fileEntryCache.js';
-import { createFromFile, normalizePath } from './fileEntryCache.js';
+import { createFromFile } from './fileEntryCache.js';
 import { ShallowObjectCollection } from './ObjectCollection.js';
 
 export type CachedFileResult = Omit<LintFileResult, 'fileInfo' | 'elapsedTimeMs' | 'cached'>;
@@ -66,7 +72,6 @@ interface DependencyCacheTree {
  * Caches cspell results on disk
  */
 export class DiskCache implements CSpellLintResultCache {
-    public readonly cacheFileLocation: string;
     private cacheDir: string;
     private dependencyCache: Map<string, Dependency> = new Map();
     private dependencyCacheTree: DependencyCacheTree = {};
@@ -75,14 +80,13 @@ export class DiskCache implements CSpellLintResultCache {
     readonly version: string;
 
     constructor(
-        cacheFileLocation: string,
+        readonly cacheFileLocation: URL,
         readonly useCheckSum: boolean,
         readonly cspellVersion: string,
         readonly useUniversalCache: boolean,
         private fileEntryCache: FileEntryCache,
     ) {
-        this.cacheFileLocation = resolvePath(cacheFileLocation);
-        this.cacheDir = dirname(this.cacheFileLocation);
+        this.cacheDir = fileURLToPath(new URL('./', cacheFileLocation));
         this.version = calcVersion(cspellVersion);
     }
 
@@ -244,7 +248,7 @@ export class DiskCache implements CSpellLintResultCache {
 }
 
 export async function createDiskCache(
-    cacheFileLocation: string,
+    cacheFileLocation: URL,
     useCheckSum: boolean,
     cspellVersion: string,
     useUniversalCache: boolean,
@@ -293,6 +297,11 @@ function calcVersion(version: string): string {
     return version + META_DATA_VERSION_SUFFIX;
 }
 
+export function normalizePath(filePath: string): string {
+    if (pathSep === '/') return filePath;
+    return filePath.split(pathSep).join('/');
+}
+
 export const __testing__: {
     calcVersion: typeof calcVersion;
 } = {

packages/cspell/src/util/cache/createCache.ts

@@ -3,6 +3,7 @@ import { stat } from 'node:fs/promises';
 import path from 'node:path';
 
 import type { CacheSettings, CSpellSettings } from '@cspell/cspell-types';
+import { toFileURL } from '@cspell/url';
 
 import { isErrorLike } from '../errors.js';
 import type { CacheOptions } from './CacheOptions.js';
@@ -33,7 +34,7 @@ const versionSuffix = '';
  */
 export async function createCache(options: CreateCacheSettings): Promise<CSpellLintResultCache> {
     const { useCache, cacheLocation, cacheStrategy, reset } = options;
-    const location = path.resolve(cacheLocation);
+    const location = toFileURL(cacheLocation);
     const useChecksum = cacheStrategy === 'content';
     const version = normalizeVersion(options.version);
     const useUniversal = options.cacheFormat === 'universal';

packages/cspell/src/util/cache/file-entry-cache/file-entry-cache.ts

@@ -2,16 +2,17 @@ import crypto from 'node:crypto';
 import type { Stats } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 import type { FlatCache } from './flatCache.js';
 import { loadCacheFile as loadFlatCache } from './flatCache.js';
 
 export async function createFromFile(
-    filePath: string,
+    cacheFileUrl: URL,
     useChecksum?: boolean,
-    currentWorkingDir?: string,
+    currentWorkingDir?: URL,
 ): Promise<FileEntryCache> {
-    const cache = await loadFlatCache<Meta>(filePath);
+    const cache = await loadFlatCache<Meta>(cacheFileUrl);
     const fec = new ImplFileEntryCache(cache, useChecksum ?? false, currentWorkingDir);
     await fec.removeNotFoundFiles();
     return fec;
@@ -27,10 +28,10 @@ class ImplFileEntryCache implements FileEntryCache {
      */
     readonly currentWorkingDir: string | undefined;
 
-    constructor(cache: FlatCache<Meta>, useChecksum?: boolean, currentWorkingDir?: string) {
+    constructor(cache: FlatCache<Meta>, useChecksum?: boolean, currentWorkingDir?: URL) {
         this.cache = cache;
         this.useChecksum = useChecksum || false;
-        this.currentWorkingDir = currentWorkingDir;
+        this.currentWorkingDir = currentWorkingDir ? fileURLToPath(currentWorkingDir) : undefined;
     }
 
     async removeNotFoundFiles() {

packages/cspell/src/util/cache/file-entry-cache/flatCache.ts

@@ -1,12 +1,11 @@
 import fs from 'node:fs/promises';
-import path from 'node:path';
 
 import { parse, stringify } from 'flatted';
 
 export class FlatCache<T> {
     #cache: Map<string, T>;
 
-    constructor(readonly cacheFilename: string) {
+    constructor(readonly cacheFilename: URL) {
         this.#cache = new Map<string, T>();
     }
 
@@ -41,7 +40,7 @@ export class FlatCache<T> {
     }
 
     async save(): Promise<void> {
-        const dir = path.dirname(this.cacheFilename);
+        const dir = new URL('.', this.cacheFilename);
         await fs.mkdir(dir, { recursive: true });
         const content = stringify(Object.fromEntries(this.#cache.entries()));
         await fs.writeFile(this.cacheFilename, content, 'utf8');
@@ -61,7 +60,12 @@ export class FlatCache<T> {
     }
 }
 
-export function loadCacheFile<T>(file: string): Promise<FlatCache<T>> {
-    const cache = new FlatCache<T>(file);
+/**
+ *
+ * @param cachefile - The location of the cache file.
+ * @returns
+ */
+export function loadCacheFile<T>(cachefile: URL): Promise<FlatCache<T>> {
+    const cache = new FlatCache<T>(cachefile);
     return cache.load();
 }

packages/cspell/src/util/cache/fileEntryCache.ts

@@ -1,23 +1,8 @@
-import { mkdirSync } from 'node:fs';
-import * as path from 'node:path';
-
 import type { FileEntryCache } from './file-entry-cache/index.js';
 import * as fec from './file-entry-cache/index.js';
 
 export type { FileDescriptor, FileEntryCache } from './file-entry-cache/index.js';
 
-export function createFromFile(
-    pathToCache: string,
-    useCheckSum: boolean,
-    useRelative: boolean,
-): Promise<FileEntryCache> {
-    const absPathToCache = path.resolve(pathToCache);
-    const relDir = path.dirname(absPathToCache);
-    mkdirSync(relDir, { recursive: true });
-    return fec.createFromFile(absPathToCache, useCheckSum, useRelative ? relDir : undefined);
-}
-
-export function normalizePath(filePath: string): string {
-    if (path.sep === '/') return filePath;
-    return filePath.split(path.sep).join('/');
+export function createFromFile(cacheFileUrl: URL, useCheckSum: boolean, useRelative: boolean): Promise<FileEntryCache> {
+    return fec.createFromFile(cacheFileUrl, useCheckSum, useRelative ? new URL('./', cacheFileUrl) : undefined);
 }