Update logging

Author: AndreasArvidsson

.pre-commit-hooks.yaml

@@ -1,17 +1,17 @@
 - id: snippet-fmt
   name: Format snippet files
-  entry: snippet-fmt --quiet
+  entry: snippet-fmt
   language: node
   files: \.snippet$
 
 - id: talon-fmt
   name: Format Talon files
-  entry: talon-fmt --quiet
+  entry: talon-fmt
   language: node
   files: \.(talon|talon-list)$
 
 - id: tree-sitter-fmt
   name: Format Tree-sitter query files
-  entry: tree-sitter-fmt --quiet
+  entry: tree-sitter-fmt
   language: node
   files: \.scm$

out/snippetFormatter.js

@@ -1,6 +1,6 @@
 {
     "name": "@cursorless/talon-tools",
-    "version": "0.1.7",
+    "version": "0.1.8",
     "description": "Linting and formatting tools for Talon and Cursorless",
     "author": "Cursorless Dev",
     "license": "MIT",

out/talonFormatter.js

@@ -119,12 +119,6 @@ async function mainFormatFiles({
         return EXIT_OK;
     }
 
-    if (changedFileCount > 0) {
-        logger.log(`Formatted ${changedFileCount} file(s).`);
-    } else {
-        logger.log("All files are already formatted.");
-    }
-
     return EXIT_OK;
 }
 
@@ -186,10 +180,9 @@ export async function formatFile({
             return false;
         }
 
-        if (check) {
-            logger.warn(filePath);
-        } else {
-            logger.log(filePath);
+        logger.log(filePath);
+
+        if (!check) {
             await fs.writeFile(filePath, formatted, "utf8");
         }
 

out/treeSitterFormatter.js

@@ -5,7 +5,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { PassThrough } from "node:stream";
-import { formatFile, formatFiles, mainFormatStdin } from "../cli/cli.js";
+import { formatFile, formatFiles, main, mainFormatStdin } from "../cli/cli.js";
 import type {
     CLI,
     EditorConfigOptions,
@@ -67,6 +67,9 @@ suite("CLI", () => {
 
             assert.equal(didChange, true);
             assert.equal(actual, "content");
+            assert.deepEqual(logger.getEntries(), [
+                { level: "log", message: fileName },
+            ]);
         } finally {
             await cleanupTempFile(fileName);
         }
@@ -301,6 +304,74 @@ suite("CLI", () => {
         assert.equal(output.text, "[warn] Code style issues found in stdin.\n");
     });
 
+    test("Captures check-mode file entries without writing when quiet", async () => {
+        const fileName = await createTempFile(
+            "talonfmt-",
+            "example.txt",
+            "content",
+        );
+        const cli = createCLI((text) => `${text} updated`);
+        const logger = createLogger(true);
+
+        try {
+            const stdout = await captureStreamWrite(process.stdout, async () =>
+                formatFile({
+                    cli,
+                    logger,
+                    check: true,
+                    debug: false,
+                    filePath: fileName,
+                }),
+            );
+            const stderr = await captureStreamWrite(process.stderr, async () =>
+                Promise.resolve(),
+            );
+
+            assert.equal(stdout.result, true);
+            assert.equal(stdout.text, "");
+            assert.equal(stderr.text, "");
+            assert.deepEqual(logger.getEntries(), [
+                { level: "log", message: fileName },
+            ]);
+        } finally {
+            await cleanupTempFile(fileName);
+        }
+    });
+
+    test("Check mode reports summary and changed file paths", async () => {
+        const fileName = await createTempFile(
+            "talonfmt-",
+            "example.txt",
+            "content",
+        );
+        const cli = createCLI((text) => `${text} updated`);
+        const originalArgv = process.argv;
+        const originalExitCode = process.exitCode;
+
+        try {
+            process.argv = ["node", "talon-fmt", "--check", fileName];
+
+            const output = await captureStdoutAndStderr(async () => {
+                await main(cli);
+                return process.exitCode;
+            });
+
+            assert.equal(output.result, EXIT_FAIL);
+            assert.equal(
+                output.stdoutText,
+                ["Checking formatting...", `${fileName}`, ""].join("\n"),
+            );
+            assert.equal(
+                output.stderrText,
+                "[warn] Code style issues found in 1 file(s).\n",
+            );
+        } finally {
+            process.argv = originalArgv;
+            process.exitCode = originalExitCode;
+            await cleanupTempFile(fileName);
+        }
+    });
+
     test("Returns success for unchanged stdin in check mode", async () => {
         const cli = createCLI((text) => text);
         const logger = createLogger();
@@ -606,6 +677,37 @@ async function captureStreamWrite<T>(
     }
 }
 
+async function captureStdoutAndStderr<T>(
+    callback: () => Promise<T>,
+): Promise<{ result: T; stdoutText: string; stderrText: string }> {
+    let stdoutText = "";
+    let stderrText = "";
+    const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+    const originalStderrWrite = process.stderr.write.bind(process.stderr);
+
+    (process.stdout.write as unknown as (chunk: string) => boolean) = (
+        chunk: string | Uint8Array,
+    ) => {
+        stdoutText += chunk.toString();
+        return true;
+    };
+
+    (process.stderr.write as unknown as (chunk: string) => boolean) = (
+        chunk: string | Uint8Array,
+    ) => {
+        stderrText += chunk.toString();
+        return true;
+    };
+
+    try {
+        const result = await callback();
+        return { result, stdoutText, stderrText };
+    } finally {
+        process.stdout.write = originalStdoutWrite;
+        process.stderr.write = originalStderrWrite;
+    }
+}
+
 function getArguments(args: Partial<ParsedArgs>) {
     return {
         ...getDefaultArguments(),