@flint.fyi/plugin-flint 0.1.0 → 0.2.1

package/lib/rules/getRuleTesterDescribedCases.js

@@ -1,59 +0,0 @@
-import { isTruthy } from "@flint.fyi/utils";
-import * as ts from "typescript";
-import { tsAstToLiteral } from "./tsAstToLiteral.js";
-export function getRuleTesterDescribedCases(node) {
-    if (!ts.isPropertyAccessExpression(node.expression) ||
-        !ts.isIdentifier(node.expression.expression) ||
-        !ts.isIdentifier(node.expression.name) ||
-        node.expression.name.text !== "describe" ||
-        node.arguments.length !== 2) {
-        return undefined;
-    }
-    // TODO: Check node.expression.expression's type for being a RuleTester
-    // https://github.com/JoshuaKGoldberg/flint/issues/152
-    const argument = node.arguments[1];
-    if (!ts.isObjectLiteralExpression(argument)) {
-        return undefined;
-    }
-    const invalid = findProperty(argument.properties, "invalid", ts.isArrayLiteralExpression);
-    if (!invalid) {
-        return undefined;
-    }
-    const valid = findProperty(argument.properties, "valid", ts.isArrayLiteralExpression);
-    if (!valid) {
-        return undefined;
-    }
-    return {
-        invalid: invalid.elements.map(parseTestCase).filter(isTruthy),
-        valid: valid.elements.map(parseTestCase).filter(isTruthy),
-    };
-}
-function findProperty(properties, name, predicate) {
-    return properties.find((property) => ts.isPropertyAssignment(property) &&
-        ts.isIdentifier(property.name) &&
-        property.name.text === name &&
-        predicate(property.initializer))?.initializer;
-}
-function parseTestCase(node) {
-    if (ts.isStringLiteralLike(node)) {
-        return {
-            code: node.text,
-            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,
-        node,
-        options: options && tsAstToLiteral(options),
-    };
-}

package/src/flint.ts

@@ -1,8 +0,0 @@
-import { createPlugin } from "@flint.fyi/core";
-
-import testCaseDuplicates from "./rules/testCaseDuplicates.js";
-
-export const flint = createPlugin({
-	name: "flint",
-	rules: [testCaseDuplicates],
-});

package/src/index.ts

@@ -1 +0,0 @@
-export * from "./flint.js";

package/src/rules/getRuleTesterDescribedCases.ts

@@ -1,102 +0,0 @@
-import { TestCase } from "@flint.fyi/rule-tester";
-import { isTruthy } from "@flint.fyi/utils";
-import * as ts from "typescript";
-
-import { tsAstToLiteral } from "./tsAstToLiteral.js";
-
-export interface ParsedTestCase extends TestCase {
-	node: ts.Node;
-}
-
-export function getRuleTesterDescribedCases(node: ts.CallExpression) {
-	if (
-		!ts.isPropertyAccessExpression(node.expression) ||
-		!ts.isIdentifier(node.expression.expression) ||
-		!ts.isIdentifier(node.expression.name) ||
-		node.expression.name.text !== "describe" ||
-		node.arguments.length !== 2
-	) {
-		return undefined;
-	}
-
-	// TODO: Check node.expression.expression's type for being a RuleTester
-	// https://github.com/JoshuaKGoldberg/flint/issues/152
-
-	const argument = node.arguments[1];
-	if (!ts.isObjectLiteralExpression(argument)) {
-		return undefined;
-	}
-
-	const invalid = findProperty(
-		argument.properties,
-		"invalid",
-		ts.isArrayLiteralExpression,
-	);
-	if (!invalid) {
-		return undefined;
-	}
-
-	const valid = findProperty(
-		argument.properties,
-		"valid",
-		ts.isArrayLiteralExpression,
-	);
-	if (!valid) {
-		return undefined;
-	}
-
-	return {
-		invalid: invalid.elements.map(parseTestCase).filter(isTruthy),
-		valid: valid.elements.map(parseTestCase).filter(isTruthy),
-	};
-}
-
-function findProperty<Node extends ts.Node>(
-	properties: ts.NodeArray<ts.ObjectLiteralElementLike>,
-	name: string,
-	predicate: (node: ts.Node) => node is Node,
-) {
-	return properties.find(
-		(property): property is ts.PropertyAssignment & { initializer: Node } =>
-			ts.isPropertyAssignment(property) &&
-			ts.isIdentifier(property.name) &&
-			property.name.text === name &&
-			predicate(property.initializer),
-	)?.initializer;
-}
-
-function parseTestCase(node: ts.Expression): ParsedTestCase | undefined {
-	if (ts.isStringLiteralLike(node)) {
-		return {
-			code: node.text,
-			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,
-		node,
-		options: options && tsAstToLiteral(options),
-	};
-}

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,64 +0,0 @@
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/ts";
-
-import {
-	getRuleTesterDescribedCases,
-	ParsedTestCase,
-} 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.node, 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/rules/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/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" }
-	]
-}