aboutsummaryrefslogtreecommitdiff
path: root/src/commands/nl.js
diff options
context:
space:
mode:
authorSoccera1 <[email protected]>2026-07-18 09:27:17 +1000
committerSoccera1 <[email protected]>2026-07-18 09:27:17 +1000
commit6f5241afb5bd1d6a1a8724bf06cc6f205c279402 (patch)
tree2aa852e968f6b89f2c8458333ce3e7c38b3c2450 /src/commands/nl.js
parenta753f669c9bedfccb9f7f400da018bb487dca5d0 (diff)
downloadbnu-6f5241afb5bd1d6a1a8724bf06cc6f205c279402.tar.gz
bnu-6f5241afb5bd1d6a1a8724bf06cc6f205c279402.zip
Refactor to single call
Diffstat (limited to 'src/commands/nl.js')
-rw-r--r--src/commands/nl.js299
1 files changed, 299 insertions, 0 deletions
diff --git a/src/commands/nl.js b/src/commands/nl.js
new file mode 100644
index 0000000..0a934d6
--- /dev/null
+++ b/src/commands/nl.js
@@ -0,0 +1,299 @@
+#!/usr/bin/env bun
+
+import { decodeSurrogateEscapedBytes, localeQuotedEscapedDiagnostic, parseOptions, readAll, readStdinRecords, systemErrorMessage, textInputDiagnosticName } from "../shared/common.js";
+import { InvocationError, UsageError, stderr, stdout } from "../shared/diagnostics.js";
+import { tacRegexPattern } from "../shared/text.js";
+import { defineCommand, runAsMain } from "../shared/command.js";
+
+export const NL_LONG_OPTIONS = ["body-numbering", "section-delimiter", "footer-numbering", "header-numbering", "line-increment", "join-blank-lines", "no-renumber", "number-separator", "number-width", "number-format", "starting-line-number", "help", "version"];
+
+export function nlMetaOption(args) {
+ const longValueOptions = new Set(["body-numbering", "section-delimiter", "footer-numbering", "header-numbering", "line-increment", "join-blank-lines", "number-format", "number-separator", "starting-line-number", "number-width"]);
+ const longNoValueOptions = new Set(["no-renumber"]);
+ const diagnostics = [];
+ for (let i = 0; i < args.length; i++) {
+ const arg = args[i];
+ if (arg === "--") return null;
+ if (arg.startsWith("--")) {
+ let option;
+ try {
+ option = normalizeNlLongOption(arg);
+ } catch (error) {
+ if (error instanceof UsageError) {
+ diagnostics.push(`nl: ${error.message}\n`);
+ continue;
+ }
+ throw error;
+ }
+ const [name, inlineValue] = option.slice(2).split(/=(.*)/s, 2);
+ if (!NL_LONG_OPTIONS.includes(name)) {
+ diagnostics.push(`nl: unrecognized option '${arg}'\n`);
+ continue;
+ }
+ if (name === "help" || name === "version") {
+ if (inlineValue == null) {
+ for (const line of diagnostics) stderr(line);
+ return `--${name}`;
+ }
+ diagnostics.push(`nl: option '--${name}' doesn't allow an argument\n`);
+ continue;
+ }
+ if (longValueOptions.has(name)) {
+ const value = inlineValue ?? args[i + 1];
+ if (value !== undefined) validateNlMetaOptionValue(name, value, diagnostics);
+ }
+ if (inlineValue == null && longValueOptions.has(name)) {
+ i++;
+ continue;
+ }
+ if (inlineValue != null) {
+ if (longNoValueOptions.has(name)) diagnostics.push(`nl: option '--${name}' doesn't allow an argument\n`);
+ else if (!longValueOptions.has(name)) return null;
+ }
+ continue;
+ }
+ if (!arg.startsWith("-") || arg === "-") continue;
+ const valueOption = arg.slice(1).match(/[bdfhilnsvw]/);
+ if (valueOption) {
+ const ch = valueOption[0];
+ const inlineValue = arg.slice(arg.indexOf(ch) + 1);
+ const value = inlineValue === "" ? args[i + 1] : inlineValue;
+ validateNlMetaShortValue(ch, value, diagnostics);
+ if (inlineValue === "") i++;
+ continue;
+ }
+ for (const ch of arg.slice(1)) {
+ if (ch !== "p") {
+ diagnostics.push(`nl: invalid option -- '${ch}'\n`);
+ break;
+ }
+ }
+ }
+ return null;
+}
+
+export function validateNlMetaOptionValue(name, value, diagnostics) {
+ if ((name === "body-numbering" || name === "header-numbering" || name === "footer-numbering") && !nlNumberingStyleValid(value)) {
+ diagnostics.push(`nl: invalid ${name.split("-", 1)[0]} numbering style: ${localeQuotedEscapedDiagnostic(value)}\n`);
+ } else if (name === "number-format" && !nlNumberFormatValid(value)) {
+ diagnostics.push(`nl: invalid line numbering format: ${localeQuotedEscapedDiagnostic(value)}\n`);
+ } else if (name === "line-increment") parseNlBigInt(value, "invalid line number increment");
+ else if (name === "starting-line-number") parseNlBigInt(value, "invalid starting line number");
+ else if (name === "join-blank-lines") parseNlJoinBlank(value);
+ else if (name === "number-width") parseNlWidth(value);
+}
+
+export function validateNlMetaShortValue(ch, value, diagnostics) {
+ if (value === undefined) return;
+ const names = { b: "body-numbering", f: "footer-numbering", h: "header-numbering", i: "line-increment", l: "join-blank-lines", n: "number-format", v: "starting-line-number", w: "number-width" };
+ const name = names[ch];
+ if (name) validateNlMetaOptionValue(name, value, diagnostics);
+}
+
+export function normalizeNlLongOptions(args, reportAmbiguous = true) {
+ const out = [];
+ for (const arg of args) {
+ if (arg === "--") {
+ out.push(arg);
+ continue;
+ }
+ if (!arg.startsWith("--") || arg === "--") {
+ out.push(arg);
+ continue;
+ }
+ out.push(normalizeNlLongOption(arg, reportAmbiguous));
+ }
+ return out;
+}
+
+export function normalizeNlLongOption(arg, reportAmbiguous = true) {
+ const body = arg.slice(2);
+ const eq = body.indexOf("=");
+ const name = eq === -1 ? body : body.slice(0, eq);
+ const matches = NL_LONG_OPTIONS.filter((option) => option.startsWith(name));
+ if (matches.length === 1) return eq === -1 ? `--${matches[0]}` : `--${matches[0]}=${body.slice(eq + 1)}`;
+ if (matches.length > 1 && reportAmbiguous) {
+ throw new UsageError(`option '${arg}' is ambiguous; possibilities: ${matches.map((option) => `'--${option}'`).join(" ")}`, true);
+ }
+ return arg;
+}
+
+export async function nlCmd(args) {
+ args = normalizeNlLongOptions(args);
+ const { opts, operands } = parseOptions(args, { short: { b: "value", d: "value", f: "value", h: "value", i: "value", l: "value", n: "value", p: false, s: "value", v: "value", w: "value" }, long: { "body-numbering": "value", "section-delimiter": "value", "footer-numbering": "value", "header-numbering": "value", "line-increment": "value", "join-blank-lines": "value", "number-format": "value", "no-renumber": false, "number-separator": "value", "starting-line-number": "value", "number-width": "value", help: false, version: false } });
+ const files = operands.length ? operands : ["-"];
+ const body = opts.b ?? opts["body-numbering"] ?? "t";
+ const header = opts.h ?? opts["header-numbering"] ?? "n";
+ const footer = opts.f ?? opts["footer-numbering"] ?? "n";
+ const format = opts.n ?? opts["number-format"] ?? "rn";
+ validateNlNumberingStyle(body, "body");
+ validateNlNumberingStyle(header, "header");
+ validateNlNumberingStyle(footer, "footer");
+ const bodyPattern = nlNumberingPattern(body);
+ const headerPattern = nlNumberingPattern(header);
+ const footerPattern = nlNumberingPattern(footer);
+ validateNlNumberFormat(format);
+ const width = parseNlWidth(opts.w ?? opts["number-width"] ?? "6");
+ const sep = opts.s ?? opts["number-separator"] ?? "\t";
+ const increment = parseNlBigInt(opts.i ?? opts["line-increment"] ?? "1", "invalid line number increment");
+ const joinBlank = parseNlJoinBlank(opts.l ?? opts["join-blank-lines"] ?? 1);
+ const start = parseNlBigInt(opts.v ?? opts["starting-line-number"] ?? "1", "invalid starting line number");
+ const delimiter = normalizeNlDelimiter(opts.d ?? opts["section-delimiter"] ?? "\\:");
+ let number = start;
+ let blankRun = 0;
+ let out = "";
+ let status = 0;
+ let currentSection = "body";
+ const renderLine = (raw) => {
+ const line = raw.replace(/\n$/, "");
+ const section = nlSection(line, delimiter);
+ if (section) {
+ if (!(opts.p || opts["no-renumber"])) number = start;
+ currentSection = section;
+ blankRun = 0;
+ return "\n";
+ }
+ const blank = raw === "\n";
+ blankRun = blank ? blankRun + 1 : 0;
+ const style = currentSection === "header" ? header : currentSection === "footer" ? footer : body;
+ const pattern = currentSection === "header" ? headerPattern : currentSection === "footer" ? footerPattern : bodyPattern;
+ const shouldNumber = shouldNumberNl(line, style, blank, blankRun, joinBlank, pattern);
+ if (shouldNumber) {
+ if (number > NlMax || number < NlMin) throw new InvocationError("line number overflow", 1, false);
+ const rendered = `${formatNlNumber(number, width, format)}${sep}${raw}`;
+ number += increment;
+ return rendered;
+ }
+ return `${" ".repeat(width + sep.length)}${raw}`;
+ };
+ if (files.length === 1 && files[0] === "-") {
+ readStdinRecords("\n", (line) => stdout(renderLine(`${line}\n`)));
+ return 0;
+ }
+ for (const file of files) {
+ let data;
+ try {
+ data = decodeSurrogateEscapedBytes(await readAll(file));
+ } catch (error) {
+ stderr(`nl: ${textInputDiagnosticName(file)}: ${systemErrorMessage(error)}\n`);
+ status = 1;
+ continue;
+ }
+ const records = splitNlRecords(data);
+ for (const raw of records) {
+ out += renderLine(raw);
+ }
+ }
+ stdout(out);
+ return status;
+}
+
+export const NlMax = 9223372036854775807n;
+
+export const NlMin = -9223372036854775808n;
+
+export function validateNlNumberingStyle(style, section) {
+ if (nlNumberingStyleValid(style)) return;
+ throw new UsageError(`invalid ${section} numbering style: ${localeQuotedEscapedDiagnostic(style)}`, true);
+}
+
+export function nlNumberingStyleValid(style) {
+ return style === "a" || style === "t" || style === "n" || String(style).startsWith("p");
+}
+
+export function validateNlNumberFormat(format) {
+ if (nlNumberFormatValid(format)) return;
+ throw new UsageError(`invalid line numbering format: ${localeQuotedEscapedDiagnostic(format)}`, true);
+}
+
+export function nlNumberFormatValid(format) {
+ return format === "ln" || format === "rn" || format === "rz";
+}
+
+export function nlNumberingPattern(style) {
+ if (!String(style).startsWith("p")) return null;
+ try {
+ return new RegExp(tacRegexPattern(String(style).slice(1)));
+ } catch {
+ throw new UsageError("Invalid regular expression");
+ }
+}
+
+export function parseNlJoinBlank(value) {
+ const text = String(value);
+ if (/^-\d+$/.test(text)) throw new UsageError(`invalid line number of blank lines: ${localeQuotedEscapedDiagnostic(text)}: Numerical result out of range`);
+ if (!/^\+?\d+$/.test(text)) throw new UsageError(`invalid line number of blank lines: ${localeQuotedEscapedDiagnostic(text)}`);
+ const n = BigInt(text);
+ if (n > NlMax) throw new UsageError(`invalid line number of blank lines: ${localeQuotedEscapedDiagnostic(text)}: Value too large for defined data type`);
+ return Number(n);
+}
+
+export function parseNlBigInt(value, message) {
+ const text = String(value);
+ if (!/^[+-]?\d+$/.test(text)) throw new UsageError(`${message}: ${localeQuotedEscapedDiagnostic(text)}`);
+ const n = BigInt(text);
+ if (n > NlMax || n < NlMin) throw new UsageError(`${message}: ${localeQuotedEscapedDiagnostic(text)}: Value too large for defined data type`);
+ return n;
+}
+
+export function parseNlWidth(value) {
+ const text = String(value);
+ if (!/^[+-]?\d+$/.test(text)) throw new UsageError(`invalid line number field width: ${localeQuotedEscapedDiagnostic(text)}`);
+ const width = BigInt(text);
+ if (width <= 0n) throw new UsageError(`invalid line number field width: ${localeQuotedEscapedDiagnostic(text)}: Numerical result out of range`);
+ if (width > 2147483647n) throw new UsageError(`invalid line number field width: ${localeQuotedEscapedDiagnostic(text)}: Value too large for defined data type`);
+ return Number(width);
+}
+
+export function normalizeNlDelimiter(value) {
+ if (value === "") return "";
+ return value.length === 1 ? `${value}:` : value;
+}
+
+export function nlSection(line, delimiter) {
+ if (!delimiter) return null;
+ if (nlDelimiterEquals(line, `${delimiter}${delimiter}${delimiter}`)) return "header";
+ if (nlDelimiterEquals(line, `${delimiter}${delimiter}`)) return "body";
+ if (nlDelimiterEquals(line, delimiter)) return "footer";
+ return null;
+}
+
+export function nlDelimiterEquals(line, marker) {
+ if (line.length !== marker.length) return false;
+ for (let i = 0; i < marker.length; i++) {
+ if (line[i] === marker[i]) continue;
+ const markerCode = marker.charCodeAt(i);
+ const lineCode = line.charCodeAt(i);
+ if (markerCode === 0xfffd && lineCode >= 0xdc80 && lineCode <= 0xdcff) continue;
+ return false;
+ }
+ return true;
+}
+
+export function splitNlRecords(data) {
+ if (data === "") return [];
+ const records = data.split(/(?<=\n)/).filter((raw) => raw !== "");
+ const last = records[records.length - 1];
+ if (last && !last.endsWith("\n")) records[records.length - 1] = `${last}\n`;
+ return records;
+}
+
+export function shouldNumberNl(line, style, blank, blankRun, joinBlank, pattern = null) {
+ if (style === "n") return false;
+ if (style === "a") return !blank || blankRun % joinBlank === 0;
+ if (style === "t") return !blank;
+ if (style.startsWith("p")) return pattern.test(line);
+ return !blank;
+}
+
+export function formatNlNumber(number, width, format) {
+ const text = String(number);
+ if (format === "ln") return text.padEnd(width);
+ if (format === "rz") return text.padStart(width, "0");
+ return text.padStart(width);
+}
+
+const singleCall = defineCommand("nl", nlCmd, nlMetaOption);
+export default singleCall;
+
+if (import.meta.main) await runAsMain(singleCall);