block-in-file 1.0.0

package/src/plugins/io.ts

@@ -0,0 +1,72 @@
+import { plugin } from "gunshi/plugin";
+import * as fs from "node:fs/promises";
+import * as readline from "node:readline";
+import { stdin as input, stdout as output } from "node:process";
+import { performBackup, type BackupOptions } from "../backup.ts";
+
+export const pluginId = "blockinfile:io" as const;
+export type PluginId = typeof pluginId;
+
+export interface IOExtension {
+  readFile: (path: string) => Promise<string>;
+  writeFile: (path: string, content: string) => Promise<void>;
+  readStdin: () => Promise<string>;
+  fileExists: (path: string) => Promise<boolean>;
+  backupFile: (path: string, options: BackupOptions, content?: string) => Promise<string | null>;
+  rename: (oldPath: string, newPath: string) => Promise<void>;
+  deleteFile: (path: string) => Promise<void>;
+}
+
+const readStdin = async (): Promise<string> => {
+  const rl = readline.createInterface({ input, output });
+  const lines: string[] = [];
+
+  for await (const line of rl) {
+    lines.push(line);
+  }
+
+  return lines.join("\n");
+};
+
+export default function io() {
+  return plugin<{}, typeof pluginId, [], IOExtension>({
+    id: pluginId,
+    name: "IO Plugin",
+    extension: (): IOExtension => ({
+      readFile: async (path: string) => {
+        if (path === "-") {
+          return await readStdin();
+        }
+        return await fs.readFile(path, "utf-8");
+      },
+      writeFile: async (path: string, content: string) => {
+        if (path === "-") {
+          console.log(content);
+          return;
+        }
+        if (path === "--") {
+          return;
+        }
+        await fs.writeFile(path, content, "utf-8");
+      },
+      readStdin,
+      fileExists: async (path: string) => {
+        try {
+          await fs.access(path);
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      backupFile: async (path: string, options: BackupOptions, content?: string) => {
+        return await performBackup(path, options, content);
+      },
+      rename: async (oldPath: string, newPath: string) => {
+        await fs.rename(oldPath, newPath);
+      },
+      deleteFile: async (path: string) => {
+        await fs.unlink(path);
+      },
+    }),
+  });
+}

package/src/plugins/logger.ts

@@ -0,0 +1,41 @@
+import { plugin } from "gunshi/plugin";
+
+export const pluginId = "blockinfile:logger" as const;
+export type PluginId = typeof pluginId;
+
+export interface LoggerExtension {
+  log: (message: string) => void;
+  error: (message: string) => void;
+  warn: (message: string) => void;
+  debug: (message: string) => void;
+  enabled: boolean;
+}
+
+export interface LoggerOptions {
+  debug?: boolean;
+}
+
+export default function logger() {
+  return plugin<{}, typeof pluginId, [], LoggerExtension>({
+    id: pluginId,
+    name: "Logger Plugin",
+    setup: (ctx) => {
+      ctx.addGlobalOption("debug", {
+        type: "boolean",
+        short: "d",
+        description: "Enable debug output",
+      });
+    },
+    extension: (ctx): LoggerExtension => ({
+      log: (message: string) => console.log(message),
+      error: (message: string) => console.error(message),
+      warn: (message: string) => console.warn(message),
+      debug: (message: string) => {
+        if (ctx.values.debug) {
+          console.debug(`[DEBUG] ${message}`);
+        }
+      },
+      enabled: (ctx.values.debug as boolean | undefined) ?? false,
+    }),
+  });
+}

package/src/tags/tag-merger.ts

@@ -0,0 +1,31 @@
+import type { Tag } from "./types.js";
+import type { TagMode } from "./tag-mode.js";
+
+export function mergeTags(existingTags: Tag[], newTags: Tag[]): Tag[] {
+  const tagMap = new Map<string, Tag>();
+
+  for (const tag of existingTags) {
+    tagMap.set(tag.name, tag);
+  }
+
+  for (const tag of newTags) {
+    tagMap.set(tag.name, tag);
+  }
+
+  return Array.from(tagMap.values());
+}
+
+export function replaceTags(existingTags: Tag[], newTags: Tag[]): Tag[] {
+  return newTags;
+}
+
+export function applyTagMode(existingTags: Tag[], newTags: Tag[], mode: TagMode): Tag[] {
+  switch (mode) {
+    case "merge":
+      return mergeTags(existingTags, newTags);
+    case "replace":
+      return replaceTags(existingTags, newTags);
+    default:
+      return mergeTags(existingTags, newTags);
+  }
+}

package/src/tags/tag-mode.ts

@@ -0,0 +1 @@
+export type TagMode = "merge" | "replace";

package/src/tags/tag.ts

@@ -0,0 +1,36 @@
+import type { Tag } from "./types.ts";
+
+export function generateTag(name: string, value: string): string {
+  return value ? `[${name}:${value}]` : `[${name}]`;
+}
+
+export function parseTags(line: string): Tag[] {
+  const tags: Tag[] = [];
+  const tagRegex = /\[([a-zA-Z0-9_-]+)(?::([^\[\]]+))?\]/g;
+  let match;
+
+  while ((match = tagRegex.exec(line)) !== null) {
+    tags.push({
+      name: match[1],
+      value: match[2] || "",
+    });
+  }
+
+  return tags;
+}
+
+export function removeTags(line: string): string {
+  return line.replace(/\s*\[[a-zA-Z0-9_-]+(?::[^\[\]]+)?\]\s*/g, "").trim();
+}
+
+export function addTags(line: string, tags: Tag[]): string {
+  if (tags.length === 0) {
+    return line;
+  }
+  const tagStrings = tags.map((t) => generateTag(t.name, t.value));
+  return `${line} ${tagStrings.join(" ")}`;
+}
+
+export function stripTagsForMatching(line: string): string {
+  return removeTags(line);
+}

package/src/tags/tags.ts

@@ -0,0 +1,4 @@
+export type { Tag } from "./types.ts";
+export { generateTag, parseTags, removeTags, addTags, stripTagsForMatching } from "./tag.ts";
+export type { TagMode } from "./tag-mode.ts";
+export { mergeTags, replaceTags, applyTagMode } from "./tag-merger.ts";

package/src/tags/types.ts

@@ -0,0 +1,4 @@
+export interface Tag {
+  name: string;
+  value: string;
+}

package/src/timestamp.ts

@@ -0,0 +1,39 @@
+import { generateTag as generateTagFromUtil } from "./tags/tags.ts";
+
+export type TimestampFormat = "epoch-nano" | "epoch-sec" | "iso8601";
+
+function generateTimestamp(format: TimestampFormat): string {
+  const now = new Date();
+
+  switch (format) {
+    case "epoch-nano": {
+      return `${now.getTime()}000000`;
+    }
+    case "epoch-sec": {
+      return Math.floor(now.getTime() / 1000).toString();
+    }
+    case "iso8601": {
+      return now.toISOString();
+    }
+    default: {
+      return `${now.getTime()}000000`;
+    }
+  }
+}
+
+export function generateTimestampTag(format: TimestampFormat): string {
+  const timestamp = generateTimestamp(format);
+  return generateTagFromUtil("timestamp", timestamp);
+}
+
+export function parseTimestampFormat(value: string | undefined): TimestampFormat | undefined {
+  if (!value) return undefined;
+
+  if (value === "epoch-nano" || value === "epoch-sec" || value === "iso8601") {
+    return value;
+  }
+
+  throw new Error(
+    `Invalid timestamp format: ${value}. Valid options: epoch-nano, epoch-sec, iso8601`,
+  );
+}

package/src/types.ts

@@ -0,0 +1,32 @@
+export type CreateArg = boolean | 0 | 1 | "file" | "block";
+
+export interface InputOptions {
+  create?: boolean;
+}
+
+export interface BlockInFileOptions {
+  after?: string | RegExp | boolean;
+  before?: string | RegExp | boolean;
+  comment: string;
+  create?: CreateArg;
+  debug?: boolean;
+  diff?: string | boolean;
+  dos?: boolean;
+  envsubst?: "recursive" | "non-recursive" | false;
+  input?: string;
+  markerStart: string;
+  markerEnd: string;
+  name: string;
+  output?: string;
+  additive?: boolean;
+  additiveBefore?: string;
+  additiveAfter?: string;
+  timestamp?: string;
+  tagMode?: string;
+}
+
+export interface ParseResult {
+  outputs: string[];
+  matched: number;
+  opened?: number;
+}

package/src/validation.ts

@@ -0,0 +1,11 @@
+import { x } from "tinyexec";
+import { tokenizeArgs } from "args-tokenizer";
+
+export async function runValidation(file: string, validateCmd: string): Promise<void> {
+  const substitutedCmd = validateCmd.replaceAll("%s", file);
+  const [command, ...args] = tokenizeArgs(substitutedCmd);
+  const result = await x(command, args, { throwOnError: true });
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr || "Validation command failed");
+  }
+}

package/test/additive-cli.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import { execSync } from "node:child_process";
+
+describe("CLI additive mode", () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "blockinfile-cli-additive-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  function runCli(args: string, input?: string): string {
+    const cwd = path.resolve(import.meta.dirname!, "..");
+    const cmd = `npx tsx block-in-file.ts ${args}`;
+    return execSync(cmd, {
+      cwd,
+      input,
+      encoding: "utf-8",
+    });
+  }
+
+  it("adds missing lines with --additive", async () => {
+    const targetFile = path.join(tempDir, "target.txt");
+    await fs.writeFile(targetFile, "header\n# blockinfile start\nline1\n# blockinfile end\nfooter");
+
+    runCli(`--additive -i - ${targetFile}`, "line1\nline2\nline3");
+
+    const result = await fs.readFile(targetFile, "utf-8");
+    expect(result).toContain("line1");
+    expect(result).toContain("line2");
+    expect(result).toContain("line3");
+    const lines = result.split("\n");
+    const blockStartIndex = lines.indexOf("# blockinfile start");
+    const blockEndIndex = lines.indexOf("# blockinfile end");
+    const blockContent = lines.slice(blockStartIndex + 1, blockEndIndex);
+    expect(blockContent).toEqual(["line1", "line2", "line3"]);
+  });
+
+  it("adds missing lines before existing content with --additive-before BOF", async () => {
+    const targetFile = path.join(tempDir, "target.txt");
+    await fs.writeFile(targetFile, "header\n# blockinfile start\nline2\n# blockinfile end\nfooter");
+
+    runCli(`--additive --additive-before BOF -i - ${targetFile}`, "line1\nline2\nline3");
+
+    const result = await fs.readFile(targetFile, "utf-8");
+    const lines = result.split("\n");
+    const blockStartIndex = lines.indexOf("# blockinfile start");
+    const blockEndIndex = lines.indexOf("# blockinfile end");
+    const blockContent = lines.slice(blockStartIndex + 1, blockEndIndex);
+    expect(blockContent).toEqual(["line1", "line3", "line2"]);
+  });
+
+  it("adds missing lines after matching line with --additive-after regex", async () => {
+    const targetFile = path.join(tempDir, "target.txt");
+    await fs.writeFile(
+      targetFile,
+      "header\n# blockinfile start\nline1\nmarker\nline3\n# blockinfile end\nfooter",
+    );
+
+    runCli(`--additive --additive-after '^marker$' -i - ${targetFile}`, "line1\nline2\nline3");
+
+    const result = await fs.readFile(targetFile, "utf-8");
+    const lines = result.split("\n");
+    const blockStartIndex = lines.indexOf("# blockinfile start");
+    const blockEndIndex = lines.indexOf("# blockinfile end");
+    const blockContent = lines.slice(blockStartIndex + 1, blockEndIndex);
+    expect(blockContent).toEqual(["line1", "marker", "line2", "line3"]);
+  });
+
+  it("errors when both --additive-before and --additive-after are specified", async () => {
+    const targetFile = path.join(tempDir, "target.txt");
+    await fs.writeFile(targetFile, "header\nfooter");
+
+    expect(() =>
+      runCli(`--additive --additive-before BOF --additive-after EOF -i - ${targetFile}`, "line1"),
+    ).toThrow("Cannot specify both --additive-before and --additive-after");
+  });
+
+  it("outputs to stdout with --additive", async () => {
+    const targetFile = path.join(tempDir, "target.txt");
+    await fs.writeFile(targetFile, "header\n# blockinfile start\nline1\n# blockinfile end\nfooter");
+
+    const output = runCli(`--additive -i - ${targetFile} -o -`, "line1\nline2\nline3");
+
+    expect(output).toContain("line1");
+    expect(output).toContain("line2");
+    expect(output).toContain("line3");
+  });
+
+  it("works with empty block", async () => {
+    const targetFile = path.join(tempDir, "target.txt");
+    await fs.writeFile(targetFile, "header\n# blockinfile start\n# blockinfile end\nfooter");
+
+    runCli(`--additive -i - ${targetFile}`, "line1\nline2\nline3");
+
+    const result = await fs.readFile(targetFile, "utf-8");
+    const lines = result.split("\n");
+    const blockStartIndex = lines.indexOf("# blockinfile start");
+    const blockEndIndex = lines.indexOf("# blockinfile end");
+    const blockContent = lines.slice(blockStartIndex + 1, blockEndIndex);
+    expect(blockContent).toEqual(["line1", "line2", "line3"]);
+  });
+});

package/test/additive.test.ts

@@ -0,0 +1,233 @@
+import { describe, it, expect } from "vitest";
+import { parseAndInsertBlock } from "../src/block-parser.ts";
+
+describe("additive mode", () => {
+  const defaultOpts = {
+    opener: "# blockinfile start",
+    closer: "# blockinfile end",
+    inputBlock: "line1\nline2\nline3",
+  };
+
+  it("adds missing lines to existing block", () => {
+    const fileContent = "header\n# blockinfile start\nline1\n# blockinfile end\nfooter";
+    const result = parseAndInsertBlock(fileContent, {
+      ...defaultOpts,
+      additive: true,
+    });
+
+    expect(result.outputs).toEqual([
+      "header",
+      "# blockinfile start",
+      "line1",
+      "line2",
+      "line3",
+      "# blockinfile end",
+      "footer",
+    ]);
+  });
+
+  it("preserves existing content and adds missing lines", () => {
+    const fileContent = "header\n# blockinfile start\nline2\n# blockinfile end\nfooter";
+    const result = parseAndInsertBlock(fileContent, {
+      ...defaultOpts,
+      additive: true,
+    });
+
+    expect(result.outputs).toEqual([
+      "header",
+      "# blockinfile start",
+      "line2",
+      "line1",
+      "line3",
+      "# blockinfile end",
+      "footer",
+    ]);
+  });
+
+  it("does nothing when all lines already exist", () => {
+    const fileContent =
+      "header\n# blockinfile start\nline1\nline2\nline3\n# blockinfile end\nfooter";
+    const result = parseAndInsertBlock(fileContent, {
+      ...defaultOpts,
+      additive: true,
+    });
+
+    expect(result.outputs).toEqual([
+      "header",
+      "# blockinfile start",
+      "line1",
+      "line2",
+      "line3",
+      "# blockinfile end",
+      "footer",
+    ]);
+  });
+
+  it("adds missing lines before existing content with --additive-before BOF", () => {
+    const fileContent = "header\n# blockinfile start\nline2\n# blockinfile end\nfooter";
+    const result = parseAndInsertBlock(fileContent, {
+      ...defaultOpts,
+      additive: true,
+      additiveBefore: "BOF",
+    });
+
+    expect(result.outputs).toEqual([
+      "header",
+      "# blockinfile start",
+      "line1",
+      "line3",
+      "line2",
+      "# blockinfile end",
+      "footer",
+    ]);
+  });
+
+  it("adds missing lines after existing content with --additive-after EOB (default)", () => {
+    const fileContent = "header\n# blockinfile start\nline1\n# blockinfile end\nfooter";
+    const result = parseAndInsertBlock(fileContent, {
+      ...defaultOpts,
+      additive: true,
+      additiveAfter: "EOB",
+    });
+
+    expect(result.outputs).toEqual([
+      "header",
+      "# blockinfile start",
+      "line1",
+      "line2",
+      "line3",
+      "# blockinfile end",
+      "footer",
+    ]);
+  });
+
+  it("adds missing lines after existing content with --additive-after EOF", () => {
+    const fileContent = "header\n# blockinfile start\nline1\n# blockinfile end\nfooter";
+    const result = parseAndInsertBlock(fileContent, {
+      ...defaultOpts,
+      additive: true,
+      additiveAfter: "EOF",
+    });
+
+    expect(result.outputs).toEqual([
+      "header",
+      "# blockinfile start",
+      "line1",
+      "line2",
+      "line3",
+      "# blockinfile end",
+      "footer",
+    ]);
+  });
+
+  it("adds missing lines after matching line with --additive-after regex", () => {
+    const fileContent =
+      "header\n# blockinfile start\nline1\nmarker\nline3\n# blockinfile end\nfooter";
+    const result = parseAndInsertBlock(fileContent, {
+      ...defaultOpts,
+      additive: true,
+      additiveAfter: /^marker$/,
+    });
+
+    expect(result.outputs).toEqual([
+      "header",
+      "# blockinfile start",
+      "line1",
+      "marker",
+      "line2",
+      "line3",
+      "# blockinfile end",
+      "footer",
+    ]);
+  });
+
+  it("adds missing lines before matching line with --additive-before regex", () => {
+    const fileContent =
+      "header\n# blockinfile start\nline1\nmarker\nline3\n# blockinfile end\nfooter";
+    const result = parseAndInsertBlock(fileContent, {
+      ...defaultOpts,
+      additive: true,
+      additiveBefore: /^marker$/,
+    });
+
+    expect(result.outputs).toEqual([
+      "header",
+      "# blockinfile start",
+      "line1",
+      "line2",
+      "marker",
+      "line3",
+      "# blockinfile end",
+      "footer",
+    ]);
+  });
+
+  it("creates new block if block does not exist and additive is set", () => {
+    const fileContent = "header\nfooter";
+    const result = parseAndInsertBlock(fileContent, {
+      ...defaultOpts,
+      additive: true,
+    });
+
+    expect(result.outputs).toContain("# blockinfile start");
+    expect(result.outputs).toContain("line1");
+    expect(result.outputs).toContain("line2");
+    expect(result.outputs).toContain("line3");
+    expect(result.outputs).toContain("# blockinfile end");
+  });
+
+  it("works with empty block", () => {
+    const fileContent = "header\n# blockinfile start\n# blockinfile end\nfooter";
+    const result = parseAndInsertBlock(fileContent, {
+      ...defaultOpts,
+      additive: true,
+    });
+
+    expect(result.outputs).toEqual([
+      "header",
+      "# blockinfile start",
+      "line1",
+      "line2",
+      "line3",
+      "# blockinfile end",
+      "footer",
+    ]);
+  });
+
+  it("replaces block when additive is false (default behavior)", () => {
+    const fileContent =
+      "header\n# blockinfile start\nold line1\nold line2\n# blockinfile end\nfooter";
+    const result = parseAndInsertBlock(fileContent, {
+      ...defaultOpts,
+      additive: false,
+    });
+
+    expect(result.outputs).toEqual([
+      "header",
+      "# blockinfile start",
+      "line1",
+      "line2",
+      "line3",
+      "# blockinfile end",
+      "footer",
+    ]);
+  });
+
+  it("handles duplicate lines in input without duplication", () => {
+    const fileContent = "header\n# blockinfile start\nline1\n# blockinfile end\nfooter";
+    const result = parseAndInsertBlock(fileContent, {
+      ...defaultOpts,
+      inputBlock: "line1\nline1\nline2",
+      additive: true,
+    });
+
+    expect(result.outputs).toEqual([
+      "header",
+      "# blockinfile start",
+      "line1",
+      "line2",
+      "# blockinfile end",
+      "footer",
+    ]);
+  });
+});