eslint-plugin-yml 1.4.0 → 1.6.0

package/README.md

@@ -207,6 +207,7 @@ The rules with the following star :star: are included in the config.
 | [yml/no-empty-mapping-value](https://ota-meshi.github.io/eslint-plugin-yml/rules/no-empty-mapping-value.html) | disallow empty mapping values |  | :star: | :star: |
 | [yml/no-empty-sequence-entry](https://ota-meshi.github.io/eslint-plugin-yml/rules/no-empty-sequence-entry.html) | disallow empty sequence entries |  | :star: | :star: |
 | [yml/no-tab-indent](https://ota-meshi.github.io/eslint-plugin-yml/rules/no-tab-indent.html) | disallow tabs for indentation. |  | :star: | :star: |
+| [yml/no-trailing-zeros](https://ota-meshi.github.io/eslint-plugin-yml/rules/no-trailing-zeros.html) | disallow trailing zeros for floats | :wrench: |  |  |
 | [yml/plain-scalar](https://ota-meshi.github.io/eslint-plugin-yml/rules/plain-scalar.html) | require or disallow plain style scalar. | :wrench: |  | :star: |
 | [yml/quotes](https://ota-meshi.github.io/eslint-plugin-yml/rules/quotes.html) | enforce the consistent use of either double, or single quotes | :wrench: |  | :star: |
 | [yml/require-string-key](https://ota-meshi.github.io/eslint-plugin-yml/rules/require-string-key.html) | disallow mapping keys other than strings |  |  |  |

package/lib/configs/prettier.d.ts

@@ -11,6 +11,7 @@ declare const _default: {
         "yml/indent": string;
         "yml/key-spacing": string;
         "yml/no-multiple-empty-lines": string;
+        "yml/no-trailing-zeros": string;
         "yml/quotes": string;
     };
 };

package/lib/configs/prettier.js

@@ -18,6 +18,7 @@ module.exports = {
         "yml/indent": "off",
         "yml/key-spacing": "off",
         "yml/no-multiple-empty-lines": "off",
+        "yml/no-trailing-zeros": "off",
         "yml/quotes": "off",
     },
 };

package/lib/index.d.ts

@@ -63,6 +63,7 @@ declare const _default: {
                 "yml/indent": string;
                 "yml/key-spacing": string;
                 "yml/no-multiple-empty-lines": string;
+                "yml/no-trailing-zeros": string;
                 "yml/quotes": string;
             };
         };

package/lib/rules/indent.js

@@ -10,14 +10,19 @@ function parseOptions(context) {
     const [indentOption, objectOptions] = context.options;
     const numOfIndent = (0, yaml_1.getNumOfIndent)(context, indentOption);
     let indentBlockSequences = true;
+    let indicatorValueIndent = numOfIndent;
     if (objectOptions) {
         if (objectOptions.indentBlockSequences === false) {
             indentBlockSequences = false;
         }
+        if (objectOptions.indicatorValueIndent != null) {
+            indicatorValueIndent = objectOptions.indicatorValueIndent;
+        }
     }
     return {
         numOfIndent,
         indentBlockSequences,
+        indicatorValueIndent,
     };
 }
 exports.default = (0, utils_1.createRule)("indent", {
@@ -38,6 +43,10 @@ exports.default = (0, utils_1.createRule)("indent", {
                 type: "object",
                 properties: {
                     indentBlockSequences: { type: "boolean" },
+                    indicatorValueIndent: {
+                        type: "integer",
+                        minimum: 2,
+                    },
                 },
                 additionalProperties: false,
             },
@@ -54,27 +63,33 @@ exports.default = (0, utils_1.createRule)("indent", {
         if ((0, yaml_1.hasTabIndent)(context)) {
             return {};
         }
-        const { numOfIndent, indentBlockSequences } = parseOptions(context);
+        const { numOfIndent, indentBlockSequences, indicatorValueIndent } = parseOptions(context);
         const sourceCode = context.getSourceCode();
-        const offsets = new Map();
-        const marks = new Set();
+        const indents = new Map();
+        const indicators = new Set();
         const blockLiteralMarks = new Set();
         const scalars = new Map();
         function setOffset(token, offset, baseToken, options) {
+            setIndent(token, offset * numOfIndent, baseToken, options && {
+                indentWhenBaseIsNotFirst: options.offsetWhenBaseIsNotFirst &&
+                    options.offsetWhenBaseIsNotFirst * numOfIndent,
+            });
+        }
+        function setIndent(token, indent, baseToken, options) {
             var _a;
             if (token == null) {
                 return;
             }
             if (Array.isArray(token)) {
                 for (const t of token) {
-                    setOffset(t, offset, baseToken, options);
+                    setIndent(t, indent, baseToken, options);
                 }
             }
             else {
-                offsets.set(token, {
+                indents.set(token, {
                     baseToken,
-                    offset,
-                    offsetWhenBaseIsNotFirst: (_a = options === null || options === void 0 ? void 0 : options.offsetWhenBaseIsNotFirst) !== null && _a !== void 0 ? _a : null,
+                    indent,
+                    indentWhenBaseIsNotFirst: (_a = options === null || options === void 0 ? void 0 : options.indentWhenBaseIsNotFirst) !== null && _a !== void 0 ? _a : null,
                 });
             }
         }
@@ -110,14 +125,23 @@ exports.default = (0, utils_1.createRule)("indent", {
                 setOffset(right, 0, left);
             }
         }
-        function calcMappingPairValueIndentOffset(node) {
+        function calcMappingPairValueIndent(node, indent) {
             if (indentBlockSequences) {
-                return 1;
+                return indent;
             }
             if (node.type === "YAMLSequence" && node.style === "block") {
                 return 0;
             }
-            return 1;
+            return indent;
+        }
+        function calcIndicatorValueIndent(token) {
+            return isBeginningToken(token) ? indicatorValueIndent : numOfIndent;
+        }
+        function isBeginningToken(token) {
+            const before = sourceCode.getTokenBefore(token, (t) => !indicators.has(t));
+            if (!before)
+                return true;
+            return before.loc.end.line < token.loc.start.line;
         }
         const documents = [];
         return {
@@ -127,10 +151,10 @@ exports.default = (0, utils_1.createRule)("indent", {
                 if (!first) {
                     return;
                 }
-                offsets.set(first, {
+                indents.set(first, {
                     baseToken: null,
-                    offsetWhenBaseIsNotFirst: null,
-                    offset: 0,
+                    indentWhenBaseIsNotFirst: null,
+                    indent: 0,
                     expectedIndent: 0,
                 });
                 processNodeList([...node.directives, node.content], first, null, 0);
@@ -160,9 +184,9 @@ exports.default = (0, utils_1.createRule)("indent", {
                             continue;
                         }
                         const hyphen = sourceCode.getTokenBefore(entry, ast_utils_1.isHyphen);
-                        marks.add(hyphen);
+                        indicators.add(hyphen);
                         const entryToken = sourceCode.getFirstToken(entry);
-                        setOffset(entryToken, 1, hyphen);
+                        setIndent(entryToken, calcIndicatorValueIndent(hyphen), hyphen);
                     }
                 }
             },
@@ -172,13 +196,13 @@ exports.default = (0, utils_1.createRule)("indent", {
                 const colonToken = findColonToken();
                 const questionToken = (0, ast_utils_1.isQuestion)(pairFirst) ? pairFirst : null;
                 if (questionToken) {
-                    marks.add(questionToken);
+                    indicators.add(questionToken);
                     if (node.key) {
-                        setOffset(keyToken, calcMappingPairValueIndentOffset(node.key), questionToken);
+                        setIndent(keyToken, calcMappingPairValueIndent(node.key, calcIndicatorValueIndent(questionToken)), questionToken);
                     }
                 }
                 if (colonToken) {
-                    marks.add(colonToken);
+                    indicators.add(colonToken);
                     if (questionToken) {
                         setOffset(colonToken, 0, questionToken, {
                             offsetWhenBaseIsNotFirst: 1,
@@ -191,7 +215,7 @@ exports.default = (0, utils_1.createRule)("indent", {
                 if (node.value) {
                     const valueToken = sourceCode.getFirstToken(node.value);
                     if (colonToken) {
-                        setOffset(valueToken, calcMappingPairValueIndentOffset(node.value), colonToken);
+                        setIndent(valueToken, calcMappingPairValueIndent(node.value, calcIndicatorValueIndent(colonToken)), colonToken);
                     }
                     else if (keyToken) {
                         setOffset(valueToken, 1, keyToken);
@@ -281,7 +305,7 @@ exports.default = (0, utils_1.createRule)("indent", {
             const lastToken = lineTokens[lineTokens.length - 1];
             let lineExpectedIndent = null;
             let cacheExpectedIndent = null;
-            const markData = [];
+            const indicatorData = [];
             const firstToken = lineTokens.shift();
             let token = firstToken;
             let expectedIndent = getExpectedIndent(token);
@@ -289,7 +313,7 @@ exports.default = (0, utils_1.createRule)("indent", {
                 lineExpectedIndent = expectedIndent;
                 cacheExpectedIndent = expectedIndent;
             }
-            while (token && marks.has(token) && expectedIndent != null) {
+            while (token && indicators.has(token) && expectedIndent != null) {
                 const nextToken = lineTokens.shift();
                 if (!nextToken) {
                     break;
@@ -300,8 +324,8 @@ exports.default = (0, utils_1.createRule)("indent", {
                     lineTokens.unshift(nextToken);
                     break;
                 }
-                markData.push({
-                    mark: token,
+                indicatorData.push({
+                    indicator: token,
                     next: nextToken,
                     expectedOffset: nextExpectedIndent - expectedIndent - 1,
                     actualOffset: nextToken.range[0] - token.range[1],
@@ -328,9 +352,9 @@ exports.default = (0, utils_1.createRule)("indent", {
             }
             if (cacheExpectedIndent != null) {
                 while ((token = lineTokens.shift()) != null) {
-                    const offset = offsets.get(token);
-                    if (offset) {
-                        offset.expectedIndent = cacheExpectedIndent;
+                    const indent = indents.get(token);
+                    if (indent) {
+                        indent.expectedIndent = cacheExpectedIndent;
                     }
                 }
             }
@@ -351,7 +375,7 @@ exports.default = (0, utils_1.createRule)("indent", {
                 actualIndent: column,
                 firstToken,
                 line,
-                markData,
+                indicatorData,
                 lastScalar,
             };
         }
@@ -359,33 +383,33 @@ exports.default = (0, utils_1.createRule)("indent", {
             if (token.type === "Marker") {
                 return 0;
             }
-            const offset = offsets.get(token);
-            if (!offset) {
+            const indent = indents.get(token);
+            if (!indent) {
                 return null;
             }
-            if (offset.expectedIndent != null) {
-                return offset.expectedIndent;
+            if (indent.expectedIndent != null) {
+                return indent.expectedIndent;
             }
-            if (offset.baseToken == null) {
+            if (indent.baseToken == null) {
                 return null;
             }
-            const baseIndent = getExpectedIndent(offset.baseToken);
+            const baseIndent = getExpectedIndent(indent.baseToken);
             if (baseIndent == null) {
                 return null;
             }
-            let offsetIndent = offset.offset;
-            if (offsetIndent === 0 && offset.offsetWhenBaseIsNotFirst != null) {
-                let before = offset.baseToken;
+            let offsetIndent = indent.indent;
+            if (offsetIndent === 0 && indent.indentWhenBaseIsNotFirst != null) {
+                let before = indent.baseToken;
                 while ((before = sourceCode.getTokenBefore(before, ITERATION_OPTS)) != null) {
-                    if (!marks.has(before)) {
+                    if (!indicators.has(before)) {
                         break;
                     }
                 }
-                if ((before === null || before === void 0 ? void 0 : before.loc.end.line) === offset.baseToken.loc.start.line) {
-                    offsetIndent = offset.offsetWhenBaseIsNotFirst;
+                if ((before === null || before === void 0 ? void 0 : before.loc.end.line) === indent.baseToken.loc.start.line) {
+                    offsetIndent = indent.indentWhenBaseIsNotFirst;
                 }
             }
-            return (offset.expectedIndent = baseIndent + numOfIndent * offsetIndent);
+            return (indent.expectedIndent = baseIndent + offsetIndent);
         }
         function processMissingLines(lineIndents) {
             const results = [];
@@ -413,7 +437,7 @@ exports.default = (0, utils_1.createRule)("indent", {
                         line,
                         expectedIndent: lineIndent.expectedIndent,
                         actualIndent: lineIndent.actualIndent,
-                        markData: lineIndent.markData,
+                        indicatorData: lineIndent.indicatorData,
                     };
                     if (!results[line]) {
                         results[line] = indent;
@@ -489,7 +513,7 @@ exports.default = (0, utils_1.createRule)("indent", {
                             line: commentLineIndent.line,
                             expectedIndent,
                             actualIndent: commentLineIndent.actualIndent,
-                            markData: commentLineIndent.markData,
+                            indicatorData: commentLineIndent.indicatorData,
                         };
                     }
                 }
@@ -538,7 +562,7 @@ exports.default = (0, utils_1.createRule)("indent", {
                         line: scalarLine,
                         expectedIndent,
                         actualIndent: scalarActualIndent,
-                        markData: [],
+                        indicatorData: [],
                     };
                 }
             }
@@ -552,7 +576,7 @@ exports.default = (0, utils_1.createRule)("indent", {
                         line: scalarLine,
                         expectedIndent,
                         actualIndent: scalarActualIndent,
-                        markData: [],
+                        indicatorData: [],
                     };
                 }
             }
@@ -582,20 +606,20 @@ exports.default = (0, utils_1.createRule)("indent", {
                         fix: buildFix(lineIndent, lineIndents),
                     });
                 }
-                else if (lineIndent.markData.length) {
-                    for (const markData of lineIndent.markData) {
-                        if (markData.actualOffset !== markData.expectedOffset) {
-                            const markLoc = markData.mark.loc.end;
-                            const loc = markData.next.loc.start;
+                else if (lineIndent.indicatorData.length) {
+                    for (const indicatorData of lineIndent.indicatorData) {
+                        if (indicatorData.actualOffset !== indicatorData.expectedOffset) {
+                            const indicatorLoc = indicatorData.indicator.loc.end;
+                            const loc = indicatorData.next.loc.start;
                             context.report({
                                 loc: {
-                                    start: markLoc,
+                                    start: indicatorLoc,
                                     end: loc,
                                 },
                                 messageId: "wrongIndentation",
                                 data: {
-                                    expected: String(markData.expectedOffset),
-                                    actual: String(markData.actualOffset),
+                                    expected: String(indicatorData.expectedOffset),
+                                    actual: String(indicatorData.actualOffset),
                                 },
                                 fix: buildFix(lineIndent, lineIndents),
                             });
@@ -619,8 +643,8 @@ exports.default = (0, utils_1.createRule)("indent", {
                     if (expectedIndent <= li.actualIndent) {
                         return null;
                     }
-                    for (const mark of li.markData) {
-                        if (mark.actualOffset !== mark.expectedOffset) {
+                    for (const indicator of li.indicatorData) {
+                        if (indicator.actualOffset !== indicator.expectedOffset) {
                             return null;
                         }
                     }
@@ -684,9 +708,9 @@ exports.default = (0, utils_1.createRule)("indent", {
                             yield* fixLine(fixer, li);
                         }
                     }
-                    if (li.markData) {
-                        for (const markData of li.markData) {
-                            yield fixer.replaceTextRange([markData.mark.range[1], markData.next.range[0]], " ".repeat(markData.expectedOffset));
+                    if (li.indicatorData) {
+                        for (const indicatorData of li.indicatorData) {
+                            yield fixer.replaceTextRange([indicatorData.indicator.range[1], indicatorData.next.range[0]], " ".repeat(indicatorData.expectedOffset));
                         }
                     }
                 }

package/lib/rules/no-trailing-zeros.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../types").RuleModule;
+export default _default;

package/lib/rules/no-trailing-zeros.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+exports.default = (0, utils_1.createRule)("no-trailing-zeros", {
+    meta: {
+        docs: {
+            description: "disallow trailing zeros for floats",
+            categories: null,
+            extensionRule: false,
+            layout: true,
+        },
+        fixable: "code",
+        schema: [],
+        messages: {
+            wrongZeros: "Trailing zeros are not allowed, fix to `{{fixed}}`.",
+        },
+        type: "layout",
+    },
+    create(context) {
+        if (!context.parserServices.isYAML) {
+            return {};
+        }
+        return {
+            YAMLScalar(node) {
+                if (node.style !== "plain") {
+                    return;
+                }
+                else if (typeof node.value !== "number") {
+                    return;
+                }
+                const floating = parseFloatingPoint(node.strValue);
+                if (!floating) {
+                    return;
+                }
+                let { decimalPart } = floating;
+                while (decimalPart.endsWith("_")) {
+                    decimalPart = decimalPart.slice(0, -1);
+                }
+                if (!decimalPart.endsWith("0")) {
+                    return;
+                }
+                while (decimalPart.endsWith("0")) {
+                    decimalPart = decimalPart.slice(0, -1);
+                    while (decimalPart.endsWith("_")) {
+                        decimalPart = decimalPart.slice(0, -1);
+                    }
+                }
+                const fixed = decimalPart
+                    ? `${floating.sign}${floating.intPart}.${decimalPart}${floating.expPart}`
+                    : `${floating.sign}${floating.intPart || "0"}${floating.expPart}`;
+                context.report({
+                    node,
+                    messageId: "wrongZeros",
+                    data: {
+                        fixed,
+                    },
+                    fix(fixer) {
+                        return fixer.replaceText(node, fixed);
+                    },
+                });
+            },
+        };
+    },
+});
+function parseFloatingPoint(str) {
+    const parts = str.split(".");
+    if (parts.length !== 2) {
+        return null;
+    }
+    let decimalPart, expPart, intPart, sign;
+    const expIndex = parts[1].search(/e/iu);
+    if (expIndex >= 0) {
+        decimalPart = parts[1].slice(0, expIndex);
+        expPart = parts[1].slice(expIndex);
+    }
+    else {
+        decimalPart = parts[1];
+        expPart = "";
+    }
+    if (parts[0].startsWith("-") || parts[0].startsWith("+")) {
+        sign = parts[0][0];
+        intPart = parts[0].slice(1);
+    }
+    else {
+        sign = "";
+        intPart = parts[0];
+    }
+    return {
+        sign,
+        intPart,
+        decimalPart,
+        expPart,
+    };
+}

package/lib/utils/rules.js

@@ -24,6 +24,7 @@ const no_empty_sequence_entry_1 = __importDefault(require("../rules/no-empty-seq
 const no_irregular_whitespace_1 = __importDefault(require("../rules/no-irregular-whitespace"));
 const no_multiple_empty_lines_1 = __importDefault(require("../rules/no-multiple-empty-lines"));
 const no_tab_indent_1 = __importDefault(require("../rules/no-tab-indent"));
+const no_trailing_zeros_1 = __importDefault(require("../rules/no-trailing-zeros"));
 const plain_scalar_1 = __importDefault(require("../rules/plain-scalar"));
 const quotes_1 = __importDefault(require("../rules/quotes"));
 const require_string_key_1 = __importDefault(require("../rules/require-string-key"));
@@ -52,6 +53,7 @@ exports.rules = [
     no_irregular_whitespace_1.default,
     no_multiple_empty_lines_1.default,
     no_tab_indent_1.default,
+    no_trailing_zeros_1.default,
     plain_scalar_1.default,
     quotes_1.default,
     require_string_key_1.default,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-yml",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "This ESLint plugin provides linting rules for YAML.",
   "main": "lib/index.js",
   "files": [
@@ -44,7 +44,8 @@
     "eslintplugin",
     "eslint-plugin",
     "yaml",
-    "yml"
+    "yml",
+    "lint"
   ],
   "author": "Yosuke Ota",
   "funding": "https://github.com/sponsors/ota-meshi",
@@ -57,7 +58,7 @@
     "debug": "^4.3.2",
     "lodash": "^4.17.21",
     "natural-compare": "^1.4.0",
-    "yaml-eslint-parser": "^1.1.0"
+    "yaml-eslint-parser": "^1.2.1"
   },
   "peerDependencies": {
     "eslint": ">=6.0.0"
@@ -80,7 +81,7 @@
     "@typescript-eslint/parser": "^5.0.0",
     "cross-env": "^7.0.2",
     "env-cmd": "^10.1.0",
-    "esbuild": "^0.16.0",
+    "esbuild": "^0.17.0",
     "esbuild-register": "^3.2.0",
     "eslint": "^8.0.0",
     "eslint-config-prettier": "^8.0.0",
@@ -98,16 +99,16 @@
     "eslint4b": "^7.3.1",
     "espree": "^9.0.0",
     "mocha": "^10.0.0",
-    "monaco-editor": "^0.34.0",
+    "monaco-editor": "^0.38.0",
     "nyc": "^15.1.0",
     "prettier": "^2.2.1",
     "raw-loader": "^4.0.1",
     "semver": "^7.3.2",
-    "stylelint": "^14.9.1",
+    "stylelint": "^15.0.0",
     "stylelint-config-recommended-vue": "^1.0.0",
-    "stylelint-config-standard": "^29.0.0",
-    "stylelint-stylus": "^0.17.0",
-    "typescript": "~4.9.0",
+    "stylelint-config-standard": "^33.0.0",
+    "stylelint-stylus": "^0.18.0",
+    "typescript": "~5.0.0",
     "vue-eslint-editor": "^1.1.0",
     "vue-eslint-parser": "^9.0.0",
     "vuepress": "^1.5.2",