@yuu1111/quality-check 0.5.1 → 0.7.0

package/src/findings.ts

@@ -1,106 +0,0 @@
-import type { EngineName } from "./config";
-
-/**
- * 検出の重大度
- */
-export type FindingSeverity = "error" | "warning";
-
-/**
- * engine間の差を吸収した検出1件
- */
-export interface NormalizedFinding {
-	column: number;
-	engine: EngineName;
-	file: string;
-	line: number;
-	rule: string;
-	severity: FindingSeverity;
-	text: string;
-}
-
-/**
- * engineが--jsonで返した検出の分類
- */
-export interface ParsedFindings {
-	errors: NormalizedFinding[];
-	warnings: NormalizedFinding[];
-}
-
-type JsonObject = Record<string, unknown>;
-
-function isJsonObject(value: unknown): value is JsonObject {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function readFinding(
-	engine: EngineName,
-	value: unknown,
-	severity: FindingSeverity,
-	textField: "message" | "text",
-): NormalizedFinding {
-	if (!isJsonObject(value)) {
-		throw new Error(`${engine} printed an unexpected finding`);
-	}
-	const { column, file, line, rule } = value;
-	const text = value[textField];
-	if (
-		typeof rule !== "string" ||
-		typeof file !== "string" ||
-		typeof line !== "number" ||
-		typeof column !== "number" ||
-		typeof text !== "string"
-	) {
-		throw new Error(`${engine} printed an unexpected finding`);
-	}
-	return { column, engine, file, line, rule, severity, text };
-}
-
-function readEntries(
-	engine: EngineName,
-	value: unknown,
-	field: string,
-): unknown[] {
-	if (!Array.isArray(value)) {
-		throw new Error(`${engine} printed JSON without a ${field} array`);
-	}
-	return value;
-}
-
-function parseJson(engine: EngineName, stdout: string): JsonObject {
-	let value: unknown;
-	try {
-		value = JSON.parse(stdout);
-	} catch {
-		throw new Error(`${engine} did not print JSON`);
-	}
-	if (!isJsonObject(value)) {
-		throw new Error(`${engine} printed an unexpected JSON value`);
-	}
-	return value;
-}
-
-/**
- * engineの--json出力を検出へ変換する 解析できない出力は例外にする
- */
-export function parseFindings(
-	engine: EngineName,
-	stdout: string,
-): ParsedFindings {
-	const value = parseJson(engine, stdout);
-	if (engine === "comment-check") {
-		return {
-			errors: readEntries(engine, value.added, "added").map((entry) =>
-				readFinding(engine, entry, "error", "text"),
-			),
-			warnings: [],
-		};
-	}
-	return {
-		errors: readEntries(engine, value.errors, "errors").map((entry) =>
-			readFinding(engine, entry, "error", "message"),
-		),
-		warnings: readEntries(engine, value.warnings, "warnings").map((entry) =>
-			readFinding(engine, entry, "warning", "message"),
-		),
-	};
-}

package/src/report.ts

@@ -1,105 +0,0 @@
-import { type Painter, plainPainter } from "./color";
-import { isFindingEngine } from "./engines";
-import type { NormalizedFinding } from "./findings";
-import type { EngineResult } from "./run";
-
-function describeFinding(
-	finding: NormalizedFinding,
-	paint: Painter,
-	tone: "error" | "warn",
-): string {
-	return `${finding.file}:${finding.line}:${finding.column} ${finding.rule} ${paint(finding.severity, tone)} ${finding.text}`;
-}
-
-function describeCounts(result: EngineResult): string {
-	if (!isFindingEngine(result.name)) {
-		return `exit ${result.exitCode}`;
-	}
-	return `${result.reported.length} new, ${result.resolved} resolved, ${result.warnings.length} warnings`;
-}
-
-function describeStatus(result: EngineResult, paint: Painter): string {
-	if (result.status === "error") {
-		return paint("error", "error");
-	}
-	const tone = result.status === "passed" ? "pass" : "error";
-	return `${paint(result.status, tone)} (${describeCounts(result)})`;
-}
-
-/**
- * engine1つ分の出力sectionを組み立てる
- */
-export function formatEngineSection(
-	result: EngineResult,
-	paint: Painter = plainPainter,
-): string {
-	const lines = [paint(`== ${result.name} ==`, "header")];
-	for (const skipped of result.skipped) {
-		lines.push(paint(`${result.name}: ${skipped}`, "muted"));
-	}
-	if (result.output !== "" && !isFindingEngine(result.name)) {
-		lines.push(result.output);
-	}
-	for (const finding of result.reported) {
-		lines.push(describeFinding(finding, paint, "error"));
-	}
-	for (const finding of result.warnings) {
-		lines.push(describeFinding(finding, paint, "warn"));
-	}
-	if (result.message !== undefined) {
-		lines.push(paint(result.message, "error"));
-	}
-	lines.push(`${result.name}: ${describeStatus(result, paint)}`);
-	return lines.join("\n");
-}
-
-/**
- * 失敗したengineを列挙した集約summaryを組み立てる
- */
-export function formatSummary(
-	results: EngineResult[],
-	paint: Painter = plainPainter,
-): string {
-	const failed = results
-		.filter((result) => result.status !== "passed")
-		.map((result) => result.name);
-	const passed = results
-		.filter((result) => result.status === "passed")
-		.map((result) => result.name);
-	if (failed.length === 0) {
-		return paint(`quality-check: ${results.length} engines passed`, "pass");
-	}
-	const lines = [
-		paint(
-			`quality-check: ${failed.length} of ${results.length} engines failed`,
-			"error",
-		),
-		`  ${paint("failed:", "error")} ${failed.join(", ")}`,
-	];
-	if (passed.length > 0) {
-		lines.push(`  ${paint("passed:", "pass")} ${passed.join(", ")}`);
-	}
-	return lines.join("\n");
-}
-
-/**
- * engineの結果をJSONへ変換する
- */
-export function toJsonReport(results: EngineResult[]): unknown {
-	return {
-		engines: results.map((result) => ({
-			detected: result.detected.length,
-			exitCode: result.exitCode,
-			message: result.message ?? null,
-			name: result.name,
-			reported: result.reported,
-			resolved: result.resolved,
-			skipped: result.skipped,
-			status: result.status,
-			warnings: result.warnings,
-		})),
-		failed: results
-			.filter((result) => result.status !== "passed")
-			.map((result) => result.name),
-	};
-}

package/src/run.ts

@@ -1,203 +0,0 @@
-import { type BaselineFile, compareWithBaseline } from "./baseline";
-import { type EngineName, enabledEngines, type QualityConfig } from "./config";
-import {
-	buildEngineCommand,
-	ENGINE_BINS,
-	type EngineCommandContext,
-	type EngineProcessResult,
-	type EngineRunner,
-	isFindingEngine,
-	type RunOverrides,
-	resolveExecutable,
-	runEngineProcess,
-	skippedEngineOptions,
-} from "./engines";
-import { type NormalizedFinding, parseFindings } from "./findings";
-
-/**
- * engine1つ分の実行状態
- */
-export type EngineStatus = "error" | "failed" | "passed";
-
-/**
- * engine1つ分の実行結果
- */
-export interface EngineResult {
-	/** baseline適用前の阻害する検出 */
-	detected: NormalizedFinding[];
-	exitCode: number | null;
-	message?: string;
-	name: EngineName;
-	output: string;
-	/** baseline適用後に残った阻害する検出 */
-	reported: NormalizedFinding[];
-	resolved: number;
-	/** engineが受け取らなかった起動条件 */
-	skipped: string[];
-	status: EngineStatus;
-	warnings: NormalizedFinding[];
-}
-
-/**
- * engineをまとめて起動するための実行条件
- */
-export interface RunOptions {
-	/** 適用するbaseline nullなら差分判定を行わない */
-	baseline: BaselineFile | null;
-	/** engine自身の出力へ色を付けるか */
-	color: boolean;
-	config: QualityConfig;
-	cwd: string;
-	/** コマンドラインから渡された起動条件の上書き */
-	overrides: RunOverrides;
-	/** comment-checkのbaseline差分を無効化する未作成のpath */
-	rawBaseline: string;
-	/** engineの実行fileを解決する関数 テストでは差し替える */
-	resolve?: (name: EngineName, cwd: string) => string | null;
-	runner?: EngineRunner;
-}
-
-function baseResult(
-	name: EngineName,
-	exitCode: number | null,
-	output: string,
-): Omit<EngineResult, "status"> {
-	return {
-		detected: [],
-		exitCode,
-		name,
-		output,
-		reported: [],
-		resolved: 0,
-		skipped: [],
-		warnings: [],
-	};
-}
-
-function joinOutput(result: EngineProcessResult): string {
-	return [result.stdout, result.stderr]
-		.map((part) => part.trimEnd())
-		.filter((part) => part !== "")
-		.join("\n");
-}
-
-function describeError(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-async function runFindingEngine(
-	name: EngineName,
-	options: RunOptions,
-	executable: string,
-	context: EngineCommandContext,
-	runner: EngineRunner,
-): Promise<EngineResult> {
-	const result = await runner(buildEngineCommand(name, executable, context), {
-		cwd: options.cwd,
-	});
-	const output = joinOutput(result);
-	if (result.exitCode === 2) {
-		return {
-			...baseResult(name, 2, output),
-			message: `${name} could not finish`,
-			status: "error",
-		};
-	}
-	let parsed: ReturnType<typeof parseFindings>;
-	try {
-		parsed = parseFindings(name, result.stdout);
-	} catch (error) {
-		return {
-			...baseResult(name, result.exitCode, output),
-			message: describeError(error),
-			status: "error",
-		};
-	}
-	const comparison =
-		options.baseline === null
-			? { added: parsed.errors, resolved: [] }
-			: compareWithBaseline(parsed.errors, options.baseline);
-	return {
-		...baseResult(name, result.exitCode, output),
-		detected: parsed.errors,
-		reported: comparison.added,
-		resolved: comparison.resolved.length,
-		status: comparison.added.length > 0 ? "failed" : "passed",
-		warnings: parsed.warnings,
-	};
-}
-
-async function runProcessEngine(
-	name: EngineName,
-	options: RunOptions,
-	executable: string,
-	context: EngineCommandContext,
-	runner: EngineRunner,
-): Promise<EngineResult> {
-	const result = await runner(buildEngineCommand(name, executable, context), {
-		cwd: options.cwd,
-	});
-	const output = joinOutput(result);
-	if (result.exitCode === 2) {
-		return {
-			...baseResult(name, 2, output),
-			message: `${name} could not finish`,
-			status: "error",
-		};
-	}
-	return {
-		...baseResult(name, result.exitCode, output),
-		status: result.exitCode === 0 ? "passed" : "failed",
-	};
-}
-
-async function executeEngine(
-	name: EngineName,
-	options: RunOptions,
-	context: EngineCommandContext,
-	runner: EngineRunner,
-): Promise<EngineResult> {
-	const executable = (options.resolve ?? resolveExecutable)(name, options.cwd);
-	if (executable === null) {
-		return {
-			...baseResult(name, null, ""),
-			message: `${ENGINE_BINS[name]} is not installed`,
-			status: "error",
-		};
-	}
-	if (isFindingEngine(name)) {
-		return await runFindingEngine(name, options, executable, context, runner);
-	}
-	return await runProcessEngine(name, options, executable, context, runner);
-}
-
-async function runEngine(
-	name: EngineName,
-	options: RunOptions,
-	context: EngineCommandContext,
-	runner: EngineRunner,
-): Promise<EngineResult> {
-	const result = await executeEngine(name, options, context, runner);
-	return {
-		...result,
-		skipped: skippedEngineOptions(name, options.config.config?.[name]),
-	};
-}
-
-/**
- * 設定で有効なengineを順に起動する
- */
-export async function runEngines(options: RunOptions): Promise<EngineResult[]> {
-	const runner = options.runner ?? runEngineProcess;
-	const context: EngineCommandContext = {
-		color: options.color,
-		config: options.config,
-		overrides: options.overrides,
-		rawBaseline: options.rawBaseline,
-	};
-	const results: EngineResult[] = [];
-	for (const name of enabledEngines(options.config)) {
-		results.push(await runEngine(name, options, context, runner));
-	}
-	return results;
-}