@flint.fyi/plugin-flint 0.2.0 → 0.2.1

package/src/rules/invalidCodeLines.test.ts

@@ -1,198 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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/ruleTester.ts

@@ -1,4 +0,0 @@
-import { RuleTester } from "@flint.fyi/rule-tester";
-import { describe, it } from "vitest";
-
-export const ruleTester = new RuleTester({ describe, it });

package/src/rules/testCaseDuplicates.test.ts

@@ -1,174 +0,0 @@
-import { ruleTester } from "./ruleTester.js";
-import rule from "./testCaseDuplicates.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-                ruleTester.describe(rule, {
-                    valid: ['a', 'a'],
-                    invalid: []
-                });
-            `,
-			snapshot: `
-                ruleTester.describe(rule, {
-                    valid: ['a', 'a'],
-                                 ~~~
-                                 This test code already appeared in a previous test.
-                    invalid: []
-                });
-            `,
-		},
-		{
-			code: `
-                ruleTester.describe(rule, {
-                    valid: [
-                        'a',
-                        "a",
-                    ],
-                    invalid: []
-                });
-            `,
-			snapshot: `
-                ruleTester.describe(rule, {
-                    valid: [
-                        'a',
-                        "a",
-                        ~~~
-                        This test code already appeared in a previous test.
-                    ],
-                    invalid: []
-                });
-            `,
-		},
-		{
-			code: `
-                ruleTester.describe(rule, {
-                    valid: [
-                        \`a\`,
-                        \`a\`,
-                    ],
-                    invalid: []
-                });
-            `,
-			snapshot: `
-                ruleTester.describe(rule, {
-                    valid: [
-                        \`a\`,
-                        \`a\`,
-                        ~~~
-                        This test code already appeared in a previous test.
-                    ],
-                    invalid: []
-                });
-            `,
-		},
-		{
-			code: `
-                ruleTester.describe(rule, {
-                    valid: [
-                        { code: "a" },
-                        { code: "a" },
-                    ],
-                    invalid: []
-                });
-            `,
-			snapshot: `
-                ruleTester.describe(rule, {
-                    valid: [
-                        { code: "a" },
-                        { code: "a" },
-                        ~~~~~~~~~~~~~
-                        This test code already appeared in a previous test.
-                    ],
-                    invalid: []
-                });
-            `,
-		},
-		{
-			code: `
-                ruleTester.describe(rule, {
-                    valid: [
-                        { code: "a", fileName: "b.ts" },
-                        { code: "a", fileName: "b.ts" },
-                    ],
-                    invalid: []
-                });
-            `,
-			snapshot: `
-                ruleTester.describe(rule, {
-                    valid: [
-                        { code: "a", fileName: "b.ts" },
-                        { code: "a", fileName: "b.ts" },
-                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-                        This test code already appeared in a previous test.
-                    ],
-                    invalid: []
-                });
-            `,
-		},
-		{
-			code: `
-                ruleTester.describe(rule, {
-                    valid: [
-                        { code: "a", fileName: "b.ts", options: { c: "d" } },
-                        { code: "a", fileName: "b.ts", options: { c: "d" } },
-                    ],
-                    invalid: []
-                });
-            `,
-			snapshot: `
-                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.
-                    ],
-                    invalid: []
-                });
-            `,
-		},
-	],
-	valid: [
-		`
-            describe(rule, {
-                valid: ['a', 'a'],
-                invalid: []
-            });
-        `,
-		`
-            ruleTester.describe(rule, {
-                valid: ['a', 'b'],
-                invalid: []
-            });
-        `,
-		`
-            ruleTester.describe(rule, {
-                valid: [
-                    { code: \`a\`, fileName: "b.ts" },
-                    { code: \`a\`, fileName: "c.ts" },
-                ],
-                invalid: []
-            });
-        `,
-		`
-            ruleTester.describe(rule, {
-                valid: [
-                    { code: \`a\`, fileName: "b.ts", options: { c: "d" } },
-                    { code: \`a\`, fileName: "b.ts", options: { c: "e" } },
-                ],
-                invalid: []
-            });
-        `,
-		`
-            ruleTester.describe(rule, {
-                valid: [
-                    { code: \`a\`, fileName: "b.ts", options: { c: "d" } },
-                    { code: \`a\`, fileName: "c.ts", options: { c: "d" } },
-                ],
-                invalid: []
-            });
-        `,
-	],
-});

package/src/rules/testCaseDuplicates.ts

@@ -1,63 +0,0 @@
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/ts";
-
-import type { ParsedTestCase } from "../types.js";
-
-import { getRuleTesterDescribedCases } from "../getRuleTesterDescribedCases.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		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: [
-				"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.",
-			],
-		},
-	},
-	setup(context) {
-		function checkTestCases(testCases: ParsedTestCase[]) {
-			const seen = new Set<string>();
-
-			for (const testCase of testCases) {
-				const key = JSON.stringify({
-					code: testCase.code,
-					fileName: testCase.fileName,
-					options: testCase.options,
-				});
-
-				if (seen.has(key)) {
-					context.report({
-						message: "duplicateTest",
-						range: getTSNodeRange(testCase.nodes.case, context.sourceFile),
-					});
-				} else {
-					seen.add(key);
-				}
-			}
-		}
-
-		return {
-			visitors: {
-				CallExpression(node) {
-					const describedCases = getRuleTesterDescribedCases(node);
-					if (!describedCases) {
-						return;
-					}
-
-					checkTestCases(describedCases.invalid);
-					checkTestCases(describedCases.valid);
-				},
-			},
-		};
-	},
-});

package/src/tsAstToLiteral.ts

@@ -1,55 +0,0 @@
-// Fork of ts-ast-to-literal pending:
-// https://github.com/dword-design/ts-ast-to-literal/issues/89
-
-// Changing from the switch to manual ifs is due to:
-// https://github.com/Microsoft/TypeScript/issues/56275
-
-import ts from "typescript";
-
-export function tsAstToLiteral(node: ts.ArrayLiteralExpression): unknown[];
-export function tsAstToLiteral(node: ts.ObjectLiteralExpression): object;
-export function tsAstToLiteral(node: ts.Node): unknown;
-export function tsAstToLiteral(node: ts.Node): unknown {
-	switch (node.kind) {
-		case ts.SyntaxKind.FalseKeyword:
-			return false;
-		case ts.SyntaxKind.NullKeyword:
-			return null;
-		case ts.SyntaxKind.TrueKeyword:
-			return true;
-	}
-
-	if (ts.isArrayLiteralExpression(node)) {
-		return node.elements
-			.filter((element) => element.kind !== ts.SyntaxKind.SpreadElement)
-			.map((element) => tsAstToLiteral(element));
-	}
-
-	if (ts.isNumericLiteral(node)) {
-		return parseFloat(node.text);
-	}
-
-	if (ts.isObjectLiteralExpression(node)) {
-		return Object.fromEntries(
-			node.properties
-				.filter(
-					(
-						property,
-					): property is ts.PropertyAssignment & { name: ts.Identifier } =>
-						ts.isPropertyAssignment(property) &&
-						(property.name.kind === ts.SyntaxKind.Identifier ||
-							property.name.kind === ts.SyntaxKind.StringLiteral),
-				)
-				.map((property) => [
-					property.name.escapedText || property.name.text,
-					tsAstToLiteral(property.initializer),
-				]),
-		);
-	}
-
-	if (ts.isStringLiteral(node)) {
-		return node.text;
-	}
-
-	return undefined;
-}

package/src/types.ts

@@ -1,22 +0,0 @@
-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;
-}

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-	"compilerOptions": {
-		"outDir": "lib",
-		"rootDir": "src"
-	},
-	"extends": "../../tsconfig.base.json",
-	"include": ["src"],
-	"references": [
-		{ "path": "../core" },
-		{ "path": "../rule-tester" },
-		{ "path": "../ts" },
-		{ "path": "../utils" }
-	]
-}