feat(ReadTask): improve SourceFile validation

Author: mceachen

src/File.spec.ts

@@ -0,0 +1,72 @@
+import { writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { expect, tmpname } from "./_chai.spec";
+import { compareFilePaths, isFileEmpty, isPlatformCaseSensitive } from "./File";
+
+describe("File", () => {
+  describe("isFileEmpty()", () => {
+    it("returns true for non-existent file", async () => {
+      const path = tmpname();
+      expect(await isFileEmpty(path)).to.eql(true);
+    });
+
+    it("returns true for empty file", async () => {
+      const path = tmpname();
+      await writeFile(path, "");
+      expect(await isFileEmpty(path)).to.eql(true);
+    });
+
+    it("returns false for non-empty file", async () => {
+      const path = tmpname();
+      await writeFile(path, "content");
+      expect(await isFileEmpty(path)).to.eql(false);
+    });
+
+    it("throws error for blank path", async () => {
+      await expect(isFileEmpty("")).to.be.rejectedWith(
+        "isFileEmpty(): blank path",
+      );
+    });
+  });
+
+  describe("compareFilePaths()", () => {
+    it("returns true for identical paths", () => {
+      const path = "/some/path/file.txt";
+      expect(compareFilePaths(path, path)).to.eql(true);
+    });
+
+    it("returns true for normalized paths", () => {
+      expect(
+        compareFilePaths(
+          join(homedir(), "file"),
+          join(homedir(), "dir", "..", "file"),
+        ),
+      ).to.eql(true);
+    });
+
+    it("returns true for case-sensitive paths", () => {
+      expect(compareFilePaths("/path/to/file", "/path/to/file")).to.eql(true);
+    });
+
+    it("returns false for case-insensitive paths on Linux", () => {
+      expect(compareFilePaths("/PATH/TO/FILE", "/path/to/file")).to.eql(
+        isPlatformCaseSensitive(),
+      );
+    });
+
+    it("returns true for case-insensitive paths on non-Linux", () => {
+      expect(compareFilePaths("/PATH/TO/FILE", "/path/to/file")).to.eql(true);
+    });
+
+    it("handles different path separators", () => {
+      expect(compareFilePaths("/path/to/file", "\\path\\to/file")).to.eql(true);
+    });
+
+    it("returns false for different paths", () => {
+      expect(compareFilePaths("/path/to/file1", "/path/to/file2")).to.eql(
+        false,
+      );
+    });
+  });
+});

src/File.ts

@@ -1,4 +1,6 @@
 import { stat, Stats } from "node:fs";
+import { normalize } from "node:path";
+import { lazy } from "./Lazy";
 import { blank } from "./String";
 
 export async function isFileEmpty(path: string): Promise<boolean> {
@@ -27,3 +29,15 @@ export async function isFileEmpty(path: string): Promise<boolean> {
     else throw err;
   }
 }
+
+export const isPlatformCaseSensitive = lazy(
+  () => process.platform !== "win32" && process.platform !== "darwin",
+);
+
+export function compareFilePaths(a: string, b: string): boolean {
+  const aNorm = normalize(a);
+  const bNorm = normalize(b);
+  return isPlatformCaseSensitive()
+    ? aNorm === bNorm
+    : aNorm.localeCompare(bNorm, undefined, { sensitivity: "base" }) === 0;
+}

src/ReadTask.spec.ts

@@ -16,7 +16,7 @@ import {
 import { hms } from "./DateTime";
 import { ExifDateTime } from "./ExifDateTime";
 import { defaultVideosToUTC, ExifTime, ExifTool } from "./ExifTool";
-import { GeolocationTagNames } from "./GeolocationTags";
+import { GeolocationTagNames, GeolocationTags } from "./GeolocationTags";
 import { omit } from "./Object";
 import { pick } from "./Pick";
 import { ReadTask, ReadTaskOptions } from "./ReadTask";
@@ -26,15 +26,16 @@ import { isUTC } from "./Timezones";
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const gt = require("geo-tz");
 
+const SourceFile = join(tmpdir(), "example.jpg");
+
 function parse(
   args: {
     tags: object;
     error?: Error;
     SourceFile?: string;
   } & Partial<ReadTaskOptions>,
 ): Tags {
-  const SourceFile = args.SourceFile ?? "/tmp/example.jpg";
-  const tt = ReadTask.for(SourceFile, {
+  const tt = ReadTask.for(args.SourceFile ?? SourceFile, {
     defaultVideosToUTC: true,
     backfillTimezones: true,
     includeImageDataMD5: true,
@@ -212,6 +213,7 @@ describe("ReadTask", () => {
       expect(
         parse({
           tags: {
+            SourceFile,
             GPSLatitude: 0,
             GPSLongitude: 0,
             GeolocationCity: "Takoradi",
@@ -234,13 +236,14 @@ describe("ReadTask", () => {
           geolocation: true,
         }),
       ).to.eql({
-        SourceFile: "/tmp/example.jpg",
+        SourceFile,
         errors: [],
         warnings: ["Ignoring zero coordinates from GPSLatitude/GPSLongitude"],
       });
     });
     it("extracts GPS tags if valid lat/lon", () => {
       const tags = {
+        SourceFile,
         GPSLatitude: "37 deg 48' 3.45\" N",
         GPSLongitude: "122 deg 23' 55.67\" W",
         GPSLatitudeRef: "North",
@@ -258,7 +261,7 @@ describe("ReadTask", () => {
         GeolocationPosition: "37.7966, -122.4086",
         GeolocationDistance: "1.01 km",
         GeolocationBearing: 246,
-      };
+      } satisfies Tags & Required<Omit<GeolocationTags, "GeolocationWarning">>;
       expect(
         parse({
           tags,
@@ -271,7 +274,6 @@ describe("ReadTask", () => {
         GPSLatitudeRef: "N",
         GPSLongitude: -122.398797,
         GPSLongitudeRef: "W",
-        SourceFile: "/tmp/example.jpg",
         tz: "America/Los_Angeles",
         tzSource: "GeolocationTimeZone",
         errors: [],

src/ReadTask.ts

@@ -10,6 +10,7 @@ import { ExifDateTime } from "./ExifDateTime";
 import { ExifTime } from "./ExifTime";
 import { ExifToolOptions, handleDeprecatedOptions } from "./ExifToolOptions";
 import { ExifToolTask } from "./ExifToolTask";
+import { compareFilePaths } from "./File";
 import { Utf8FilenameCharsetArgs } from "./FilenameCharsetArgs";
 import { parseGPSLocation } from "./GPS";
 import { lazy } from "./Lazy";
@@ -152,10 +153,8 @@ export class ReadTask extends ExifToolTask<Tags> {
     }
     // ExifTool does "humorous" things to paths, like flip path separators. resolve() undoes that.
     if (notBlank(this.#raw.SourceFile)) {
-      const SourceFile = _path.resolve(this.#raw.SourceFile);
-      // Sanity check that the result is for the file we want:
-      if (SourceFile !== this.sourceFile) {
-        // Throw an error rather than add an errors string because this is *really* bad:
+      if (!compareFilePaths(this.#raw.SourceFile, this.sourceFile)) {
+        // this would indicate a bug in batch-cluster:
         throw new Error(
           `Internal error: unexpected SourceFile of ${this.#raw.SourceFile} for file ${this.sourceFile}`,
         );