@shivaedev/quality 0.2.0 → 0.3.0

package/src/rules/suppressions/no-inline.ts

@@ -0,0 +1,63 @@
+import { Effect, Schema } from "effect";
+import ignore from "ignore";
+import { CONFIG_FILE } from "../../config/file.ts";
+import { defineRule, type Finding, type RuleInputs } from "../../rule.ts";
+import { type SourceComment, scanComments } from "../comments/scan.ts";
+import { suppressionIn } from "./directives.ts";
+import { STYLESHEET, stylesheetComments } from "./stylesheet-comments.ts";
+
+const Declaration = Schema.Struct({
+	directive: Schema.Literal("@ts-expect-error"),
+	includes: Schema.NonEmptyArray(Schema.NonEmptyString),
+	reason: Schema.String.check(Schema.isPattern(/\S/, { expected: "a reason that says why these files assert type errors" })),
+});
+
+type Declaration = typeof Declaration.Type;
+
+const NoInlineOptions = Schema.Struct({
+	declared: Schema.Array(Declaration).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
+});
+
+interface Site extends Finding {
+	readonly subject: string;
+}
+
+const sitesIn = (file: string, comments: ReadonlyArray<SourceComment>): ReadonlyArray<Site> =>
+	comments.flatMap((comment) => {
+		const directive = suppressionIn(comment);
+		return directive === undefined ? [] : [{ file, line: comment.line, message: `Suppresses a check: "${directive}".`, subject: directive }];
+	});
+
+const stylesheetSites = async ({ files, readText, sources }: RuleInputs): Promise<ReadonlyArray<Site>> => {
+	const read = files.filter((path) => STYLESHEET.test(path));
+	const texts = await Promise.all(read.map(async (path) => sources.find((source) => source.path === path)?.text ?? (await readText(path))));
+	return read.flatMap((path, index) => sitesIn(path, stylesheetComments(path, texts[index] ?? "")));
+};
+
+const allows = (declaration: Declaration, site: Site): boolean =>
+	declaration.directive === site.subject &&
+	ignore()
+		.add([...declaration.includes])
+		.ignores(site.file);
+
+const unused = (declaration: Declaration): Finding => ({
+	file: CONFIG_FILE,
+	message: `Declares "${declaration.directive}" for ${declaration.includes.map((glob) => `"${glob}"`).join(", ")}, which matches no directive. Remove the declaration.`,
+	subject: declaration.directive,
+});
+
+export const noInline = defineRule({
+	id: "suppressions/no-inline",
+	description:
+		"A suppression silences a check at one site instead of fixing the cause. Fix the code; where a lint rule truly cannot apply, turn it off for that scope in the Biome config and declare it under suppressions/biome-overrides.",
+	options: Schema.toStandardSchemaV1(NoInlineOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+	registrable: false,
+	check: async (inputs) => {
+		const { declared } = inputs.options;
+		const sites = [...inputs.sources.flatMap((file) => sitesIn(file.path, scanComments(file))), ...(await stylesheetSites(inputs))];
+		return [
+			...sites.filter((site) => !declared.some((declaration) => allows(declaration, site))),
+			...declared.filter((declaration) => !sites.some((site) => allows(declaration, site))).map(unused),
+		];
+	},
+});

package/src/rules/suppressions/stylesheet-comments.ts

@@ -0,0 +1,27 @@
+import { bodyOf, type SourceComment } from "../comments/scan.ts";
+
+export const STYLESHEET = /\.(?:css|scss|less)$/;
+
+const LINE_COMMENTS = /\.(?:scss|less)$/;
+
+const TOKENS = String.raw`"(?:[^"\\\n]|\\.)*"?|'(?:[^'\\\n]|\\.)*'?|url\([^)]*\)?|\/\*[\s\S]*?(?:\*\/|$)`;
+
+const tokensOf = (path: string): RegExp => new RegExp(LINE_COMMENTS.test(path) ? `${TOKENS}|\\/\\/[^\\n]*` : TOKENS, "gi");
+
+const lineOf = (text: string, offset: number): number => text.slice(0, offset).split("\n").length;
+
+const toComment = (text: string, token: string, offset: number): SourceComment => {
+	const kind = token.startsWith("//") ? "line" : "block";
+	const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
+	return {
+		body: bodyOf(kind, kind === "block" && !token.endsWith("*/") ? `${token}*/` : token),
+		endLine: lineOf(text, offset + token.length),
+		kind,
+		line: lineOf(text, offset),
+		ownLine: text.slice(lineStart, offset).trim() === "",
+		text: token,
+	};
+};
+
+export const stylesheetComments = (path: string, text: string): ReadonlyArray<SourceComment> =>
+	[...text.matchAll(tokensOf(path))].flatMap((match) => (match[0].startsWith("/") ? [toComment(text, match[0], match.index)] : []));

package/src/rules/syntax.ts

@@ -0,0 +1,14 @@
+import ts from "typescript";
+import type { SourceFile } from "../rule.ts";
+
+const SCRIPT_KINDS: ReadonlyArray<readonly [RegExp, ts.ScriptKind]> = [
+	[/\.[cm]?ts$/, ts.ScriptKind.TS],
+	[/\.tsx$/, ts.ScriptKind.TSX],
+	[/\.[cm]?js$/, ts.ScriptKind.JS],
+	[/\.jsx$/, ts.ScriptKind.JSX],
+];
+
+export const parse = (file: SourceFile): ts.SourceFile | undefined => {
+	const kind = SCRIPT_KINDS.find(([pattern]) => pattern.test(file.path))?.[1];
+	return kind === undefined ? undefined : ts.createSourceFile(file.path, file.text, ts.ScriptTarget.Latest, true, kind);
+};