eslint-plugin-markdown-preferences 0.19.0 → 0.20.0

package/README.md

@@ -118,6 +118,8 @@ The rules with the following star ⭐ are included in the configs.
 | [markdown-preferences/atx-heading-closing-sequence](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-heading-closing-sequence.html) | enforce consistent use of closing sequence in ATX headings. | 🔧 |  |
 | [markdown-preferences/blockquote-marker-alignment](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/blockquote-marker-alignment.html) | enforce consistent alignment of blockquote markers | 🔧 | ⭐ |
 | [markdown-preferences/bullet-list-marker-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/bullet-list-marker-style.html) | enforce consistent bullet list (unordered list) marker style | 🔧 |  |
+| [markdown-preferences/code-fence-length](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-length.html) | enforce consistent code fence length in fenced code blocks. | 🔧 |  |
+| [markdown-preferences/code-fence-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-style.html) | enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks. | 🔧 |  |
 | [markdown-preferences/definitions-last](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html) | require link definitions and footnote definitions to be placed at the end of the document | 🔧 |  |
 | [markdown-preferences/emphasis-delimiters-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/emphasis-delimiters-style.html) | enforce a consistent delimiter style for emphasis and strong emphasis | 🔧 |  |
 | [markdown-preferences/hard-linebreak-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html) | enforce consistent hard linebreak style. | 🔧 | ⭐ |

package/lib/index.d.ts

@@ -35,6 +35,16 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/canonical-code-block-language.html
    */
   'markdown-preferences/canonical-code-block-language'?: Linter.RuleEntry<MarkdownPreferencesCanonicalCodeBlockLanguage>;
+  /**
+   * enforce consistent code fence length in fenced code blocks.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-length.html
+   */
+  'markdown-preferences/code-fence-length'?: Linter.RuleEntry<MarkdownPreferencesCodeFenceLength>;
+  /**
+   * enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-style.html
+   */
+  'markdown-preferences/code-fence-style'?: Linter.RuleEntry<MarkdownPreferencesCodeFenceStyle>;
   /**
    * require link definitions and footnote definitions to be placed at the end of the document
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html
@@ -198,6 +208,18 @@ type MarkdownPreferencesCanonicalCodeBlockLanguage = [] | [{
     [k: string]: string;
   };
 }];
+type MarkdownPreferencesCodeFenceLength = [] | [{
+  length?: number;
+  fallbackLength?: (number | ("minimum" | "as-is"));
+  overrides?: {
+    lang: string;
+    length?: number;
+    fallbackLength?: (number | ("minimum" | "as-is"));
+  }[];
+}];
+type MarkdownPreferencesCodeFenceStyle = [] | [{
+  style?: ("backtick" | "tilde");
+}];
 type MarkdownPreferencesEmojiNotation = [] | [{
   prefer?: ("unicode" | "colon");
   ignoreUnknown?: boolean;
@@ -346,7 +368,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.19.0";
+declare const version: "0.20.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -873,6 +873,108 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 	}
 });
 
+//#endregion
+//#region src/utils/fenced-code-block.ts
+const RE_OPENING_FENCE = /^(`{3,}|~{3,})/u;
+const RE_LANGUAGE = /^(\w*)/u;
+/**
+* Parse the fenced code block.
+*/
+function parseFencedCodeBlock(sourceCode, node) {
+	const loc = sourceCode.getLoc(node);
+	const range = sourceCode.getRange(node);
+	const text = sourceCode.text.slice(...range);
+	const match = RE_OPENING_FENCE.exec(text);
+	if (!match) return null;
+	const [, fenceText] = match;
+	const fenceChar = fenceText[0];
+	let closingFenceText = "";
+	const trimmed = text.trimEnd();
+	const trailingSpacesLength = text.length - trimmed.length;
+	for (let index = trimmed.length - 1; index >= 0; index--) {
+		const c = trimmed[index];
+		if (c === fenceChar || isSpaceOrTab(c)) {
+			closingFenceText = c + closingFenceText;
+			continue;
+		}
+		if (c === "\n") break;
+		return null;
+	}
+	closingFenceText = closingFenceText.trimStart();
+	if (!closingFenceText || !closingFenceText.startsWith(fenceText)) return null;
+	const lines = getParsedLines(sourceCode);
+	const afterOpeningFence = lines.get(loc.start.line).text.slice(fenceText.length);
+	const trimmedAfterOpeningFence = afterOpeningFence.trimStart();
+	const spaceAfterOpeningFenceLength = afterOpeningFence.length - trimmedAfterOpeningFence.length;
+	let languageText = "";
+	if (trimmedAfterOpeningFence) {
+		const langMatch = RE_LANGUAGE.exec(trimmedAfterOpeningFence);
+		languageText = langMatch[1];
+	}
+	const afterLanguage = trimmedAfterOpeningFence.slice(languageText.length);
+	const trimmedAfterLanguage = afterLanguage.trimStart();
+	const spaceAfterLanguageLength = afterLanguage.length - trimmedAfterLanguage.length;
+	const metaText = trimmedAfterLanguage.trimEnd();
+	const openingFence = {
+		text: fenceText,
+		range: [range[0], range[0] + fenceText.length],
+		loc: {
+			start: loc.start,
+			end: {
+				line: loc.start.line,
+				column: loc.start.column + fenceText.length
+			}
+		}
+	};
+	const language$1 = languageText ? {
+		text: languageText,
+		range: [openingFence.range[1] + spaceAfterOpeningFenceLength, openingFence.range[1] + spaceAfterOpeningFenceLength + languageText.length],
+		loc: {
+			start: {
+				line: openingFence.loc.end.line,
+				column: openingFence.loc.end.column + spaceAfterOpeningFenceLength
+			},
+			end: {
+				line: openingFence.loc.end.line,
+				column: openingFence.loc.end.column + spaceAfterOpeningFenceLength + languageText.length
+			}
+		}
+	} : null;
+	const meta = language$1 && metaText ? {
+		text: metaText,
+		range: [language$1.range[1] + spaceAfterLanguageLength, language$1.range[1] + spaceAfterLanguageLength + metaText.length],
+		loc: {
+			start: {
+				line: language$1.loc.end.line,
+				column: language$1.loc.end.column + spaceAfterLanguageLength
+			},
+			end: {
+				line: language$1.loc.end.line,
+				column: language$1.loc.end.column + spaceAfterLanguageLength + metaText.length
+			}
+		}
+	} : null;
+	return {
+		openingFence,
+		language: language$1,
+		meta,
+		closingFence: {
+			text: closingFenceText,
+			range: [range[1] - trailingSpacesLength - closingFenceText.length, range[1] - trailingSpacesLength],
+			loc: {
+				start: {
+					line: loc.end.line,
+					column: loc.end.column - trailingSpacesLength - closingFenceText.length
+				},
+				end: {
+					line: loc.end.line,
+					column: loc.end.column - trailingSpacesLength
+				}
+			}
+		}
+	};
+}
+
 //#endregion
 //#region src/rules/canonical-code-block-language.ts
 const DEFAULT_LANGUAGES = {
@@ -927,23 +1029,204 @@ var canonical_code_block_language_default = createRule("canonical-code-block-lan
 			const canonical = languages[node.lang];
 			const current = node.lang;
 			if (current === canonical) return;
-			const nodeRange = sourceCode.getRange(node);
-			const nodeText = sourceCode.text.slice(nodeRange[0], nodeRange[1]);
-			const fenceRegex = /^(`{3,}|~{3,})(\w*)(?:\s.*)?$/mu;
-			const fenceMatch = fenceRegex.exec(nodeText.split("\n")[0]);
-			if (!fenceMatch) return;
-			const [, fence, langInfo] = fenceMatch;
-			const range = [nodeRange[0] + fence.length, nodeRange[0] + fence.length + langInfo.length];
+			const parsed = parseFencedCodeBlock(sourceCode, node);
+			if (!parsed || !parsed.language) return;
 			context.report({
 				node,
-				loc: getSourceLocationFromRange(sourceCode, node, range),
+				loc: parsed.language.loc,
 				messageId: "useCanonical",
 				data: {
 					canonical,
 					current
 				},
 				fix(fixer) {
-					return fixer.replaceTextRange(range, canonical);
+					return fixer.replaceTextRange(parsed.language.range, canonical);
+				}
+			});
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/code-fence-length.ts
+var code_fence_length_default = createRule("code-fence-length", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent code fence length in fenced code blocks.",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				length: {
+					type: "integer",
+					minimum: 3
+				},
+				fallbackLength: { anyOf: [{
+					type: "integer",
+					minimum: 3
+				}, { enum: ["minimum", "as-is"] }] },
+				overrides: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							lang: { type: "string" },
+							length: {
+								type: "integer",
+								minimum: 3
+							},
+							fallbackLength: { anyOf: [{
+								type: "integer",
+								minimum: 3
+							}, { enum: ["minimum", "as-is"] }] }
+						},
+						required: ["lang"],
+						additionalProperties: false
+					}
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			notMatch: "The opening and closing code fence lengths must match.",
+			notPreferred: "Code fence length should be {{expected}} (was {{actual}})."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = context.options[0] ?? {};
+		/**
+		* Get the effective options for the given code block node.
+		*/
+		function getOptionForCode(node) {
+			const override = options.overrides?.find((o) => o.lang === node.lang);
+			return {
+				length: override?.length ?? options.length ?? 3,
+				fallbackLength: override?.fallbackLength ?? options.fallbackLength ?? "minimum"
+			};
+		}
+		/**
+		* Report the given code block node for not preferred length.
+		*/
+		function reportNotPreferred(node, parsed, length) {
+			const expectedFence = getExpectedFence(parsed, length);
+			context.report({
+				node,
+				loc: parsed.openingFence.loc,
+				data: {
+					expected: expectedFence,
+					actual: parsed.openingFence.text
+				},
+				messageId: "notPreferred",
+				fix(fixer) {
+					return [fixer.replaceTextRange(parsed.openingFence.range, expectedFence), fixer.replaceTextRange(parsed.closingFence.range, expectedFence)];
+				}
+			});
+		}
+		/**
+		* Verify the length of the given code block node.
+		*/
+		function verifyFenceLength(node, parsed) {
+			const { length, fallbackLength } = getOptionForCode(node);
+			if (parsed.openingFence.text.length === length) return true;
+			const expectedFence = getExpectedFence(parsed, length);
+			if (!node.value.includes(expectedFence)) {
+				reportNotPreferred(node, parsed, length);
+				return false;
+			}
+			if (fallbackLength === "as-is") return true;
+			if (fallbackLength === "minimum") {
+				let fallback = length + 1;
+				while (node.value.includes(getExpectedFence(parsed, fallback))) fallback++;
+				if (parsed.openingFence.text.length === fallback) return true;
+				reportNotPreferred(node, parsed, fallback);
+				return false;
+			}
+			if (fallbackLength <= length) return true;
+			if (parsed.openingFence.text.length === fallbackLength) return true;
+			const fallbackExpectedFence = getExpectedFence(parsed, fallbackLength);
+			if (node.value.includes(fallbackExpectedFence)) return true;
+			reportNotPreferred(node, parsed, fallbackLength);
+			return false;
+		}
+		/**
+		* Get the expected fence string for the given length.
+		*/
+		function getExpectedFence(parsed, length) {
+			const fenceChar = parsed.openingFence.text[0];
+			return fenceChar.repeat(Math.max(3, length));
+		}
+		/**
+		* Verify that the opening and closing fence lengths match.
+		*/
+		function verifyClosingFenceLength(node, parsed) {
+			if (parsed.openingFence.text.length === parsed.closingFence.text.length) return true;
+			context.report({
+				node,
+				loc: parsed.closingFence.loc,
+				messageId: "notMatch",
+				fix(fixer) {
+					return [fixer.replaceTextRange(parsed.closingFence.range, parsed.openingFence.text)];
+				}
+			});
+			return false;
+		}
+		return { code(node) {
+			const parsed = parseFencedCodeBlock(sourceCode, node);
+			if (!parsed) return;
+			if (!verifyFenceLength(node, parsed)) return;
+			verifyClosingFenceLength(node, parsed);
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/code-fence-style.ts
+var code_fence_style_default = createRule("code-fence-style", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce a consistent code fence style (backtick or tilde) in Markdown fenced code blocks.",
+			categories: [],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { style: {
+				type: "string",
+				enum: ["backtick", "tilde"]
+			} },
+			additionalProperties: false
+		}],
+		messages: { useCodeFenceStyle: "Use {{expected}} code fence style instead of {{actual}}." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const styleOption = context.options[0]?.style ?? "backtick";
+		const expectedChar = styleOption === "tilde" ? "~" : "`";
+		return { code(node) {
+			const parsed = parseFencedCodeBlock(sourceCode, node);
+			if (!parsed) return;
+			if (parsed.openingFence.text.includes(expectedChar)) return;
+			const expectedOpeningFence = expectedChar.repeat(Math.max(3, parsed.openingFence.text.length));
+			if (node.value.includes(expectedOpeningFence)) return;
+			context.report({
+				node,
+				loc: parsed.openingFence.loc,
+				data: {
+					expected: expectedOpeningFence,
+					actual: parsed.openingFence.text
+				},
+				messageId: "useCodeFenceStyle",
+				fix(fixer) {
+					return [fixer.replaceTextRange(parsed.openingFence.range, expectedOpeningFence), fixer.replaceTextRange(parsed.closingFence.range, expectedChar.repeat(Math.max(3, parsed.closingFence.text.length)))];
 				}
 			});
 		} };
@@ -6950,6 +7233,8 @@ const rules$1 = [
 	blockquote_marker_alignment_default,
 	bullet_list_marker_style_default,
 	canonical_code_block_language_default,
+	code_fence_length_default,
+	code_fence_style_default,
 	definitions_last_default,
 	emoji_notation_default,
 	emphasis_delimiters_style_default,
@@ -7020,7 +7305,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.19.0";
+const version = "0.20.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {