editorconfig 0.15.2 → 1.0.0

package/lib/index.js

@@ -0,0 +1,458 @@
+"use strict";
+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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSync = exports.parse = exports.parseFromFilesSync = exports.parseFromFiles = exports.parseString = exports.parseBuffer = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const semver = __importStar(require("semver"));
+const minimatch_1 = __importDefault(require("minimatch"));
+const wasm_1 = require("@one-ini/wasm");
+// @ts-ignore So we can set the rootDir to be 'lib', without processing
+// package.json
+const package_json_1 = __importDefault(require("../package.json"));
+const escapedSep = new RegExp(path.sep.replace(/\\/g, '\\\\'), 'g');
+const matchOptions = { matchBase: true, dot: true, noext: true };
+// These are specified by the editorconfig script
+/* eslint-disable @typescript-eslint/naming-convention */
+const knownProps = {
+    end_of_line: true,
+    indent_style: true,
+    indent_size: true,
+    insert_final_newline: true,
+    trim_trailing_whitespace: true,
+    charset: true,
+};
+/**
+ * Parse a buffer using the faster one-ini WASM approach into something
+ * relatively easy to deal with in JS.
+ *
+ * @param data UTF8-encoded bytes.
+ * @returns Parsed contents.  Will be truncated if there was a parse error.
+ */
+function parseBuffer(data) {
+    const parsed = (0, wasm_1.parse_to_uint32array)(data);
+    let cur = {};
+    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 = {};
+                res.push([
+                    data.toString('utf8', parsed[i + 1], parsed[i + 2]),
+                    cur,
+                ]);
+                break;
+            }
+            case wasm_1.TokenTypes.Key:
+                key = data.toString('utf8', parsed[i + 1], parsed[i + 2]);
+                break;
+            case wasm_1.TokenTypes.Value: {
+                cur[key] = data.toString('utf8', parsed[i + 1], parsed[i + 2]);
+                break;
+            }
+            default: // Comments, etc.
+                break;
+        }
+    }
+    return res;
+}
+exports.parseBuffer = parseBuffer;
+/**
+ * Parses a string.  If possible, you should always use ParseBuffer instead,
+ * since this function does a UTF16-to-UTF8 conversion first.
+ *
+ * @param data String to parse.
+ * @returns Parsed contents.  Will be truncated if there was a parse error.
+ * @deprecated Use {@link ParseBuffer} instead.
+ */
+function parseString(data) {
+    return parseBuffer(Buffer.from(data));
+}
+exports.parseString = parseString;
+/**
+ * Gets a list of *potential* filenames based on the path of the target
+ * filename.
+ *
+ * @param filepath File we are asking about.
+ * @param options Config file name and root directory
+ * @returns List of potential fully-qualified filenames that might have configs.
+ */
+function getConfigFileNames(filepath, options) {
+    const paths = [];
+    do {
+        filepath = path.dirname(filepath);
+        paths.push(path.join(filepath, options.config));
+    } while (filepath !== options.root);
+    return paths;
+}
+/**
+ * Take a combined config for the target file, and tweak it slightly based on
+ * which editorconfig version's rules we are using.
+ *
+ * @param matches Combined config.
+ * @param version Editorconfig version to enforce.
+ * @returns The passed-in matches object, modified in place.
+ */
+function processMatches(matches, version) {
+    // Set indent_size to 'tab' if indent_size is unspecified and
+    // indent_style is set to 'tab'.
+    if ('indent_style' in matches
+        && matches.indent_style === 'tab'
+        && !('indent_size' in matches)
+        && semver.gte(version, '0.10.0')) {
+        matches.indent_size = 'tab';
+    }
+    // Set tab_width to indent_size if indent_size is specified and
+    // tab_width is unspecified
+    if ('indent_size' in matches
+        && !('tab_width' in matches)
+        && matches.indent_size !== 'tab') {
+        matches.tab_width = matches.indent_size;
+    }
+    // Set indent_size to tab_width if indent_size is 'tab'
+    if ('indent_size' in matches
+        && 'tab_width' in matches
+        && matches.indent_size === 'tab') {
+        matches.indent_size = matches.tab_width;
+    }
+    return matches;
+}
+function buildFullGlob(pathPrefix, glob) {
+    switch (glob.indexOf('/')) {
+        case -1:
+            glob = '**/' + glob;
+            break;
+        case 0:
+            glob = glob.substring(1);
+            break;
+        default:
+            break;
+    }
+    // braces_escaped_backslash2
+    // backslash_not_on_windows
+    glob = glob.replace(/\\\\/g, '\\\\\\\\');
+    // star_star_over_separator{1,3,5,6,9,15}
+    glob = glob.replace(/\*\*/g, '{*,**/**/**}');
+    // NOT path.join.  Must stay in forward slashes.
+    return new minimatch_1.default.Minimatch(`${pathPrefix}/${glob}`, matchOptions);
+}
+/**
+ * Normalize the properties read from a config file so that their key names
+ * are lowercased for the known properties, and their values are parsed into
+ * the correct JS types if possible.
+ *
+ * @param options
+ * @returns
+ */
+function normalizeProps(options) {
+    const props = {};
+    for (const key in options) {
+        if (options.hasOwnProperty(key)) {
+            const value = options[key];
+            const key2 = key.toLowerCase();
+            let value2 = value;
+            if (knownProps[key2]) {
+                // All of the values for the known props are lowercase.
+                value2 = String(value).toLowerCase();
+            }
+            try {
+                value2 = JSON.parse(String(value));
+            }
+            catch (e) { }
+            if (typeof value2 === 'undefined' || value2 === null) {
+                // null and undefined are values specific to JSON (no special meaning
+                // in editorconfig) & should just be returned as regular strings.
+                value2 = String(value);
+            }
+            props[key2] = value2;
+        }
+    }
+    return props;
+}
+/**
+ * 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
+ * work that is per-file should be done here.
+ *
+ * @param filepath The fully-qualified path of the file.
+ * @param contents The contents as read from that file.
+ * @param options Access to the cache.
+ * @returns Processed file with globs pre-computed.
+ */
+function processFileContents(filepath, contents, options) {
+    let res;
+    if (!contents) {
+        // Negative cache
+        res = {
+            root: false,
+            notfound: true,
+            name: filepath,
+            config: [[null, {}, null]],
+        };
+    }
+    else {
+        let pathPrefix = path.dirname(filepath);
+        if (path.sep !== '/') {
+            // Windows-only
+            pathPrefix = pathPrefix.replace(escapedSep, '/');
+        }
+        // After Windows path backslash's are turned into slashes, so that
+        // the backslashes we add here aren't turned into forward slashes:
+        // All of these characters are special to minimatch, but can be
+        // forced into path names on many file systems.  Escape them. Note
+        // that these are in the order of the case statement in minimatch.
+        pathPrefix = pathPrefix.replace(/[?*+@!()|[\]{}]/g, '\\$&');
+        // I can't think of a way for this to happen in the filesystems I've
+        // seen (because of the path.dirname above), but let's be thorough.
+        pathPrefix = pathPrefix.replace(/^#/, '\\#');
+        const globbed = parseBuffer(contents).map(([name, body]) => [
+            name,
+            normalizeProps(body),
+            name ? buildFullGlob(pathPrefix, name) : null,
+        ]);
+        res = {
+            root: !!globbed[0][1].root,
+            name: filepath,
+            config: globbed,
+        };
+    }
+    if (options.cache) {
+        options.cache.set(filepath, res);
+    }
+    return res;
+}
+/**
+ * Get a file from the cache, or read its 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.
+ */
+async function getConfig(filepath, options) {
+    if (options.cache) {
+        const cached = options.cache.get(filepath);
+        if (cached) {
+            return cached;
+        }
+    }
+    const contents = await new Promise(resolve => {
+        fs.readFile(filepath, (_, buf) => {
+            // Ignore errors.  contents will be undefined
+            // Perhaps only file-not-found should be ignored?
+            resolve(buf);
+        });
+    });
+    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).  Synchronous.
+ *
+ * @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.
+ */
+function getConfigSync(filepath, options) {
+    if (options.cache) {
+        const cached = options.cache.get(filepath);
+        if (cached) {
+            return cached;
+        }
+    }
+    let contents;
+    try {
+        contents = fs.readFileSync(filepath);
+    }
+    catch (_) {
+        // Ignore errors
+        // Perhaps only file-not-found should be ignored
+    }
+    return processFileContents(filepath, contents, options);
+}
+/**
+ * Get all of the possibly-existing config files, stopping when one is marked
+ * root=true.
+ *
+ * @param files List of potential files
+ * @param options Access to cache if configured
+ * @returns List of processed configs for existing files
+ */
+async function getAllConfigs(files, options) {
+    const configs = [];
+    for (const file of files) {
+        const config = await getConfig(file, options);
+        if (!config.notfound) {
+            configs.push(config);
+            if (config.root) {
+                break;
+            }
+        }
+    }
+    return configs;
+}
+/**
+ * Get all of the possibly-existing config files, stopping when one is marked
+ * root=true.  Synchronous.
+ *
+ * @param files List of potential files
+ * @param options Access to cache if configured
+ * @returns List of processed configs for existing files
+ */
+function getAllConfigsSync(files, options) {
+    const configs = [];
+    for (const file of files) {
+        const config = getConfigSync(file, options);
+        if (!config.notfound) {
+            configs.push(config);
+            if (config.root) {
+                break;
+            }
+        }
+    }
+    return configs;
+}
+/**
+ * Normalize the options passed in to the publicly-visible functions.
+ *
+ * @param filepath The name of the target file, relative to process.cwd().
+ * @param options Potentially-incomplete options.
+ * @returns The fully-qualified target file name and the normalized options.
+ */
+function opts(filepath, options = {}) {
+    const resolvedFilePath = path.resolve(filepath);
+    return [
+        resolvedFilePath,
+        {
+            config: options.config || '.editorconfig',
+            version: options.version || package_json_1.default.version,
+            root: path.resolve(options.root || path.parse(resolvedFilePath).root),
+            files: options.files,
+            cache: options.cache,
+        },
+    ];
+}
+/**
+ * Low-level interface, which exists only for backward-compatibility.
+ * Deprecated.
+ *
+ * @param filepath The name of the target file, relative to process.cwd().
+ * @param files A promise for a list of objects describing the files.
+ * @param options All options
+ * @returns The properties found for filepath
+ * @deprecated
+ */
+async function parseFromFiles(filepath, files, options = {}) {
+    return parseFromFilesSync(filepath, await files, options);
+}
+exports.parseFromFiles = parseFromFiles;
+/**
+ * Low-level interface, which exists only for backward-compatibility.
+ * Deprecated.
+ *
+ * @param filepath The name of the target file, relative to process.cwd().
+ * @param files A list of objects describing the files.
+ * @param options All options
+ * @returns The properties found for filepath
+ * @deprecated
+ */
+function parseFromFilesSync(filepath, files, options = {}) {
+    const [resolvedFilePath, processedOptions] = opts(filepath, options);
+    const configs = [];
+    for (const ecf of files) {
+        let cfg;
+        if (!options.cache || !(cfg = options.cache.get(ecf.name))) { // Single "="!
+            cfg = processFileContents(ecf.name, ecf.contents, processedOptions);
+        }
+        if (!cfg.notfound) {
+            configs.push(cfg);
+        }
+        if (cfg.root) {
+            break;
+        }
+    }
+    return combine(resolvedFilePath, configs, processedOptions);
+}
+exports.parseFromFilesSync = parseFromFilesSync;
+/**
+ * Combine the pre-parsed results of all matching config file sections, in
+ * order.
+ *
+ * @param filepath The target file path
+ * @param configs All of the found config files, up to the root
+ * @param options Adds to `options.files` if it exists
+ * @returns Combined properties
+ */
+function combine(filepath, configs, options) {
+    const ret = configs.reverse().reduce((props, processed) => {
+        for (const [name, body, glob] of processed.config) {
+            if (glob && glob.match(filepath)) {
+                Object.assign(props, body);
+                if (options.files) {
+                    options.files.push({
+                        fileName: processed.name,
+                        glob: name,
+                    });
+                }
+            }
+        }
+        return props;
+    }, {});
+    return processMatches(ret, options.version);
+}
+/**
+ * Find all of the properties from matching sections in config files in the
+ * same directory or toward the root of the filesystem.
+ *
+ * @param filepath The target file name, relative to process.cwd().
+ * @param options All options
+ * @returns Combined properties for the target file
+ */
+async function parse(filepath, options = {}) {
+    const [resolvedFilePath, processedOptions] = opts(filepath, options);
+    const filepaths = getConfigFileNames(resolvedFilePath, processedOptions);
+    const configs = await getAllConfigs(filepaths, processedOptions);
+    return combine(resolvedFilePath, configs, processedOptions);
+}
+exports.parse = parse;
+/**
+ * Find all of the properties from matching sections in config files in the
+ * same directory or toward the root of the filesystem.  Synchronous.
+ *
+ * @param filepath The target file name, relative to process.cwd().
+ * @param options All options
+ * @returns Combined properties for the target file
+ */
+function parseSync(filepath, options = {}) {
+    const [resolvedFilePath, processedOptions] = opts(filepath, options);
+    const filepaths = getConfigFileNames(resolvedFilePath, processedOptions);
+    const configs = getAllConfigsSync(filepaths, processedOptions);
+    return combine(resolvedFilePath, configs, processedOptions);
+}
+exports.parseSync = parseSync;

package/package.json

@@ -1,59 +1,66 @@
-{
-    "name": "editorconfig",
-    "version": "0.15.2",
-    "description": "EditorConfig File Locator and Interpreter for Node.js",
-    "keywords": [
-        "editorconfig",
-        "core"
-    ],
-    "main": "src/index.js",
-    "contributors": [
-        "Hong Xu (topbug.net)",
-        "Jed Mao (https://github.com/jedmao/)",
-        "Trey Hunner (http://treyhunner.com)"
-    ],
-    "directories": {
-        "bin": "./bin",
-        "lib": "./lib"
-    },
-    "scripts": {
-        "clean": "rimraf dist",
-        "prebuild": "npm run clean",
-        "build": "tsc",
-        "pretest": "npm run lint && npm run build && npm run copy && cmake .",
-        "test": "ctest .",
-        "pretest:ci": "npm run pretest",
-        "test:ci": "ctest -VV --output-on-failure .",
-        "lint": "npm run eclint && npm run tslint",
-        "eclint": "eclint check --indent_size ignore \"src/**\"",
-        "tslint": "tslint --project tsconfig.json --exclude package.json",
-        "copy": "cpy .npmignore LICENSE README.md CHANGELOG.md dist && cpy bin/* dist/bin && cpy src/lib/fnmatch*.* dist/src/lib",
-        "prepub": "npm run lint && npm run build && npm run copy",
-        "pub": "npm publish ./dist"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git://github.com/editorconfig/editorconfig-core-js.git"
-    },
-    "bugs": "https://github.com/editorconfig/editorconfig-core-js/issues",
-    "author": "EditorConfig Team",
-    "license": "MIT",
-    "dependencies": {
-        "@types/node": "^10.11.7",
-        "@types/semver": "^5.5.0",
-        "commander": "^2.19.0",
-        "lru-cache": "^4.1.3",
-        "semver": "^5.6.0",
-        "sigmund": "^1.0.1"
-    },
-    "devDependencies": {
-        "@types/mocha": "^5.2.5",
-        "cpy-cli": "^2.0.0",
-        "eclint": "^2.8.0",
-        "mocha": "^5.2.0",
-        "rimraf": "^2.6.2",
-        "should": "^13.2.3",
-        "tslint": "^5.11.0",
-        "typescript": "^3.1.3"
-    }
-}
+{
+  "name": "editorconfig",
+  "version": "1.0.0",
+  "description": "EditorConfig File Locator and Interpreter for Node.js",
+  "keywords": [
+    "editorconfig",
+    "core"
+  ],
+  "main": "./lib/index.js",
+  "contributors": [
+    "Hong Xu (topbug.net)",
+    "Jed Mao (https://github.com/jedmao/)",
+    "Trey Hunner (http://treyhunner.com)",
+    "Joe Hildebrand (https://github.com/hildjj/)"
+  ],
+  "directories": {
+    "bin": "./bin",
+    "lib": "./lib"
+  },
+  "scripts": {
+    "clean": "rimraf lib *.cmake Makefile",
+    "prebuild": "npm run clean",
+    "build": "cmake . && tsc",
+    "pretest": "npm run build && npm run lint",
+    "test": "npm run test:all",
+    "test:all": "mocha && ctest . --preset Test",
+    "precoverage": "npm run build -- --inlineSourceMap",
+    "coverage": "c8 npm run test:all",
+    "postcoverage": "npm run build",
+    "ci": "npm run coverage -- -- -VV --output-on-failure",
+    "lint": "eslint . --ext ts",
+    "prepub": "npm run lint && npm run build",
+    "pub": "npm publish"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/editorconfig/editorconfig-core-js.git"
+  },
+  "bugs": "https://github.com/editorconfig/editorconfig-core-js/issues",
+  "author": "EditorConfig Team",
+  "license": "MIT",
+  "dependencies": {
+    "@one-ini/wasm": "0.1.0",
+    "commander": "^9.4.1",
+    "minimatch": "5.1.0",
+    "semver": "^7.3.8"
+  },
+  "devDependencies": {
+    "@types/minimatch": "5.1.2",
+    "@types/mocha": "^10.0.0",
+    "@types/node": "^18.11.0",
+    "@types/semver": "^7.3.12",
+    "@typescript-eslint/eslint-plugin": "5.40.1",
+    "@typescript-eslint/parser": "5.40.1",
+    "c8": "7.12.0",
+    "eslint": "8.25.0",
+    "eslint-plugin-jsdoc": "39.3.12",
+    "mocha": "^10.1.0",
+    "rimraf": "^3.0.2",
+    "should": "^13.2.3",
+    "typescript": "^4.8.4"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}

package/CHANGELOG.md

@@ -1,10 +0,0 @@
-## 0.15.2
-- Fix publish.
-
-## 0.15.1
-- Update dependencies.
-
-## 0.15.0
-- Convert source code into TypeScript. Generated type definitions are now provided.
-- Remove dependency on Bluebird.
-- **Breaking**: Node v4 no longer supported.

package/src/cli.d.ts

@@ -1 +0,0 @@
-export default function cli(args: string[]): void;

package/src/cli.js

@@ -1,53 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// tslint:disable:no-console
-var commander_1 = __importDefault(require("commander"));
-var editorconfig = __importStar(require("./"));
-var package_json_1 = __importDefault(require("../package.json"));
-function cli(args) {
-    commander_1.default.version('EditorConfig Node.js Core Version ' + package_json_1.default.version);
-    commander_1.default
-        .usage([
-        '[OPTIONS] FILEPATH1 [FILEPATH2 FILEPATH3 ...]',
-        commander_1.default._version,
-        'FILEPATH can be a hyphen (-) if you want path(s) to be read from stdin.',
-    ].join('\n\n  '))
-        .option('-f <path>', 'Specify conf filename other than \'.editorconfig\'')
-        .option('-b <version>', 'Specify version (used by devs to test compatibility)')
-        .option('-v, --version', 'Display version information')
-        .parse(args);
-    // Throw away the native -V flag in lieu of the one we've manually specified
-    // to adhere to testing requirements
-    commander_1.default.options.shift();
-    var files = commander_1.default.args;
-    if (!files.length) {
-        commander_1.default.help();
-    }
-    files
-        .map(function (filePath) { return editorconfig.parse(filePath, {
-        config: commander_1.default.F,
-        version: commander_1.default.B,
-    }); })
-        .forEach(function (parsing, i, _a) {
-        var length = _a.length;
-        parsing.then(function (parsed) {
-            if (length > 1) {
-                console.log("[" + files[i] + "]");
-            }
-            Object.keys(parsed).forEach(function (key) {
-                console.log(key + "=" + parsed[key]);
-            });
-        });
-    });
-}
-exports.default = cli;

package/src/index.d.ts

@@ -1,29 +0,0 @@
-/// <reference types="node" />
-import { parseString, ParseStringResult } from './lib/ini';
-export { parseString };
-export interface KnownProps {
-    end_of_line?: 'lf' | 'crlf' | 'unset';
-    indent_style?: 'tab' | 'space' | 'unset';
-    indent_size?: number | 'tab' | 'unset';
-    insert_final_newline?: true | false | 'unset';
-    tab_width?: number | 'unset';
-    trim_trailing_whitespace?: true | false | 'unset';
-    charset?: string | 'unset';
-}
-export interface ECFile {
-    name: string;
-    contents: string | Buffer;
-}
-export interface FileConfig {
-    name: string;
-    contents: ParseStringResult;
-}
-export interface ParseOptions {
-    config?: string;
-    version?: string;
-    root?: string;
-}
-export declare function parseFromFiles(filepath: string, files: Promise<ECFile[]>, options?: ParseOptions): Promise<KnownProps>;
-export declare function parseFromFilesSync(filepath: string, files: ECFile[], options?: ParseOptions): KnownProps;
-export declare function parse(_filepath: string, _options?: ParseOptions): Promise<KnownProps>;
-export declare function parseSync(_filepath: string, _options?: ParseOptions): KnownProps;