eslint-plugin-toml 0.1.0 → 0.3.1

package/lib/rules/key-spacing.js

@@ -0,0 +1,385 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const ast_utils_1 = require("../utils/ast-utils");
+function containsLineTerminator(str) {
+    return /[\n\r\u2028\u2029]/u.test(str);
+}
+function last(arr) {
+    return arr[arr.length - 1];
+}
+function isSingleLine(node) {
+    return node.loc.end.line === node.loc.start.line;
+}
+function isSingleLineProperties(properties) {
+    const [firstProp] = properties;
+    const lastProp = last(properties);
+    return firstProp.loc.start.line === lastProp.loc.end.line;
+}
+function initOptionProperty(fromOptions) {
+    const mode = fromOptions.mode || "strict";
+    let beforeEqual, afterEqual;
+    if (typeof fromOptions.beforeEqual !== "undefined") {
+        beforeEqual = fromOptions.beforeEqual;
+    }
+    else {
+        beforeEqual = true;
+    }
+    if (typeof fromOptions.afterEqual !== "undefined") {
+        afterEqual = fromOptions.afterEqual;
+    }
+    else {
+        afterEqual = true;
+    }
+    let align = undefined;
+    if (typeof fromOptions.align !== "undefined") {
+        if (typeof fromOptions.align === "object") {
+            align = fromOptions.align;
+        }
+        else {
+            align = {
+                on: fromOptions.align,
+                mode,
+                beforeEqual,
+                afterEqual,
+            };
+        }
+    }
+    return {
+        mode,
+        beforeEqual,
+        afterEqual,
+        align,
+    };
+}
+function initOptions(fromOptions) {
+    let align, multiLine, singleLine;
+    if (typeof fromOptions.align === "object") {
+        align = Object.assign(Object.assign({}, initOptionProperty(fromOptions.align)), { on: fromOptions.align.on || "equal", mode: fromOptions.align.mode || "strict" });
+        multiLine = initOptionProperty(fromOptions.multiLine || fromOptions);
+        singleLine = initOptionProperty(fromOptions.singleLine || fromOptions);
+    }
+    else {
+        multiLine = initOptionProperty(fromOptions.multiLine || fromOptions);
+        singleLine = initOptionProperty(fromOptions.singleLine || fromOptions);
+        if (multiLine.align) {
+            align = {
+                on: multiLine.align.on,
+                mode: multiLine.align.mode || multiLine.mode,
+                beforeEqual: multiLine.align.beforeEqual,
+                afterEqual: multiLine.align.afterEqual,
+            };
+        }
+    }
+    return {
+        align,
+        multiLine,
+        singleLine,
+    };
+}
+const ON_SCHEMA = {
+    enum: ["equal", "value"],
+};
+const OBJECT_WITHOUT_ON_SCHEMA = {
+    type: "object",
+    properties: {
+        mode: {
+            enum: ["strict", "minimum"],
+        },
+        beforeEqual: {
+            type: "boolean",
+        },
+        afterEqual: {
+            type: "boolean",
+        },
+    },
+    additionalProperties: false,
+};
+const ALIGN_OBJECT_SCHEMA = {
+    type: "object",
+    properties: Object.assign({ on: ON_SCHEMA }, OBJECT_WITHOUT_ON_SCHEMA.properties),
+    additionalProperties: false,
+};
+exports.default = (0, utils_1.createRule)("key-spacing", {
+    meta: {
+        docs: {
+            description: "enforce consistent spacing between keys and values in key/value pairs",
+            categories: ["standard"],
+            extensionRule: "key-spacing",
+        },
+        fixable: "whitespace",
+        schema: [
+            {
+                anyOf: [
+                    {
+                        type: "object",
+                        properties: Object.assign({ align: {
+                                anyOf: [ON_SCHEMA, ALIGN_OBJECT_SCHEMA],
+                            } }, OBJECT_WITHOUT_ON_SCHEMA.properties),
+                        additionalProperties: false,
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            singleLine: OBJECT_WITHOUT_ON_SCHEMA,
+                            multiLine: {
+                                type: "object",
+                                properties: Object.assign({ align: {
+                                        anyOf: [ON_SCHEMA, ALIGN_OBJECT_SCHEMA],
+                                    } }, OBJECT_WITHOUT_ON_SCHEMA.properties),
+                                additionalProperties: false,
+                            },
+                        },
+                        additionalProperties: false,
+                    },
+                    {
+                        type: "object",
+                        properties: {
+                            singleLine: OBJECT_WITHOUT_ON_SCHEMA,
+                            multiLine: OBJECT_WITHOUT_ON_SCHEMA,
+                            align: ALIGN_OBJECT_SCHEMA,
+                        },
+                        additionalProperties: false,
+                    },
+                ],
+            },
+        ],
+        messages: {
+            extraKey: "Extra space after key '{{key}}'.",
+            extraValue: "Extra space before value for key '{{key}}'.",
+            missingKey: "Missing space after key '{{key}}'.",
+            missingValue: "Missing space before value for key '{{key}}'.",
+        },
+        type: "layout",
+    },
+    create,
+});
+function create(context) {
+    if (!context.parserServices.isTOML) {
+        return {};
+    }
+    const options = context.options[0] || {};
+    const { multiLine: multiLineOptions, singleLine: singleLineOptions, align: alignmentOptions, } = initOptions(options);
+    const sourceCode = context.getSourceCode();
+    function isKeyValueProperty(property) {
+        return property.type === "TOMLKeyValue";
+    }
+    function getLastTokenBeforeEqual(node) {
+        const equalToken = sourceCode.getTokenAfter(node, ast_utils_1.isEqualSign);
+        return sourceCode.getTokenBefore(equalToken);
+    }
+    function getNextEqual(node) {
+        return sourceCode.getTokenAfter(node, ast_utils_1.isEqualSign);
+    }
+    function getKey(property) {
+        const keys = property.key.keys;
+        return keys
+            .map((key) => sourceCode.getText().slice(key.range[0], key.range[1]))
+            .join(".");
+    }
+    function report(property, side, whitespace, expected, mode) {
+        const diff = whitespace.length - expected;
+        const nextEqual = getNextEqual(property.key);
+        const tokenBeforeEqual = sourceCode.getTokenBefore(nextEqual, {
+            includeComments: true,
+        });
+        const tokenAfterEqual = sourceCode.getTokenAfter(nextEqual, {
+            includeComments: true,
+        });
+        const invalid = (mode === "strict"
+            ? diff !== 0
+            :
+                diff < 0 || (diff > 0 && expected === 0)) &&
+            !(expected && containsLineTerminator(whitespace));
+        if (!invalid) {
+            return;
+        }
+        const { locStart, locEnd, missingLoc } = side === "key"
+            ? {
+                locStart: tokenBeforeEqual.loc.end,
+                locEnd: nextEqual.loc.start,
+                missingLoc: tokenBeforeEqual.loc,
+            }
+            : {
+                locStart: nextEqual.loc.start,
+                locEnd: tokenAfterEqual.loc.start,
+                missingLoc: tokenAfterEqual.loc,
+            };
+        const { loc, messageId } = diff > 0
+            ? {
+                loc: { start: locStart, end: locEnd },
+                messageId: side === "key" ? "extraKey" : "extraValue",
+            }
+            : {
+                loc: missingLoc,
+                messageId: side === "key" ? "missingKey" : "missingValue",
+            };
+        context.report({
+            node: property[side],
+            loc,
+            messageId,
+            data: {
+                key: getKey(property),
+            },
+            fix(fixer) {
+                if (diff > 0) {
+                    if (side === "key") {
+                        return fixer.removeRange([
+                            tokenBeforeEqual.range[1],
+                            tokenBeforeEqual.range[1] + diff,
+                        ]);
+                    }
+                    return fixer.removeRange([
+                        tokenAfterEqual.range[0] - diff,
+                        tokenAfterEqual.range[0],
+                    ]);
+                }
+                const spaces = " ".repeat(-diff);
+                if (side === "key") {
+                    return fixer.insertTextAfter(tokenBeforeEqual, spaces);
+                }
+                return fixer.insertTextBefore(tokenAfterEqual, spaces);
+            },
+        });
+    }
+    function getKeyWidth(pair) {
+        const startToken = sourceCode.getFirstToken(pair);
+        const endToken = getLastTokenBeforeEqual(pair.key);
+        return endToken.range[1] - startToken.range[0];
+    }
+    function getPropertyWhitespace(pair) {
+        const whitespace = /(\s*)=(\s*)/u.exec(sourceCode.getText().slice(pair.key.range[1], pair.value.range[0]));
+        if (whitespace) {
+            return {
+                beforeEqual: whitespace[1],
+                afterEqual: whitespace[2],
+            };
+        }
+        return null;
+    }
+    function verifySpacing(node, lineOptions) {
+        const actual = getPropertyWhitespace(node);
+        if (actual) {
+            report(node, "key", actual.beforeEqual, lineOptions.beforeEqual ? 1 : 0, lineOptions.mode);
+            report(node, "value", actual.afterEqual, lineOptions.afterEqual ? 1 : 0, lineOptions.mode);
+        }
+    }
+    function verifyListSpacing(properties, lineOptions) {
+        const length = properties.length;
+        for (let i = 0; i < length; i++) {
+            verifySpacing(properties[i], lineOptions);
+        }
+    }
+    if (alignmentOptions) {
+        return defineAlignmentVisitor(alignmentOptions);
+    }
+    return defineSpacingVisitor();
+    function defineAlignmentVisitor(alignmentOptions) {
+        return {
+            "TOMLTopLevelTable, TOMLTable, TOMLInlineTable"(node) {
+                if (isSingleLine(node)) {
+                    const body = node.body;
+                    verifyListSpacing(body.filter(isKeyValueProperty), singleLineOptions);
+                }
+                else {
+                    verifyAlignment(node);
+                }
+            },
+        };
+        function verifyGroupAlignment(properties) {
+            const length = properties.length;
+            const widths = properties.map(getKeyWidth);
+            const align = alignmentOptions.on;
+            let targetWidth = Math.max(...widths);
+            let beforeEqual, afterEqual, mode;
+            if (alignmentOptions && length > 1) {
+                beforeEqual = alignmentOptions.beforeEqual ? 1 : 0;
+                afterEqual = alignmentOptions.afterEqual ? 1 : 0;
+                mode = alignmentOptions.mode;
+            }
+            else {
+                beforeEqual = multiLineOptions.beforeEqual ? 1 : 0;
+                afterEqual = multiLineOptions.afterEqual ? 1 : 0;
+                mode = alignmentOptions.mode;
+            }
+            targetWidth += align === "equal" ? beforeEqual : afterEqual;
+            for (let i = 0; i < length; i++) {
+                const property = properties[i];
+                const whitespace = getPropertyWhitespace(property);
+                if (whitespace) {
+                    const width = widths[i];
+                    if (align === "value") {
+                        report(property, "key", whitespace.beforeEqual, beforeEqual, mode);
+                        report(property, "value", whitespace.afterEqual, targetWidth - width, mode);
+                    }
+                    else {
+                        report(property, "key", whitespace.beforeEqual, targetWidth - width, mode);
+                        report(property, "value", whitespace.afterEqual, afterEqual, mode);
+                    }
+                }
+            }
+        }
+        function continuesPropertyGroup(lastMember, candidate) {
+            const groupEndLine = lastMember.loc.start.line;
+            const candidateStartLine = candidate.loc.start.line;
+            if (candidateStartLine - groupEndLine <= 1) {
+                return true;
+            }
+            const leadingComments = sourceCode.getCommentsBefore(candidate);
+            if (leadingComments.length &&
+                leadingComments[0].loc.start.line - groupEndLine <= 1 &&
+                candidateStartLine - last(leadingComments).loc.end.line <= 1) {
+                for (let i = 1; i < leadingComments.length; i++) {
+                    if (leadingComments[i].loc.start.line -
+                        leadingComments[i - 1].loc.end.line >
+                        1) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+        function createGroups(node) {
+            const body = node.body;
+            const pairs = body.filter(isKeyValueProperty);
+            if (pairs.length === 1) {
+                return [pairs];
+            }
+            return pairs.reduce((groups, property) => {
+                const currentGroup = last(groups);
+                const prev = last(currentGroup);
+                if (!prev || continuesPropertyGroup(prev, property)) {
+                    currentGroup.push(property);
+                }
+                else {
+                    groups.push([property]);
+                }
+                return groups;
+            }, [[]]);
+        }
+        function verifyAlignment(node) {
+            createGroups(node).forEach((group) => {
+                const properties = group;
+                if (properties.length > 0 &&
+                    isSingleLineProperties(properties)) {
+                    verifyListSpacing(properties, multiLineOptions);
+                }
+                else {
+                    verifyGroupAlignment(properties);
+                }
+            });
+        }
+    }
+    function defineSpacingVisitor() {
+        return {
+            TOMLKeyValue(node) {
+                if (!isKeyValueProperty(node))
+                    return;
+                verifySpacing(node, isSingleLine(node.parent)
+                    ? singleLineOptions
+                    : multiLineOptions);
+            },
+        };
+    }
+}

package/lib/rules/keys-order.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const toml_eslint_parser_1 = require("toml-eslint-parser");
 const lodash_1 = __importDefault(require("lodash"));
 const utils_1 = require("../utils");
-exports.default = utils_1.createRule("keys-order", {
+exports.default = (0, utils_1.createRule)("keys-order", {
     meta: {
         docs: {
             description: "disallow defining pair keys out-of-order",
@@ -27,7 +27,7 @@ exports.default = utils_1.createRule("keys-order", {
         const sourceCode = context.getSourceCode();
         function applyKey(tableKeys, node) {
             var _a;
-            const keyNames = toml_eslint_parser_1.getStaticTOMLValue(node.key);
+            const keyNames = (0, toml_eslint_parser_1.getStaticTOMLValue)(node.key);
             let before = null;
             let keys = tableKeys;
             while (keyNames.length) {
@@ -36,14 +36,14 @@ exports.default = utils_1.createRule("keys-order", {
                 if (!next) {
                     next = {
                         key,
-                        lastNode: node,
+                        node,
                         keys: [],
                     };
-                    before = ((_a = lodash_1.default.last(keys)) === null || _a === void 0 ? void 0 : _a.lastNode) || null;
+                    before = ((_a = lodash_1.default.last(keys)) === null || _a === void 0 ? void 0 : _a.node) || null;
                     keys.push(next);
                 }
                 else {
-                    next.lastNode = node;
+                    next.node = node;
                 }
                 keys = next.keys;
             }
@@ -62,8 +62,8 @@ exports.default = utils_1.createRule("keys-order", {
                         node: body.key,
                         messageId: "outOfOrder",
                         data: {
-                            target: toml_eslint_parser_1.getStaticTOMLValue(body.key).join("."),
-                            before: toml_eslint_parser_1.getStaticTOMLValue(before.key).join("."),
+                            target: (0, toml_eslint_parser_1.getStaticTOMLValue)(body.key).join("."),
+                            before: (0, toml_eslint_parser_1.getStaticTOMLValue)(before.key).join("."),
                         },
                         fix(fixer) {
                             const startToken = sourceCode.getTokenBefore(body);

package/lib/rules/no-mixed-type-in-array.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-exports.default = utils_1.createRule("no-mixed-type-in-array", {
+exports.default = (0, utils_1.createRule)("no-mixed-type-in-array", {
     meta: {
         docs: {
             description: "disallow mixed data types in array",

package/lib/rules/no-non-decimal-integer.js

@@ -17,7 +17,7 @@ function toDecimalText(str, radix) {
     }
     return digits.reverse().join("");
 }
-exports.default = utils_1.createRule("no-non-decimal-integer", {
+exports.default = (0, utils_1.createRule)("no-non-decimal-integer", {
     meta: {
         docs: {
             description: "disallow hexadecimal, octal and binary integer",
@@ -57,20 +57,19 @@ exports.default = utils_1.createRule("no-non-decimal-integer", {
         const allowHexadecimal = Boolean((_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.allowHexadecimal);
         const allowOctal = Boolean((_b = context.options[0]) === null || _b === void 0 ? void 0 : _b.allowOctal);
         const allowBinary = Boolean((_c = context.options[0]) === null || _c === void 0 ? void 0 : _c.allowBinary);
-        const sourceCode = context.getSourceCode();
         function buildFixer(node, text, mark) {
             if (allowHexadecimal || allowOctal || allowBinary) {
                 return undefined;
             }
             return (fixer) => {
                 const d = mark === "x" ? 16 : mark === "o" ? 8 : 2;
-                const code = text.slice(2).replace(/_/gu, "");
+                const code = text.slice(2);
                 const decimalText = toDecimalText(code, d);
                 return fixer.replaceText(node, decimalText);
             };
         }
         function verifyText(node) {
-            const text = sourceCode.getText(node);
+            const text = node.number;
             if (text.startsWith("0")) {
                 const maybeMark = text[1];
                 if (maybeMark === "x" && !allowHexadecimal) {

package/lib/rules/no-space-dots.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-exports.default = utils_1.createRule("no-space-dots", {
+exports.default = (0, utils_1.createRule)("no-space-dots", {
     meta: {
         docs: {
             description: "disallow spacing around infix operators",

package/lib/rules/no-unreadable-number-separator.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-exports.default = utils_1.createRule("no-unreadable-number-separator", {
+exports.default = (0, utils_1.createRule)("no-unreadable-number-separator", {
     meta: {
         docs: {
             description: "disallow number separators that to not enhance readability.",

package/lib/rules/padding-line-between-pairs.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const toml_eslint_parser_1 = require("toml-eslint-parser");
 const utils_1 = require("../utils");
-exports.default = utils_1.createRule("padding-line-between-pairs", {
+exports.default = (0, utils_1.createRule)("padding-line-between-pairs", {
     meta: {
         docs: {
             description: "require or disallow padding lines between pairs",
@@ -66,7 +66,7 @@ exports.default = utils_1.createRule("padding-line-between-pairs", {
                 if (body.type !== "TOMLKeyValue") {
                     continue;
                 }
-                const keys = toml_eslint_parser_1.getStaticTOMLValue(body.key);
+                const keys = (0, toml_eslint_parser_1.getStaticTOMLValue)(body.key);
                 if (prev) {
                     verifyPairs(prev.node, prev.keys, body, keys);
                 }

package/lib/rules/padding-line-between-tables.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-exports.default = utils_1.createRule("padding-line-between-tables", {
+exports.default = (0, utils_1.createRule)("padding-line-between-tables", {
     meta: {
         docs: {
             description: "require or disallow padding lines between tables",

package/lib/rules/precision-of-fractional-seconds.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-exports.default = utils_1.createRule("precision-of-fractional-seconds", {
+exports.default = (0, utils_1.createRule)("precision-of-fractional-seconds", {
     meta: {
         docs: {
             description: "disallow precision of fractional seconds greater than the specified value.",
@@ -34,7 +34,7 @@ exports.default = utils_1.createRule("precision-of-fractional-seconds", {
         function verifyText(node) {
             var _a, _b;
             const text = node.datetime;
-            const fractional = ((_a = /^\d{4}-\d{2}-\d{2}[ tT]\d{2}:\d{2}:\d{2}.(\d+)/u.exec(text)) === null || _a === void 0 ? void 0 : _a[1]) || ((_b = /^\d{2}:\d{2}:\d{2}.(\d+)/u.exec(text)) === null || _b === void 0 ? void 0 : _b[1]);
+            const fractional = ((_a = /^\d{4}-\d{2}-\d{2}[ Tt]\d{2}:\d{2}:\d{2}.(\d+)/u.exec(text)) === null || _a === void 0 ? void 0 : _a[1]) || ((_b = /^\d{2}:\d{2}:\d{2}.(\d+)/u.exec(text)) === null || _b === void 0 ? void 0 : _b[1]);
             if (!fractional) {
                 return;
             }

package/lib/rules/precision-of-integer.js

@@ -50,7 +50,7 @@ function getMaxValues(bit) {
     }
     return (cacheMaxValues[bit] = maxBitToMaxValues(bit));
 }
-exports.default = utils_1.createRule("precision-of-integer", {
+exports.default = (0, utils_1.createRule)("precision-of-integer", {
     meta: {
         docs: {
             description: "disallow precision of integer greater than the specified value.",
@@ -81,12 +81,8 @@ exports.default = utils_1.createRule("precision-of-integer", {
         }
         const maxBit = (_b = (_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.maxBit) !== null && _b !== void 0 ? _b : 64;
         const maxValues = getMaxValues(maxBit);
-        const sourceCode = context.getSourceCode();
         function verifyMaxValue(node, numText, max) {
-            const num = numText
-                .replace(/_/g, "")
-                .replace(/^0+/, "")
-                .toLowerCase();
+            const num = numText.replace(/^0+/, "").toLowerCase();
             if (num.length < max.length) {
                 return;
             }
@@ -102,7 +98,7 @@ exports.default = utils_1.createRule("precision-of-integer", {
             });
         }
         function verifyText(node) {
-            const text = sourceCode.getText(node);
+            const text = node.number;
             if (text.startsWith("0")) {
                 const maybeMark = text[1];
                 if (maybeMark === "x") {

package/lib/rules/quoted-keys.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-exports.default = utils_1.createRule("quoted-keys", {
+exports.default = (0, utils_1.createRule)("quoted-keys", {
     meta: {
         docs: {
             description: "require or disallow quotes around keys",

package/lib/rules/space-eq-sign.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-exports.default = utils_1.createRule("space-eq-sign", {
+exports.default = (0, utils_1.createRule)("space-eq-sign", {
     meta: {
         docs: {
             description: "require spacing around equals sign",
             categories: ["standard"],
             extensionRule: false,
+            replacedBy: ["key-spacing"],
         },
+        deprecated: true,
         fixable: "whitespace",
         schema: [],
         messages: {

package/lib/rules/spaced-comment.js

@@ -48,7 +48,7 @@ function createNeverStylePattern(markers) {
     const pattern = `^(${markers.map(escapeText).join("|")})?[ \t]+`;
     return new RegExp(pattern, "u");
 }
-exports.default = utils_1.createRule("spaced-comment", {
+exports.default = (0, utils_1.createRule)("spaced-comment", {
     meta: {
         docs: {
             description: "enforce consistent spacing after the `#` in a comment",

package/lib/rules/table-bracket-spacing.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-exports.default = utils_1.createRule("table-bracket-spacing", {
+exports.default = (0, utils_1.createRule)("table-bracket-spacing", {
     meta: {
         docs: {
             description: "enforce consistent spacing inside table brackets",