Fix CI and ts-format.

Author: koculu

packages/ts-format/src/files.test.ts

@@ -1,5 +1,12 @@
 import { execFileSync } from 'node:child_process'
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import {
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  symlink,
+  writeFile,
+} from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
 import { describe, expect, it } from 'vitest'
@@ -31,39 +38,78 @@ describe('formatFiles', () => {
     }
   })
 
-  it('honors Git ignores and exclusions while collecting errors and formatting other files', async () => {
-    const cwd = await mkdtemp(path.join(tmpdir(), 'purestack-format-'))
+  const caseInsensitivePaths =
+    process.platform === 'win32' || process.platform === 'darwin'
+
+  it.each(caseInsensitivePaths ? [false, true] : [false])(
+    'honors Git ignores and exclusions while collecting errors (uppercase path: %s)',
+    async (uppercase) => {
+      const directory = await mkdtemp(path.join(tmpdir(), 'purestack-format-'))
+      const cwd = uppercase ? directory.toUpperCase() : directory
+      try {
+        execFileSync('git', ['init', cwd], { stdio: 'ignore' })
+        await writeFile(path.join(cwd, '.gitignore'), 'ignored.mdx\n')
+        await writeFile(
+          path.join(cwd, 'ignored.mdx'),
+          '<Panel><Badge /></Panel>',
+        )
+        await writeFile(
+          path.join(cwd, 'excluded.mdx'),
+          '<Panel><Badge /></Panel>',
+        )
+        await writeFile(path.join(cwd, 'good.mdx'), '<Panel><Badge /></Panel>')
+        await writeFile(
+          path.join(cwd, 'bad.mdx'),
+          '<Panel title="broken></Panel>',
+        )
+        const result = await formatFiles(['.', 'missing.mdx'], {
+          cwd,
+          write: true,
+          exclude: [uppercase ? 'EXCLUDED.mdx' : 'excluded.mdx'],
+        })
+        expect(result.checked).toBe(2)
+        expect(result.changed).toEqual([path.join(cwd, 'good.mdx')])
+        expect(
+          result.errors.map((error) => path.basename(error.filePath)).sort(),
+        ).toEqual(['bad.mdx', 'missing.mdx'])
+        expect(await readFile(path.join(cwd, 'bad.mdx'), 'utf8')).toBe(
+          '<Panel title="broken></Panel>',
+        )
+        expect(await readFile(path.join(cwd, 'ignored.mdx'), 'utf8')).toBe(
+          '<Panel><Badge /></Panel>',
+        )
+      } finally {
+        await rm(directory, { recursive: true, force: true })
+      }
+    },
+  )
+
+  it('honors Git ignores and exclusions through a directory alias', async () => {
+    const directory = await mkdtemp(path.join(tmpdir(), 'purestack-format-'))
+    const projects = path.join(directory, 'projects')
+    const repository = path.join(projects, 'project with spaces')
+    const alias = path.join(directory, 'projects-alias')
+    const cwd = path.join(alias, 'project with spaces')
     try {
-      execFileSync('git', ['init', cwd], { stdio: 'ignore' })
-      await writeFile(path.join(cwd, '.gitignore'), 'ignored.mdx\n')
-      await writeFile(path.join(cwd, 'ignored.mdx'), '<Panel><Badge /></Panel>')
-      await writeFile(
-        path.join(cwd, 'excluded.mdx'),
-        '<Panel><Badge /></Panel>',
-      )
-      await writeFile(path.join(cwd, 'good.mdx'), '<Panel><Badge /></Panel>')
-      await writeFile(
-        path.join(cwd, 'bad.mdx'),
-        '<Panel title="broken></Panel>',
+      await mkdir(repository, { recursive: true })
+      execFileSync('git', ['init', repository], { stdio: 'ignore' })
+      await writeFile(path.join(repository, '.gitignore'), 'ignored.mdx\n')
+      for (const file of ['good.mdx', 'excluded.mdx', 'ignored.mdx'])
+        await writeFile(path.join(repository, file), '<Panel><Badge /></Panel>')
+      await symlink(
+        projects,
+        alias,
+        process.platform === 'win32' ? 'junction' : 'dir',
       )
-      const result = await formatFiles(['.', 'missing.mdx'], {
+      const result = await formatFiles(['.'], {
         cwd,
-        write: true,
         exclude: ['excluded.mdx'],
       })
-      expect(result.checked).toBe(2)
+      expect(result.errors).toEqual([])
+      expect(result.checked).toBe(1)
       expect(result.changed).toEqual([path.join(cwd, 'good.mdx')])
-      expect(
-        result.errors.map((error) => path.basename(error.filePath)).sort(),
-      ).toEqual(['bad.mdx', 'missing.mdx'])
-      expect(await readFile(path.join(cwd, 'bad.mdx'), 'utf8')).toBe(
-        '<Panel title="broken></Panel>',
-      )
-      expect(await readFile(path.join(cwd, 'ignored.mdx'), 'utf8')).toBe(
-        '<Panel><Badge /></Panel>',
-      )
     } finally {
-      await rm(cwd, { recursive: true, force: true })
+      await rm(directory, { recursive: true, force: true })
     }
   })
 })

packages/ts-format/src/files.ts

@@ -6,6 +6,11 @@ import { formatSource } from './index'
 import type { FormatOptions } from './source'
 
 const exec = promisify(execFile)
+// Windows and macOS file systems ignore letter case by default.
+const caseInsensitivePaths =
+  process.platform === 'win32' || process.platform === 'darwin'
+const comparablePath = (value: string) =>
+  caseInsensitivePaths ? value.toLowerCase() : value
 const extensions = /\.(?:[cm]?ts|mdx|rmdx)$/i
 const ignoredDirectories = new Set([
   '.git',
@@ -40,20 +45,22 @@ export async function formatFiles(
 ) {
   const cwd = path.resolve(options.cwd ?? process.cwd())
   const excluded = (options.exclude ?? []).map((entry) =>
-    path.resolve(cwd, entry),
+    comparablePath(path.resolve(cwd, entry)),
   )
   const files = new Set<string>()
   const errors: FormatFileError[] = []
   const changed: string[] = []
 
   function isExcluded(file: string) {
+    const comparable = comparablePath(file)
     return (
       path
         .relative(cwd, file)
         .split(path.sep)
-        .some((part) => ignoredDirectories.has(part)) ||
+        .some((part) => ignoredDirectories.has(comparablePath(part))) ||
       excluded.some(
-        (entry) => file === entry || file.startsWith(`${entry}${path.sep}`),
+        (entry) =>
+          comparable === entry || comparable.startsWith(`${entry}${path.sep}`),
       )
     )
   }
@@ -84,34 +91,26 @@ export async function formatFiles(
       if (!entry.isDirectory() || isExcluded(target)) continue
       let gitFiles: string[] | undefined
       try {
-        const { stdout: root } = await exec('git', [
-          '-C',
-          target,
-          'rev-parse',
-          '--show-toplevel',
-        ])
-        const repository = root.trim()
-        const relative =
-          path.relative(repository, target).split(path.sep).join('/') || '.'
         const { stdout } = await exec(
           'git',
           [
             '-C',
-            repository,
+            target,
             'ls-files',
             '--cached',
             '--others',
             '--exclude-standard',
             '-z',
             '--',
-            relative,
+            '.',
           ],
           { maxBuffer: 32 * 1024 * 1024 },
         )
         gitFiles = stdout
           .split('\0')
           .filter(Boolean)
-          .map((file) => path.resolve(repository, file))
+          // Git lists paths relative to -C, so keep the caller's path spelling.
+          .map((file) => path.resolve(target, file))
       } catch {
         // Git is optional; a standalone project still has a formatter.
       }