editorconfig 3.0.2 → 4.0.0

package/lib/index.js

@@ -72,13 +72,13 @@ const knownProps = new Set(knownPropNames);
  */
 function parseBuffer(data) {
     const parsed = (0, wasm_1.parse_to_uint32array)(data);
-    let cur = {};
+    let cur = Object.create(null);
     const res = [[null, cur]];
     let key = null;
     for (let i = 0; i < parsed.length; i += 3) {
         switch (parsed[i]) {
             case wasm_1.TokenTypes.Section: {
-                cur = {};
+                cur = Object.create(null);
                 res.push([
                     data.toString('utf8', parsed[i + 1], parsed[i + 2]),
                     cur,
@@ -122,7 +122,7 @@ function getConfigFileNames(filepath, options) {
     do {
         filepath = path.dirname(filepath);
         paths.push(path.join(filepath, options.config));
-    } while (filepath !== options.root);
+    } while (filepath !== options.root && filepath !== path.dirname(filepath));
     return paths;
 }
 /**
@@ -187,7 +187,7 @@ function buildFullGlob(pathPrefix, glob) {
  * @returns
  */
 function normalizeProps(options) {
-    const props = {};
+    const props = Object.create(null);
     for (const key in options) {
         if (Object.prototype.hasOwnProperty.call(options, key)) {
             const value = options[key];
@@ -214,6 +214,50 @@ function normalizeProps(options) {
     }
     return props;
 }
+/**
+ * Section globs are matched against paths that are already relative to the
+ * directory holding the `.editorconfig` file, so no glob can ever refer to a
+ * parent directory.  The glob engines do not resolve a `..` component against
+ * that path though; they let it consume any one directory level.  That makes a
+ * section such as `[dir/../x.c]` match `x.c` sitting next to the config file,
+ * even though `x.c` is not inside `dir`.  Detect those components so the
+ * section can be rejected.
+ *
+ * @param glob Section name, as written in the config file.
+ * @returns True if the glob has an unescaped `..` path component.
+ */
+function hasParentDirComponent(glob) {
+    return glob.split('/').some(part => {
+        let name = '';
+        for (let i = 0; i < part.length; i++) {
+            if (part[i] === '\\') {
+                // A backslash escapes the next character, so it is a literal.
+                i++;
+            }
+            else {
+                name += part[i];
+            }
+        }
+        return name === '..';
+    });
+}
+/**
+ * Build the matcher for a single section of a config file.
+ *
+ * The global section has no name and never matches a file, and a section whose
+ * glob names a parent directory cannot match a file below the config's own
+ * directory, so both get no matcher at all.
+ *
+ * @param pathPrefix Escaped path of the directory holding the config file.
+ * @param name Section name, as written in the config file.
+ * @returns The section's matcher, or null if it cannot match anything.
+ */
+function buildSectionGlob(pathPrefix, name) {
+    if (!name || hasParentDirComponent(name)) {
+        return null;
+    }
+    return buildFullGlob(pathPrefix, name);
+}
 /**
  * Take the contents of a config file, and prepare it for use.  If a cache is
  * provided, the result will be stored there.  As such, all of the higher-CPU
@@ -233,7 +277,7 @@ function processFileContents(filepath, contents, options) {
             root: false,
             notfound: true,
             name: filepath,
-            config: [[null, {}, null]],
+            config: [[null, Object.create(null), null]],
         };
     }
     else {
@@ -248,7 +292,7 @@ function processFileContents(filepath, contents, options) {
         const globbed = parseBuffer(contents).map(([name, body]) => [
             name,
             normalizeProps(body),
-            name ? buildFullGlob(pathPrefix, name) : null,
+            buildSectionGlob(pathPrefix, name),
         ]);
         res = {
             root: Boolean(globbed[0][1].root), // Global section: globbed[0]
@@ -262,20 +306,20 @@ function processFileContents(filepath, contents, options) {
     return res;
 }
 /**
- * Get a file from the cache, or read its contents from disk, process, and
- * insert into the cache (if configured).
+ * Reads of config files that are in progress, per cache, so that concurrent
+ * lookups of the same file share one read.  Entries are removed once the read
+ * settles; the finished result lives in the cache.
+ */
+const pendingConfigs = new WeakMap();
+/**
+ * Read a config file's contents from disk, process, and insert into the cache
+ * (if configured).
  *
  * @param filepath The fully-qualified path of the config file.
  * @param options Access to the cache, if configured.
- * @returns The processed file, or undefined if there was an error reading it.
+ * @returns The processed file.
  */
-async function getConfig(filepath, options) {
-    if (options.cache) {
-        const cached = options.cache.get(filepath);
-        if (cached) {
-            return cached;
-        }
-    }
+async function readConfig(filepath, options) {
     const contents = await new Promise(resolve => {
         fs.readFile(filepath, (_, buf) => {
             // Ignore errors.  contents will be undefined
@@ -285,6 +329,46 @@ async function getConfig(filepath, options) {
     });
     return processFileContents(filepath, contents, options);
 }
+/**
+ * Get a file from the cache, or read its contents from disk, process, and
+ * insert into the cache (if configured).  If the cache is configured,
+ * concurrent calls for the same file share one read.
+ *
+ * @param filepath The fully-qualified path of the config file.
+ * @param options Access to the cache, if configured.
+ * @returns The processed file, or undefined if there was an error reading it.
+ */
+async function getConfig(filepath, options) {
+    if (!options.cache) {
+        return readConfig(filepath, options);
+    }
+    const cached = options.cache.get(filepath);
+    if (cached) {
+        return cached;
+    }
+    let pending = pendingConfigs.get(options.cache);
+    let config = undefined;
+    if (pending) {
+        config = pending.get(filepath);
+    }
+    else {
+        pending = new Map();
+        pendingConfigs.set(options.cache, pending);
+    }
+    if (!config) {
+        config = readConfig(filepath, options);
+        pending.set(filepath, config);
+        try {
+            // Reminder: this returns immediately with a promise, and the finally
+            // block doesn't fire until the promise is settled.
+            return await config;
+        }
+        finally {
+            pending.delete(filepath);
+        }
+    }
+    return config;
+}
 /**
  * Get a file from the cache, or read its contents from disk, process, and
  * insert into the cache (if configured).  Synchronous.
@@ -412,7 +496,7 @@ function combine(filepath, configs, options) {
             }
         }
         return props;
-    }, {});
+    }, Object.create(null));
     if (options.unset) {
         unset(ret);
     }

package/lib/index.test.d.ts

@@ -1 +1 @@
-import 'chai/register-should.js';
+export {};

package/lib/index.test.js

@@ -32,15 +32,21 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/no-deprecated */
-require("chai/register-should.js");
 const editorconfig = __importStar(require("./index.js"));
 const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
+const chai_1 = require("chai");
 const node_buffer_1 = require("node:buffer");
+const node_process_1 = __importDefault(require("node:process"));
+(0, chai_1.should)();
 describe('parse', () => {
-    const expected = {
+    const expected = Object.assign(Object.create(null), {
         indent_style: 'space',
         indent_size: 2,
         end_of_line: 'lf',
@@ -51,24 +57,43 @@ describe('parse', () => {
         block_comment: '*',
         block_comment_end: '*/',
         block_comment_start: '/**',
-    };
+    });
     const target = path.join(__dirname, '/app.js');
     it('async', async () => {
         const cfg = await editorconfig.parse(target);
-        cfg.should.eql(expected);
+        (0, chai_1.expect)(cfg).to.eql(expected);
     });
     it('sync', () => {
         const visited = [];
         const cfg = editorconfig.parseSync(target, { files: visited });
-        cfg.should.eql(expected);
+        (0, chai_1.expect)(cfg).to.eql(expected);
         visited.should.have.lengthOf(1);
         visited[0].glob.should.eql('*');
         visited[0].fileName.should.match(/\.editorconfig$/);
     });
+    it('stops at the filesystem root when the configured root is not an ancestor', async () => {
+        const root = path.join(__dirname, 'not-an-ancestor');
+        const cfg = await editorconfig.parse(target, { root });
+        (0, chai_1.expect)(cfg).to.eql(expected);
+    });
+    it('stops at the filesystem root synchronously when the configured root is not an ancestor', () => {
+        const root = path.join(__dirname, 'not-an-ancestor');
+        const cfg = editorconfig.parseSync(target, { root });
+        (0, chai_1.expect)(cfg).to.eql(expected);
+    });
+    const windowsIt = node_process_1.default.platform === 'win32' ? it : it.skip;
+    windowsIt('parses Windows extended-length paths', async () => {
+        const cfg = await editorconfig.parse(path.toNamespacedPath(target));
+        (0, chai_1.expect)(cfg).to.eql(expected);
+    });
+    windowsIt('parses Windows extended-length paths synchronously', () => {
+        const cfg = editorconfig.parseSync(path.toNamespacedPath(target));
+        (0, chai_1.expect)(cfg).to.eql(expected);
+    });
     it('caches', async () => {
         const cache = new Map();
         const cfg = await editorconfig.parse(target, { cache });
-        cfg.should.eql(expected);
+        (0, chai_1.expect)(cfg).to.eql(expected);
         cache.size.should.be.eql(2);
         await editorconfig.parse(target, { cache });
         cache.size.should.be.eql(2);
@@ -76,11 +101,28 @@ describe('parse', () => {
     it('caches sync', () => {
         const cache = new Map();
         const cfg = editorconfig.parseSync(target, { cache });
-        cfg.should.eql(expected);
+        (0, chai_1.expect)(cfg).to.eql(expected);
         cache.size.should.be.eql(2);
         editorconfig.parseSync(target, { cache });
         cache.size.should.be.eql(2);
     });
+    it('shares concurrent reads through the cache', async () => {
+        const cache = new Map();
+        let sets = 0;
+        const counting = {
+            get: p => cache.get(p),
+            set(p, config) {
+                sets++;
+                cache.set(p, config);
+                return this;
+            },
+        };
+        const cfgs = await Promise.all(Array.from({ length: 10 }, () => editorconfig.parse(target, { cache: counting })));
+        for (const cfg of cfgs) {
+            (0, chai_1.expect)(cfg).to.eql(expected);
+        }
+        sets.should.be.eql(2);
+    });
 });
 describe('parseFromFiles', () => {
     const expected = {
@@ -108,35 +150,35 @@ describe('parseFromFiles', () => {
     ];
     it('async', async () => {
         const cfg = await editorconfig.parseFromFiles(target, Promise.resolve(configs));
-        cfg.should.eql(expected);
+        (0, chai_1.expect)(cfg).to.eql(expected);
     });
     it('sync', () => {
         const cfg = editorconfig.parseFromFilesSync(target, configs);
-        cfg.should.eql(expected);
+        (0, chai_1.expect)(cfg).to.eql(expected);
     });
     it('handles null', () => {
         const cfg = editorconfig.parseFromFilesSync(target, [{
                 name: configPath,
                 contents: node_buffer_1.Buffer.from('[*]\nfoo = null\n'),
             }]);
-        cfg.should.eql({ foo: 'null' });
+        (0, chai_1.expect)(cfg).to.eql({ foo: 'null' });
     });
     it('caches async', async () => {
         const cache = new Map();
         const cfg = await editorconfig.parseFromFiles(target, Promise.resolve(configs2), { cache });
-        cfg.should.eql(expected);
+        (0, chai_1.expect)(cfg).to.eql(expected);
         cache.size.should.be.eql(2);
         const cfg2 = await editorconfig.parseFromFiles(target, Promise.resolve(configs2), { cache });
-        cfg2.should.eql(expected);
+        (0, chai_1.expect)(cfg2).to.eql(expected);
         cache.size.should.be.eql(2);
     });
     it('caches sync', () => {
         const cache = new Map();
         const cfg = editorconfig.parseFromFilesSync(target, configs2, { cache });
-        cfg.should.eql(expected);
+        (0, chai_1.expect)(cfg).to.eql(expected);
         cache.size.should.be.eql(2);
         const cfg2 = editorconfig.parseFromFilesSync(target, configs2, { cache });
-        cfg2.should.eql(expected);
+        (0, chai_1.expect)(cfg2).to.eql(expected);
         cache.size.should.be.eql(2);
     });
     it('handles minimatch escapables', () => {
@@ -153,7 +195,7 @@ describe('parseFromFiles', () => {
         ];
         const escTarget = `${bogusPath}/app.js`;
         const cfg = editorconfig.parseFromFilesSync(escTarget, escConfigs);
-        cfg.should.eql(expected);
+        (0, chai_1.expect)(cfg).to.eql(expected);
     });
 });
 describe('parseString', () => {
@@ -176,19 +218,70 @@ describe('parseString', () => {
     const contents = fs.readFileSync(configPath, 'utf8');
     it('sync', () => {
         const cfg = editorconfig.parseString(contents);
-        cfg.should.eql(expected);
+        (0, chai_1.expect)(cfg).to.eql(expected);
     });
     it('handles errors', () => {
         const cfg = editorconfig.parseString('root: ');
-        cfg.should.eql([[null, {}]]);
+        (0, chai_1.expect)(cfg).to.eql([[null, Object.create(null)]]);
     });
     it('handles backslashes in glob', () => {
         const cfg = editorconfig.parseString('[a\\\\b]');
-        cfg.should.eql([[null, {}], ['a\\\\b', {}]]);
+        (0, chai_1.expect)(cfg).to.eql([[null, {}], ['a\\\\b', Object.create(null)]]);
     });
     it('handles blank comments', () => {
         const cfg = editorconfig.parseString('#');
-        cfg.should.eql([[null, {}]]);
+        (0, chai_1.expect)(cfg).to.eql([[null, Object.create(null)]]);
+    });
+    it('handles __proto__', () => {
+        const cfg = editorconfig.parseString('__proto__ = foo');
+        const obj = Object.create(null);
+        // eslint-disable-next-line no-proto
+        obj.__proto__ = 'foo';
+        (0, chai_1.expect)(cfg).to.eql([[null, obj]]);
+    });
+});
+describe('parent directory components in section globs', () => {
+    let dir = '';
+    let target = '';
+    before(() => {
+        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'editorconfig-'));
+        target = path.join(dir, 'x.c');
+        fs.writeFileSync(target, '');
+    });
+    after(() => {
+        fs.rmSync(dir, { recursive: true, force: true });
+    });
+    /**
+     * Write a one-section config and return the properties for `x.c`.
+     *
+     * @param glob Section name to test.
+     * @returns Properties found for the target file.
+     */
+    function configFor(glob) {
+        fs.writeFileSync(path.join(dir, '.editorconfig'), `root = true\n\n[${glob}]\nhit = yes\n`);
+        return editorconfig.parseSync(target);
+    }
+    it('does not let a `..` component consume a directory', () => {
+        // `[dir/../x.c]` must not match `x.c`, which is not inside `dir`.
+        (0, chai_1.expect)(configFor('dir/../x.c')).to.not.have.property('hit');
+        (0, chai_1.expect)(configFor('a/../b/../x.c')).to.not.have.property('hit');
+        (0, chai_1.expect)(configFor('**/../x.c')).to.not.have.property('hit');
+        (0, chai_1.expect)(configFor('../x.c')).to.not.have.property('hit');
+        (0, chai_1.expect)(configFor('./x.c')).to.not.have.property('hit');
+    });
+    it('still matches a plain name and a `**` pattern', () => {
+        (0, chai_1.expect)(configFor('x.c')).to.have.property('hit', 'yes');
+        (0, chai_1.expect)(configFor('**/x.c')).to.have.property('hit', 'yes');
+        (0, chai_1.expect)(configFor('*.c')).to.have.property('hit', 'yes');
+    });
+    it('treats an escaped `..` as a literal name', () => {
+        // `a\.\.` is a file called `a..`, not a parent-directory reference.
+        (0, chai_1.expect)(configFor('a\\.\\.c')).to.not.have.property('hit');
+    });
+    it('does not match through the async parse either', async () => {
+        fs.writeFileSync(path.join(dir, '.editorconfig'), 'root = true\n\n[dir/../x.c]\nhit = yes\n');
+        const cfg = await editorconfig.parse(target);
+        (0, chai_1.expect)(cfg).to.not.have.property('hit');
     });
 });
 describe('extra behavior', () => {
@@ -202,12 +295,12 @@ indent_size = 4
 
 [!(package).json]
 indent_size = 3`));
-        matcher(path.join(__dirname, 'package.json')).should.include({ indent_size: 4 });
-        matcher(path.join(__dirname, 'foo.json')).should.include({ indent_size: 3 });
+        (0, chai_1.expect)(matcher(path.join(__dirname, 'package.json'))).to.include({ indent_size: 4 });
+        (0, chai_1.expect)(matcher(path.join(__dirname, 'foo.json'))).to.include({ indent_size: 3 });
     });
 });
 describe('unset', () => {
-    it('pair witht the value `unset`', () => {
+    it('pair with the value `unset`', () => {
         const matcher = editorconfig.matcher({
             root: __dirname,
             unset: true,
@@ -218,7 +311,7 @@ indent_size = 4
 [*.json]
 indent_size = unset
 `));
-        matcher(path.join(__dirname, 'index.js')).should.include({ indent_size: 4 });
-        matcher(path.join(__dirname, 'index.json')).should.be.eql({});
+        (0, chai_1.expect)(matcher(path.join(__dirname, 'index.js'))).to.include({ indent_size: 4 });
+        (0, chai_1.expect)(matcher(path.join(__dirname, 'index.json'))).to.be.eql(Object.create(null));
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "editorconfig",
-  "version": "3.0.2",
+  "version": "4.0.0",
   "description": "EditorConfig File Locator and Interpreter for Node.js",
   "keywords": [
     "editorconfig",
@@ -17,7 +17,11 @@
     "Trey Hunner (http://treyhunner.com)",
     "Joe Hildebrand (https://github.com/hildjj/)",
     "SunsetTechuila (https://github.com/SunsetTechuila/)",
-    "Rex Lorenzo (https://github.com/rlorenzo/)"
+    "Rex Lorenzo (https://github.com/rlorenzo/)",
+    "Gareth Jones (https://github.com/G-Rath)",
+    "Lorie (https://github.com/Lorie-Capella)",
+    "simpleqt (https://github.com/simpleqt)",
+    "Eli (https://github.com/lishaduck)"
   ],
   "directories": {
     "bin": "./bin",
@@ -31,12 +35,13 @@
   "author": "EditorConfig Team",
   "license": "MIT",
   "dependencies": {
-    "@one-ini/wasm": "0.2.1",
-    "commander": "^14.0.3",
-    "minimatch": "~10.2.4",
-    "semver": "^7.7.4"
+    "@one-ini/wasm": "0.2.3",
+    "commander": "^15.0.0",
+    "minimatch": "~11.0.4",
+    "semver": "^7.8.6"
   },
+  "packageManager": "pnpm@12.17.0",
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   }
 }