eslint-plugin-yml 1.9.0 → 1.11.0

package/README.md

@@ -161,7 +161,12 @@ Example **.vscode/settings.json**:
 
 ```json
 {
-  "eslint.validate": ["javascript", "javascriptreact", "yaml"]
+  "eslint.validate": [
+    "javascript",
+    "javascriptreact",
+    "yaml",
+    "github-actions-workflow" // for GitHub Actions workflow files
+  ]
 }
 ```
 

package/lib/meta.d.ts

@@ -1,2 +1,2 @@
 export declare const name: "eslint-plugin-yml";
-export declare const version: "1.9.0";
+export declare const version: "1.11.0";

package/lib/meta.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = exports.name = void 0;
 exports.name = "eslint-plugin-yml";
-exports.version = "1.9.0";
+exports.version = "1.11.0";

package/lib/rules/block-mapping-colon-indicator-newline.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const ast_utils_1 = require("../utils/ast-utils");
+const compat_1 = require("../utils/compat");
 exports.default = (0, utils_1.createRule)("block-mapping-colon-indicator-newline", {
     meta: {
         docs: {
@@ -23,8 +24,8 @@ exports.default = (0, utils_1.createRule)("block-mapping-colon-indicator-newline
         type: "layout",
     },
     create(context) {
-        const sourceCode = context.getSourceCode();
-        if (!context.parserServices.isYAML) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isYAML) {
             return {};
         }
         const option = context.options[0] || "never";

package/lib/rules/block-mapping-question-indicator-newline.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const ast_utils_1 = require("../utils/ast-utils");
+const compat_1 = require("../utils/compat");
 exports.default = (0, utils_1.createRule)("block-mapping-question-indicator-newline", {
     meta: {
         docs: {
@@ -23,8 +24,8 @@ exports.default = (0, utils_1.createRule)("block-mapping-question-indicator-newl
         type: "layout",
     },
     create(context) {
-        const sourceCode = context.getSourceCode();
-        if (!context.parserServices.isYAML) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isYAML) {
             return {};
         }
         const option = context.options[0] || "never";

package/lib/rules/block-mapping.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const ast_utils_1 = require("../utils/ast-utils");
 const yaml_1 = require("../utils/yaml");
+const compat_1 = require("../utils/compat");
 const OPTIONS_ENUM = ["always", "never", "ignore"];
 function parseOptions(option) {
     const opt = {
@@ -56,7 +57,8 @@ exports.default = (0, utils_1.createRule)("block-mapping", {
         type: "layout",
     },
     create(context) {
-        if (!context.parserServices.isYAML) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isYAML) {
             return {};
         }
         const options = parseOptions(context.options[0]);
@@ -201,7 +203,7 @@ function canFixToFlow(mappingInfo, node) {
 }
 function buildFixFlowToBlock(node, context) {
     return function* (fixer) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = (0, compat_1.getSourceCode)(context);
         const open = sourceCode.getFirstToken(node);
         const close = sourceCode.getLastToken(node);
         if ((open === null || open === void 0 ? void 0 : open.value) !== "{" || (close === null || close === void 0 ? void 0 : close.value) !== "}") {

package/lib/rules/block-sequence-hyphen-indicator-newline.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const ast_utils_1 = require("../utils/ast-utils");
+const compat_1 = require("../utils/compat");
 exports.default = (0, utils_1.createRule)("block-sequence-hyphen-indicator-newline", {
     meta: {
         docs: {
@@ -30,8 +31,8 @@ exports.default = (0, utils_1.createRule)("block-sequence-hyphen-indicator-newli
     },
     create(context) {
         var _a, _b;
-        const sourceCode = context.getSourceCode();
-        if (!context.parserServices.isYAML) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isYAML) {
             return {};
         }
         const style = context.options[0] || "never";

package/lib/rules/block-sequence.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const yaml_1 = require("../utils/yaml");
 const ast_utils_1 = require("../utils/ast-utils");
+const compat_1 = require("../utils/compat");
 const OPTIONS_ENUM = ["always", "never", "ignore"];
 function parseOptions(option) {
     const opt = {
@@ -56,7 +57,8 @@ exports.default = (0, utils_1.createRule)("block-sequence", {
         type: "layout",
     },
     create(context) {
-        if (!context.parserServices.isYAML) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isYAML) {
             return {};
         }
         const options = parseOptions(context.options[0]);
@@ -130,7 +132,7 @@ exports.default = (0, utils_1.createRule)("block-sequence", {
                     if ((0, yaml_1.isKeyNode)(node)) {
                         return;
                     }
-                    const canFix = canFixToBlock(sequenceInfo, node, context.getSourceCode()) &&
+                    const canFix = canFixToBlock(sequenceInfo, node, sourceCode) &&
                         !(0, yaml_1.hasTabIndent)(context);
                     context.report({
                         loc: node.loc,
@@ -213,7 +215,7 @@ function canFixToFlow(sequenceInfo, node, context) {
 }
 function buildFixFlowToBlock(node, context) {
     return function* (fixer) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = (0, compat_1.getSourceCode)(context);
         const open = sourceCode.getFirstToken(node);
         const close = sourceCode.getLastToken(node);
         if ((open === null || open === void 0 ? void 0 : open.value) !== "[" || (close === null || close === void 0 ? void 0 : close.value) !== "]") {
@@ -295,7 +297,7 @@ function buildFixFlowToBlock(node, context) {
     };
 }
 function buildFixBlockToFlow(node, context) {
-    const sourceCode = context.getSourceCode();
+    const sourceCode = (0, compat_1.getSourceCode)(context);
     return function* (fixer) {
         const entries = node.entries.filter((e) => e != null);
         if (entries.length !== node.entries.length) {

package/lib/rules/file-extension.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const utils_1 = require("../utils");
+const compat_1 = require("../utils/compat");
 exports.default = (0, utils_1.createRule)("file-extension", {
     meta: {
         docs: {
@@ -34,14 +35,15 @@ exports.default = (0, utils_1.createRule)("file-extension", {
     },
     create(context) {
         var _a, _b, _c;
-        if (!context.parserServices.isYAML) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isYAML) {
             return {};
         }
         const expected = ((_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.extension) || "yaml";
         const caseSensitive = (_c = (_b = context.options[0]) === null || _b === void 0 ? void 0 : _b.caseSensitive) !== null && _c !== void 0 ? _c : true;
         return {
             Program(node) {
-                const filename = context.getFilename();
+                const filename = (0, compat_1.getFilename)(context);
                 const actual = path_1.default.extname(filename);
                 if ((caseSensitive ? actual : actual.toLocaleLowerCase()) ===
                     `.${expected}`) {

package/lib/rules/flow-mapping-curly-newline.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const ast_utils_1 = require("../utils/ast-utils");
 const yaml_1 = require("../utils/yaml");
+const compat_1 = require("../utils/compat");
 const OPTION_VALUE = {
     oneOf: [
         {
@@ -75,10 +76,10 @@ exports.default = (0, utils_1.createRule)("flow-mapping-curly-newline", {
         type: "layout",
     },
     create(context) {
-        if (!context.parserServices.isYAML) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isYAML) {
             return {};
         }
-        const sourceCode = context.getSourceCode();
         const options = normalizeOptionValue(context.options[0]);
         function check(node) {
             if ((0, yaml_1.isKeyNode)(node)) {

package/lib/rules/flow-mapping-curly-spacing.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-const coreRule = (0, utils_1.getCoreRule)("object-curly-spacing");
+const compat_1 = require("../utils/compat");
+const ast_utils_1 = require("../utils/ast-utils");
 exports.default = (0, utils_1.createRule)("flow-mapping-curly-spacing", {
     meta: {
         docs: {
@@ -10,32 +11,181 @@ exports.default = (0, utils_1.createRule)("flow-mapping-curly-spacing", {
             extensionRule: "object-curly-spacing",
             layout: true,
         },
-        fixable: coreRule.meta.fixable,
-        hasSuggestions: coreRule.meta.hasSuggestions,
-        schema: coreRule.meta.schema,
-        messages: coreRule.meta.messages,
-        type: coreRule.meta.type,
+        type: "layout",
+        fixable: "whitespace",
+        schema: [
+            {
+                type: "string",
+                enum: ["always", "never"],
+            },
+            {
+                type: "object",
+                properties: {
+                    arraysInObjects: {
+                        type: "boolean",
+                    },
+                    objectsInObjects: {
+                        type: "boolean",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            requireSpaceBefore: "A space is required before '{{token}}'.",
+            requireSpaceAfter: "A space is required after '{{token}}'.",
+            unexpectedSpaceBefore: "There should be no space before '{{token}}'.",
+            unexpectedSpaceAfter: "There should be no space after '{{token}}'.",
+        },
     },
     create(context) {
-        if (!context.parserServices.isYAML) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isYAML) {
             return {};
         }
-        return (0, utils_1.defineWrapperListener)(coreRule, context, {
-            options: context.options,
-            createListenerProxy(listener) {
-                return {
-                    YAMLMapping(node) {
-                        if (node.style === "flow") {
-                            listener.ObjectExpression((0, utils_1.getProxyNode)(node, {
-                                type: "ObjectExpression",
-                                get properties() {
-                                    return node.pairs;
-                                },
-                            }));
-                        }
-                    },
-                };
+        const spaced = context.options[0] === "always";
+        function isOptionSet(option) {
+            return context.options[1]
+                ? context.options[1][option] === !spaced
+                : false;
+        }
+        const options = {
+            spaced,
+            arraysInObjectsException: isOptionSet("arraysInObjects"),
+            objectsInObjectsException: isOptionSet("objectsInObjects"),
+            isOpeningCurlyBraceMustBeSpaced(second) {
+                var _a;
+                const targetPenultimateType = options.arraysInObjectsException && (0, ast_utils_1.isOpeningBracketToken)(second)
+                    ? "YAMLSequence"
+                    : options.objectsInObjectsException && (0, ast_utils_1.isOpeningBraceToken)(second)
+                        ? "YAMLMapping"
+                        : null;
+                return targetPenultimateType &&
+                    ((_a = sourceCode.getNodeByRangeIndex(second.range[0])) === null || _a === void 0 ? void 0 : _a.type) ===
+                        targetPenultimateType
+                    ? !options.spaced
+                    : options.spaced;
+            },
+            isClosingCurlyBraceMustBeSpaced(penultimate) {
+                var _a;
+                const targetPenultimateType = options.arraysInObjectsException && (0, ast_utils_1.isClosingBracketToken)(penultimate)
+                    ? "YAMLSequence"
+                    : options.objectsInObjectsException &&
+                        (0, ast_utils_1.isClosingBraceToken)(penultimate)
+                        ? "YAMLMapping"
+                        : null;
+                return targetPenultimateType &&
+                    ((_a = sourceCode.getNodeByRangeIndex(penultimate.range[0])) === null || _a === void 0 ? void 0 : _a.type) ===
+                        targetPenultimateType
+                    ? !options.spaced
+                    : options.spaced;
+            },
+        };
+        function reportNoBeginningSpace(node, token) {
+            const nextToken = sourceCode.getTokenAfter(token, {
+                includeComments: true,
+            });
+            context.report({
+                node,
+                loc: { start: token.loc.end, end: nextToken.loc.start },
+                messageId: "unexpectedSpaceAfter",
+                data: {
+                    token: token.value,
+                },
+                fix(fixer) {
+                    return fixer.removeRange([token.range[1], nextToken.range[0]]);
+                },
+            });
+        }
+        function reportNoEndingSpace(node, token) {
+            const previousToken = sourceCode.getTokenBefore(token, {
+                includeComments: true,
+            });
+            context.report({
+                node,
+                loc: { start: previousToken.loc.end, end: token.loc.start },
+                messageId: "unexpectedSpaceBefore",
+                data: {
+                    token: token.value,
+                },
+                fix(fixer) {
+                    return fixer.removeRange([previousToken.range[1], token.range[0]]);
+                },
+            });
+        }
+        function reportRequiredBeginningSpace(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "requireSpaceAfter",
+                data: {
+                    token: token.value,
+                },
+                fix(fixer) {
+                    return fixer.insertTextAfter(token, " ");
+                },
+            });
+        }
+        function reportRequiredEndingSpace(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "requireSpaceBefore",
+                data: {
+                    token: token.value,
+                },
+                fix(fixer) {
+                    return fixer.insertTextBefore(token, " ");
+                },
+            });
+        }
+        function validateBraceSpacing(node, first, second, penultimate, last) {
+            if ((0, ast_utils_1.isTokenOnSameLine)(first, second)) {
+                const firstSpaced = sourceCode.isSpaceBetweenTokens(first, second);
+                if (options.isOpeningCurlyBraceMustBeSpaced(second)) {
+                    if (!firstSpaced)
+                        reportRequiredBeginningSpace(node, first);
+                }
+                else {
+                    if (firstSpaced && second.type !== "Line")
+                        reportNoBeginningSpace(node, first);
+                }
+            }
+            if ((0, ast_utils_1.isTokenOnSameLine)(penultimate, last)) {
+                const lastSpaced = sourceCode.isSpaceBetweenTokens(penultimate, last);
+                if (options.isClosingCurlyBraceMustBeSpaced(penultimate)) {
+                    if (!lastSpaced)
+                        reportRequiredEndingSpace(node, last);
+                }
+                else {
+                    if (lastSpaced)
+                        reportNoEndingSpace(node, last);
+                }
+            }
+        }
+        function getClosingBraceOfObject(node) {
+            const lastProperty = node.pairs[node.pairs.length - 1];
+            return sourceCode.getTokenAfter(lastProperty, ast_utils_1.isClosingBraceToken);
+        }
+        function checkForObject(node) {
+            if (node.pairs.length === 0)
+                return;
+            const first = sourceCode.getFirstToken(node);
+            const last = getClosingBraceOfObject(node);
+            const second = sourceCode.getTokenAfter(first, {
+                includeComments: true,
+            });
+            const penultimate = sourceCode.getTokenBefore(last, {
+                includeComments: true,
+            });
+            validateBraceSpacing(node, first, second, penultimate, last);
+        }
+        return {
+            YAMLMapping(node) {
+                if (node.style === "flow") {
+                    checkForObject(node);
+                }
             },
-        });
+        };
     },
 });

package/lib/rules/flow-sequence-bracket-newline.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
 const yaml_1 = require("../utils/yaml");
 const ast_utils_1 = require("../utils/ast-utils");
+const compat_1 = require("../utils/compat");
 exports.default = (0, utils_1.createRule)("flow-sequence-bracket-newline", {
     meta: {
         docs: {
@@ -43,10 +44,10 @@ exports.default = (0, utils_1.createRule)("flow-sequence-bracket-newline", {
         type: "layout",
     },
     create(context) {
-        if (!context.parserServices.isYAML) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isYAML) {
             return {};
         }
-        const sourceCode = context.getSourceCode();
         function normalizeOptionValue(option) {
             let consistent = false;
             let multiline = false;

package/lib/rules/flow-sequence-bracket-spacing.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../utils");
-const coreRule = (0, utils_1.getCoreRule)("array-bracket-spacing");
+const compat_1 = require("../utils/compat");
+const ast_utils_1 = require("../utils/ast-utils");
 exports.default = (0, utils_1.createRule)("flow-sequence-bracket-spacing", {
     meta: {
         docs: {
@@ -10,32 +11,173 @@ exports.default = (0, utils_1.createRule)("flow-sequence-bracket-spacing", {
             extensionRule: "array-bracket-spacing",
             layout: true,
         },
-        fixable: coreRule.meta.fixable,
-        hasSuggestions: coreRule.meta.hasSuggestions,
-        schema: coreRule.meta.schema,
-        messages: coreRule.meta.messages,
-        type: coreRule.meta.type,
+        type: "layout",
+        fixable: "whitespace",
+        schema: [
+            {
+                type: "string",
+                enum: ["always", "never"],
+            },
+            {
+                type: "object",
+                properties: {
+                    singleValue: {
+                        type: "boolean",
+                    },
+                    objectsInArrays: {
+                        type: "boolean",
+                    },
+                    arraysInArrays: {
+                        type: "boolean",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            unexpectedSpaceAfter: "There should be no space after '{{tokenValue}}'.",
+            unexpectedSpaceBefore: "There should be no space before '{{tokenValue}}'.",
+            missingSpaceAfter: "A space is required after '{{tokenValue}}'.",
+            missingSpaceBefore: "A space is required before '{{tokenValue}}'.",
+        },
     },
     create(context) {
-        if (!context.parserServices.isYAML) {
+        const sourceCode = (0, compat_1.getSourceCode)(context);
+        if (!sourceCode.parserServices.isYAML) {
             return {};
         }
-        return (0, utils_1.defineWrapperListener)(coreRule, context, {
-            options: context.options,
-            createListenerProxy(listener) {
-                return {
-                    YAMLSequence(node) {
-                        if (node.style === "flow") {
-                            listener.ArrayExpression((0, utils_1.getProxyNode)(node, {
-                                type: "ArrayExpression",
-                                get elements() {
-                                    return node.entries;
-                                },
-                            }));
-                        }
-                    },
-                };
+        const spaced = context.options[0] === "always";
+        function isOptionSet(option) {
+            return context.options[1]
+                ? context.options[1][option] === !spaced
+                : false;
+        }
+        const options = {
+            spaced,
+            singleElementException: isOptionSet("singleValue"),
+            objectsInArraysException: isOptionSet("objectsInArrays"),
+            arraysInArraysException: isOptionSet("arraysInArrays"),
+            isOpeningBracketMustBeSpaced(node) {
+                if (options.singleElementException && node.entries.length === 1) {
+                    return !options.spaced;
+                }
+                const firstElement = node.entries[0];
+                return firstElement &&
+                    ((options.objectsInArraysException && isObjectType(firstElement)) ||
+                        (options.arraysInArraysException && isArrayType(firstElement)))
+                    ? !options.spaced
+                    : options.spaced;
+            },
+            isClosingBracketMustBeSpaced(node) {
+                if (options.singleElementException && node.entries.length === 1) {
+                    return !options.spaced;
+                }
+                const lastElement = node.entries[node.entries.length - 1];
+                return lastElement &&
+                    ((options.objectsInArraysException && isObjectType(lastElement)) ||
+                        (options.arraysInArraysException && isArrayType(lastElement)))
+                    ? !options.spaced
+                    : options.spaced;
+            },
+        };
+        function reportNoBeginningSpace(node, token) {
+            const nextToken = sourceCode.getTokenAfter(token);
+            context.report({
+                node,
+                loc: { start: token.loc.end, end: nextToken.loc.start },
+                messageId: "unexpectedSpaceAfter",
+                data: {
+                    tokenValue: token.value,
+                },
+                fix(fixer) {
+                    return fixer.removeRange([token.range[1], nextToken.range[0]]);
+                },
+            });
+        }
+        function reportNoEndingSpace(node, token) {
+            const previousToken = sourceCode.getTokenBefore(token);
+            context.report({
+                node,
+                loc: { start: previousToken.loc.end, end: token.loc.start },
+                messageId: "unexpectedSpaceBefore",
+                data: {
+                    tokenValue: token.value,
+                },
+                fix(fixer) {
+                    return fixer.removeRange([previousToken.range[1], token.range[0]]);
+                },
+            });
+        }
+        function reportRequiredBeginningSpace(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "missingSpaceAfter",
+                data: {
+                    tokenValue: token.value,
+                },
+                fix(fixer) {
+                    return fixer.insertTextAfter(token, " ");
+                },
+            });
+        }
+        function reportRequiredEndingSpace(node, token) {
+            context.report({
+                node,
+                loc: token.loc,
+                messageId: "missingSpaceBefore",
+                data: {
+                    tokenValue: token.value,
+                },
+                fix(fixer) {
+                    return fixer.insertTextBefore(token, " ");
+                },
+            });
+        }
+        function isObjectType(node) {
+            return node && node.type === "YAMLMapping";
+        }
+        function isArrayType(node) {
+            return node && node.type === "YAMLSequence";
+        }
+        function validateArraySpacing(node) {
+            if (options.spaced && node.entries.length === 0)
+                return;
+            const first = sourceCode.getFirstToken(node);
+            const last = sourceCode.getLastToken(node);
+            const second = sourceCode.getTokenAfter(first, {
+                includeComments: true,
+            });
+            const penultimate = sourceCode.getTokenBefore(last, {
+                includeComments: true,
+            });
+            if ((0, ast_utils_1.isTokenOnSameLine)(first, second)) {
+                if (options.isOpeningBracketMustBeSpaced(node)) {
+                    if (!sourceCode.isSpaceBetweenTokens(first, second))
+                        reportRequiredBeginningSpace(node, first);
+                }
+                else {
+                    if (sourceCode.isSpaceBetweenTokens(first, second))
+                        reportNoBeginningSpace(node, first);
+                }
+            }
+            if (first !== penultimate && (0, ast_utils_1.isTokenOnSameLine)(penultimate, last)) {
+                if (options.isClosingBracketMustBeSpaced(node)) {
+                    if (!sourceCode.isSpaceBetweenTokens(penultimate, last))
+                        reportRequiredEndingSpace(node, last);
+                }
+                else {
+                    if (sourceCode.isSpaceBetweenTokens(penultimate, last))
+                        reportNoEndingSpace(node, last);
+                }
+            }
+        }
+        return {
+            YAMLSequence(node) {
+                if (node.style === "flow") {
+                    validateArraySpacing(node);
+                }
             },
-        });
+        };
     },
 });