diff options
| author | Lily <[email protected]> | 2026-07-28 16:12:21 +1000 |
|---|---|---|
| committer | GitHub <[email protected]> | 2026-07-28 16:12:21 +1000 |
| commit | c11e17573334dfb487a8e1cc25fa84fa9e138f5c (patch) | |
| tree | e91dbd19b524f9432da6bcb86b1fc193e0d02e26 /src/commands/unexpand.js | |
| parent | 6a2f098e72e71437154ec00506e8e736aa8e1026 (diff) | |
| download | bnu-c11e17573334dfb487a8e1cc25fa84fa9e138f5c.tar.gz bnu-c11e17573334dfb487a8e1cc25fa84fa9e138f5c.zip | |
Refactor coreutils into single-call command modules (#1)
* Refactor to single call
Diffstat (limited to 'src/commands/unexpand.js')
| -rw-r--r-- | src/commands/unexpand.js | 195 |
1 files changed, 195 insertions, 0 deletions
diff --git a/src/commands/unexpand.js b/src/commands/unexpand.js new file mode 100644 index 0000000..2d2b0f2 --- /dev/null +++ b/src/commands/unexpand.js @@ -0,0 +1,195 @@ +#!/usr/bin/env bun + +import { closeSync, openSync } from "node:fs"; +import { concatBytes, enc, isWriteError, nodeErrorMessage, parseOptions, readFdChunkViews, systemErrorMessage } from "../shared/common.js"; +import { UsageError, stderr, stdout } from "../shared/diagnostics.js"; +import { UNEXPAND_LONG_OPTIONS, combinedTabSpec, nextTabColumn, normalizeTabArgs, normalizeTabCommandLongOptions, parseTabStops, tabCommandMetaOption } from "../shared/tabs.js"; +import { nextUtf8Token, tabFoldDiagnosticName } from "../shared/text.js"; +import { defineCommand, runAsMain } from "../shared/command.js"; + +export async function unexpand(args) { + const obsoleteTabs = args.some((arg) => /^-\d[\d,\s]*$/.test(arg)); + args = normalizeTabArgs(normalizeTabCommandLongOptions(args, UNEXPAND_LONG_OPTIONS)); + const { opts, operands } = parseOptions(args, { short: { t: "value", a: false }, long: { tabs: "value", all: false, "first-only": false, help: false, version: false } }); + let stops; + try { + stops = parseTabStops(combinedTabSpec(opts.tabs ?? opts.tab, opts.t), "unexpand"); + } catch (error) { + if (obsoleteTabs && error instanceof UsageError && error.message.startsWith("tab stop is too large")) throw new UsageError("tab stop value is too large"); + throw error; + } + const hasExplicitTabs = opts.t != null || opts.tab != null || opts.tabs != null; + const convertAll = Boolean(opts.a || opts.all || (hasExplicitTabs && !opts["first-only"] && !obsoleteTabs)); + const files = operands.length ? operands : ["-"]; + let failed = false; + for (const file of files) { + let fd; + try { + fd = file === "-" ? 0 : openSync(file, "r"); + streamUnexpandFd(fd, stops, convertAll); + } catch (error) { + if (isWriteError(error)) throw error; + stderr(file === "-" ? `unexpand: ${nodeErrorMessage(error)}\n` : `unexpand: ${tabFoldDiagnosticName(file)}: ${systemErrorMessage(error)}\n`); + failed = true; + } finally { + if (fd != null && fd !== 0) closeSync(fd); + } + } + return failed ? 1 : 0; +} + +export function streamUnexpandFd(fd, stops, convertAll) { + const newline = Uint8Array.of(0x0a); + let column = 0; + let fieldStarted = false; + let blankStartColumn = 0; + let blanks = []; + let carry = Buffer.alloc(0); + const output = []; + const flushOutput = () => { + for (const piece of output) stdout(piece); + output.length = 0; + }; + const emit = (piece) => { + if (piece.length) output.push(piece); + if (output.length >= 256) flushOutput(); + }; + const flushBlanks = (atEnd) => { + if (!blanks.length) return; + const canConvert = convertAll || !fieldStarted; + emit(canConvert + ? renderUnexpandedBlankTokens(blankStartColumn, column, blanks, stops, atEnd, blanks.some((token) => isAsciiByteToken(token, 0x09)), !fieldStarted) + : concatBytes(blanks.map((token) => token.bytes))); + blanks = []; + }; + const addBlank = (token) => { + if (!blanks.length) blankStartColumn = column; + blanks.push({ ...token, bytes: Buffer.from(token.bytes) }); + column = tokenEndColumn(token, column, stops); + }; + readFdChunkViews(fd, (chunk) => { + const bytes = carry.length ? Buffer.concat([carry, chunk]) : chunk; + carry = Buffer.alloc(0); + let runStart = -1; + const endRun = (end) => { + if (runStart !== -1) emit(bytes.subarray(runStart, end)); + runStart = -1; + }; + let index = 0; + while (index < bytes.length) { + const byte = bytes[index]; + if (byte < 0x80) { + if (byte === 0x0a) { + endRun(index); + flushBlanks(true); + emit(newline); + column = 0; + fieldStarted = false; + } else if (byte === 0x20 || byte === 0x09) { + endRun(index); + addBlank({ bytes: bytes.subarray(index, index + 1), char: String.fromCharCode(byte), width: byte === 0x09 ? 0 : 1 }); + } else { + if (runStart === -1) { + flushBlanks(false); + runStart = index; + } + column = byte === 0x08 ? Math.max(0, column - 1) : column + 1; + fieldStarted = true; + } + index++; + continue; + } + const length = byte >= 0xc2 && byte <= 0xdf ? 2 : byte >= 0xe0 && byte <= 0xef ? 3 : byte >= 0xf0 && byte <= 0xf4 ? 4 : 1; + if (length > 1 && index + length > bytes.length) { + endRun(index); + carry = Buffer.from(bytes.subarray(index)); + break; + } + endRun(index); + const token = nextUtf8Token(bytes, index); + if (isUnexpandBlank(token)) addBlank(token); + else { + flushBlanks(false); + emit(token.bytes); + column = tokenEndColumn(token, column, stops); + fieldStarted = true; + } + index = token.next; + } + endRun(bytes.length); + flushOutput(); + }); + if (carry.length) { + flushBlanks(false); + emit(carry); + fieldStarted = true; + } + flushBlanks(true); + flushOutput(); +} + +export function isUnexpandBlank(token) { + return isAsciiByteToken(token, 0x20) || isAsciiByteToken(token, 0x09) || (token.char != null && /\p{Zs}/u.test(token.char)); +} + +export function isAsciiByteToken(token, byte) { + return token.bytes.length === 1 && token.bytes[0] === byte; +} + +export function tokenEndColumn(token, column, stops) { + if (isAsciiByteToken(token, 0x09)) return nextTabColumn(column, stops); + if (isAsciiByteToken(token, 0x08)) return Math.max(0, column - 1); + return column + token.width; +} + +export function renderUnexpandedBlankTokens(startColumn, endColumn, run, stops, atEnd, containsTab, atFieldStart = false) { + const original = concatBytes(run.map((token) => token.bytes)); + const originalWidth = endColumn - startColumn; + const rendered = containsTab + ? renderUnexpandedBlankTokenTabs(startColumn, run, stops, atEnd, atFieldStart) + : renderUnexpandedSpaces(startColumn, endColumn, stops, atEnd, originalWidth, false, atFieldStart); + if (!rendered.includes("\t") && run.some((token) => token.char != null && !isAsciiByteToken(token, 0x20))) return original; + return enc.encode(rendered); +} + +export function renderUnexpandedBlankTokenTabs(startColumn, run, stops, atEnd, atFieldStart = false) { + const lastTab = run.findLastIndex((token) => isAsciiByteToken(token, 0x09)); + const prefix = run.slice(0, lastTab + 1); + const suffix = run.slice(lastTab + 1); + const prefixEnd = blankTokenRunEndColumn(startColumn, prefix, stops); + const suffixEnd = blankTokenRunEndColumn(prefixEnd, suffix, stops); + return renderUnexpandedSpaces(startColumn, prefixEnd, stops, true, prefixEnd - startColumn, true, atFieldStart) + + renderUnexpandedSpaces(prefixEnd, suffixEnd, stops, atEnd, suffixEnd - prefixEnd, false, atFieldStart); +} + +export function blankTokenRunEndColumn(startColumn, run, stops) { + let column = startColumn; + for (const token of run) column = tokenEndColumn(token, column, stops); + return column; +} + +export function renderUnexpandedSpaces(startColumn, endColumn, stops, atEnd, originalLength, fromTabs = false, atFieldStart = false) { + let column = startColumn; + let out = ""; + while (column < endColumn) { + const next = nextTabColumn(column, stops); + const remaining = endColumn - column; + const width = next - column; + const hasExplicitStop = stops.interval || stops.length === 1 || stops.some((stop) => stop > column && stop <= endColumn) || (fromTabs && width === 1); + const finalSingleBeforeText = !atEnd && width === remaining && width === 1 && originalLength <= 1 && (!atFieldStart || stops[0] !== 1); + const finalSingleAtEnd = atEnd && !fromTabs && width === remaining && width === 1 && originalLength <= 1; + if (hasExplicitStop && width <= remaining && !finalSingleBeforeText && !finalSingleAtEnd) { + out += "\t"; + column = next; + } else { + out += " "; + column++; + } + } + return out; +} + +const singleCall = defineCommand("unexpand", unexpand, (args) => tabCommandMetaOption("unexpand", args)); +export default singleCall; + +if (import.meta.main) await runAsMain(singleCall); |
