eslint-plugin-toml 1.2.1 → 1.3.0

package/README.md

@@ -167,7 +167,9 @@ The rules with the following star :star: are included in the configs.
 | [toml/array-bracket-spacing](https://ota-meshi.github.io/eslint-plugin-toml/rules/array-bracket-spacing.html) | enforce consistent spacing inside array brackets | :wrench: |  | :star: |
 | [toml/array-element-newline](https://ota-meshi.github.io/eslint-plugin-toml/rules/array-element-newline.html) | enforce line breaks between array elements | :wrench: |  | :star: |
 | [toml/comma-style](https://ota-meshi.github.io/eslint-plugin-toml/rules/comma-style.html) | enforce consistent comma style in array | :wrench: |  | :star: |
+| [toml/inline-table-curly-newline](https://ota-meshi.github.io/eslint-plugin-toml/rules/inline-table-curly-newline.html) | enforce linebreaks after opening and before closing braces | :wrench: |  | :star: |
 | [toml/inline-table-curly-spacing](https://ota-meshi.github.io/eslint-plugin-toml/rules/inline-table-curly-spacing.html) | enforce consistent spacing inside braces | :wrench: |  | :star: |
+| [toml/inline-table-key-value-newline](https://ota-meshi.github.io/eslint-plugin-toml/rules/inline-table-key-value-newline.html) | enforce placing inline table key-value pairs on separate lines | :wrench: |  | :star: |
 | [toml/key-spacing](https://ota-meshi.github.io/eslint-plugin-toml/rules/key-spacing.html) | enforce consistent spacing between keys and values in key/value pairs | :wrench: |  | :star: |
 | [toml/spaced-comment](https://ota-meshi.github.io/eslint-plugin-toml/rules/spaced-comment.html) | enforce consistent spacing after the `#` in a comment | :wrench: |  | :star: |
 | [toml/table-bracket-spacing](https://ota-meshi.github.io/eslint-plugin-toml/rules/table-bracket-spacing.html) | enforce consistent spacing inside table brackets | :wrench: |  | :star: |

package/lib/index.mjs

@@ -1173,6 +1173,153 @@ var indent_default = createRule("indent", {
 	}
 });
 
+//#endregion
+//#region src/rules/inline-table-curly-newline.ts
+var inline_table_curly_newline_default = createRule("inline-table-curly-newline", {
+	meta: {
+		docs: {
+			description: "enforce linebreaks after opening and before closing braces",
+			categories: ["standard"],
+			extensionRule: "object-curly-newline"
+		},
+		type: "layout",
+		fixable: "whitespace",
+		schema: [{ oneOf: [{
+			type: "string",
+			enum: ["always", "never"]
+		}, {
+			type: "object",
+			properties: {
+				multiline: { type: "boolean" },
+				minProperties: {
+					type: "integer",
+					minimum: 0
+				},
+				consistent: { type: "boolean" }
+			},
+			additionalProperties: false,
+			minProperties: 1
+		}] }],
+		messages: {
+			unexpectedLinebreakBeforeClosingBrace: "Unexpected line break before this closing brace.",
+			unexpectedLinebreakAfterOpeningBrace: "Unexpected line break after this opening brace.",
+			expectedLinebreakBeforeClosingBrace: "Expected a line break before this closing brace.",
+			expectedLinebreakAfterOpeningBrace: "Expected a line break after this opening brace."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		if (!sourceCode.parserServices?.isTOML) return {};
+		if (context.languageOptions.parserOptions?.tomlVersion) {
+			const tomlVersion = context.languageOptions.parserOptions.tomlVersion.includes(".") && context.languageOptions.parserOptions.tomlVersion.split(".");
+			if (tomlVersion && tomlVersion[0] === "1" && tomlVersion[1] === "0") return {};
+		}
+		/**
+		* Normalizes a given option.
+		* @param value An option value to parse.
+		* @returns Normalized option object.
+		*/
+		function normalizeOptions(value) {
+			let multiline = false;
+			let minProperties = Number.POSITIVE_INFINITY;
+			let consistent = false;
+			if (value) if (value === "always") minProperties = 0;
+			else if (value === "never") minProperties = Number.POSITIVE_INFINITY;
+			else {
+				multiline = Boolean(value.multiline);
+				minProperties = value.minProperties || Number.POSITIVE_INFINITY;
+				consistent = Boolean(value.consistent);
+			}
+			else consistent = true;
+			return {
+				multiline,
+				minProperties,
+				consistent
+			};
+		}
+		const options = normalizeOptions(context.options[0]);
+		/**
+		* Determines if ObjectExpression, ObjectPattern, ImportDeclaration, ExportNamedDeclaration, TSTypeLiteral or TSInterfaceBody
+		* node needs to be checked for missing line breaks
+		* @param node Node under inspection
+		* @param options option specific to node type
+		* @param first First object property
+		* @param last Last object property
+		* @returns `true` if node needs to be checked for missing line breaks
+		*/
+		function areLineBreaksRequired(node, options, first, last) {
+			const objectProperties = node.body;
+			return objectProperties.length >= options.minProperties || options.multiline && objectProperties.length > 0 && !isTokenOnSameLine(last, first);
+		}
+		/**
+		* Reports a given node if it violated this rule.
+		* @param node A node to check. This is an ObjectExpression, ObjectPattern, ImportDeclaration, ExportNamedDeclaration, TSTypeLiteral or TSInterfaceBody node.
+		*/
+		function check(node) {
+			const openBrace = sourceCode.getFirstToken(node, (token) => token.value === "{");
+			const closeBrace = sourceCode.getLastToken(node, (token) => token.value === "}");
+			const firstTokenOrComment = sourceCode.getTokenAfter(openBrace, { includeComments: true });
+			const lastTokenOrComment = sourceCode.getTokenBefore(closeBrace, { includeComments: true });
+			const needsLineBreaks = areLineBreaksRequired(node, options, firstTokenOrComment, lastTokenOrComment);
+			const hasCommentsFirstToken = isCommentToken(firstTokenOrComment);
+			const hasCommentsLastToken = isCommentToken(lastTokenOrComment);
+			/**
+			* Use tokens or comments to check multiline or not.
+			* But use only tokens to check whether line breaks are needed.
+			* This allows:
+			*     obj = { # eslint-disable-line foo
+			*         a: 1
+			*     }
+			*/
+			const firstToken = sourceCode.getTokenAfter(openBrace);
+			const lastToken = sourceCode.getTokenBefore(closeBrace);
+			if (needsLineBreaks) {
+				if (isTokenOnSameLine(openBrace, firstToken)) context.report({
+					messageId: "expectedLinebreakAfterOpeningBrace",
+					node,
+					loc: openBrace.loc,
+					fix(fixer) {
+						if (hasCommentsFirstToken) return null;
+						return fixer.insertTextAfter(openBrace, "\n");
+					}
+				});
+				if (isTokenOnSameLine(lastToken, closeBrace)) context.report({
+					messageId: "expectedLinebreakBeforeClosingBrace",
+					node,
+					loc: closeBrace.loc,
+					fix(fixer) {
+						if (hasCommentsLastToken) return null;
+						return fixer.insertTextBefore(closeBrace, "\n");
+					}
+				});
+			} else {
+				const consistent = options.consistent;
+				const hasLineBreakBetweenOpenBraceAndFirst = !isTokenOnSameLine(openBrace, firstToken);
+				const hasLineBreakBetweenCloseBraceAndLast = !isTokenOnSameLine(lastToken, closeBrace);
+				if (!consistent && hasLineBreakBetweenOpenBraceAndFirst || consistent && hasLineBreakBetweenOpenBraceAndFirst && !hasLineBreakBetweenCloseBraceAndLast) context.report({
+					messageId: "unexpectedLinebreakAfterOpeningBrace",
+					node,
+					loc: openBrace.loc,
+					fix(fixer) {
+						if (hasCommentsFirstToken) return null;
+						return fixer.removeRange([openBrace.range[1], firstToken.range[0]]);
+					}
+				});
+				if (!consistent && hasLineBreakBetweenCloseBraceAndLast || consistent && !hasLineBreakBetweenOpenBraceAndFirst && hasLineBreakBetweenCloseBraceAndLast) context.report({
+					messageId: "unexpectedLinebreakBeforeClosingBrace",
+					node,
+					loc: closeBrace.loc,
+					fix(fixer) {
+						if (hasCommentsLastToken) return null;
+						return fixer.removeRange([lastToken.range[1], closeBrace.range[0]]);
+					}
+				});
+			}
+		}
+		return { TOMLInlineTable: check };
+	}
+});
+
 //#endregion
 //#region src/rules/inline-table-curly-spacing.ts
 /**
@@ -1183,7 +1330,7 @@ var indent_default = createRule("indent", {
 * @param sourceCode The source code object, used to get nodes by range index.
 * @returns An object containing the spacing option, the emptyObjects option, and two functions to determine if there should be spaces after the opening curly brace and before the closing curly brace.
 */
-function parseOptions(options, sourceCode) {
+function parseOptions$1(options, sourceCode) {
 	const spaced = options[0] ?? "always";
 	/**
 	* Determines whether an option is set, relative to the spacing option.
@@ -1267,7 +1414,7 @@ var inline_table_curly_spacing_default = createRule("inline-table-curly-spacing"
 	create(context) {
 		const sourceCode = context.sourceCode;
 		if (!sourceCode.parserServices?.isTOML) return {};
-		const options = parseOptions(context.options, sourceCode);
+		const options = parseOptions$1(context.options, sourceCode);
 		/**
 		* Reports that there shouldn't be a space after the first token
 		* @param node The node to report in the event of an error.
@@ -1442,6 +1589,78 @@ var inline_table_curly_spacing_default = createRule("inline-table-curly-spacing"
 	}
 });
 
+//#endregion
+//#region src/rules/inline-table-key-value-newline.ts
+/**
+* Parses the options for the rule and returns a normalized options object.
+* @param options The raw options provided to the rule.
+* @returns A normalized options object with default values applied.
+*/
+function parseOptions(options) {
+	return { allowAllPropertiesOnSameLine: options?.allowAllPropertiesOnSameLine ?? true };
+}
+var inline_table_key_value_newline_default = createRule("inline-table-key-value-newline", {
+	meta: {
+		docs: {
+			description: "enforce placing inline table key-value pairs on separate lines",
+			categories: ["standard"],
+			extensionRule: "object-property-newline"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { allowAllPropertiesOnSameLine: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		messages: {
+			propertiesOnNewlineAll: "Inline table key-value pairs must go on a new line if they aren't all on the same line.",
+			propertiesOnNewline: "Inline table key-value pairs must go on a new line."
+		},
+		type: "layout"
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		if (!sourceCode.parserServices?.isTOML) return {};
+		if (context.languageOptions.parserOptions?.tomlVersion) {
+			const tomlVersion = context.languageOptions.parserOptions.tomlVersion.includes(".") && context.languageOptions.parserOptions.tomlVersion.split(".");
+			if (tomlVersion && tomlVersion[0] === "1" && tomlVersion[1] === "0") return {};
+		}
+		const allowSameLine = parseOptions(context.options[0]).allowAllPropertiesOnSameLine;
+		const messageId = allowSameLine ? "propertiesOnNewlineAll" : "propertiesOnNewline";
+		/**
+		* Checks whether the given tokens are on the same line.
+		* @param token1 The first token to compare.
+		* @param token2 The second token to compare.
+		* @returns True if the tokens are on the same line, false otherwise.
+		*/
+		function check(node, children) {
+			if (allowSameLine) {
+				if (children.length > 1) {
+					if (isTokenOnSameLine(sourceCode.getFirstToken(children[0]), sourceCode.getLastToken(children[children.length - 1]))) return;
+				}
+			}
+			for (let i = 1; i < children.length; i++) {
+				const lastTokenOfPreviousProperty = sourceCode.getLastToken(children[i - 1]);
+				const firstTokenOfCurrentProperty = sourceCode.getFirstToken(children[i]);
+				if (isTokenOnSameLine(lastTokenOfPreviousProperty, firstTokenOfCurrentProperty)) context.report({
+					node,
+					loc: firstTokenOfCurrentProperty.loc,
+					messageId,
+					fix(fixer) {
+						const rangeAfterComma = [sourceCode.getTokenBefore(firstTokenOfCurrentProperty).range[1], firstTokenOfCurrentProperty.range[0]];
+						if (sourceCode.text.slice(rangeAfterComma[0], rangeAfterComma[1]).trim()) return null;
+						return fixer.replaceTextRange(rangeAfterComma, "\n");
+					}
+				});
+			}
+		}
+		return { TOMLInlineTable(node) {
+			check(node, node.body);
+		} };
+	}
+});
+
 //#endregion
 //#region src/rules/key-spacing.ts
 /**
@@ -3094,7 +3313,9 @@ const rules$1 = [
 	array_element_newline_default,
 	comma_style_default,
 	indent_default,
+	inline_table_curly_newline_default,
 	inline_table_curly_spacing_default,
+	inline_table_key_value_newline_default,
 	key_spacing_default,
 	keys_order_default,
 	no_mixed_type_in_array_default,
@@ -3143,7 +3364,9 @@ var standard_default = [...base_default, { rules: {
 	"toml/array-element-newline": "error",
 	"toml/comma-style": "error",
 	"toml/indent": "error",
+	"toml/inline-table-curly-newline": "error",
 	"toml/inline-table-curly-spacing": "error",
+	"toml/inline-table-key-value-newline": "error",
 	"toml/key-spacing": "error",
 	"toml/keys-order": "error",
 	"toml/no-space-dots": "error",
@@ -3162,7 +3385,7 @@ var standard_default = [...base_default, { rules: {
 //#endregion
 //#region package.json
 var name$1 = "eslint-plugin-toml";
-var version$1 = "1.2.1";
+var version$1 = "1.3.0";
 
 //#endregion
 //#region src/meta.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-toml",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "This ESLint plugin provides linting rules for TOML.",
   "type": "module",
   "exports": {