cspell 5.14.0-alpha.0 → 5.15.2

package/README.md

@@ -56,6 +56,12 @@ cspell lint "src/**/*.js"
 cspell "**"
 ```
 
+**Git: Check Only Changed Files**
+
+```sh
+ git diff --name-only | npx cspell --file-list stdin
+```
+
 ## Command: `lint` -- Spell Checking
 
 The `lint` command is used for spell checking files.
@@ -110,8 +116,8 @@ Options:
   --show-suggestions           Show spelling suggestions.
   --no-must-find-files         Do not error if no files are found.
 
-  --cache                      Only check changed files. (default: false)
-
+  --cache                      Use cache to only check changed files.
+  --no-cache                   Do not use cache.
   --cache-strategy <strategy>  Strategy to use for detecting changed files.
                                (choices: "metadata", "content")
 

package/dist/commandLint.js

@@ -73,12 +73,13 @@ function commandLint(prog) {
         // .option('--force', 'Force the exit value to always be 0')
         .addOption(new commander_1.Option('--legacy', 'Legacy output').hideHelp())
         .addOption(new commander_1.Option('--local <local>', 'Deprecated -- Use: --locale').hideHelp())
-        .option('--cache', 'Only check changed files.', false)
+        .option('--cache', 'Use cache to only check changed files.')
+        .option('--no-cache', 'Do not use cache.')
         .addOption(new commander_1.Option('--cache-strategy <strategy>', 'Strategy to use for detecting changed files.').choices([
         'metadata',
         'content',
     ]))
-        .option('--cache-location <path>', `Path to the cache file or directory.`, cache_1.DEFAULT_CACHE_LOCATION)
+        .option('--cache-location <path>', `Path to the cache file or directory. (default: "${cache_1.DEFAULT_CACHE_LOCATION}")`)
         .option('--dot', 'Include files and directories starting with `.` (period) when matching globs.')
         .option('--gitignore', 'Ignore files matching glob patterns found in .gitignore files.')
         .option('--no-gitignore', 'Do NOT use .gitignore files.')

package/dist/lint/lint.js

@@ -45,7 +45,7 @@ async function runLint(cfg) {
     return lintResult;
     async function processFile(filename, configInfo, cache) {
         var _a, _b, _c, _d;
-        const cachedResult = await cache.getCachedLintResults(filename, configInfo);
+        const cachedResult = await cache.getCachedLintResults(filename);
         if (cachedResult) {
             reporter.debug(`Filename: ${filename}, using cache`);
             return cachedResult;
@@ -86,7 +86,8 @@ async function runLint(cfg) {
         reporter.info(`Checked: ${filename}, File type: ${config.languageId}, Language: ${config.language} ... Issues: ${result.issues.length} ${elapsed}S`, cspell_types_1.MessageTypes.Info);
         reporter.info(`Config file Used: ${spellResult.localConfigFilepath || configInfo.source}`, cspell_types_1.MessageTypes.Info);
         reporter.info(`Dictionaries Used: ${dictionaries.join(', ')}`, cspell_types_1.MessageTypes.Info);
-        cache.setCachedLintResults(result, configInfo);
+        const dep = calcDependencies(config);
+        cache.setCachedLintResults(result, dep.files);
         return result;
     }
     function mapIssue({ doc: _, ...tdo }) {
@@ -95,9 +96,10 @@ async function runLint(cfg) {
             : { text: tdo.line.text.trimEnd(), offset: tdo.line.offset };
         return { ...tdo, context };
     }
-    async function processFiles(files, configInfo, fileCount) {
+    async function processFiles(files, configInfo, cacheSettings) {
+        const fileCount = files.length;
         const status = runResult();
-        const cache = (0, cache_1.createCache)({ ...cfg.options, root: cfg.root });
+        const cache = (0, cache_1.createCache)(cacheSettings);
         const emitProgress = (filename, fileNum, result) => reporter.progress({
             type: 'ProgressFileComplete',
             fileNum,
@@ -117,12 +119,8 @@ async function runLint(cfg) {
         }
         for await (const fileP of loadAndProcessFiles()) {
             const { filename, fileNum, result } = await fileP;
-            if (!result.fileInfo.text === undefined) {
-                status.files += result.cached ? 1 : 0;
-                emitProgress(filename, fileNum, result);
-                continue;
-            }
             status.files += 1;
+            status.cachedFiles = (status.cachedFiles || 0) + (result.cached ? 1 : 0);
             emitProgress(filename, fileNum, result);
             // Show the spelling errors after emitting the progress.
             result.issues.filter(cfg.uniqueFilter).forEach((issue) => reporter.issue(issue));
@@ -136,6 +134,10 @@ async function runLint(cfg) {
         cache.reconcile();
         return status;
     }
+    function calcDependencies(config) {
+        const { configFiles, dictionaryFiles } = cspell.extractDependencies(config);
+        return { files: configFiles.concat(dictionaryFiles) };
+    }
     async function reportConfigurationErrors(config) {
         const errors = cspell.extractImportErrors(config);
         let count = 0;
@@ -212,12 +214,13 @@ async function runLint(cfg) {
             globOptions.dot = enableGlobDot;
         }
         try {
+            const cacheSettings = await (0, cache_1.calcCacheSettings)(configInfo.config, cfg.options, root);
             const foundFiles = await (hasFileLists
                 ? useFileLists(fileLists, allGlobs, root, enableGlobDot)
                 : (0, fileHelper_1.findFiles)(fileGlobs, globOptions));
             const filtered = gitIgnore ? await gitIgnore.filterOutIgnored(foundFiles) : foundFiles;
             const files = filterFiles(filtered, globMatcher);
-            return await processFiles(files, configInfo, files.length);
+            return await processFiles(files, configInfo, cacheSettings);
         }
         catch (e) {
             const err = (0, errors_1.toApplicationError)(e);
@@ -300,8 +303,8 @@ function extractContext(tdo, contextRange) {
     return context;
 }
 function runResult(init = {}) {
-    const { files = 0, filesWithIssues = new Set(), issues = 0, errors = 0 } = init;
-    return { files, filesWithIssues, issues, errors };
+    const { files = 0, filesWithIssues = new Set(), issues = 0, errors = 0, cachedFiles = 0 } = init;
+    return { files, filesWithIssues, issues, errors, cachedFiles };
 }
 function yesNo(value) {
     return value ? 'Yes' : 'No';

package/dist/options.d.ts

@@ -60,9 +60,21 @@ export interface TraceOptions extends BaseOptions {
     ignoreCase?: boolean;
 }
 export interface BaseOptions {
+    /**
+     * Path to configuration file.
+     */
     config?: string;
+    /**
+     * Programming Language ID.
+     */
     languageId?: string;
+    /**
+     * Locale to use.
+     */
     locale?: string;
+    /**
+     * @deprecated
+     */
     local?: string;
 }
 export interface LinterCliOptions extends Omit<LinterOptions, 'fileLists'> {

package/dist/util/cache/CSpellLintResultCache.d.ts

@@ -1,13 +1,13 @@
-import { ConfigInfo, FileResult } from '../../fileHelper';
+import { FileResult } from '../../fileHelper';
 export interface CSpellLintResultCache {
     /**
      * Retrieve cached lint results for a given file name, if present in the cache.
      */
-    getCachedLintResults(filename: string, configInfo: ConfigInfo): Promise<FileResult | undefined>;
+    getCachedLintResults(filename: string): Promise<FileResult | undefined>;
     /**
      * Set the cached lint results.
      */
-    setCachedLintResults(result: FileResult, configInfo: ConfigInfo): void;
+    setCachedLintResults(result: FileResult, dependsUponFiles: string[]): void;
     /**
      * Persists the in-memory cache to disk.
      */

package/dist/util/cache/CacheOptions.d.ts

@@ -1,3 +1,4 @@
+import type { CacheStrategy } from '@cspell/cspell-types';
 export interface CacheOptions {
     /**
      * Store the info about processed files in order to only operate on the changed ones.
@@ -12,6 +13,6 @@ export interface CacheOptions {
     /**
      * Strategy to use for detecting changed files, default: metadata
      */
-    cacheStrategy?: 'metadata' | 'content';
+    cacheStrategy?: CacheStrategy;
 }
 //# sourceMappingURL=CacheOptions.d.ts.map

package/dist/util/cache/DiskCache.d.ts

@@ -1,13 +1,34 @@
-import type { ConfigInfo, FileResult } from '../../fileHelper';
+import type { FileDescriptor } from 'file-entry-cache';
+import type { FileResult } from '../../fileHelper';
 import type { CSpellLintResultCache } from './CSpellLintResultCache';
+export declare type CachedFileResult = Omit<FileResult, 'fileInfo' | 'elapsedTimeMs'>;
+/**
+ * This is the data cached.
+ * Property names are short to help keep the cache file size small.
+ */
+interface CachedData {
+    /** results */
+    r: CachedFileResult;
+    /** dependencies */
+    d: string[];
+}
+interface CSpellCachedMetaData {
+    data?: CachedData;
+}
+export declare type CSpellCacheMeta = (FileDescriptor['meta'] & CSpellCachedMetaData) | undefined;
 /**
  * Caches cspell results on disk
  */
 export declare class DiskCache implements CSpellLintResultCache {
     private fileEntryCache;
+    private changedDependencies;
+    private knownDependencies;
     constructor(cacheFileLocation: string, useCheckSum: boolean);
-    getCachedLintResults(filename: string, configInfo: ConfigInfo): Promise<FileResult | undefined>;
-    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }: FileResult, configInfo: ConfigInfo): void;
+    getCachedLintResults(filename: string): Promise<FileResult | undefined>;
+    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }: FileResult, dependsUponFiles: string[]): void;
     reconcile(): void;
+    private cacheDependencies;
+    private checkDependencies;
 }
+export {};
 //# sourceMappingURL=DiskCache.d.ts.map

package/dist/util/cache/DiskCache.js

@@ -1,53 +1,95 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiskCache = void 0;
-const file_entry_cache_1 = require("file-entry-cache");
+const fileEntryCache = __importStar(require("file-entry-cache"));
+const path_1 = require("path");
 const fileHelper_1 = require("../../fileHelper");
-const getConfigHash_1 = require("./getConfigHash");
 /**
  * Caches cspell results on disk
  */
 class DiskCache {
     constructor(cacheFileLocation, useCheckSum) {
-        this.fileEntryCache = (0, file_entry_cache_1.create)(cacheFileLocation, undefined, useCheckSum);
+        this.changedDependencies = new Set();
+        this.knownDependencies = new Set();
+        this.fileEntryCache = fileEntryCache.createFromFile((0, path_1.resolve)(cacheFileLocation), useCheckSum);
     }
-    async getCachedLintResults(filename, configInfo) {
+    async getCachedLintResults(filename) {
         const fileDescriptor = this.fileEntryCache.getFileDescriptor(filename);
         const meta = fileDescriptor.meta;
+        const data = meta === null || meta === void 0 ? void 0 : meta.data;
+        const result = data === null || data === void 0 ? void 0 : data.r;
         // Cached lint results are valid if and only if:
         // 1. The file is present in the filesystem
         // 2. The file has not changed since the time it was previously linted
         // 3. The CSpell configuration has not changed since the time the file was previously linted
         // If any of these are not true, we will not reuse the lint results.
-        if (fileDescriptor.notFound ||
-            fileDescriptor.changed ||
-            !meta ||
-            meta.configHash !== (0, getConfigHash_1.getConfigHash)(configInfo)) {
+        if (fileDescriptor.notFound || fileDescriptor.changed || !meta || !result || !this.checkDependencies(data.d)) {
             return undefined;
         }
         // Skip reading empty files and files without lint error
-        const hasErrors = meta.result.errors > 0 || meta.result.configErrors > 0 || meta.result.issues.length > 0;
-        const cached = !!meta.size;
+        const hasErrors = !!result && (result.errors > 0 || result.configErrors > 0 || result.issues.length > 0);
+        const cached = true;
         const shouldReadFile = cached && hasErrors;
         return {
-            ...meta.result,
+            ...result,
             elapsedTimeMs: undefined,
             fileInfo: shouldReadFile ? await (0, fileHelper_1.readFileInfo)(filename) : { filename },
             cached,
         };
     }
-    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }, configInfo) {
+    setCachedLintResults({ fileInfo, elapsedTimeMs: _, ...result }, dependsUponFiles) {
         const fileDescriptor = this.fileEntryCache.getFileDescriptor(fileInfo.filename);
         const meta = fileDescriptor.meta;
         if (fileDescriptor.notFound || !meta) {
             return;
         }
-        meta.result = result;
-        meta.configHash = (0, getConfigHash_1.getConfigHash)(configInfo);
+        const data = {
+            r: result,
+            d: dependsUponFiles,
+        };
+        meta.data = data;
+        this.cacheDependencies(dependsUponFiles);
     }
     reconcile() {
         this.fileEntryCache.reconcile();
     }
+    cacheDependencies(files) {
+        this.fileEntryCache.analyzeFiles(files);
+    }
+    checkDependencies(files) {
+        for (const file of files) {
+            if (this.changedDependencies.has(file)) {
+                return false;
+            }
+        }
+        const unknown = files.filter((f) => !this.knownDependencies.has(f));
+        if (!unknown.length) {
+            return true;
+        }
+        const { changedFiles, notFoundFiles } = this.fileEntryCache.analyzeFiles(files);
+        changedFiles.map((f) => this.changedDependencies.add(f));
+        unknown.forEach((f) => this.knownDependencies.add(f));
+        return changedFiles.length === 0 && notFoundFiles.length === 0;
+    }
 }
 exports.DiskCache = DiskCache;
 //# sourceMappingURL=DiskCache.js.map

package/dist/util/cache/createCache.d.ts

@@ -1,11 +1,11 @@
-import { CacheOptions } from './CacheOptions';
+import { CacheSettings, CSpellSettings } from '@cspell/cspell-types';
+import { CacheOptions } from '.';
 import { CSpellLintResultCache } from './CSpellLintResultCache';
 export declare const DEFAULT_CACHE_LOCATION = ".cspellcache";
-export interface CreateCacheOptions extends CacheOptions {
-    root: string;
-}
+export declare type CreateCacheSettings = Required<CacheSettings>;
 /**
  * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)
  */
-export declare function createCache(options: CreateCacheOptions): CSpellLintResultCache;
+export declare function createCache(options: CreateCacheSettings): CSpellLintResultCache;
+export declare function calcCacheSettings(config: CSpellSettings, cacheOptions: CacheOptions, root: string): Promise<CreateCacheSettings>;
 //# sourceMappingURL=createCache.d.ts.map

package/dist/util/cache/createCache.js

@@ -3,18 +3,47 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCache = exports.DEFAULT_CACHE_LOCATION = void 0;
+exports.calcCacheSettings = exports.createCache = exports.DEFAULT_CACHE_LOCATION = void 0;
 const path_1 = __importDefault(require("path"));
 const DiskCache_1 = require("./DiskCache");
 const DummyCache_1 = require("./DummyCache");
+const fs_extra_1 = require("fs-extra");
+const errors_1 = require("../errors");
 // cspell:word cspellcache
 exports.DEFAULT_CACHE_LOCATION = '.cspellcache';
 /**
  * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)
  */
 function createCache(options) {
-    const { cache, cacheLocation = exports.DEFAULT_CACHE_LOCATION, cacheStrategy = 'metadata', root } = options;
-    return cache ? new DiskCache_1.DiskCache(path_1.default.resolve(root, cacheLocation), cacheStrategy === 'content') : new DummyCache_1.DummyCache();
+    const { useCache, cacheLocation, cacheStrategy } = options;
+    return useCache ? new DiskCache_1.DiskCache(path_1.default.resolve(cacheLocation), cacheStrategy === 'content') : new DummyCache_1.DummyCache();
 }
 exports.createCache = createCache;
+async function calcCacheSettings(config, cacheOptions, root) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const cs = (_a = config.cache) !== null && _a !== void 0 ? _a : {};
+    const useCache = (_c = (_b = cacheOptions.cache) !== null && _b !== void 0 ? _b : cs.useCache) !== null && _c !== void 0 ? _c : false;
+    const cacheLocation = await resolveCacheLocation(path_1.default.resolve(root, (_e = (_d = cacheOptions.cacheLocation) !== null && _d !== void 0 ? _d : cs.cacheLocation) !== null && _e !== void 0 ? _e : exports.DEFAULT_CACHE_LOCATION));
+    const cacheStrategy = (_g = (_f = cacheOptions.cacheStrategy) !== null && _f !== void 0 ? _f : cs.cacheStrategy) !== null && _g !== void 0 ? _g : 'metadata';
+    return {
+        useCache,
+        cacheLocation,
+        cacheStrategy,
+    };
+}
+exports.calcCacheSettings = calcCacheSettings;
+async function resolveCacheLocation(cacheLocation) {
+    try {
+        const s = await (0, fs_extra_1.stat)(cacheLocation);
+        if (s.isFile())
+            return cacheLocation;
+        return path_1.default.join(cacheLocation, exports.DEFAULT_CACHE_LOCATION);
+    }
+    catch (err) {
+        if ((0, errors_1.isError)(err) && err.code === 'ENOENT') {
+            return cacheLocation;
+        }
+        throw err;
+    }
+}
 //# sourceMappingURL=createCache.js.map

package/dist/util/cache/index.d.ts

@@ -1,5 +1,4 @@
-export { createCache, DEFAULT_CACHE_LOCATION } from './createCache';
-export type { CreateCacheOptions } from './createCache';
+export { createCache, calcCacheSettings, DEFAULT_CACHE_LOCATION, type CreateCacheSettings } from './createCache';
 export type { CSpellLintResultCache } from './CSpellLintResultCache';
 export type { CacheOptions } from './CacheOptions';
 //# sourceMappingURL=index.d.ts.map

package/dist/util/cache/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CACHE_LOCATION = exports.createCache = void 0;
+exports.DEFAULT_CACHE_LOCATION = exports.calcCacheSettings = exports.createCache = void 0;
 var createCache_1 = require("./createCache");
 Object.defineProperty(exports, "createCache", { enumerable: true, get: function () { return createCache_1.createCache; } });
+Object.defineProperty(exports, "calcCacheSettings", { enumerable: true, get: function () { return createCache_1.calcCacheSettings; } });
 Object.defineProperty(exports, "DEFAULT_CACHE_LOCATION", { enumerable: true, get: function () { return createCache_1.DEFAULT_CACHE_LOCATION; } });
 //# sourceMappingURL=index.js.map

package/dist/util/errors.d.ts

@@ -8,6 +8,10 @@ export declare class ApplicationError extends Error {
     constructor(message: string, exitCode?: number, cause?: Error | undefined);
 }
 export declare function toError(e: unknown): Error;
-export declare function isError(e: unknown): e is Error;
+export declare function isError(e: unknown): e is NodeError;
 export declare function toApplicationError(e: unknown, message?: string): ApplicationError;
+interface NodeError extends Error {
+    code?: string;
+}
+export {};
 //# sourceMappingURL=errors.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell",
-  "version": "5.14.0-alpha.0",
+  "version": "5.15.2",
   "description": "A Spelling Checker for Code!",
   "funding": "https://github.com/streetsidesoftware/cspell?sponsor=1",
   "main": "dist/index.js",
@@ -72,9 +72,9 @@
     "chalk": "^4.1.2",
     "commander": "^8.3.0",
     "comment-json": "^4.1.1",
-    "cspell-gitignore": "^5.14.0-alpha.0",
-    "cspell-glob": "^5.14.0-alpha.0",
-    "cspell-lib": "^5.14.0-alpha.0",
+    "cspell-gitignore": "^5.15.2",
+    "cspell-glob": "^5.15.2",
+    "cspell-lib": "^5.15.2",
     "fast-json-stable-stringify": "^2.1.0",
     "file-entry-cache": "^6.0.1",
     "fs-extra": "^10.0.0",
@@ -89,8 +89,8 @@
     "node": ">=12.13.0"
   },
   "devDependencies": {
-    "@cspell/cspell-json-reporter": "^5.14.0-alpha.0",
-    "@cspell/cspell-types": "^5.14.0-alpha.0",
+    "@cspell/cspell-json-reporter": "^5.15.2",
+    "@cspell/cspell-types": "^5.15.2",
     "@types/file-entry-cache": "^5.0.2",
     "@types/fs-extra": "^9.0.13",
     "@types/glob": "^7.2.0",
@@ -98,10 +98,10 @@
     "@types/micromatch": "^4.0.2",
     "@types/minimatch": "^3.0.5",
     "@types/semver": "^7.3.9",
-    "jest": "^27.4.5",
+    "jest": "^27.4.7",
     "micromatch": "^4.0.4",
     "minimatch": "^3.0.4",
     "rimraf": "^3.0.2"
   },
-  "gitHead": "bb136daa99b18e826a5e720ad1dfba94caa1e16e"
+  "gitHead": "b047b5458980010a8f3ab31c6dc9434e0e782d5e"
 }