@mux-magic/tools 0.1.0

package/src/createRenameFileOrFolder.test.ts

@@ -0,0 +1,220 @@
+import { join } from "node:path"
+import { vol } from "memfs"
+import { EmptyError, firstValueFrom } from "rxjs"
+import { describe, expect, test } from "vitest"
+import { captureLogMessage } from "./captureLogMessage.js"
+import {
+  createRenameFileOrFolderObservable,
+  getLastItemInFilePath,
+  renameFileOrFolder,
+} from "./createRenameFileOrFolder.js"
+
+describe(getLastItemInFilePath.name, () => {
+  test("gets filename when no path", async () => {
+    expect(
+      getLastItemInFilePath("Star Wars (1977).mkv"),
+    ).toBe("Star Wars (1977)")
+  })
+
+  test("gets filename from shallow path", async () => {
+    expect(
+      getLastItemInFilePath(
+        "~/movies/Star Wars (1977) {edition-4K77}.mkv",
+      ),
+    ).toBe("Star Wars (1977) {edition-4K77}")
+  })
+
+  test("gets filename from deep path", async () => {
+    expect(
+      getLastItemInFilePath(
+        "~/movies/Star Wars (1977)/Star Wars (1977) {edition-4K77}.mkv",
+      ),
+    ).toBe("Star Wars (1977) {edition-4K77}")
+  })
+
+  test("gets folder name from path if no file", async () => {
+    expect(
+      getLastItemInFilePath("~/movies/Star Wars (1977)"),
+    ).toBe("Star Wars (1977)")
+  })
+})
+
+describe(renameFileOrFolder.name, () => {
+  test("errors when the current file is missing", async () => {
+    expect(
+      firstValueFrom(
+        renameFileOrFolder({
+          newPath:
+            "/movies/Star Wars (1977)/Star Wars (1977) {edition-4K77}.mkv",
+          oldPath:
+            "/movies/Star Wars (1977)/Star Wars (1977).mkv",
+        }),
+      ),
+    ).rejects.toThrow("no such file or directory")
+  })
+
+  test("errors when the renamed file already exists", async () => {
+    vol.fromJSON({
+      "/movies/Star Wars (1977)/Star Wars (1977).mkv": "",
+      "/movies/Star Wars (1977)/Star Wars (1977) {edition-4K77}.mkv":
+        "",
+    })
+
+    expect(
+      firstValueFrom(
+        renameFileOrFolder({
+          newPath:
+            "/movies/Star Wars (1977)/Star Wars (1977) {edition-4K77}.mkv",
+          oldPath:
+            "/movies/Star Wars (1977)/Star Wars (1977).mkv",
+        }),
+      ),
+    ).rejects.toThrow("already exists")
+  })
+
+  test("renames a file", async () => {
+    vol.fromJSON({
+      "/movies/Star Wars (1977)/Star Wars (1977).mkv": "",
+    })
+
+    expect(
+      firstValueFrom(
+        renameFileOrFolder({
+          newPath:
+            "/movies/Star Wars (1977)/Star Wars (1977) {edition-4K77}.mkv",
+          oldPath:
+            "/movies/Star Wars (1977)/Star Wars (1977).mkv",
+        }),
+      ),
+    ).resolves.toBeUndefined()
+  })
+})
+
+describe(createRenameFileOrFolderObservable.name, () => {
+  test("completes when the old and new names are the same", async () => {
+    expect(
+      firstValueFrom(
+        createRenameFileOrFolderObservable({
+          fullPath:
+            "/movies/Star Wars (1977)/Star Wars (1977).mkv",
+          sourcePath: "/movies/Star Wars (1977)",
+        })("Star Wars (1977)"),
+      ),
+    ).rejects.toThrow(EmptyError)
+  })
+
+  test("errors when the current file is missing", async () => {
+    await captureLogMessage(
+      "error",
+      async (logMessageSpy) => {
+        await expect(
+          firstValueFrom(
+            createRenameFileOrFolderObservable({
+              fullPath:
+                "/movies/Star Wars (1977)/Star Wars (1977).mkv",
+              sourcePath: "/movies/Star Wars (1977)",
+            })("Star Wars (1977) {edition-4K77}"),
+          ),
+        ).rejects.toThrow(EmptyError)
+
+        expect(
+          logMessageSpy.mock.calls[0].find(
+            (error) =>
+              error instanceof Error && error.message,
+          ).message,
+        ).toContain("no such file or directory")
+      },
+    )
+  })
+
+  test("errors when the renamed file already exists", async () => {
+    vol.fromJSON({
+      "/movies/Star Wars (1977)/Star Wars (1977).mkv": "",
+      "/movies/Star Wars (1977)/Star Wars (1977) {edition-4K77}.mkv":
+        "",
+    })
+
+    await captureLogMessage(
+      "error",
+      async (logMessageSpy) => {
+        await expect(
+          firstValueFrom(
+            createRenameFileOrFolderObservable({
+              fullPath:
+                "/movies/Star Wars (1977)/Star Wars (1977).mkv",
+              sourcePath: "/movies/Star Wars (1977)",
+            })("Star Wars (1977) {edition-4K77}"),
+          ),
+        ).rejects.toThrow(EmptyError)
+
+        expect(
+          logMessageSpy.mock.calls[0].find((text) =>
+            text.includes("already exists"),
+          ),
+        ).toContain("already exists")
+      },
+    )
+  })
+
+  test("renames a file", async () => {
+    vol.fromJSON({
+      "/movies/Star Wars (1977)/Star Wars (1977).mkv": "",
+    })
+
+    await captureLogMessage(
+      "info",
+      async (logMessageSpy) => {
+        await expect(
+          firstValueFrom(
+            createRenameFileOrFolderObservable({
+              fullPath:
+                "/movies/Star Wars (1977)/Star Wars (1977).mkv",
+              sourcePath: "/movies/Star Wars (1977)",
+            })("Star Wars (1977) {edition-4K77}"),
+          ),
+        ).resolves.toEqual({
+          newPath: join(
+            "/movies/Star Wars (1977)",
+            "Star Wars (1977) {edition-4K77}.mkv",
+          ),
+          oldPath:
+            "/movies/Star Wars (1977)/Star Wars (1977).mkv",
+        })
+
+        const logMessageArgs = logMessageSpy.mock.calls[0]
+
+        expect(
+          logMessageArgs.find((text) =>
+            text.includes("RENAMED"),
+          ),
+        ).toContain("RENAMED")
+
+        expect(
+          logMessageArgs.find((text) =>
+            text.includes(
+              "/movies/Star Wars (1977)/Star Wars (1977).mkv",
+            ),
+          ),
+        ).toContain(
+          "/movies/Star Wars (1977)/Star Wars (1977).mkv",
+        )
+
+        expect(
+          logMessageArgs.find((text) =>
+            text.includes(
+              join(
+                "/movies/Star Wars (1977)",
+                "Star Wars (1977) {edition-4K77}.mkv",
+              ),
+            ),
+          ),
+        ).toContain(
+          join(
+            "/movies/Star Wars (1977)",
+            "Star Wars (1977) {edition-4K77}.mkv",
+          ),
+        )
+      },
+    )
+  })
+})

package/src/createRenameFileOrFolder.ts

@@ -0,0 +1,79 @@
+import { rename, stat } from "node:fs/promises"
+import { basename, extname, join } from "node:path"
+import {
+  catchError,
+  concatMap,
+  filter,
+  from,
+  map,
+  of,
+  tap,
+} from "rxjs"
+
+import { logAndSwallowPipelineError } from "./logAndSwallowPipelineError.js"
+import { logInfo } from "./logMessage.js"
+
+export const getLastItemInFilePath = (filePath: string) =>
+  basename(filePath, extname(filePath))
+
+export const renameFileOrFolder = ({
+  newPath,
+  oldPath,
+}: {
+  newPath: string
+  oldPath: string
+}) =>
+  from(stat(newPath)).pipe(
+    // If the file or folder doesn't already exist, this function throws an error. We can safely perform the rename in that case..
+    catchError(() => rename(oldPath, newPath)),
+    // If the `stat` succeeded, then we'll hit this `tap`. That means we can't rename the file because the one we're renaming to already exists.
+    tap((stats) => {
+      if (stats) {
+        throw "File or folder already exists for".concat(
+          " ",
+          '"',
+          getLastItemInFilePath(newPath),
+          '".',
+          " ",
+          `Cannot rename "${oldPath}".`,
+        )
+      }
+    }),
+  )
+
+export const createRenameFileOrFolderObservable =
+  ({
+    fullPath: oldPath,
+    sourcePath,
+  }: {
+    fullPath: string
+    sourcePath: string
+  }) =>
+  (newName: string) =>
+    of({
+      oldPath,
+      newPath: join(sourcePath, newName).concat(
+        extname(oldPath),
+      ),
+    }).pipe(
+      filter(({ newPath, oldPath }) => newPath !== oldPath),
+      concatMap(({ newPath, oldPath }) =>
+        renameFileOrFolder({
+          newPath,
+          oldPath,
+        }).pipe(
+          tap(() => {
+            logInfo("RENAMED", oldPath, newPath)
+          }),
+          // Emit { oldPath, newPath } instead of void so callers
+          // (renameDemos / renameMovieClipDownloads / nameAnimeEpisodes /
+          // nameTvShowEpisodes — every command that streams renameFile
+          // calls into job.results) get a useful per-rename record
+          // instead of a chain of nulls.
+          map(() => ({ newPath, oldPath })),
+        ),
+      ),
+      logAndSwallowPipelineError(
+        createRenameFileOrFolderObservable,
+      ),
+    )

package/src/eslintBooleanPrefixRule.test.ts

@@ -0,0 +1,30 @@
+import { resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { ESLint } from "eslint"
+import { expect, test } from "vitest"
+
+const workspaceRoot = resolve(
+  fileURLToPath(import.meta.url),
+  "../../../..",
+)
+
+const fixturePath = resolve(
+  workspaceRoot,
+  "packages/tools/src/__fixtures__/badBooleanName.ts",
+)
+
+test("boolean variable without is/has prefix triggers naming-convention error", async () => {
+  const eslint = new ESLint({ cwd: workspaceRoot })
+  const [result] = await eslint.lintFiles([fixturePath])
+  // suppressedMessages items are LintMessage objects extended with `suppressions`
+  // (not wrapped in a { message } envelope), so spread them directly.
+  const namingViolations = [
+    ...result.messages,
+    ...result.suppressedMessages,
+  ].filter(
+    (message) =>
+      message.ruleId ===
+      "@typescript-eslint/naming-convention",
+  )
+  expect(namingViolations.length).toBeGreaterThan(0)
+}, 30_000)

package/src/eslintWebtypesGuardRule.test.ts

@@ -0,0 +1,26 @@
+import { resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { ESLint } from "eslint"
+import { expect, test } from "vitest"
+
+const workspaceRoot = resolve(
+  fileURLToPath(import.meta.url),
+  "../../../..",
+)
+
+const fixturePath = resolve(
+  workspaceRoot,
+  "packages/web/src/__eslintFixtures__/localApiShape.tsx",
+)
+
+test("local API-shape type declarations in packages/web trigger no-restricted-syntax error", async () => {
+  const eslint = new ESLint({ cwd: workspaceRoot })
+  const [result] = await eslint.lintFiles([fixturePath])
+  const apiShapeViolations = [
+    ...result.messages,
+    ...result.suppressedMessages,
+  ].filter(
+    (message) => message.ruleId === "no-restricted-syntax",
+  )
+  expect(apiShapeViolations.length).toBeGreaterThan(0)
+}, 30_000)

package/src/getFiles.ts

@@ -0,0 +1,72 @@
+import { readdir, stat } from "node:fs/promises"
+import { join } from "node:path"
+import {
+  catchError,
+  concatAll,
+  concatMap,
+  defer,
+  EMPTY,
+  filter,
+  from,
+  map,
+  type Observable,
+  type OperatorFunction,
+} from "rxjs"
+
+import {
+  createRenameFileOrFolderObservable,
+  getLastItemInFilePath,
+} from "./createRenameFileOrFolder.js"
+import { logAndRethrowPipelineError } from "./logAndRethrowPipelineError.js"
+
+export type FileInfo = {
+  filename: string
+  fullPath: string
+  renameFile: (renamedFilename: string) => Observable<{
+    newPath: string
+    oldPath: string
+  }>
+}
+
+export const filterFileAtPath = <PipelineValue>(
+  getFullPath: (pipelineValue: PipelineValue) => string,
+): OperatorFunction<PipelineValue, PipelineValue> =>
+  concatMap((pipelineValue) =>
+    from(stat(getFullPath(pipelineValue))).pipe(
+      filter((stats) => stats.isFile()),
+      map(() => pipelineValue),
+      catchError((error) => {
+        if (error.code === "ENOENT") {
+          return EMPTY
+        }
+
+        throw error
+      }),
+    ),
+  )
+
+export const getFiles = ({
+  sourcePath,
+}: {
+  sourcePath: string
+}): Observable<FileInfo> =>
+  defer(() => readdir(sourcePath)).pipe(
+    concatAll(),
+    map((filePath) => ({
+      filename: getLastItemInFilePath(filePath),
+      fullPath: join(sourcePath, filePath),
+    })),
+    filterFileAtPath(({ fullPath }) => fullPath),
+    map(
+      ({ filename, fullPath }) =>
+        ({
+          filename,
+          fullPath,
+          renameFile: createRenameFileOrFolderObservable({
+            fullPath,
+            sourcePath,
+          }),
+        }) satisfies FileInfo as FileInfo,
+    ),
+    logAndRethrowPipelineError(getFiles),
+  )

package/src/getFilesAtDepth.test.ts

@@ -0,0 +1,158 @@
+import { join } from "node:path"
+import { vol } from "memfs"
+import { firstValueFrom, toArray } from "rxjs"
+import { beforeEach, describe, expect, test } from "vitest"
+
+import { captureLogMessage } from "./captureLogMessage.js"
+import type { FileInfo } from "./getFiles.js"
+import { getFilesAtDepth } from "./getFilesAtDepth.js"
+
+describe(getFilesAtDepth.name, () => {
+  beforeEach(() => {
+    vol.fromJSON({
+      "/demos/Dolby/[Dolby] 747 (Audio) {FHD SDR & Dolby Atmos TrueHD}.mkv":
+        "",
+      "/movies/Star Wars (1977)/Star Wars (1977).mkv": "",
+      "/movies/Star Wars (1977)/Star Wars (1977) {edition-4K77}.mkv":
+        "",
+      "/movies/Super Mario Bros (1993)/Super Mario Bros (1993).mkv":
+        "",
+    })
+  })
+
+  test("errors if source path can't be found", async () => {
+    captureLogMessage("error", async () => {
+      expect(
+        firstValueFrom(
+          getFilesAtDepth({
+            depth: 0,
+            sourcePath: "non-existent-path",
+          }),
+        ),
+      ).rejects.toThrow("ENOENT")
+    })
+  })
+
+  test("emits no files when source only contains folders", async () => {
+    await expect(
+      firstValueFrom(
+        getFilesAtDepth({
+          depth: 0,
+          sourcePath: "/movies",
+        }).pipe(toArray()),
+      ),
+    ).resolves.toEqual([] satisfies FileInfo[])
+  })
+
+  test("emits files when source contains files", async () => {
+    const expected: FileInfo[] = [
+      {
+        filename: "Star Wars (1977)",
+        fullPath: join(
+          "/movies/Star Wars (1977)",
+          "Star Wars (1977).mkv",
+        ),
+        renameFile: expect.any(Function),
+      },
+      {
+        filename: "Star Wars (1977) {edition-4K77}",
+        fullPath: join(
+          "/movies/Star Wars (1977)",
+          "Star Wars (1977) {edition-4K77}.mkv",
+        ),
+        renameFile: expect.any(Function),
+      },
+    ]
+    const actual = await firstValueFrom(
+      getFilesAtDepth({
+        depth: 0,
+        sourcePath: "/movies/Star Wars (1977)",
+      }).pipe(toArray()),
+    )
+    expect(actual).toEqual(expect.arrayContaining(expected))
+    expect(actual).toHaveLength(expected.length)
+  })
+
+  test("emits files when source contains files 1-level deep", async () => {
+    const expected: FileInfo[] = [
+      {
+        filename: "Star Wars (1977)",
+        fullPath: join(
+          "/movies/Star Wars (1977)",
+          "Star Wars (1977).mkv",
+        ),
+        renameFile: expect.any(Function),
+      },
+      {
+        filename: "Star Wars (1977) {edition-4K77}",
+        fullPath: join(
+          "/movies/Star Wars (1977)",
+          "Star Wars (1977) {edition-4K77}.mkv",
+        ),
+        renameFile: expect.any(Function),
+      },
+      {
+        filename: "Super Mario Bros (1993)",
+        fullPath: join(
+          "/movies/Super Mario Bros (1993)",
+          "Super Mario Bros (1993).mkv",
+        ),
+        renameFile: expect.any(Function),
+      },
+    ]
+    const actual = await firstValueFrom(
+      getFilesAtDepth({
+        depth: 1,
+        sourcePath: "/movies",
+      }).pipe(toArray()),
+    )
+    expect(actual).toEqual(expect.arrayContaining(expected))
+    expect(actual).toHaveLength(expected.length)
+  })
+
+  test("emits files when source contains files 2-levels deep", async () => {
+    const expected: FileInfo[] = [
+      {
+        filename:
+          "[Dolby] 747 (Audio) {FHD SDR & Dolby Atmos TrueHD}",
+        fullPath: join(
+          "/demos/Dolby",
+          "[Dolby] 747 (Audio) {FHD SDR & Dolby Atmos TrueHD}.mkv",
+        ),
+        renameFile: expect.any(Function),
+      },
+      {
+        filename: "Star Wars (1977)",
+        fullPath: join(
+          "/movies/Star Wars (1977)",
+          "Star Wars (1977).mkv",
+        ),
+        renameFile: expect.any(Function),
+      },
+      {
+        filename: "Star Wars (1977) {edition-4K77}",
+        fullPath: join(
+          "/movies/Star Wars (1977)",
+          "Star Wars (1977) {edition-4K77}.mkv",
+        ),
+        renameFile: expect.any(Function),
+      },
+      {
+        filename: "Super Mario Bros (1993)",
+        fullPath: join(
+          "/movies/Super Mario Bros (1993)",
+          "Super Mario Bros (1993).mkv",
+        ),
+        renameFile: expect.any(Function),
+      },
+    ]
+    const actual = await firstValueFrom(
+      getFilesAtDepth({
+        depth: 2,
+        sourcePath: "/",
+      }).pipe(toArray()),
+    )
+    expect(actual).toEqual(expect.arrayContaining(expected))
+    expect(actual).toHaveLength(expected.length)
+  })
+})

package/src/getFilesAtDepth.ts

@@ -0,0 +1,32 @@
+import { concat, concatMap, EMPTY, filter, iif } from "rxjs"
+import { getFiles } from "./getFiles.js"
+import { getFolder } from "./getFolder.js"
+import { logAndRethrowPipelineError } from "./logAndRethrowPipelineError.js"
+
+export const getFilesAtDepth = ({
+  depth,
+  sourcePath,
+}: {
+  depth: number
+  sourcePath: string
+}): ReturnType<typeof getFiles> =>
+  concat(
+    getFiles({
+      sourcePath,
+    }),
+    iif(
+      () => depth > 0,
+      getFolder({
+        sourcePath,
+      }).pipe(
+        concatMap((folderInfo) =>
+          getFilesAtDepth({
+            depth: depth - 1,
+            sourcePath: folderInfo.fullPath,
+          }),
+        ),
+        filter(Boolean),
+      ),
+      EMPTY,
+    ),
+  ).pipe(logAndRethrowPipelineError(getFilesAtDepth))