path-class 0.12.2 → 0.13.0

package/src/Path.ts

@@ -36,6 +36,7 @@ import type {
   readFileType,
   statType,
 } from "./modifiedNodeTypes";
+import { stringifyIfPath } from "./stringifyfIfPath";
 
 // Note that (non-static) functions in this file are defined using `function(…)
 // { … }` rather than arrow functions, specifically because we want `this` to
@@ -76,6 +77,30 @@ export function resolutionPrefix(pathString: string): ResolutionPrefix {
   return ResolutionPrefix.Bare;
 }
 
+const DEFAULT_TEMP_PREFIX = "js-temp-";
+const DEFAULT_TEMP_FILE_NAME = "file";
+
+function preserveRelativeResolutionPrefix(
+  pathString: string,
+  from: string,
+): string {
+  if (
+    resolutionPrefix(from) === ResolutionPrefix.Relative &&
+    resolutionPrefix(pathString) !== ResolutionPrefix.Relative
+  ) {
+    // We don't have to handle the case of `"."`, as it already starts with `"."`
+    return `./${pathString}`;
+  }
+  return pathString;
+}
+
+function joinPreservingRelativeResolutionPrefix(
+  base: string,
+  relative: string[],
+): string {
+  return preserveRelativeResolutionPrefix(join(base, ...relative), base);
+}
+
 export class Path {
   // @ts-expect-error ts(2564): False positive. https://github.com/microsoft/TypeScript/issues/32194
   #path: string;
@@ -87,6 +112,27 @@ export class Path {
     this.#setNormalizedPath(s);
   }
 
+  static #pathlikeToString(path: string | URL | Path): string {
+    if (path instanceof Path) {
+      return path.#path;
+    }
+    if (path instanceof URL) {
+      return fileURLToPath(path);
+    }
+    if (typeof path === "string") {
+      // TODO: allow turning off this heuristic?
+      if (path.startsWith("file:///")) {
+        return fileURLToPath(path);
+      }
+      return path;
+    }
+    throw new Error("Invalid path");
+  }
+
+  // Preserves the `ResolutionPrefix` status when possible.
+  #setNormalizedPath(path: string): void {
+    this.#path = joinPreservingRelativeResolutionPrefix(path, []);
+  }
   static fromString(s: string): Path {
     if (typeof s !== "string") {
       throw new Error(
@@ -126,31 +172,80 @@ export class Path {
     return new Path(new URL(Path.#pathlikeToString(path), baseURL));
   }
 
-  static #pathlikeToString(path: string | URL | Path): string {
-    if (path instanceof Path) {
-      return path.#path;
+  /**
+   * Convenience function. The following are equivalent:
+   *
+   *     B.resolve(A);
+   *     Path.resolve(A, B);
+   *
+   */
+  resolve(path: string | URL | Path): Path {
+    return Path.resolve(path, this);
+  }
+
+  /**
+   * Computes the relative path from an ancestor (this) to another path.
+   *
+   * - If the path is a descendant *or is the same path*, this returns a
+   *   relative path. Call {@link Path.asBare `.asBare()`} on the output if
+   *   needed.
+   * - The output is `null` unless the input paths are:
+   *   - Both absolute paths.
+   *   - Both relative paths. Resolve the paths before passing to this function
+   *     if needed.
+   * - Trailing slashes:
+   *   - By default, the ancestor path must have a trailing slash for the
+   *     function to be called. Pass `{ requireTrailingSlashForAncestor: false
+   *     }` if needed. Note that recombining the ancestor path with the output
+   *     using {@link Path.prototype.resolve `.resolve(…)` } does not result in
+   *     the original input path if the ancestor path did not have a trailing
+   *     slash.
+   *   - For the descendant/same path check, trailing slashes are ignored. In
+   *     particular, if the ancestor path has a trailing slash and the
+   *     descendant path is the same path without a trailing slash, this is
+   *     still considered to be the same path.
+   *   - The output has trailing slash if and only if:
+   *       - the input descendant does, or
+   *       - the output is the absolute path `/`.
+   */
+  descendantRelativePath(
+    potentialDescendant: string | URL | Path,
+    options?: { requireTrailingSlashForAncestor: boolean },
+  ): Path | null {
+    const requireTrailingSlashForAncestor =
+      options?.requireTrailingSlashForAncestor ?? true;
+    if (requireTrailingSlashForAncestor && !this.hasTrailingSlash()) {
+      throw new Error(
+        "Ancestor must have a trailing slash. Pass `{ requireTrailingSlashForAncestor: false }` if needed.",
+      );
     }
-    if (path instanceof URL) {
-      return fileURLToPath(path);
+
+    const other = new Path(potentialDescendant);
+    if (this.isAbsolutePath() !== other.isAbsolutePath()) {
+      return null;
     }
-    if (typeof path === "string") {
-      // TODO: allow turning off this heuristic?
-      if (path.startsWith("file:///")) {
-        return fileURLToPath(path);
+
+    // Leading slashes are okay, as they will result in a `""` component for
+    // absolute paths (and we don't compare absolute paths to relative paths.)
+    const thisParts = this.toggleTrailingSlash(false).#path.split("/");
+    const otherParts = other.toggleTrailingSlash(false).#path.split("/");
+
+    if (otherParts.length < thisParts.length) {
+      return null;
+    }
+    for (let i = 0; i < thisParts.length; i++) {
+      console.log(i, thisParts[i], otherParts[i]);
+      if (thisParts[i] !== otherParts[i]) {
+        return null;
       }
-      return path;
     }
-    throw new Error("Invalid path");
+    return new Path("./")
+      .join(...otherParts.slice(thisParts.length))
+      .toggleTrailingSlash(other.hasTrailingSlash());
   }
 
-  // Preserves the `ResolutionPrefix` status when possible.
-  #setNormalizedPath(path: string): void {
-    const prefix = resolutionPrefix(path);
-    this.#path = join(path);
-    if (prefix === ResolutionPrefix.Relative && !this.#path.startsWith(".")) {
-      // We don't have to handle the case of `"."`, as it already starts with `"."`
-      this.#path = `./${this.#path}`;
-    }
+  unresolve(path: string | URL | Path): Path {
+    return Path.resolve(path, this);
   }
 
   isAbsolutePath(): boolean {
@@ -237,7 +332,9 @@ export class Path {
       }
       return s;
     });
-    return new Path(join(this.#path, ...segmentStrings));
+    return new Path(
+      joinPreservingRelativeResolutionPrefix(this.#path, segmentStrings),
+    );
   }
 
   /**
@@ -496,7 +593,47 @@ export class Path {
    * */
   static async makeTempDir(prefix?: string): Promise<AsyncDisposablePath> {
     return new AsyncDisposablePath(
-      await mkdtemp(new Path(tmpdir()).join(prefix ?? "js-temp-").toString()),
+      await mkdtemp(
+        new Path(tmpdir()).join(prefix ?? DEFAULT_TEMP_PREFIX).toString(),
+      ),
+    );
+  }
+
+  /**
+   * Return a path:
+   *
+   * - whose parent dir is a temp dir that *has* been created, but
+   * - which has itself not yet been created.
+   *
+   * Note that this path can actually also be used to create dir, but it is most
+   * convenient to get a path for a temporary file that can be written to, while
+   * having a disposal implementation that cleans everything up:
+   *
+   *     await using tempFile = await Path.tempFilePath({ basename: "foo.txt" });
+   *     await tempFile.write("hello world!");
+   *     // …
+   *
+   * Note that that the following are equivalent when *not* using `await using`:
+   *
+   *     await Path.tempFilePath({ basename: "foo.txt" });
+   *     (await Path.makeTempDir()).join("file.txt");
+   *
+   * However, it is recommended to use `await using` to ensure cleanup.
+   */
+  static async tempFilePath(options: {
+    tempDirPrefix?: string;
+    basename?: string | Path;
+  }): Promise<AsyncDisposablePath> {
+    const tempDir = new Path(
+      await mkdtemp(
+        new Path(tmpdir())
+          .join(options?.tempDirPrefix ?? DEFAULT_TEMP_PREFIX)
+          .toString(),
+      ),
+    );
+    return new AsyncDisposablePath(
+      tempDir.join(options?.basename ?? DEFAULT_TEMP_FILE_NAME),
+      { disposePathInstead: tempDir },
     );
   }
 
@@ -711,25 +848,22 @@ export class Path {
 }
 
 export class AsyncDisposablePath extends Path {
-  async [Symbol.asyncDispose]() {
-    await this.rm_rf();
+  #options?: { disposePathInstead: Path };
+  constructor(
+    path: ConstructorParameters<typeof Path>[0],
+    options?: { disposePathInstead: Path | string },
+  ) {
+    super(path);
+    if (options) {
+      this.#options = {
+        disposePathInstead: new Path(options.disposePathInstead),
+      };
+    }
   }
-}
 
-/**
- * This function is useful to serialize any `Path`s in a structure to pass on to
- * functions that do not know about the `Path` class, e.g.
- *
- *     function process(args: (string | Path)[]) {
- *       const argsAsStrings = args.map(stringifyIfPath);
- *     }
- *
- */
-export function stringifyIfPath<T>(value: T | Path): T | string {
-  if (value instanceof Path) {
-    return value.toString();
-  }
-  return value;
+  async [Symbol.asyncDispose]() {
+    await (this.#options?.disposePathInstead ?? this).rm_rf();
+  }
 }
 
 export function mustNotHaveTrailingSlash(path: Path): void {
@@ -739,8 +873,3 @@ export function mustNotHaveTrailingSlash(path: Path): void {
     );
   }
 }
-
-const tmp = await Path.makeTempDir();
-(await tmp.join("foo.json").write("foo")).rename(
-  tmp.join("sdfsD", "sdfsdfsdf", "sdfsdf.json"),
-);

package/src/index.ts

@@ -2,5 +2,6 @@ export {
   AsyncDisposablePath,
   Path,
   ResolutionPrefix,
-  stringifyIfPath,
 } from "./Path";
+
+export { stringifyIfPath } from "./stringifyfIfPath";

package/src/stringifyIfPath.test.ts

@@ -0,0 +1,9 @@
+import { expect, test } from "bun:test";
+import { Path } from "./Path";
+import { stringifyIfPath } from "./stringifyfIfPath";
+
+test.concurrent(".stringifyIfPath(…)", async () => {
+  expect(stringifyIfPath(Path.homedir)).toBe("/mock/home/dir");
+  expect(stringifyIfPath("/mock/home/dir")).toBe("/mock/home/dir");
+  expect(stringifyIfPath(4)).toBe(4);
+});

package/src/stringifyfIfPath.ts

@@ -0,0 +1,17 @@
+import { Path } from "./Path";
+
+/**
+ * This function is useful to serialize any `Path`s in a structure to pass on to
+ * functions that do not know about the `Path` class, e.g.
+ *
+ *     function process(args: (string | Path)[]) {
+ *       const argsAsStrings = args.map(stringifyIfPath);
+ *     }
+ *
+ */
+export function stringifyIfPath<T>(value: Exclude<T, Path> | Path): T | string {
+  if (value instanceof Path) {
+    return value.toString();
+  }
+  return value;
+}

package/src/sync/PathSync.test.ts

@@ -2,12 +2,46 @@ import { expect, test } from "bun:test";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import "./PathSync";
+import { execSync } from "node:child_process";
 import { constants } from "node:fs/promises";
-import { PrintableShellCommand } from "printable-shell-command";
 import { PathSync } from "./PathSync";
 
+test.concurrent("PathSync.resolve(…)", () => {
+  expect(PathSync.resolve("foo/lish", new PathSync("/bar/baz")).path).toEqual(
+    "/bar/foo/lish",
+  );
+  expect(PathSync.resolve("foo/lish", new PathSync("/bar/baz/")).path).toEqual(
+    "/bar/baz/foo/lish",
+  );
+  expect(
+    () => PathSync.resolve("foo/lish", new PathSync("bar/baz")).path,
+  ).toThrow(/must be an absolute path/);
+  expect(PathSync.resolve("foo/lish", import.meta.url).path).toEqual(
+    new PathSync(import.meta.url).parent.join("foo/lish").path,
+  );
+  expect(PathSync.resolve("foo", "file:///hello/world").path).toEqual(
+    "/hello/foo",
+  );
+  expect(PathSync.resolve("foo", "file:///hello/world/").path).toEqual(
+    "/hello/world/foo",
+  );
+});
+
+test.concurrent(".resolve(…)", () => {
+  expect(new PathSync("/bar/baz").resolve("foo/lish").path).toEqual(
+    "/bar/foo/lish",
+  );
+  expect(new PathSync("/bar/baz/").resolve("foo/lish").path).toEqual(
+    "/bar/baz/foo/lish",
+  );
+  expect(() => new PathSync("bar/baz").resolve("foo/lish").path).toThrow(
+    /must be an absolute path/,
+  );
+  expect(new PathSync("/bar/baz").resolve("foo/lish")).toBeInstanceOf(PathSync);
+});
+
 test.concurrent(".existsAsFileSync()", () => {
-  const filePath = PathSync.makeTempDirSync().join("file.txt");
+  using filePath = PathSync.tempFilePathSync({ basename: "file.txt" });
   expect(filePath.existsSync()).toBe(false);
   expect(filePath.existsSync({ mustBe: "file" })).toBe(false);
   expect(filePath.existsSync({ mustBe: "directory" })).toBe(false);
@@ -25,29 +59,31 @@ test.concurrent(".existsAsFileSync()", () => {
 });
 
 test.concurrent(".existsAsDir()", () => {
-  const filePath = PathSync.makeTempDirSync();
-  expect(filePath.existsSync()).toBe(true);
-  expect(() => filePath.existsSync({ mustBe: "file" })).toThrow(
+  using tempDir = PathSync.makeTempDirSync();
+  expect(tempDir.existsSync()).toBe(true);
+  expect(() => tempDir.existsSync({ mustBe: "file" })).toThrow(
     /PathSync exists but is not a file/,
   );
-  expect(filePath.existsSync({ mustBe: "directory" })).toBe(true);
-  expect(filePath.existsAsDirSync()).toBe(true);
-  filePath.rm_rfSync();
-  expect(filePath.existsSync()).toBe(false);
-  expect(filePath.existsSync({ mustBe: "file" })).toBe(false);
-  expect(filePath.existsSync({ mustBe: "directory" })).toBe(false);
-  expect(filePath.existsAsDirSync()).toBe(false);
+  expect(tempDir.existsSync({ mustBe: "directory" })).toBe(true);
+  expect(tempDir.existsAsDirSync()).toBe(true);
+  tempDir.rm_rfSync();
+  expect(tempDir.existsSync()).toBe(false);
+  expect(tempDir.existsSync({ mustBe: "file" })).toBe(false);
+  expect(tempDir.existsSync({ mustBe: "directory" })).toBe(false);
+  expect(tempDir.existsAsDirSync()).toBe(false);
 });
 
 test.concurrent(".mkdirSync(…) (un-nested)", () => {
-  const dir = PathSync.makeTempDirSync().join("mkdir-test");
+  using tempDir = PathSync.makeTempDirSync();
+  const dir = tempDir.join("mkdir-test");
   expect(dir.existsSync()).toBe(false);
   dir.mkdirSync();
   expect(dir.existsSync()).toBe(true);
 });
 
 test.concurrent(".mkdirSync(…) (nested)", () => {
-  const dir = PathSync.makeTempDirSync().join("mkdir-test/nested");
+  using tempDir = PathSync.makeTempDirSync();
+  const dir = tempDir.join("mkdir-test/nested");
   expect(dir.existsSync()).toBe(false);
   expect(() => dir.mkdirSync({ recursive: false })).toThrow("no such file");
   dir.mkdirSync();
@@ -55,7 +91,7 @@ test.concurrent(".mkdirSync(…) (nested)", () => {
 });
 
 test.concurrent(".cpSync(…)", () => {
-  const parentDir = PathSync.makeTempDirSync();
+  using parentDir = PathSync.makeTempDirSync();
   const file1 = parentDir.join("file1.txt");
   const file2 = parentDir.join("file2.txt");
   const file3 = parentDir.join("nonexistent/dirs/file3.txt");
@@ -80,7 +116,7 @@ test.concurrent(".cpSync(…)", () => {
 });
 
 test.concurrent(".renameSync(…)", () => {
-  const parentDir = PathSync.makeTempDirSync();
+  using parentDir = PathSync.makeTempDirSync();
   const file1 = parentDir.join("file1.txt");
   const file2 = parentDir.join("file2.txt");
   const file3 = parentDir.join("nonexistent/dirs/file3.txt");
@@ -105,18 +141,28 @@ test.concurrent(".renameSync(…)", () => {
 });
 
 test.concurrent(".makeTempDirSync(…)", () => {
-  const tempDir = PathSync.makeTempDirSync();
-  expect(tempDir.path).toContain("/js-temp-");
-  expect(tempDir.basename.path).toStartWith("js-temp-");
-  expect(tempDir.existsAsDirSync()).toBe(true);
-
-  const tempDir2 = PathSync.makeTempDirSync("foo");
-  expect(tempDir2.path).not.toContain("/js-temp-");
-  expect(tempDir2.basename.path).toStartWith("foo");
+  let disposablePathSyncString: string;
+  {
+    using tempDir = PathSync.makeTempDirSync();
+    disposablePathSyncString = tempDir.path;
+    expect(tempDir.path).toContain("/js-temp-");
+    expect(tempDir.basename.path).toStartWith("js-temp-");
+    expect(tempDir.existsAsDirSync()).toBe(true);
+  }
+  expect(new PathSync(disposablePathSyncString).existsAsDirSync()).toBe(false);
+
+  let disposablePathSyncString2: string;
+  {
+    using tempDir2 = PathSync.makeTempDirSync("foo");
+    disposablePathSyncString2 = tempDir2.path;
+    expect(tempDir2.path).not.toContain("/js-temp-");
+    expect(tempDir2.basename.path).toStartWith("foo");
+  }
+  expect(new PathSync(disposablePathSyncString2).existsAsDirSync()).toBe(false);
 });
 
 test.concurrent(".rmSync(…) (file)", () => {
-  const file = PathSync.makeTempDirSync().join("file.txt");
+  using file = PathSync.tempFilePathSync({ basename: "file.txt" });
   file.writeSync("");
   expect(file.existsAsFileSync()).toBe(true);
   file.rmSync();
@@ -126,7 +172,7 @@ test.concurrent(".rmSync(…) (file)", () => {
 });
 
 test.concurrent(".rmSync(…) (folder)", () => {
-  const tempDir = PathSync.makeTempDirSync();
+  using tempDir = PathSync.makeTempDirSync();
   const file = tempDir.join("file.txt");
   file.writeSync("");
   expect(tempDir.existsAsDirSync()).toBe(true);
@@ -138,7 +184,7 @@ test.concurrent(".rmSync(…) (folder)", () => {
 });
 
 test.concurrent(".rmDirSync(…) (folder)", () => {
-  const tempDir = PathSync.makeTempDirSync();
+  using tempDir = PathSync.makeTempDirSync();
   const file = tempDir.join("file.txt");
   file.writeSync("");
   expect(tempDir.existsAsDirSync()).toBe(true);
@@ -150,7 +196,7 @@ test.concurrent(".rmDirSync(…) (folder)", () => {
 });
 
 test.concurrent(".rm_rfSync(…) (file)", () => {
-  const file = PathSync.makeTempDirSync().join("file.txt");
+  using file = PathSync.tempFilePathSync({ basename: "file.txt" });
   file.writeSync("");
   expect(file.existsAsFileSync()).toBe(true);
   file.rm_rfSync();
@@ -161,7 +207,7 @@ test.concurrent(".rm_rfSync(…) (file)", () => {
 });
 
 test.concurrent(".rm_rfSync(…) (folder)", () => {
-  const tempDir = PathSync.makeTempDirSync();
+  using tempDir = PathSync.makeTempDirSync();
   tempDir.join("file.txt").writeSync("");
   expect(tempDir.path).toContain("/js-temp-");
   expect(tempDir.existsSync()).toBe(true);
@@ -172,7 +218,7 @@ test.concurrent(".rm_rfSync(…) (folder)", () => {
 });
 
 test.concurrent(".readTextSync()", () => {
-  const file = PathSync.makeTempDirSync().join("file.txt");
+  using file = PathSync.tempFilePathSync({ basename: "file.txt" });
   file.writeSync("hi");
   file.writeSync("bye");
 
@@ -181,7 +227,7 @@ test.concurrent(".readTextSync()", () => {
 });
 
 test.concurrent(".readJSONSync()", () => {
-  const file = PathSync.makeTempDirSync().join("file.json");
+  using file = PathSync.tempFilePathSync({ basename: "file.json" });
   file.writeSync(JSON.stringify({ foo: "bar" }));
 
   expect(file.readJSONSync()).toEqual<Record<string, string>>({ foo: "bar" });
@@ -192,7 +238,7 @@ test.concurrent(".readJSONSync()", () => {
 });
 
 test.concurrent(".readJSONSync(…) with fallback", () => {
-  const tempDir = PathSync.makeTempDirSync();
+  using tempDir = PathSync.makeTempDirSync();
   const file = tempDir.join("file.json");
   const json: { foo?: number } = file.readJSONSync({ fallback: { foo: 4 } });
   expect(json).toEqual({ foo: 4 });
@@ -210,7 +256,7 @@ test.concurrent(".readJSONSync(…) with fallback", () => {
 });
 
 test.concurrent(".writeSync(…)", () => {
-  const tempDir = PathSync.makeTempDirSync();
+  using tempDir = PathSync.makeTempDirSync();
   const file = tempDir.join("file.json");
   expect(file.writeSync("foo")).toBe(file);
 
@@ -226,14 +272,14 @@ test.concurrent(".writeSync(…)", () => {
 });
 
 test.concurrent(".writeJSONSync(…)", () => {
-  const file = PathSync.makeTempDirSync().join("file.json");
+  using file = PathSync.tempFilePathSync({ basename: "file.json" });
   expect(file.writeJSONSync({ foo: "bar" })).toBe(file);
 
   expect(file.readJSONSync()).toEqual<Record<string, string>>({ foo: "bar" });
 });
 
 test.concurrent(".appendFileSync(…)", () => {
-  const file = PathSync.makeTempDirSync().join("file.txt");
+  using file = PathSync.tempFilePathSync({ basename: "file.txt" });
   file.appendFileSync("test\n");
   expect(file.readTextSync()).toEqual("test\n");
   file.appendFileSync("more\n");
@@ -241,7 +287,7 @@ test.concurrent(".appendFileSync(…)", () => {
 });
 
 test.concurrent(".readDirSync(…)", () => {
-  const dir = PathSync.makeTempDirSync();
+  using dir = PathSync.makeTempDirSync();
   dir.join("file.txt").writeSync("hello");
   dir.join("dir/file.json").writeSync("hello");
 
@@ -255,7 +301,7 @@ test.concurrent(".readDirSync(…)", () => {
 });
 
 test.concurrent(".symlinkSync(…)", () => {
-  const tempDir = PathSync.makeTempDirSync();
+  using tempDir = PathSync.makeTempDirSync();
   const source = tempDir.join("foo.txt");
   const target = tempDir.join("bar.txt");
   source.symlinkSync(target);
@@ -267,7 +313,7 @@ test.concurrent(".symlinkSync(…)", () => {
 });
 
 test.concurrent(".realpathSync(…)", () => {
-  const tempDir = PathSync.makeTempDirSync();
+  using tempDir = PathSync.makeTempDirSync();
   const source = tempDir.join("foo.txt");
   source.writeSync("hello world!");
   const target = tempDir.join("bar.txt");
@@ -276,7 +322,7 @@ test.concurrent(".realpathSync(…)", () => {
 });
 
 test.concurrent(".statSync(…)", () => {
-  const file = PathSync.makeTempDirSync().join("foo.txt");
+  using file = PathSync.tempFilePathSync({ basename: "foo.txt" });
   file.writeSync("hello");
 
   expect(file.statSync()?.size).toEqual(5);
@@ -285,7 +331,7 @@ test.concurrent(".statSync(…)", () => {
 });
 
 test.concurrent(".lstatSync(…)", () => {
-  const tempDir = PathSync.makeTempDirSync();
+  using tempDir = PathSync.makeTempDirSync();
   const source = tempDir.join("foo.txt");
   const target = tempDir.join("bar.txt");
   source.symlinkSync(target);
@@ -297,46 +343,47 @@ test.concurrent(".lstatSync(…)", () => {
   expect(target.readTextSync()).toEqual("hello");
 });
 
+// Note: this test uses `execSync(…)` because it runs the binary and returns
+// expected error messages correctly. Further, it helps keep this entire test
+// file sync (which we have some basic checks for in `lint-sync-code.ts` that
+// don't seem like a great idea to work around).
 test.concurrent(".chmodSync(…)", () => {
-  const binPath = PathSync.makeTempDirSync().join("nonexistent.bin");
-  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
-    /ENOENT|Premature close/,
+  using binPath = PathSync.tempFilePathSync({ basename: "bin.bash" });
+  expect(() => execSync(binPath.path, { stdio: ["ignore"] })).toThrow(
+    /No such file or directory|not found/,
   );
-  binPath.writeSync(`#!/usr/bin/env bash
-
-echo hi`);
-  // TODO: why doesn't this work here instead (but works in `printable-shell-comand`)?
-  //    binPath.writeSync(`#!/usr/bin/env -S bun run --
+  binPath.writeSync(`#!/usr/bin/env -S bun run --
 
-  // console.log("hi");`);
-  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
-    /EACCES|Premature close/,
+console.log("hi");`);
+  expect(() => execSync(binPath.path, { stdio: ["ignore"] })).toThrow(
+    /Permission denied/,
   );
   binPath.chmodSync(0o755);
-  expect(() => new PrintableShellCommand(binPath, []).text()).not.toThrow();
+  expect(execSync(binPath.path, { encoding: "utf-8" })).toEqual("hi\n");
 });
 
+// Note: this test uses `execSync(…)` because it runs the binary and returns
+// expected error messages correctly. Further, it helps keep this entire test
+// file sync (which we have some basic checks for in `lint-sync-code.ts` that
+// don't seem like a great idea to work around).
 test.concurrent(".chmodXSync(…)", () => {
-  const binPath = PathSync.makeTempDirSync().join("nonexistent.bin");
-  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
-    /ENOENT|Premature close/,
+  using binPath = PathSync.tempFilePathSync({ basename: "bin.bash" });
+  expect(() => execSync(binPath.path, { stdio: ["ignore"] })).toThrow(
+    /No such file or directory|not found/,
   );
-  binPath.writeSync(`#!/usr/bin/env bash
-
-echo hi`);
-  // TODO: why doesn't this work here instead (but works in `printable-shell-comand`)?
-  //    binPath.writeSync(`#!/usr/bin/env -S bun run --
+  binPath.writeSync(`#!/usr/bin/env -S bun run --
 
-  // console.log("hi");`);
-  expect(() => new PrintableShellCommand(binPath, []).text()).toThrow(
-    /EACCES|Premature close/,
+console.log("hi");`);
+  // TODO: Should not be `ENOENT`? Probably `EACCES`.
+  expect(() => execSync(binPath.path, { stdio: ["ignore"] })).toThrow(
+    /Permission denied/,
   );
   expect(binPath.statSync().mode & constants.S_IWUSR).toBeTruthy();
   binPath.chmodSync(0o444);
   expect(binPath.statSync().mode & constants.S_IWUSR).toBeFalsy();
   expect(binPath.statSync().mode & constants.S_IXUSR).toBeFalsy();
   binPath.chmodXSync();
-  expect(() => new PrintableShellCommand(binPath, []).text()).not.toThrow();
+  expect(execSync(binPath.path, { encoding: "utf-8" })).toEqual("hi\n");
   expect(binPath.statSync().mode & constants.S_IWUSR).toBeFalsy();
   expect(binPath.statSync().mode & constants.S_IXUSR).toBeTruthy();
 });