banhaten 0.3.0 → 0.5.0

package/src/cli/file-transaction.js

@@ -1,295 +1,302 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-import process from "node:process"
-
-let activeFileTransaction = null
-let transactionFileCounter = 0
-
-export async function runFileTransaction(action) {
-  if (activeFileTransaction) {
-    throw new Error("nested file transactions are not supported")
-  }
-
-  const transaction = {
-    writes: new Map(),
-    preconditions: new Map(),
-    afterApply: [],
-  }
-  activeFileTransaction = transaction
-
-  try {
-    const result = await action()
-    await commitFileTransaction(transaction)
-    activeFileTransaction = null
-
-    for (const callback of transaction.afterApply) {
-      await callback()
-    }
-
-    return result
-  } catch (error) {
-    activeFileTransaction = null
-    throw error
-  }
-}
-
-export function deferUntilApplied(callback) {
-  if (!activeFileTransaction) {
-    return callback()
-  }
-
-  activeFileTransaction.afterApply.push(callback)
-}
-
-async function commitFileTransaction(transaction) {
-  const staged = []
-  const committed = []
-  const createdDirectories = new Set()
-  let failed = false
-
-  try {
-    await assertTransactionPreconditions(transaction)
-
-    for (const entry of transaction.writes.values()) {
-      await ensureDirectory(
-        path.dirname(entry.targetPath),
-        createdDirectories
-      )
-      const tempPath = `${entry.targetPath}.banhaten-${process.pid}-${transactionFileCounter += 1}.tmp`
-      const previous = await readFileSnapshot(entry.targetPath)
-
-      await fs.writeFile(tempPath, entry.content)
-      if (previous?.mode !== undefined) {
-        await fs.chmod(tempPath, previous.mode)
-      }
-      staged.push({ ...entry, tempPath, previous })
-    }
-
-    await assertTransactionPreconditions(transaction)
-
-    for (const entry of staged) {
-      await fs.rename(entry.tempPath, entry.targetPath)
-      committed.push(entry)
-    }
-  } catch (error) {
-    failed = true
-    for (const entry of [...committed].reverse()) {
-      await restoreFileSnapshot(entry.targetPath, entry.previous)
-    }
-
-    throw new Error(`file transaction failed and was rolled back: ${error.message}`)
-  } finally {
-    await Promise.all(
-      staged.map((entry) => fs.rm(entry.tempPath, { force: true }).catch(() => {}))
-    )
-    if (failed) {
-      await removeCreatedDirectories(createdDirectories)
-    }
-  }
-}
-
-async function ensureDirectory(targetPath, createdDirectories) {
-  const missing = []
-  let directory = targetPath
-
-  while (!(await exists(directory))) {
-    missing.push(directory)
-    const parent = path.dirname(directory)
-    if (parent === directory) break
-    directory = parent
-  }
-
-  for (const missingDirectory of missing.reverse()) {
-    try {
-      await fs.mkdir(missingDirectory)
-      createdDirectories.add(missingDirectory)
-    } catch (error) {
-      if (error.code !== "EEXIST") throw error
-    }
-  }
-}
-
-async function removeCreatedDirectories(createdDirectories) {
-  for (const directory of [...createdDirectories].reverse()) {
-    await fs.rmdir(directory).catch(() => {})
-  }
-}
-
-async function assertTransactionPreconditions(transaction) {
-  for (const [targetPath, expectedCurrent] of transaction.preconditions) {
-    const current = await readFileSnapshot(targetPath)
-    assertExpectedCurrent(targetPath, current?.content ?? null, expectedCurrent)
-  }
-}
-
-async function readFileSnapshot(targetPath) {
-  try {
-    const [content, stats] = await Promise.all([
-      fs.readFile(targetPath),
-      fs.stat(targetPath),
-    ])
-    return { content, mode: stats.mode }
-  } catch (error) {
-    if (error.code === "ENOENT") return null
-    throw error
-  }
-}
-
-async function restoreFileSnapshot(targetPath, snapshot) {
-  if (!snapshot) {
-    await fs.rm(targetPath, { force: true })
-    return
-  }
-
-  const tempPath = `${targetPath}.banhaten-rollback-${process.pid}-${transactionFileCounter += 1}.tmp`
-  await fs.writeFile(tempPath, snapshot.content)
-  await fs.chmod(tempPath, snapshot.mode)
-  await fs.rename(tempPath, targetPath)
-}
-
-export async function writeFile(targetPath, content, options) {
-  const alreadyExists = await exists(targetPath)
-  const isBinary = Buffer.isBuffer(content)
-  const contentBuffer = isBinary ? content : Buffer.from(content, "utf8")
-  const current = alreadyExists ? await fs.readFile(targetPath) : null
-  const isEqual = current?.equals(contentBuffer) || false
-  if (options.expectedCurrent !== undefined) {
-    const expectedCurrent = toExpectedBuffer(options.expectedCurrent)
-    assertExpectedCurrent(targetPath, current, expectedCurrent)
-    registerPrecondition(targetPath, expectedCurrent)
-  }
-
-  if (options.dryRun) {
-    if (!alreadyExists) return "would write"
-    if (isEqual) return "would keep"
-
-    return "would update"
-  }
-
-  if (alreadyExists && isEqual) {
-    return "kept"
-  }
-
-  if (!activeFileTransaction) {
-    throw new Error(`refusing non-transactional write to ${targetPath}`)
-  }
-
-  const existingPlan = activeFileTransaction.writes.get(targetPath)
-  if (existingPlan && !existingPlan.content.equals(contentBuffer)) {
-    throw new Error(`conflicting planned writes for ${targetPath}`)
-  }
-  activeFileTransaction.writes.set(targetPath, {
-    targetPath,
-    content: contentBuffer,
-  })
-
-  return alreadyExists ? "updated" : "wrote"
-}
-
-export async function assertFileUnchanged(targetPath, expectedCurrent) {
-  if (!activeFileTransaction) {
-    throw new Error(`refusing non-transactional precondition for ${targetPath}`)
-  }
-
-  const expectedBuffer = toExpectedBuffer(expectedCurrent)
-  const current = await readFileContent(targetPath)
-  assertExpectedCurrent(targetPath, current, expectedBuffer)
-  registerPrecondition(targetPath, expectedBuffer)
-}
-
-function registerPrecondition(targetPath, expectedCurrent) {
-  if (!activeFileTransaction) {
-    throw new Error(`refusing non-transactional precondition for ${targetPath}`)
-  }
-
-  const existing = activeFileTransaction.preconditions.get(targetPath)
-  if (existing !== undefined) {
-    assertExpectedCurrent(targetPath, existing, expectedCurrent)
-    return
-  }
-  activeFileTransaction.preconditions.set(targetPath, expectedCurrent)
-}
-
-function assertExpectedCurrent(targetPath, current, expected) {
-  const matches = expected === null
-    ? current === null
-    : current?.equals(expected) || false
-  if (!matches) {
-    throw new Error(
-      `${targetPath} changed while Banhaten was preparing the install plan`
-    )
-  }
-}
-
-function toExpectedBuffer(expectedCurrent) {
-  return expectedCurrent === null
-    ? null
-    : Buffer.from(expectedCurrent)
-}
-
-async function readFileContent(targetPath) {
-  try {
-    return await fs.readFile(targetPath)
-  } catch (error) {
-    if (error.code === "ENOENT") return null
-    throw error
-  }
-}
-
-export function formatUnifiedDiff(fileLabel, currentContent, nextContent) {
-  const current = toDiffLines(currentContent)
-  const next = toDiffLines(nextContent)
-  let prefix = 0
-
-  while (
-    prefix < current.length &&
-    prefix < next.length &&
-    current[prefix] === next[prefix]
-  ) {
-    prefix += 1
-  }
-
-  let currentSuffix = current.length
-  let nextSuffix = next.length
-  while (
-    currentSuffix > prefix &&
-    nextSuffix > prefix &&
-    current[currentSuffix - 1] === next[nextSuffix - 1]
-  ) {
-    currentSuffix -= 1
-    nextSuffix -= 1
-  }
-
-  const context = 3
-  const start = Math.max(0, prefix - context)
-  const currentEnd = Math.min(current.length, currentSuffix + context)
-  const nextEnd = Math.min(next.length, nextSuffix + context)
-  const currentCount = currentEnd - start
-  const nextCount = nextEnd - start
-  const output = [
-    `--- a/${fileLabel}`,
-    `+++ b/${fileLabel}`,
-    `@@ -${start + 1},${currentCount} +${start + 1},${nextCount} @@`,
-  ]
-
-  for (const line of current.slice(start, prefix)) output.push(` ${line}`)
-  for (const line of current.slice(prefix, currentSuffix)) output.push(`-${line}`)
-  for (const line of next.slice(prefix, nextSuffix)) output.push(`+${line}`)
-  for (const line of current.slice(currentSuffix, currentEnd)) output.push(` ${line}`)
-
-  return output.join("\n")
-}
-
-function toDiffLines(content) {
-  if (Buffer.isBuffer(content)) return [`Binary content (${content.byteLength} bytes)`]
-  return String(content).replace(/\r\n/g, "\n").split("\n")
-}
-
-async function exists(filePath) {
-  try {
-    await fs.access(filePath)
-    return true
-  } catch {
-    return false
-  }
-}
+import fs from "node:fs/promises"
+import path from "node:path"
+import process from "node:process"
+
+let activeFileTransaction = null
+let transactionFileCounter = 0
+
+export async function runFileTransaction(action) {
+  if (activeFileTransaction) {
+    throw new Error("nested file transactions are not supported")
+  }
+
+  const transaction = {
+    writes: new Map(),
+    preconditions: new Map(),
+    afterApply: [],
+  }
+  activeFileTransaction = transaction
+
+  try {
+    const result = await action()
+    await commitFileTransaction(transaction)
+    activeFileTransaction = null
+
+    for (const callback of transaction.afterApply) {
+      await callback()
+    }
+
+    return result
+  } catch (error) {
+    activeFileTransaction = null
+    throw error
+  }
+}
+
+export function deferUntilApplied(callback) {
+  if (!activeFileTransaction) {
+    return callback()
+  }
+
+  activeFileTransaction.afterApply.push(callback)
+}
+
+async function commitFileTransaction(transaction) {
+  const staged = []
+  const committed = []
+  const createdDirectories = new Set()
+  let failed = false
+
+  try {
+    await assertTransactionPreconditions(transaction)
+
+    for (const entry of transaction.writes.values()) {
+      await ensureDirectory(
+        path.dirname(entry.targetPath),
+        createdDirectories
+      )
+      const tempPath = `${entry.targetPath}.banhaten-${process.pid}-${transactionFileCounter += 1}.tmp`
+      const previous = await readFileSnapshot(entry.targetPath)
+
+      await fs.writeFile(tempPath, entry.content)
+      if (previous?.mode !== undefined) {
+        await fs.chmod(tempPath, previous.mode)
+      }
+      staged.push({ ...entry, tempPath, previous })
+    }
+
+    await assertTransactionPreconditions(transaction)
+
+    for (const entry of staged) {
+      await fs.rename(entry.tempPath, entry.targetPath)
+      committed.push(entry)
+    }
+  } catch (error) {
+    failed = true
+    for (const entry of [...committed].reverse()) {
+      await restoreFileSnapshot(entry.targetPath, entry.previous)
+    }
+
+    throw new Error(`file transaction failed and was rolled back: ${error.message}`)
+  } finally {
+    await Promise.all(
+      staged.map((entry) => fs.rm(entry.tempPath, { force: true }).catch(() => {}))
+    )
+    if (failed) {
+      await removeCreatedDirectories(createdDirectories)
+    }
+  }
+}
+
+async function ensureDirectory(targetPath, createdDirectories) {
+  const missing = []
+  let directory = targetPath
+
+  while (!(await exists(directory))) {
+    missing.push(directory)
+    const parent = path.dirname(directory)
+    if (parent === directory) break
+    directory = parent
+  }
+
+  for (const missingDirectory of missing.reverse()) {
+    try {
+      await fs.mkdir(missingDirectory)
+      createdDirectories.add(missingDirectory)
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error
+    }
+  }
+}
+
+async function removeCreatedDirectories(createdDirectories) {
+  for (const directory of [...createdDirectories].reverse()) {
+    await fs.rmdir(directory).catch(() => {})
+  }
+}
+
+async function assertTransactionPreconditions(transaction) {
+  for (const [targetPath, expectedCurrent] of transaction.preconditions) {
+    const current = await readFileSnapshot(targetPath)
+    assertExpectedCurrent(targetPath, current?.content ?? null, expectedCurrent)
+  }
+}
+
+async function readFileSnapshot(targetPath) {
+  try {
+    const [content, stats] = await Promise.all([
+      fs.readFile(targetPath),
+      fs.stat(targetPath),
+    ])
+    return { content, mode: stats.mode }
+  } catch (error) {
+    if (error.code === "ENOENT") return null
+    throw error
+  }
+}
+
+async function restoreFileSnapshot(targetPath, snapshot) {
+  if (!snapshot) {
+    await fs.rm(targetPath, { force: true })
+    return
+  }
+
+  const tempPath = `${targetPath}.banhaten-rollback-${process.pid}-${transactionFileCounter += 1}.tmp`
+  await fs.writeFile(tempPath, snapshot.content)
+  await fs.chmod(tempPath, snapshot.mode)
+  await fs.rename(tempPath, targetPath)
+}
+
+export async function writeFile(targetPath, content, options) {
+  if (!activeFileTransaction) {
+    throw new Error(`refusing non-transactional write to ${targetPath}`)
+  }
+
+  const current = await readFileForUpdate(targetPath)
+  const alreadyExists = current !== null
+  const isBinary = Buffer.isBuffer(content)
+  const contentBuffer = isBinary ? content : Buffer.from(content, "utf8")
+  const isEqual = current?.equals(contentBuffer) || false
+  if (options.expectedCurrent !== undefined) {
+    const expectedCurrent = toExpectedBuffer(options.expectedCurrent)
+    assertExpectedCurrent(targetPath, current, expectedCurrent)
+  }
+
+  if (options.dryRun) {
+    if (!alreadyExists) return "would write"
+    if (isEqual) return "would keep"
+
+    return "would update"
+  }
+
+  if (alreadyExists && isEqual) {
+    return "kept"
+  }
+
+  const existingPlan = activeFileTransaction.writes.get(targetPath)
+  if (existingPlan && !existingPlan.content.equals(contentBuffer)) {
+    throw new Error(`conflicting planned writes for ${targetPath}`)
+  }
+  activeFileTransaction.writes.set(targetPath, {
+    targetPath,
+    content: contentBuffer,
+  })
+
+  return alreadyExists ? "updated" : "wrote"
+}
+
+// Pin the bytes (or absence) used for ownership checks and read/modify/write
+// planning. Later reads and writes must agree with this first observation.
+export async function readFileForUpdate(targetPath) {
+  const current = await readFileContent(targetPath)
+  registerPrecondition(targetPath, current)
+  return current
+}
+
+export async function assertFileUnchanged(targetPath, expectedCurrent) {
+  if (!activeFileTransaction) {
+    throw new Error(`refusing non-transactional precondition for ${targetPath}`)
+  }
+
+  const expectedBuffer = toExpectedBuffer(expectedCurrent)
+  const current = await readFileContent(targetPath)
+  assertExpectedCurrent(targetPath, current, expectedBuffer)
+  registerPrecondition(targetPath, expectedBuffer)
+}
+
+function registerPrecondition(targetPath, expectedCurrent) {
+  if (!activeFileTransaction) {
+    throw new Error(`refusing non-transactional precondition for ${targetPath}`)
+  }
+
+  const existing = activeFileTransaction.preconditions.get(targetPath)
+  if (existing !== undefined) {
+    assertExpectedCurrent(targetPath, existing, expectedCurrent)
+    return
+  }
+  activeFileTransaction.preconditions.set(targetPath, toExpectedBuffer(expectedCurrent))
+}
+
+function assertExpectedCurrent(targetPath, current, expected) {
+  const matches = expected === null
+    ? current === null
+    : current?.equals(expected) || false
+  if (!matches) {
+    throw new Error(
+      `${targetPath} changed while Banhaten was preparing the install plan`
+    )
+  }
+}
+
+function toExpectedBuffer(expectedCurrent) {
+  return expectedCurrent === null
+    ? null
+    : Buffer.from(expectedCurrent)
+}
+
+async function readFileContent(targetPath) {
+  try {
+    return await fs.readFile(targetPath)
+  } catch (error) {
+    if (error.code === "ENOENT") return null
+    throw error
+  }
+}
+
+export function formatUnifiedDiff(fileLabel, currentContent, nextContent) {
+  const current = toDiffLines(currentContent)
+  const next = toDiffLines(nextContent)
+  let prefix = 0
+
+  while (
+    prefix < current.length &&
+    prefix < next.length &&
+    current[prefix] === next[prefix]
+  ) {
+    prefix += 1
+  }
+
+  let currentSuffix = current.length
+  let nextSuffix = next.length
+  while (
+    currentSuffix > prefix &&
+    nextSuffix > prefix &&
+    current[currentSuffix - 1] === next[nextSuffix - 1]
+  ) {
+    currentSuffix -= 1
+    nextSuffix -= 1
+  }
+
+  const context = 3
+  const start = Math.max(0, prefix - context)
+  const currentEnd = Math.min(current.length, currentSuffix + context)
+  const nextEnd = Math.min(next.length, nextSuffix + context)
+  const currentCount = currentEnd - start
+  const nextCount = nextEnd - start
+  const output = [
+    `--- a/${fileLabel}`,
+    `+++ b/${fileLabel}`,
+    `@@ -${start + 1},${currentCount} +${start + 1},${nextCount} @@`,
+  ]
+
+  for (const line of current.slice(start, prefix)) output.push(` ${line}`)
+  for (const line of current.slice(prefix, currentSuffix)) output.push(`-${line}`)
+  for (const line of next.slice(prefix, nextSuffix)) output.push(`+${line}`)
+  for (const line of current.slice(currentSuffix, currentEnd)) output.push(` ${line}`)
+
+  return output.join("\n")
+}
+
+function toDiffLines(content) {
+  if (Buffer.isBuffer(content)) return [`Binary content (${content.byteLength} bytes)`]
+  return String(content).replace(/\r\n/g, "\n").split("\n")
+}
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath)
+    return true
+  } catch {
+    return false
+  }
+}