cspell 6.7.0 → 6.8.2

package/dist/application.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { CSpellReporter, RunResult } from '@cspell/cspell-types';
-import type { CheckTextInfo, TraceResult } from 'cspell-lib';
+import { CheckTextInfo, TraceResult } from 'cspell-lib';
 import { TimedSuggestionsForWordResult } from './emitters/suggestionsEmitter';
 import { BaseOptions, LegacyOptions, LinterCliOptions, SuggestionOptions, TraceOptions } from './options';
 export { IncludeExcludeFlag } from 'cspell-lib';

package/dist/application.js

@@ -26,7 +26,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createInit = exports.suggestions = exports.checkText = exports.trace = exports.lint = exports.IncludeExcludeFlag = void 0;
 const cspell_pipe_1 = require("@cspell/cspell-pipe");
 const cspell_lib_1 = require("cspell-lib");
-const path = __importStar(require("path"));
 const cli_reporter_1 = require("./cli-reporter");
 const lint_1 = require("./lint");
 const options_1 = require("./options");
@@ -55,15 +54,19 @@ async function* trace(words, options) {
 exports.trace = trace;
 async function checkText(filename, options) {
     options = (0, options_1.fixLegacy)(options);
-    const pSettings = (0, fileHelper_1.readConfig)(options.config, path.dirname(filename));
-    const [foundSettings, text] = await Promise.all([pSettings, (0, fileHelper_1.readFile)(filename)]);
+    const fileInfo = await (0, fileHelper_1.readFileInfo)(filename);
+    const { locale, languageId, validateDirectives } = options;
+    const doc = (0, fileHelper_1.fileInfoToDocument)(fileInfo, languageId, locale);
+    const checkOptions = {
+        configFile: options.config,
+        validateDirectives,
+    };
     const settingsFromCommandLine = util.clean({
-        languageId: options.languageId || undefined,
-        language: options.locale || options.local || undefined,
+        languageId,
+        language: locale,
         loadDefaultConfiguration: options.defaultConfiguration,
     });
-    const info = (0, fileHelper_1.calcFinalConfigInfo)(foundSettings, settingsFromCommandLine, filename, text);
-    return (0, cspell_lib_1.checkText)(text, info.configInfo.config);
+    return (0, cspell_lib_1.checkTextDocument)(doc, checkOptions, settingsFromCommandLine);
 }
 exports.checkText = checkText;
 async function* suggestions(words, options) {

package/dist/cli-reporter.js

@@ -164,7 +164,8 @@ function formatIssue(templateStr, issue, maxIssueTextWidth) {
     const colText = col.toString();
     const padRowCol = ' '.repeat(Math.max(1, 8 - (rowText.length + colText.length)));
     const suggestions = issue.suggestions?.join(', ') || '';
-    const message = issue.isFlagged ? '{yellow Forbidden word}' : 'Unknown word';
+    const msg = issue.message || (issue.isFlagged ? 'Forbidden word' : 'Unknown word');
+    const message = issue.isFlagged ? `{yellow ${msg}}` : msg;
     const substitutions = {
         $col: colText,
         $contextFull: contextFull,

package/dist/commandCheck.js

@@ -34,6 +34,8 @@ function commandCheck(prog) {
         .command('check <files...>')
         .description('Spell check file(s) and display the result. The full file is displayed in color.')
         .option('-c, --config <cspell.json>', 'Configuration file to use.  By default cspell looks for cspell.json in the current directory.')
+        .option('--validate-directives', 'Validate in-document CSpell directives.')
+        .option('--no-validate-directives', 'Do not validate in-document CSpell directives.')
         .option('--no-color', 'Turn off color.')
         .option('--color', 'Force color')
         .addOption(new commander_1.Option('--default-configuration', 'Load the default configuration and dictionaries.').hideHelp())

package/dist/commandLint.js

@@ -90,6 +90,8 @@ function commandLint(prog) {
         .option('--gitignore', 'Ignore files matching glob patterns found in .gitignore files.')
         .option('--no-gitignore', 'Do NOT use .gitignore files.')
         .option('--gitignore-root <path>', 'Prevent searching for .gitignore files past root.', collect)
+        .option('--validate-directives', 'Validate in-document CSpell directives.')
+        .option('--no-validate-directives', 'Do not validate in-document CSpell directives.')
         .option('--no-color', 'Turn off color.')
         .option('--color', 'Force color.')
         .addOption(new commander_1.Option('--default-configuration', 'Load the default configuration and dictionaries.').hideHelp())

package/dist/lint/lint.js

@@ -83,7 +83,8 @@ async function runLint(cfg) {
         let spellResult = {};
         reporter.info(`Checking: ${filename}, File type: ${doc.languageId ?? 'auto'}, Language: ${doc.locale ?? 'default'}`, cspell_types_1.MessageTypes.Info);
         try {
-            const validateOptions = { generateSuggestions: cfg.options.showSuggestions, numSuggestions: 5 };
+            const { showSuggestions: generateSuggestions, validateDirectives } = cfg.options;
+            const validateOptions = { generateSuggestions, numSuggestions: 5, validateDirectives };
             const r = await cspell.spellCheckDocument(doc, validateOptions, configInfo.config);
             spellResult = r;
             result.processed = r.checked;
@@ -125,9 +126,6 @@ async function runLint(cfg) {
         const fileCount = files instanceof Array ? files.length : undefined;
         const status = runResult();
         const cache = (0, cache_1.createCache)(cacheSettings);
-        if (cfg.options.cacheReset) {
-            cache.reset();
-        }
         const failFast = cfg.options.failFast ?? configInfo.config.failFast ?? false;
         const emitProgressBegin = (filename, fileNum, fileCount) => reporter.progress({
             type: 'ProgressFileBegin',

package/dist/options.d.ts

@@ -124,6 +124,10 @@ export interface BaseOptions {
      * @default true
      */
     defaultConfiguration?: boolean;
+    /**
+     * Check In-Document CSpell directives for correctness.
+     */
+    validateDirectives?: boolean;
 }
 export interface LinterCliOptions extends LinterOptions {
     /**

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

@@ -1,4 +1,4 @@
-import type { CacheStrategy } from '@cspell/cspell-types';
+import type { CacheStrategy, CacheFormat } from '@cspell/cspell-types';
 export interface CacheOptions {
     /**
      * The version of `cspell` that made the cache entry.
@@ -23,5 +23,12 @@ export interface CacheOptions {
      * Resets the cache
      */
     cacheReset?: boolean;
+    /**
+     * Format of the cache file.
+     * - `legacy` - use absolute paths in the cache file
+     * - `universal` - use a sharable format.
+     * @default 'legacy'
+     */
+    cacheFormat?: CacheFormat;
 }
 //# sourceMappingURL=CacheOptions.d.ts.map

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

@@ -1,6 +1,6 @@
-import type { FileDescriptor } from 'file-entry-cache';
 import type { FileResult } from '../../util/fileHelper';
 import type { CSpellLintResultCache } from './CSpellLintResultCache';
+import { FileDescriptor } from './fileEntryCache';
 export declare type CachedFileResult = Omit<FileResult, 'fileInfo' | 'elapsedTimeMs' | 'cached'>;
 /**
  * This is the data cached.
@@ -31,15 +31,18 @@ export declare type CSpellCacheMeta = (Meta & CSpellCachedMetaData) | undefined;
 export declare class DiskCache implements CSpellLintResultCache {
     readonly useCheckSum: boolean;
     readonly cspellVersion: string;
+    readonly useUniversalCache: boolean;
+    readonly cacheFileLocation: string;
+    private cacheDir;
     private fileEntryCache;
     private dependencyCache;
     private dependencyCacheTree;
     private objectCollection;
     private ocCacheFileResult;
     readonly version: string;
-    constructor(cacheFileLocation: string, useCheckSum: boolean, cspellVersion: string);
+    constructor(cacheFileLocation: string, useCheckSum: boolean, cspellVersion: string, useUniversalCache: boolean);
     getCachedLintResults(filename: string): Promise<FileResult | undefined>;
-    setCachedLintResults({ fileInfo, elapsedTimeMs: _, cached: __, ...result }: FileResult, dependsUponFiles: string[]): void;
+    setCachedLintResults({ fileInfo, elapsedTimeMs, cached, ...result }: FileResult, dependsUponFiles: string[]): void;
     reconcile(): void;
     reset(): void;
     private normalizeResult;
@@ -49,6 +52,8 @@ export declare class DiskCache implements CSpellLintResultCache {
     private getFileDep;
     private checkDependencies;
     private getHash;
+    private resolveFile;
+    private toRelFile;
 }
 declare function calcVersion(version: string): string;
 export declare const __testing__: {

package/dist/util/cache/DiskCache.js

@@ -22,13 +22,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__testing__ = exports.DiskCache = void 0;
+const assert_1 = __importDefault(require("assert"));
 const crypto = __importStar(require("crypto"));
-const fileEntryCache = __importStar(require("file-entry-cache"));
 const fs = __importStar(require("fs"));
 const path_1 = require("path");
 const fileHelper_1 = require("../../util/fileHelper");
+const fileEntryCache_1 = require("./fileEntryCache");
 const ObjectCollection_1 = require("./ObjectCollection");
 const cacheDataKeys = {
     v: 'v',
@@ -45,17 +49,21 @@ const META_DATA_VERSION_SUFFIX = '-' + META_DATA_BASE_VERSION + '-' + Object.key
  * Caches cspell results on disk
  */
 class DiskCache {
-    constructor(cacheFileLocation, useCheckSum, cspellVersion) {
+    constructor(cacheFileLocation, useCheckSum, cspellVersion, useUniversalCache) {
         this.useCheckSum = useCheckSum;
         this.cspellVersion = cspellVersion;
+        this.useUniversalCache = useUniversalCache;
         this.dependencyCache = new Map();
         this.dependencyCacheTree = {};
         this.objectCollection = new ObjectCollection_1.ShallowObjectCollection();
         this.ocCacheFileResult = new ObjectCollection_1.ShallowObjectCollection();
-        this.fileEntryCache = fileEntryCache.createFromFile((0, path_1.resolve)(cacheFileLocation), useCheckSum);
+        this.cacheFileLocation = (0, path_1.resolve)(cacheFileLocation);
+        this.cacheDir = (0, path_1.dirname)(this.cacheFileLocation);
+        this.fileEntryCache = (0, fileEntryCache_1.createFromFile)(this.cacheFileLocation, useCheckSum, useUniversalCache);
         this.version = calcVersion(cspellVersion);
     }
     async getCachedLintResults(filename) {
+        filename = (0, fileEntryCache_1.normalizePath)(filename);
         const fileDescriptor = this.fileEntryCache.getFileDescriptor(filename);
         const meta = fileDescriptor.meta;
         const data = meta?.data;
@@ -131,17 +139,18 @@ class DiskCache {
         return setTreeEntry(this.dependencyCacheTree, dependencies);
     }
     checkDependency(dep) {
-        const cDep = this.dependencyCache.get(dep.f);
+        const depFile = this.resolveFile(dep.f);
+        const cDep = this.dependencyCache.get(depFile);
         if (cDep && compDep(dep, cDep))
             return true;
         if (cDep)
             return false;
-        const d = this.getFileDep(dep.f);
+        const d = this.getFileDep(depFile);
         if (compDep(dep, d)) {
-            this.dependencyCache.set(dep.f, dep);
+            this.dependencyCache.set(depFile, dep);
             return true;
         }
-        this.dependencyCache.set(d.f, d);
+        this.dependencyCache.set(depFile, d);
         return false;
     }
     getDependency(file) {
@@ -153,15 +162,17 @@ class DiskCache {
         return d;
     }
     getFileDep(file) {
+        (0, assert_1.default)((0, path_1.isAbsolute)(file));
+        const f = this.toRelFile(file);
         let h;
         try {
             const buffer = fs.readFileSync(file);
             h = this.getHash(buffer);
         }
         catch (e) {
-            return { f: file };
+            return { f };
         }
-        return { f: file, h };
+        return { f, h };
     }
     checkDependencies(dependencies) {
         if (!dependencies)
@@ -176,6 +187,12 @@ class DiskCache {
     getHash(buffer) {
         return crypto.createHash('md5').update(buffer).digest('hex');
     }
+    resolveFile(file) {
+        return (0, fileEntryCache_1.normalizePath)((0, path_1.resolve)(this.cacheDir, file));
+    }
+    toRelFile(file) {
+        return (0, fileEntryCache_1.normalizePath)(this.useUniversalCache ? (0, path_1.relative)(this.cacheDir, file) : file);
+    }
 }
 exports.DiskCache = DiskCache;
 function getTreeEntry(tree, keys) {

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

@@ -7,6 +7,11 @@ export interface CreateCacheSettings extends Required<CacheSettings> {
      * cspell version used to validate cache entries.
      */
     version: string;
+    /**
+     * When true, causes the cache to be reset, removing any entries
+     * or cache files.
+     */
+    reset?: true;
 }
 /**
  * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)

package/dist/util/cache/createCache.js

@@ -17,10 +17,14 @@ const versionSuffix = '';
  * Creates CSpellLintResultCache (disk cache if caching is enabled in config or dummy otherwise)
  */
 function createCache(options) {
-    const { useCache, cacheLocation, cacheStrategy } = options;
-    return useCache
-        ? new DiskCache_1.DiskCache(path_1.default.resolve(cacheLocation), cacheStrategy === 'content', normalizeVersion(options.version))
-        : new DummyCache_1.DummyCache();
+    const { useCache, cacheLocation, cacheStrategy, reset } = options;
+    const location = path_1.default.resolve(cacheLocation);
+    const useChecksum = cacheStrategy === 'content';
+    const version = normalizeVersion(options.version);
+    const useUniversal = options.cacheFormat === 'universal';
+    const cache = useCache ? new DiskCache_1.DiskCache(location, useChecksum, version, useUniversal) : new DummyCache_1.DummyCache();
+    reset && cache.reset();
+    return cache;
 }
 exports.createCache = createCache;
 async function calcCacheSettings(config, cacheOptions, root) {
@@ -28,11 +32,17 @@ async function calcCacheSettings(config, cacheOptions, root) {
     const useCache = cacheOptions.cache ?? cs.useCache ?? false;
     const cacheLocation = await resolveCacheLocation(path_1.default.resolve(root, cacheOptions.cacheLocation ?? cs.cacheLocation ?? exports.DEFAULT_CACHE_LOCATION));
     const cacheStrategy = cacheOptions.cacheStrategy ?? cs.cacheStrategy ?? 'metadata';
+    const optionals = {};
+    if (cacheOptions.cacheReset) {
+        optionals.reset = true;
+    }
     return {
+        ...optionals,
         useCache,
         cacheLocation,
         cacheStrategy,
         version: cacheOptions.version,
+        cacheFormat: cacheOptions.cacheFormat || 'legacy',
     };
 }
 exports.calcCacheSettings = calcCacheSettings;

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

@@ -0,0 +1,9 @@
+/**
+ * This is a wrapper for 'file-entry-cache'
+ */
+export type { FileDescriptor } from 'file-entry-cache';
+import type { FileEntryCache as FecFileEntryCache } from 'file-entry-cache';
+export declare type FileEntryCache = FecFileEntryCache;
+export declare function createFromFile(pathToCache: string, useCheckSum: boolean, useRelative: boolean): FileEntryCache;
+export declare function normalizePath(filePath: string): string;
+//# sourceMappingURL=fileEntryCache.d.ts.map

package/dist/util/cache/fileEntryCache.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * This is a wrapper for 'file-entry-cache'
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.normalizePath = exports.createFromFile = void 0;
+const file_entry_cache = __importStar(require("file-entry-cache"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+function createFromFile(pathToCache, useCheckSum, useRelative) {
+    const absPathToCache = path.resolve(pathToCache);
+    const relDir = path.dirname(absPathToCache);
+    fs.mkdirpSync(relDir);
+    const create = wrap(() => file_entry_cache.createFromFile(absPathToCache, useCheckSum));
+    const feCache = create();
+    const cacheWrapper = {
+        get cache() {
+            return feCache.cache;
+        },
+        getHash(buffer) {
+            return feCache.getHash(buffer);
+        },
+        hasFileChanged: wrap((cwd, file) => {
+            console.log(file);
+            return feCache.hasFileChanged(resolveFile(cwd, file));
+        }),
+        analyzeFiles: wrap((cwd, files) => {
+            return feCache.analyzeFiles(resolveFiles(cwd, files));
+        }),
+        getFileDescriptor: wrap((cwd, file) => {
+            return feCache.getFileDescriptor(resolveFile(cwd, file));
+        }),
+        getUpdatedFiles: wrap((cwd, files) => {
+            return feCache.getUpdatedFiles(resolveFiles(cwd, files));
+        }),
+        normalizeEntries: wrap((cwd, files) => {
+            return feCache.normalizeEntries(resolveFiles(cwd, files));
+        }),
+        removeEntry: wrap((cwd, file) => {
+            console.log(file);
+            return feCache.removeEntry(resolveFile(cwd, file));
+        }),
+        deleteCacheFile() {
+            feCache.deleteCacheFile();
+        },
+        destroy() {
+            feCache.destroy();
+        },
+        reconcile: wrap((_cwd, noPrune) => {
+            feCache.reconcile(noPrune);
+        }),
+    };
+    return cacheWrapper;
+    function resolveFile(cwd, file) {
+        if (!useRelative)
+            return file;
+        const r = path.relative(relDir, path.resolve(cwd, file));
+        return normalizePath(r);
+    }
+    function resolveFiles(cwd, files) {
+        return files?.map((file) => resolveFile(cwd, file));
+    }
+    function wrap(fn) {
+        return (...params) => {
+            const cwd = process.cwd();
+            try {
+                process.chdir(relDir);
+                return fn(cwd, ...params);
+            }
+            finally {
+                process.chdir(cwd);
+            }
+        };
+    }
+}
+exports.createFromFile = createFromFile;
+function normalizePath(filePath) {
+    return filePath;
+    // if (path.sep !== '\\') return filePath;
+    // return filePath.replace(/\\/g, '/');
+}
+exports.normalizePath = normalizePath;
+//# sourceMappingURL=fileEntryCache.js.map

package/dist/util/fileHelper.js

@@ -63,6 +63,7 @@ function fileInfoToDocument(fileInfo, languageId, locale) {
 }
 exports.fileInfoToDocument = fileInfoToDocument;
 function readFileInfo(filename, encoding = UTF8, handleNotFound = false) {
+    filename = filename !== STDIN ? path.resolve(filename) : filename;
     const pText = filename === STDIN ? (0, get_stdin_1.default)() : fs_1.promises.readFile(filename, encoding);
     return pText.then((text) => ({ text, filename }), (e) => {
         const error = (0, errors_1.toError)(e);

package/dist/util/util.d.ts

@@ -3,7 +3,7 @@ declare type FilterFn<T> = (_v: T) => boolean;
 export declare function uniqueFilterFnGenerator<T>(): FilterFn<T>;
 export declare function uniqueFilterFnGenerator<T, U>(extractFn: (v: T) => U): FilterFn<T>;
 export declare function unique<T>(src: T[]): T[];
-export declare function clean<T>(src: T): T;
+export declare function clean<T extends object>(src: T): T;
 export declare function padWidth(s: string, target: number): number;
 export declare function pad(s: string, w: number): string;
 export declare function padLeft(s: string, w: number): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell",
-  "version": "6.7.0",
+  "version": "6.8.2",
   "description": "A Spelling Checker for Code!",
   "funding": "https://github.com/streetsidesoftware/cspell?sponsor=1",
   "main": "dist/index.js",
@@ -70,12 +70,12 @@
   },
   "homepage": "https://streetsidesoftware.github.io/cspell/",
   "dependencies": {
-    "@cspell/cspell-pipe": "^6.7.0",
+    "@cspell/cspell-pipe": "^6.8.2",
     "chalk": "^4.1.2",
     "commander": "^9.4.0",
-    "cspell-gitignore": "^6.7.0",
-    "cspell-glob": "^6.7.0",
-    "cspell-lib": "^6.7.0",
+    "cspell-gitignore": "^6.8.2",
+    "cspell-glob": "^6.8.2",
+    "cspell-lib": "^6.8.2",
     "fast-json-stable-stringify": "^2.1.0",
     "file-entry-cache": "^6.0.1",
     "fs-extra": "^10.1.0",
@@ -90,21 +90,21 @@
     "node": ">=14"
   },
   "devDependencies": {
-    "@cspell/cspell-json-reporter": "^6.7.0",
-    "@cspell/cspell-types": "^6.7.0",
+    "@cspell/cspell-json-reporter": "^6.8.2",
+    "@cspell/cspell-types": "^6.8.2",
     "@types/file-entry-cache": "^5.0.2",
     "@types/fs-extra": "^9.0.13",
-    "@types/glob": "^7.2.0",
+    "@types/glob": "^8.0.0",
     "@types/imurmurhash": "^0.1.1",
     "@types/micromatch": "^4.0.2",
-    "@types/minimatch": "^3.0.5",
+    "@types/minimatch": "^5.1.2",
     "@types/semver": "^7.3.12",
-    "jest": "^28.1.3",
+    "jest": "^29.0.3",
     "micromatch": "^4.0.5",
     "minimatch": "^5.1.0",
     "rimraf": "^3.0.2",
-    "rollup": "^2.78.0",
+    "rollup": "^2.79.0",
     "rollup-plugin-dts": "^4.2.2"
   },
-  "gitHead": "3a7312a15d2df1507d9e01863ec5842f5a99e0cc"
+  "gitHead": "fb47a5f2f93d333fe5540142f3217e4981a7c27d"
 }