@flint.fyi/plugin-flint 0.0.2 → 0.2.0

package/src/parseTestCases.ts

@@ -0,0 +1,96 @@
+import * as ts from "typescript";
+
+import type { ParsedTestCase, ParsedTestCaseInvalid } from "./types.js";
+
+import { findProperty } from "./findProperty.js";
+import { tsAstToLiteral } from "./tsAstToLiteral.js";
+
+export function parseTestCase(node: ts.Expression): ParsedTestCase | undefined {
+	if (ts.isStringLiteralLike(node)) {
+		return {
+			code: node.text,
+			nodes: {
+				case: node,
+				code: node,
+			},
+		};
+	}
+
+	if (!ts.isObjectLiteralExpression(node)) {
+		return undefined;
+	}
+
+	const code = findProperty(node.properties, "code", ts.isStringLiteralLike);
+	if (!code) {
+		return undefined;
+	}
+
+	const fileName = findProperty(
+		node.properties,
+		"fileName",
+		ts.isStringLiteralLike,
+	);
+	const options = findProperty(
+		node.properties,
+		"options",
+		ts.isObjectLiteralExpression,
+	);
+
+	return {
+		code: code.text,
+		fileName: fileName?.text,
+		nodes: {
+			case: node,
+			code,
+			fileName,
+			options,
+		},
+		options: options && tsAstToLiteral(options),
+	};
+}
+
+export function parseTestCaseInvalid(
+	node: ts.Expression,
+): ParsedTestCaseInvalid | undefined {
+	if (!ts.isObjectLiteralExpression(node)) {
+		return undefined;
+	}
+
+	const code = findProperty(node.properties, "code", ts.isStringLiteralLike);
+	if (!code) {
+		return undefined;
+	}
+
+	const fileName = findProperty(
+		node.properties,
+		"fileName",
+		ts.isStringLiteralLike,
+	);
+	const options = findProperty(
+		node.properties,
+		"options",
+		ts.isObjectLiteralExpression,
+	);
+	const snapshot = findProperty(
+		node.properties,
+		"snapshot",
+		ts.isStringLiteralLike,
+	);
+	if (!snapshot) {
+		return undefined;
+	}
+
+	return {
+		code: code.text,
+		fileName: fileName?.text,
+		nodes: {
+			case: node,
+			code,
+			fileName,
+			options,
+			snapshot,
+		},
+		options: options && tsAstToLiteral(options),
+		snapshot: snapshot.text,
+	};
+}

package/src/rules/invalidCodeLines.test.ts

@@ -0,0 +1,198 @@
+import rule from "./invalidCodeLines.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: "",
+        snapshot: \`
+~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+			output: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`
+
+\`,
+        snapshot: \`
+~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+			snapshot: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: "",
+              ~~
+              This code block should be formatted across multiple lines for more readable reports.
+        snapshot: \`
+~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+		},
+		{
+			code: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`console.log(
+);\`,
+        snapshot: \`console.log(
+);
+~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+			output: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`
+console.log(
+);
+\`,
+        snapshot: \`
+console.log(
+);
+~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+			snapshot: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`console.log(
+              ~~~~~~~~~~~~~
+              This code block should be formatted across multiple lines for more readable reports.
+);\`,
+~~~
+        snapshot: \`console.log(
+);
+~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+		},
+		{
+			code: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`console.log();\`,
+        snapshot: \`console.log();
+~~~~~~~~~~~~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+			output: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`
+console.log();
+\`,
+        snapshot: \`
+console.log();
+~~~~~~~~~~~~~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+			snapshot: `
+ruleTester.describe(rule, {
+    valid: ['a', 'a'],
+    invalid: [
+      {
+        code: \`console.log();\`,
+              ~~~~~~~~~~~~~~~~
+              This code block should be formatted across multiple lines for more readable reports.
+        snapshot: \`console.log();
+~~~~~~~~~~~~
+Rule report message.
+\`,
+      }
+    ],
+});
+`,
+		},
+	],
+	valid: [
+		`
+            ruleTester.describe(rule, {
+                valid: [],
+                invalid: []
+            });
+    `,
+		`
+            ruleTester.describe(rule, {
+                valid: [],
+                invalid: [
+                {
+                    code: \`
+\`,
+                    snapshot: \`
+~
+\`,
+    }
+                ],
+            });
+    `,
+		`
+            ruleTester.describe(rule, {
+                valid: [],
+                invalid: [
+                {
+                    code: \`
+console.log();
+\`,
+                    snapshot: \`
+~~~~~~~~~~~~
+Rule report message.
+\`,
+    }
+                ],
+            });
+    `,
+	],
+});

package/src/rules/invalidCodeLines.ts

@@ -0,0 +1,84 @@
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/ts";
+import * as ts from "typescript";
+
+import type { ParsedTestCaseInvalid } from "../types.js";
+
+import { getRuleTesterDescribedCases } from "../getRuleTesterDescribedCases.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports cases for invalid code that isn't formatted across lines.",
+		id: "invalidCodeLines",
+		preset: "logical",
+	},
+	messages: {
+		singleLineTest: {
+			primary:
+				"This code block should be formatted across multiple lines for more readable reports.",
+			secondary: [
+				"When writing `invalid` case code blocks, it's better to start code on a new line in a template literal string.",
+				"Doing so allows the case's `snapshot` to visualize the `~` characters visually underneath reported ranges.",
+			],
+			suggestions: [
+				"Delete this redundant test case.",
+				"Change a property to make the test case unique.",
+			],
+		},
+	},
+	setup(context) {
+		function checkTestCase(testCase: ParsedTestCaseInvalid) {
+			if (!testCase.code.startsWith("\n")) {
+				context.report({
+					fix: [createFixForCode(testCase), createFixForSnapshot(testCase)],
+					message: "singleLineTest",
+					range: getTSNodeRange(testCase.nodes.code, context.sourceFile),
+				});
+			}
+		}
+
+		function createFixForCode(testCase: ParsedTestCaseInvalid) {
+			if (ts.isStringLiteral(testCase.nodes.code)) {
+				return {
+					range: getTSNodeRange(testCase.nodes.code, context.sourceFile),
+					text: `\`\n${testCase.code}\n\``,
+				};
+			}
+
+			const begin = testCase.nodes.code.getStart(context.sourceFile) + 1;
+
+			return {
+				range: {
+					begin,
+					end: begin,
+				},
+				text: "\n",
+			};
+		}
+
+		function createFixForSnapshot(testCase: ParsedTestCaseInvalid) {
+			const begin = testCase.nodes.snapshot.getStart(context.sourceFile) + 1;
+
+			return {
+				range: {
+					begin,
+					end: begin,
+				},
+				text: "\n",
+			};
+		}
+
+		return {
+			visitors: {
+				CallExpression(node) {
+					const describedCases = getRuleTesterDescribedCases(node);
+					if (!describedCases) {
+						return;
+					}
+
+					describedCases.invalid.forEach(checkTestCase);
+				},
+			},
+		};
+	},
+});

package/src/rules/{duplicateTestCases.test.ts → testCaseDuplicates.test.ts}

@@ -1,5 +1,5 @@
-import rule from "./duplicateTestCases.js";
 import { ruleTester } from "./ruleTester.js";
+import rule from "./testCaseDuplicates.js";
 
 ruleTester.describe(rule, {
 	invalid: [
@@ -13,8 +13,8 @@ ruleTester.describe(rule, {
 			snapshot: `
                 ruleTester.describe(rule, {
                     valid: ['a', 'a'],
-                                ~~~
-                                This test code already appeared in a previous test.
+                                 ~~~
+                                 This test code already appeared in a previous test.
                     invalid: []
                 });
             `,
@@ -34,8 +34,8 @@ ruleTester.describe(rule, {
                     valid: [
                         'a',
                         "a",
-                       ~~~
-                       This test code already appeared in a previous test.
+                        ~~~
+                        This test code already appeared in a previous test.
                     ],
                     invalid: []
                 });
@@ -56,8 +56,8 @@ ruleTester.describe(rule, {
                     valid: [
                         \`a\`,
                         \`a\`,
-                       ~~~
-                       This test code already appeared in a previous test.
+                        ~~~
+                        This test code already appeared in a previous test.
                     ],
                     invalid: []
                 });
@@ -78,8 +78,8 @@ ruleTester.describe(rule, {
                     valid: [
                         { code: "a" },
                         { code: "a" },
-                       ~~~~~~~~~~~~~
-                       This test code already appeared in a previous test.
+                        ~~~~~~~~~~~~~
+                        This test code already appeared in a previous test.
                     ],
                     invalid: []
                 });
@@ -100,8 +100,8 @@ ruleTester.describe(rule, {
                     valid: [
                         { code: "a", fileName: "b.ts" },
                         { code: "a", fileName: "b.ts" },
-                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-                       This test code already appeared in a previous test.
+                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                        This test code already appeared in a previous test.
                     ],
                     invalid: []
                 });
@@ -122,8 +122,8 @@ ruleTester.describe(rule, {
                     valid: [
                         { code: "a", fileName: "b.ts", options: { c: "d" } },
                         { code: "a", fileName: "b.ts", options: { c: "d" } },
-                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-                       This test code already appeared in a previous test.
+                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                        This test code already appeared in a previous test.
                     ],
                     invalid: []
                 });

package/src/rules/{duplicateTestCases.ts → testCaseDuplicates.ts}

@@ -1,19 +1,23 @@
 import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/ts";
 
-import {
-	getRuleTesterDescribedCases,
-	ParsedTestCase,
-} from "./getRuleTesterDescribedCases.js";
+import type { ParsedTestCase } from "../types.js";
+
+import { getRuleTesterDescribedCases } from "../getRuleTesterDescribedCases.js";
 
 export default typescriptLanguage.createRule({
 	about: {
-		id: "duplicateTestCases",
+		description:
+			"Reports test cases that are identical to previous test cases.",
+		id: "testCaseDuplicates",
 		preset: "logical",
 	},
 	messages: {
 		duplicateTest: {
 			primary: "This test code already appeared in a previous test.",
-			secondary: ["TODO"],
+			secondary: [
+				"When writing tests for lint rules, it's possible to accidentally create deeply identical test cases.",
+				"Doing so provides no added benefit for testing and is unnecessary.",
+			],
 			suggestions: [
 				"Delete this redundant test case.",
 				"Change a property to make the test case unique.",
@@ -34,7 +38,7 @@ export default typescriptLanguage.createRule({
 				if (seen.has(key)) {
 					context.report({
 						message: "duplicateTest",
-						range: getTSNodeRange(testCase.node, context.sourceFile),
+						range: getTSNodeRange(testCase.nodes.case, context.sourceFile),
 					});
 				} else {
 					seen.add(key);

package/src/types.ts

@@ -0,0 +1,22 @@
+import type { InvalidTestCase, TestCase } from "@flint.fyi/rule-tester";
+
+import * as ts from "typescript";
+
+export interface ParsedTestCase extends TestCase {
+	nodes: ParsedTestCaseNodes;
+}
+
+export interface ParsedTestCaseInvalid extends InvalidTestCase {
+	nodes: ParsedTestCaseNodesInvalid;
+}
+
+export interface ParsedTestCaseNodes {
+	case: ts.Node;
+	code: ts.StringLiteralLike;
+	fileName?: ts.StringLiteralLike;
+	options?: ts.ObjectLiteralExpression;
+}
+
+export interface ParsedTestCaseNodesInvalid extends ParsedTestCaseNodes {
+	snapshot: ts.Node;
+}