block-in-file 1.0.0

package/test/block-in-file.test.ts

@@ -0,0 +1,235 @@
+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("BlockInFile integration", () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "blockinfile-test-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  function runBlockInFile(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",
+    });
+  }
+
+  describe("basic operations", () => {
+    it("inserts block into file", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\n");
+
+      runBlockInFile(targetFile, "INSERTED CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("# blockinfile start");
+      expect(result).toContain("INSERTED CONTENT");
+      expect(result).toContain("# blockinfile end");
+    });
+
+    it("replaces existing block", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\n# blockinfile start\nOLD\n# blockinfile end\nline2\n");
+
+      runBlockInFile(targetFile, "NEW");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("NEW");
+      expect(result).not.toContain("OLD");
+    });
+  });
+
+  describe("options", () => {
+    it("uses custom comment character", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\n");
+
+      runBlockInFile(`-c "//" ${targetFile}`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("// blockinfile start");
+      expect(result).toContain("// blockinfile end");
+    });
+
+    it("uses custom block name", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\n");
+
+      runBlockInFile(`-n myblock ${targetFile}`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("# myblock start");
+      expect(result).toContain("# myblock end");
+    });
+
+    it("uses custom markers", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\n");
+
+      runBlockInFile(`--marker-start BEGIN --marker-end END ${targetFile}`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("# blockinfile BEGIN");
+      expect(result).toContain("# blockinfile END");
+    });
+
+    it("uses dos line endings", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\n");
+
+      runBlockInFile(`--dos ${targetFile}`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("\r\n");
+    });
+  });
+
+  describe("before/after positioning", () => {
+    it("inserts before matching pattern", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nMARKER\nline3\n");
+
+      runBlockInFile(`-b MARKER ${targetFile}`, "INSERTED");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      const lines = result.split("\n");
+      const markerIndex = lines.indexOf("MARKER");
+      const startIndex = lines.indexOf("# blockinfile start");
+      expect(startIndex).toBeLessThan(markerIndex);
+    });
+
+    it("inserts after matching pattern", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nMARKER\nline3\n");
+
+      runBlockInFile(`-a MARKER ${targetFile}`, "INSERTED");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      const lines = result.split("\n");
+      const markerIndex = lines.indexOf("MARKER");
+      const startIndex = lines.indexOf("# blockinfile start");
+      expect(startIndex).toBeGreaterThan(markerIndex);
+    });
+  });
+
+  describe("output modes", () => {
+    it("writes to different output file", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      const outputFile = path.join(tempDir, "output.txt");
+      await fs.writeFile(targetFile, "original\n");
+
+      runBlockInFile(`-o ${outputFile} ${targetFile}`, "CONTENT");
+
+      const originalContent = await fs.readFile(targetFile, "utf-8");
+      expect(originalContent).toBe("original\n");
+
+      const outputContent = await fs.readFile(outputFile, "utf-8");
+      expect(outputContent).toContain("CONTENT");
+    });
+
+    it("outputs to stdout with -o -", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "original\n");
+
+      const output = runBlockInFile(`-o - ${targetFile}`, "CONTENT");
+      expect(output).toContain("CONTENT");
+
+      const fileContent = await fs.readFile(targetFile, "utf-8");
+      expect(fileContent).toBe("original\n");
+    });
+  });
+
+  describe("input sources", () => {
+    it("reads input from file", async () => {
+      const inputFile = path.join(tempDir, "input.txt");
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(inputFile, "FROM FILE");
+      await fs.writeFile(targetFile, "original\n");
+
+      runBlockInFile(`-i ${inputFile} ${targetFile}`);
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      expect(result).toContain("FROM FILE");
+    });
+  });
+
+  describe("append-newline option", () => {
+    it("inserts block without blank line after (default)", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\n");
+
+      runBlockInFile(`${targetFile}`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      const lines = result.split("\n");
+      const endIdx = lines.indexOf("# blockinfile end");
+      expect(lines[endIdx + 1]).toBe("");
+      expect(lines[endIdx + 2]).toBeUndefined();
+    });
+
+    it("inserts block with blank line after when --append-newline is set", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nline2\n");
+
+      runBlockInFile(`--append-newline ${targetFile}`, "CONTENT");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      const lines = result.split("\n");
+      const endIdx = lines.indexOf("# blockinfile end");
+      expect(lines[endIdx + 1]).toBe("");
+      expect(lines[endIdx + 2]).toBe("");
+    });
+
+    it("replaces existing block with blank line after when --append-newline is set", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\n# blockinfile start\nOLD\n# blockinfile end\nline2\n");
+
+      runBlockInFile(`--append-newline ${targetFile}`, "NEW");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      const lines = result.split("\n");
+      const endIdx = lines.indexOf("# blockinfile end");
+      expect(lines[endIdx + 1]).toBe("");
+      expect(lines[endIdx + 2]).toBe("line2");
+      expect(result).toContain("NEW");
+      expect(result).not.toContain("OLD");
+    });
+
+    it("inserts before pattern with blank line after", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nMARKER\nline3\n");
+
+      runBlockInFile(`--append-newline -b MARKER ${targetFile}`, "INSERTED");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      const lines = result.split("\n");
+      const endIdx = lines.indexOf("# blockinfile end");
+      expect(lines[endIdx + 1]).toBe("");
+      expect(lines[endIdx + 2]).toBe("MARKER");
+    });
+
+    it("inserts after pattern with blank line after", async () => {
+      const targetFile = path.join(tempDir, "target.txt");
+      await fs.writeFile(targetFile, "line1\nMARKER\nline3\n");
+
+      runBlockInFile(`--append-newline -a MARKER ${targetFile}`, "INSERTED");
+
+      const result = await fs.readFile(targetFile, "utf-8");
+      const lines = result.split("\n");
+      const endIdx = lines.indexOf("# blockinfile end");
+      expect(lines[endIdx + 1]).toBe("");
+      expect(lines[endIdx + 2]).toBe("line3");
+    });
+  });
+});

package/test/block-parser.test.ts

@@ -0,0 +1,221 @@
+import { describe, it, expect } from "vitest";
+
+interface ParseOptions {
+  opener: string;
+  closer: string;
+  inputBlock: string;
+  before?: RegExp | boolean;
+  after?: RegExp | boolean;
+}
+
+interface ParseResult {
+  outputs: string[];
+  matched: number;
+  opened?: number;
+}
+
+function parseLines(lines: string[], opts: ParseOptions): ParseResult {
+  const { opener, closer, inputBlock, before, after } = opts;
+  const match = before || after;
+  const outputs: string[] = [];
+
+  let done = false;
+  let opened: number | undefined;
+  let matched = -1;
+  let i = -1;
+
+  if (before === true) {
+    outputs.push(opener, inputBlock, closer);
+    done = true;
+  }
+
+  for (const line of lines) {
+    const isOpen = opened !== undefined;
+    i++;
+
+    if (!isOpen && line === opener) {
+      opened = outputs.length;
+    } else if (isOpen) {
+      if (line !== closer) {
+        continue;
+      }
+
+      opened = undefined;
+
+      if (done) {
+        continue;
+      }
+
+      outputs.push(opener, inputBlock, closer);
+      done = true;
+    } else {
+      outputs.push(line);
+
+      if (!done && matched === -1 && typeof match === "object" && match?.test?.(line)) {
+        matched = i;
+      }
+    }
+  }
+
+  if (opened !== undefined) {
+    outputs.push(opener, inputBlock, closer);
+    done = true;
+  }
+
+  if (!done) {
+    if (matched === -1) {
+      matched = i;
+    }
+    outputs.splice(matched + (after ? 1 : 0), 0, opener, inputBlock, closer);
+  }
+
+  return { outputs, matched, opened };
+}
+
+describe("block-parser", () => {
+  const defaultOpts: ParseOptions = {
+    opener: "# blockinfile start",
+    closer: "# blockinfile end",
+    inputBlock: "NEW CONTENT",
+  };
+
+  describe("insertion into empty or simple files", () => {
+    it.each([
+      { lines: [], expected: ["# blockinfile start", "NEW CONTENT", "# blockinfile end"] },
+      { lines: ["line1", "line2", "line3"], expectedContains: ["# blockinfile start", "NEW CONTENT", "# blockinfile end", "line1", "line2", "line3"] },
+    ])("inserts block: lines=$lines", ({ lines, expected, expectedContains }) => {
+      const result = parseLines(lines, defaultOpts);
+      if (expected) {
+        expect(result.outputs).toEqual(expected);
+      }
+      if (expectedContains) {
+        expectedContains.forEach(str => expect(result.outputs).toContain(str));
+      }
+    });
+  });
+
+  describe("replacing existing blocks", () => {
+    it.each([
+      {
+        lines: ["line1", "# blockinfile start", "OLD CONTENT", "# blockinfile end", "line2"],
+        opts: undefined as any,
+        expected: ["line1", "# blockinfile start", "NEW CONTENT", "# blockinfile end", "line2"],
+      },
+      {
+        lines: ["line1", "line2"],
+        opts: { ...defaultOpts, after: true },
+        expected: ["line1", "line2", "# blockinfile start", "NEW CONTENT", "# blockinfile end"],
+      },
+      {
+        lines: ["line1", "line2"],
+        opts: { ...defaultOpts, before: true },
+        expected: ["# blockinfile start", "NEW CONTENT", "# blockinfile end", "line1", "line2"],
+      },
+    ])("handles block replacement", ({ lines, opts, expected }) => {
+      const result = parseLines(lines, opts ?? defaultOpts);
+      expect(result.outputs).toEqual(expected);
+    });
+
+    it("replaces multi-line existing block", () => {
+      const lines = [
+        "header",
+        "# blockinfile start",
+        "old line 1",
+        "old line 2",
+        "old line 3",
+        "# blockinfile end",
+        "footer",
+      ];
+      const result = parseLines(lines, defaultOpts);
+      expect(result.outputs).toEqual([
+        "header",
+        "# blockinfile start",
+        "NEW CONTENT",
+        "# blockinfile end",
+        "footer",
+      ]);
+    });
+
+    it("removes duplicate blocks", () => {
+      const lines = [
+        "# blockinfile start",
+        "first block",
+        "# blockinfile end",
+        "middle",
+        "# blockinfile start",
+        "second block",
+        "# blockinfile end",
+      ];
+      const result = parseLines(lines, defaultOpts);
+      expect(result.outputs).toEqual([
+        "# blockinfile start",
+        "NEW CONTENT",
+        "# blockinfile end",
+        "middle",
+      ]);
+    });
+  });
+
+  describe("before/after matching", () => {
+    it.each([
+      {
+        description: "at beginning when before=true",
+        lines: ["line1", "line2"],
+        opts: { ...defaultOpts, before: true },
+        expected: ["# blockinfile start", "NEW CONTENT", "# blockinfile end", "line1", "line2"],
+      },
+      {
+        description: "before matching line",
+        lines: ["line1", "TARGET", "line3"],
+        opts: { ...defaultOpts, before: /TARGET/ },
+        expected: ["line1", "# blockinfile start", "NEW CONTENT", "# blockinfile end", "TARGET", "line3"],
+      },
+      {
+        description: "after matching line",
+        lines: ["line1", "TARGET", "line3"],
+        opts: { ...defaultOpts, after: /TARGET/ },
+        expected: ["line1", "TARGET", "# blockinfile start", "NEW CONTENT", "# blockinfile end", "line3"],
+      },
+      {
+        description: "falls back to end when no match",
+        lines: ["line1", "line2"],
+        opts: { ...defaultOpts, after: /NOMATCH/ },
+        expected: ["line1", "line2", "# blockinfile start", "NEW CONTENT", "# blockinfile end"],
+      },
+    ])("inserts $description", ({ lines, opts, expected }) => {
+      const result = parseLines(lines, opts);
+      expect(result.outputs).toEqual(expected);
+    });
+
+    it("matches first occurrence only", () => {
+      const result = parseLines(["TARGET", "middle", "TARGET"], {
+        ...defaultOpts,
+        after: /TARGET/,
+      });
+      expect(result.outputs[0]).toBe("TARGET");
+      expect(result.outputs[1]).toBe("# blockinfile start");
+    });
+  });
+
+  describe("unclosed blocks", () => {
+    it("handles unclosed block by closing it", () => {
+      const lines = ["line1", "# blockinfile start", "unclosed content"];
+      const result = parseLines(lines, defaultOpts);
+      expect(result.outputs).toContain("# blockinfile start");
+      expect(result.outputs).toContain("NEW CONTENT");
+      expect(result.outputs).toContain("# blockinfile end");
+    });
+  });
+
+  describe("custom markers", () => {
+    it("uses custom opener and closer", () => {
+      const lines = ["line1", "// BEGIN", "old", "// END", "line2"];
+      const result = parseLines(lines, {
+        opener: "// BEGIN",
+        closer: "// END",
+        inputBlock: "REPLACED",
+      });
+      expect(result.outputs).toEqual(["line1", "// BEGIN", "REPLACED", "// END", "line2"]);
+    });
+  });
+});

package/test/block-remover.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect } from "vitest";
+import { removeBlocks } from "../src/block-remover.ts";
+
+describe("block-remover", () => {
+  describe("removeBlocks", () => {
+    it("removes single block by name", () => {
+      const fileContent = "line1\n# blockinfile start\ncontent\n# blockinfile end\nline2\n";
+      const { content, stats } = removeBlocks({
+        fileContent,
+        blockNames: ["blockinfile"],
+        comment: "#",
+        markerStart: "start",
+        markerEnd: "end",
+        removeOrphans: false,
+        debug: false,
+        logger: { debug: () => {}, log: () => {}, warn: () => {} },
+      });
+
+      expect(content).toBe("line1\nline2\n");
+      expect(stats.removed).toBe(1);
+      expect(stats.orphans).toBe(0);
+      expect(stats.blocks.length).toBe(1);
+      expect(stats.blocks[0].blockName).toBe("blockinfile");
+    });
+
+    it("removes multiple blocks with same name", () => {
+      const fileContent =
+        "line1\n# blockinfile start\ncontent1\n# blockinfile end\nline2\n# blockinfile start\ncontent2\n# blockinfile end\nline3\n";
+      const { content, stats } = removeBlocks({
+        fileContent,
+        blockNames: ["blockinfile"],
+        comment: "#",
+        markerStart: "start",
+        markerEnd: "end",
+        removeOrphans: false,
+        debug: false,
+        logger: { debug: () => {}, log: () => {}, warn: () => {} },
+      });
+
+      expect(content).toBe("line1\nline2\nline3\n");
+      expect(stats.removed).toBe(2);
+      expect(stats.blocks.length).toBe(2);
+    });
+
+    it("removes orphan blocks when removeOrphans is true", () => {
+      const fileContent =
+        "line1\n# blockinfile start\n\n# blockinfile end\nline2\n# blockinfile start   \n# blockinfile end\nline3\n";
+      const { content, stats } = removeBlocks({
+        fileContent,
+        blockNames: [],
+        comment: "#",
+        markerStart: "start",
+        markerEnd: "end",
+        removeOrphans: true,
+        debug: false,
+        logger: { debug: () => {}, log: () => {}, warn: () => {} },
+      });
+
+      expect(content).toBe("line1\nline2\nline3\n");
+      expect(stats.removed).toBe(2);
+      expect(stats.orphans).toBe(2);
+    });
+
+    it("keeps orphan blocks when removeOrphans is false", () => {
+      const fileContent = "line1\n# blockinfile start\n\n# blockinfile end\nline2\n";
+      const { content, stats } = removeBlocks({
+        fileContent,
+        blockNames: ["blockinfile"],
+        comment: "#",
+        markerStart: "start",
+        markerEnd: "end",
+        removeOrphans: false,
+        debug: false,
+        logger: { debug: () => {}, log: () => {}, warn: () => {} },
+      });
+
+      expect(content).toBe("line1\nline2\n");
+      expect(stats.removed).toBe(1);
+      expect(stats.orphans).toBe(0);
+    });
+
+    it("preserves content outside blocks", () => {
+      const fileContent = "before\n# blockinfile start\ncontent\n# blockinfile end\nafter\n";
+      const { content, stats } = removeBlocks({
+        fileContent,
+        blockNames: ["blockinfile"],
+        comment: "#",
+        markerStart: "start",
+        markerEnd: "end",
+        removeOrphans: false,
+        debug: false,
+        logger: { debug: () => {}, log: () => {}, warn: () => {} },
+      });
+
+      expect(content).toBe("before\nafter\n");
+      expect(stats.removed).toBe(1);
+    });
+
+    it("handles empty file content", () => {
+      const { content, stats } = removeBlocks({
+        fileContent: "",
+        blockNames: ["blockinfile"],
+        comment: "#",
+        markerStart: "start",
+        markerEnd: "end",
+        removeOrphans: false,
+        debug: false,
+        logger: { debug: () => {}, log: () => {}, warn: () => {} },
+      });
+
+      expect(content).toBe("");
+      expect(stats.removed).toBe(0);
+    });
+
+    it("handles file with no matching blocks", () => {
+      const fileContent = "line1\nline2\nline3\n";
+      const { content, stats } = removeBlocks({
+        fileContent,
+        blockNames: ["blockinfile"],
+        comment: "#",
+        markerStart: "start",
+        markerEnd: "end",
+        removeOrphans: false,
+        debug: false,
+        logger: { debug: () => {}, log: () => {}, warn: () => {} },
+      });
+
+      expect(content).toBe(fileContent);
+      expect(stats.removed).toBe(0);
+    });
+
+    it("handles unclosed blocks gracefully", () => {
+      const fileContent = "line1\n# blockinfile start\ncontent\n";
+      const { content, stats } = removeBlocks({
+        fileContent,
+        blockNames: ["blockinfile"],
+        comment: "#",
+        markerStart: "start",
+        markerEnd: "end",
+        removeOrphans: false,
+        debug: true,
+        logger: {
+          debug: () => {},
+          log: () => {},
+          warn: (msg: string) => expect(msg).toContain("Unclosed block"),
+        },
+      });
+
+      expect(content).toContain("content");
+      expect(stats.removed).toBe(0);
+    });
+
+    it("correctly tracks line numbers", () => {
+      const fileContent = "line1\nline2\n# blockinfile start\ncontent\n# blockinfile end\nline5\n";
+      const { stats } = removeBlocks({
+        fileContent,
+        blockNames: ["blockinfile"],
+        comment: "#",
+        markerStart: "start",
+        markerEnd: "end",
+        removeOrphans: false,
+        debug: false,
+        logger: { debug: () => {}, log: () => {}, warn: () => {} },
+      });
+
+      expect(stats.blocks[0].startLine).toBe(3);
+      expect(stats.blocks[0].endLine).toBe(5);
+      expect(stats.blocks[0].content).toBe("content");
+    });
+
+    it("handles blocks with multi-line content", () => {
+      const fileContent =
+        "line1\n# blockinfile start\nlineA\nlineB\nlineC\n# blockinfile end\nline2\n";
+      const { content, stats } = removeBlocks({
+        fileContent,
+        blockNames: ["blockinfile"],
+        comment: "#",
+        markerStart: "start",
+        markerEnd: "end",
+        removeOrphans: false,
+        debug: false,
+        logger: { debug: () => {}, log: () => {}, warn: () => {} },
+      });
+
+      expect(content).toBe("line1\nline2\n");
+      expect(stats.removed).toBe(1);
+      expect(stats.blocks[0].content).toBe("lineA\nlineB\nlineC");
+    });
+
+    it("handles mixed orphan and named blocks", () => {
+      const fileContent =
+        "line1\n# blockinfile start\n\n# blockinfile end\nline2\n# other start\ncontent\n# other end\nline3\n";
+      const { content, stats } = removeBlocks({
+        fileContent,
+        blockNames: ["other"],
+        comment: "#",
+        markerStart: "start",
+        markerEnd: "end",
+        removeOrphans: true,
+        debug: false,
+        logger: { debug: () => {}, log: () => {}, warn: () => {} },
+      });
+
+      expect(content).toBe("line1\nline2\nline3\n");
+      expect(stats.removed).toBe(2);
+      expect(stats.orphans).toBe(1);
+    });
+  });
+});