@flint.fyi/plugin-flint 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @flint.fyi/plugin-flint
 
+## 0.2.0
+
+### Minor Changes
+
+- 950e84c: feat(rule-tester): [invalidCodeLines] add rule
+
 ## 0.1.0
 
 ### Minor Changes

package/lib/findProperty.d.ts

@@ -0,0 +1,2 @@
+import * as ts from "typescript";
+export declare function findProperty<Node extends ts.Node>(properties: ts.NodeArray<ts.ObjectLiteralElementLike>, name: string, predicate: (node: ts.Node) => node is Node): (ts.Expression & Node) | undefined;

package/lib/findProperty.js

@@ -0,0 +1,7 @@
+import * as ts from "typescript";
+export function findProperty(properties, name, predicate) {
+    return properties.find((property) => ts.isPropertyAssignment(property) &&
+        ts.isIdentifier(property.name) &&
+        property.name.text === name &&
+        predicate(property.initializer))?.initializer;
+}

package/lib/flint.d.ts

@@ -1,4 +1,8 @@
 export declare const flint: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout, string | undefined, [import("@flint.fyi/core").Rule<{
+    readonly description: "Reports cases for invalid code that isn't formatted across lines.";
+    readonly id: "invalidCodeLines";
+    readonly preset: "logical";
+}, import("@flint.fyi/ts/lib/nodes.js").TSNodesByName, import("@flint.fyi/ts").TypeScriptServices, "singleLineTest", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports test cases that are identical to previous test cases.";
     readonly id: "testCaseDuplicates";
     readonly preset: "logical";

package/lib/flint.js

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

package/lib/getRuleTesterDescribedCases.d.ts

@@ -0,0 +1,5 @@
+import * as ts from "typescript";
+export declare function getRuleTesterDescribedCases(node: ts.CallExpression): {
+    invalid: import("./types.js").ParsedTestCaseInvalid[];
+    valid: import("./types.js").ParsedTestCase[];
+} | undefined;

package/lib/getRuleTesterDescribedCases.js

@@ -0,0 +1,31 @@
+import { isTruthy } from "@flint.fyi/utils";
+import * as ts from "typescript";
+import { findProperty } from "./findProperty.js";
+import { parseTestCase, parseTestCaseInvalid } from "./parseTestCases.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(parseTestCaseInvalid).filter(isTruthy),
+        valid: valid.elements.map(parseTestCase).filter(isTruthy),
+    };
+}

package/lib/parseTestCases.d.ts

@@ -0,0 +1,4 @@
+import * as ts from "typescript";
+import type { ParsedTestCase, ParsedTestCaseInvalid } from "./types.js";
+export declare function parseTestCase(node: ts.Expression): ParsedTestCase | undefined;
+export declare function parseTestCaseInvalid(node: ts.Expression): ParsedTestCaseInvalid | undefined;

package/lib/parseTestCases.js

@@ -0,0 +1,62 @@
+import * as ts from "typescript";
+import { findProperty } from "./findProperty.js";
+import { tsAstToLiteral } from "./tsAstToLiteral.js";
+export function parseTestCase(node) {
+    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) {
+    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/lib/rules/invalidCodeLines.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports cases for invalid code that isn't formatted across lines.";
+    readonly id: "invalidCodeLines";
+    readonly preset: "logical";
+}, import("@flint.fyi/ts/lib/nodes.js").TSNodesByName, import("@flint.fyi/ts").TypeScriptServices, "singleLineTest", undefined>;
+export default _default;

package/lib/rules/invalidCodeLines.js

@@ -0,0 +1,71 @@
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/ts";
+import * as ts from "typescript";
+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) {
+            if (!testCase.code.startsWith("\n")) {
+                context.report({
+                    fix: [createFixForCode(testCase), createFixForSnapshot(testCase)],
+                    message: "singleLineTest",
+                    range: getTSNodeRange(testCase.nodes.code, context.sourceFile),
+                });
+            }
+        }
+        function createFixForCode(testCase) {
+            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) {
+            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/lib/rules/invalidCodeLines.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/rules/invalidCodeLines.test.js

@@ -0,0 +1,197 @@
+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/lib/rules/testCaseDuplicates.js

@@ -1,5 +1,5 @@
 import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/ts";
-import { getRuleTesterDescribedCases, } from "./getRuleTesterDescribedCases.js";
+import { getRuleTesterDescribedCases } from "../getRuleTesterDescribedCases.js";
 export default typescriptLanguage.createRule({
     about: {
         description: "Reports test cases that are identical to previous test cases.",
@@ -31,7 +31,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 {

package/lib/types.d.ts

@@ -0,0 +1,17 @@
+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/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flint.fyi/plugin-flint",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "[Experimental] A Flint plugin for linting Flint plugins.",
   "repository": {
     "type": "git",

package/src/findProperty.ts

@@ -0,0 +1,15 @@
+import * as ts from "typescript";
+
+export 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;
+}

package/src/flint.ts

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

package/src/getRuleTesterDescribedCases.ts

@@ -0,0 +1,48 @@
+import { isTruthy } from "@flint.fyi/utils";
+import * as ts from "typescript";
+
+import { findProperty } from "./findProperty.js";
+import { parseTestCase, parseTestCaseInvalid } from "./parseTestCases.js";
+
+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(parseTestCaseInvalid).filter(isTruthy),
+		valid: valid.elements.map(parseTestCase).filter(isTruthy),
+	};
+}

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,
+	};
+}