aboutsummaryrefslogtreecommitdiff
path: root/src/commands/paste.js
diff options
context:
space:
mode:
authorLily <[email protected]>2026-07-28 16:12:21 +1000
committerGitHub <[email protected]>2026-07-28 16:12:21 +1000
commitc11e17573334dfb487a8e1cc25fa84fa9e138f5c (patch)
treee91dbd19b524f9432da6bcb86b1fc193e0d02e26 /src/commands/paste.js
parent6a2f098e72e71437154ec00506e8e736aa8e1026 (diff)
downloadbnu-c11e17573334dfb487a8e1cc25fa84fa9e138f5c.tar.gz
bnu-c11e17573334dfb487a8e1cc25fa84fa9e138f5c.zip
Refactor coreutils into single-call command modules (#1)
* Refactor to single call
Diffstat (limited to 'src/commands/paste.js')
-rw-r--r--src/commands/paste.js233
1 files changed, 233 insertions, 0 deletions
diff --git a/src/commands/paste.js b/src/commands/paste.js
new file mode 100644
index 0000000..6b656ab
--- /dev/null
+++ b/src/commands/paste.js
@@ -0,0 +1,233 @@
+#!/usr/bin/env bun
+
+import { closeSync, openSync } from "node:fs";
+import { isUtf8Locale, isWriteError, nodeErrorMessage, parseOptions, rawCommandArgs, readAll, readFdChunkViews, systemErrorMessage, textInputDiagnosticName } from "../shared/common.js";
+import { UsageError, stderr, stdout } from "../shared/diagnostics.js";
+import { concatOutputParts } from "../shared/text.js";
+import { defineCommand, runAsMain } from "../shared/command.js";
+
+export const PASTE_LONG_OPTIONS = ["delimiters", "serial", "zero-terminated", "help", "version"];
+
+export function pasteMetaOption(args) {
+ for (let i = 0; i < args.length; i++) {
+ const arg = args[i];
+ if (arg === "--") return null;
+ if (arg.startsWith("--")) {
+ const option = normalizePasteLongOption(arg);
+ const [name, inlineValue] = option.slice(2).split(/=(.*)/s, 2);
+ if (!PASTE_LONG_OPTIONS.includes(name)) return null;
+ if (option === "--help" || option === "--version") return option;
+ if (name === "delimiters") {
+ if (inlineValue == null) i++;
+ } else if (inlineValue != null) return null;
+ continue;
+ }
+ if (!arg.startsWith("-") || arg === "-") continue;
+ for (let j = 1; j < arg.length; j++) {
+ const ch = arg[j];
+ if (ch === "s" || ch === "z") continue;
+ if (ch !== "d") return null;
+ if (!arg.slice(j + 1)) i++;
+ break;
+ }
+ }
+ return null;
+}
+
+export function normalizePasteLongOptions(args) {
+ const out = [];
+ let end = false;
+ for (const arg of args) {
+ if (end || arg === "--" || !arg.startsWith("--")) {
+ out.push(arg);
+ if (arg === "--") end = true;
+ continue;
+ }
+ out.push(normalizePasteLongOption(arg));
+ }
+ return out;
+}
+
+export function normalizePasteLongOption(arg) {
+ const body = arg.slice(2);
+ const eq = body.indexOf("=");
+ const name = eq === -1 ? body : body.slice(0, eq);
+ if (!name) return arg;
+ const matches = PASTE_LONG_OPTIONS.filter((option) => option.startsWith(name));
+ if (matches.length !== 1) return arg;
+ return eq === -1 ? `--${matches[0]}` : `--${matches[0]}=${body.slice(eq + 1)}`;
+}
+
+export async function paste(args) {
+ const { opts, operands } = parseOptions(normalizePasteLongOptions(args), { short: { d: "value", s: false, z: false }, long: { delimiters: "value", serial: false, "zero-terminated": false, help: false, version: false } });
+ const files = operands.length ? operands : ["-"];
+ const recordSep = opts.z || opts["zero-terminated"] ? "\0" : "\n";
+ const delimiterValue = opts.d ?? opts.delimiters ?? "\t";
+ const rawDelimiter = delimiterValue.includes("\uFFFD") ? pasteReplacementDelimiterBytes(delimiterValue, args) : null;
+ const delimiters = parsePasteDelimiters(delimiterValue, rawDelimiter);
+ const pick = (i) => delimiters[i % delimiters.length] ?? "\t";
+ const out = [];
+ let failed = false;
+ if (!(opts.s || opts.serial) && files.length === 1) {
+ const file = files[0];
+ let fd;
+ try {
+ fd = file === "-" ? 0 : openSync(file, "r");
+ streamPasteSingleFd(fd, recordSep.charCodeAt(0));
+ return 0;
+ } catch (error) {
+ if (isWriteError(error)) throw error;
+ stderr(file === "-" ? `paste: ${nodeErrorMessage(error)}\n` : `paste: ${textInputDiagnosticName(file)}: ${systemErrorMessage(error)}\n`);
+ return 1;
+ } finally {
+ if (fd != null && fd !== 0) closeSync(fd);
+ }
+ }
+ if (opts.s || opts.serial) {
+ const lineSets = [];
+ for (const file of files) {
+ try {
+ lineSets.push(splitPasteByteRecords(await readAll(file), recordSep));
+ } catch (error) {
+ if (error?.code === "EISDIR") lineSets.push([]);
+ stderr(file === "-" ? `paste: ${nodeErrorMessage(error)}\n` : `paste: ${textInputDiagnosticName(file)}: ${systemErrorMessage(error)}\n`);
+ failed = true;
+ }
+ }
+ for (const lines of lineSets) {
+ for (let i = 0; i < lines.length; i++) {
+ if (i) out.push(pick(i - 1));
+ out.push(lines[i]);
+ }
+ out.push(recordSep);
+ }
+ } else {
+ const stdinRecords = files.includes("-") ? splitPasteByteRecords(await readAll("-"), recordSep) : [];
+ let stdinIndex = 0;
+ const lineSets = [];
+ let fatalReadError = false;
+ for (const file of files) {
+ if (file === "-") {
+ lineSets.push(null);
+ continue;
+ }
+ try {
+ lineSets.push(splitPasteByteRecords(await readAll(file), recordSep));
+ } catch (error) {
+ stderr(`paste: ${textInputDiagnosticName(file)}: ${systemErrorMessage(error)}\n`);
+ lineSets.push([]);
+ if (error?.code !== "EISDIR") fatalReadError = true;
+ failed = true;
+ }
+ }
+ if (fatalReadError) {
+ stdout(concatOutputParts(out));
+ return 1;
+ }
+ const maxFileRows = Math.max(0, ...lineSets.filter(Boolean).map((lines) => lines.length));
+ for (let row = 0; row < maxFileRows || stdinIndex < stdinRecords.length; row++) {
+ for (let col = 0; col < lineSets.length; col++) {
+ const lines = lineSets[col];
+ const value = lines ? lines[row] ?? "" : stdinRecords[stdinIndex++] ?? "";
+ if (col) out.push(pick(col - 1));
+ out.push(value);
+ }
+ out.push(recordSep);
+ }
+ }
+ stdout(concatOutputParts(out));
+ return failed ? 1 : 0;
+}
+
+export function streamPasteSingleFd(fd, separator) {
+ let sawData = false;
+ let lastByte = separator;
+ readFdChunkViews(fd, (chunk) => {
+ if (!chunk.length) return;
+ sawData = true;
+ lastByte = chunk[chunk.length - 1];
+ stdout(chunk);
+ });
+ if (sawData && lastByte !== separator) stdout(Uint8Array.of(separator));
+}
+
+export function splitPasteByteRecords(bytes, sep) {
+ const sepByte = sep === "\0" ? 0 : 0x0a;
+ if (bytes.length === 0) return [];
+ const end = bytes[bytes.length - 1] === sepByte ? bytes.length - 1 : bytes.length;
+ if (end === 0) return [];
+ const records = [];
+ let start = 0;
+ for (let i = 0; i < end; i++) {
+ if (bytes[i] === sepByte) {
+ records.push(bytes.slice(start, i));
+ start = i + 1;
+ }
+ }
+ records.push(bytes.slice(start, end));
+ return records;
+}
+
+export function pasteReplacementDelimiterBytes(value, args) {
+ if (isUtf8Locale()) return Buffer.from(value);
+ return rawPasteDelimiterBytes(args) ?? Buffer.from(value);
+}
+
+export function parsePasteDelimiters(value, rawBytes = null) {
+ if (rawBytes) return parsePasteDelimiterBytes(rawBytes);
+ const out = [];
+ const chars = [...value];
+ for (let i = 0; i < chars.length; i++) {
+ if (chars[i] === "\\") {
+ if (i + 1 >= chars.length) throw new UsageError(`delimiter list ends with an unescaped backslash: ${value}`, false);
+ const ch = chars[++i];
+ out.push(({ "0": "", b: "\b", f: "\f", n: "\n", r: "\r", t: "\t", v: "\v", "\\": "\\" })[ch] ?? ch);
+ } else {
+ out.push(chars[i]);
+ }
+ }
+ return out.length ? out : [""];
+}
+
+export function parsePasteDelimiterBytes(bytes) {
+ const out = [];
+ const gb18030 = /gb18030/i.test(process.env.LC_ALL ?? process.env.LC_CTYPE ?? process.env.LANG ?? "");
+ for (let i = 0; i < bytes.length; i++) {
+ const byte = bytes[i];
+ if (byte === 0x5c) {
+ if (i + 1 >= bytes.length) throw new UsageError(`delimiter list ends with an unescaped backslash: ${new TextDecoder().decode(bytes)}`, false);
+ const next = bytes[++i];
+ const escaped = ({ 0x30: "", 0x62: "\b", 0x66: "\f", 0x6e: "\n", 0x72: "\r", 0x74: "\t", 0x76: "\v", 0x5c: "\\" })[next];
+ if (escaped != null) out.push(escaped);
+ else if (gb18030 && next >= 0x80 && i + 1 < bytes.length) out.push(bytes.subarray(i, ++i + 1));
+ else out.push(bytes.subarray(i, i + 1));
+ } else if (gb18030 && byte >= 0x80 && i + 1 < bytes.length) {
+ out.push(bytes.subarray(i, ++i + 1));
+ } else {
+ out.push(bytes.subarray(i, i + 1));
+ }
+ }
+ return out.length ? out : [""];
+}
+
+export function rawPasteDelimiterBytes(args) {
+ const rawArgs = rawCommandArgs("paste");
+ if (!rawArgs) return null;
+ for (let i = 0; i < rawArgs.length; i++) {
+ const arg = rawArgs[i];
+ if (arg.equals(Buffer.from("-d")) || arg.equals(Buffer.from("--delimiters"))) return rawArgs[i + 1] ?? null;
+ if (arg.length > 2 && arg[0] === 0x2d && arg[1] === 0x64) return arg.subarray(2);
+ const eq = arg.indexOf(0x3d);
+ if (arg.length > 2 && arg[0] === 0x2d && arg[1] === 0x2d) {
+ const rawName = eq === -1 ? arg.subarray(2) : arg.subarray(2, eq);
+ const name = new TextDecoder("ascii").decode(rawName);
+ if ("delimiters".startsWith(name)) return eq === -1 ? rawArgs[i + 1] ?? null : arg.subarray(eq + 1);
+ }
+ }
+ return null;
+}
+
+const singleCall = defineCommand("paste", paste, pasteMetaOption);
+export default singleCall;
+
+if (import.meta.main) await runAsMain(singleCall);