block-in-file 1.0.0

package/src/block-parser.ts

@@ -0,0 +1,170 @@
+import type { ParseResult } from "./types.ts";
+import { stripTagsForMatching } from "./tags/tags.ts";
+
+export interface ParseOptions {
+  opener: string;
+  closer: string;
+  inputBlock: string;
+  before?: RegExp | boolean;
+  after?: RegExp | boolean;
+  appendNewline?: boolean;
+  additive?: boolean;
+  additiveBefore?: RegExp | "EOB" | "EOF" | "BOF";
+  additiveAfter?: RegExp | "EOB" | "EOF" | "BOF";
+  actualOpener?: string;
+  actualCloser?: string;
+}
+
+export function parseAndInsertBlock(fileContent: string, opts: ParseOptions): ParseResult {
+  const {
+    opener,
+    closer,
+    inputBlock,
+    before,
+    after,
+    appendNewline,
+    additive,
+    additiveBefore,
+    additiveAfter,
+    actualOpener,
+    actualCloser,
+  } = opts;
+  const match = before || after;
+  const outputs: string[] = [];
+  const lines = fileContent.split("\n");
+
+  let done = false;
+  let opened: number | undefined;
+  let matched = -1;
+  let i = -1;
+  let blockContentLines: string[] = [];
+  let blockStartIndex = -1;
+  let blockEndIndex = -1;
+
+  const inputLines = inputBlock.split("\n");
+  const outputOpener = actualOpener || opener;
+  const outputCloser = actualCloser || closer;
+
+  const isOpener = (line: string) => {
+    return stripTagsForMatching(line.trim()) === opener;
+  };
+
+  const isCloser = (line: string) => {
+    return stripTagsForMatching(line.trim()) === closer;
+  };
+
+  if (before === true) {
+    outputs.push(outputOpener, ...inputLines, outputCloser);
+    if (appendNewline) {
+      outputs.push("");
+    }
+    done = true;
+  }
+
+  for (const line of lines) {
+    const isOpen = opened !== undefined;
+    i++;
+
+    if (!isOpen && isOpener(line)) {
+      opened = outputs.length;
+      blockStartIndex = outputs.length;
+    } else if (isOpen) {
+      if (!isCloser(line)) {
+        if (additive) {
+          blockContentLines.push(line);
+        }
+        continue;
+      }
+
+      opened = undefined;
+      blockEndIndex = outputs.length;
+
+      if (done) {
+        continue;
+      }
+
+      if (additive) {
+        const missingLines = inputLines.filter((line) => !blockContentLines.includes(line));
+
+        if (missingLines.length > 0 || blockContentLines.length === 0) {
+          let newContentLines: string[];
+
+          if (blockContentLines.length === 0) {
+            newContentLines = inputLines;
+          } else if (
+            additiveAfter === "EOB" ||
+            additiveAfter === "EOF" ||
+            (!additiveBefore && !additiveAfter)
+          ) {
+            newContentLines = [...blockContentLines, ...missingLines];
+          } else if (additiveBefore === "BOF") {
+            newContentLines = [...missingLines, ...blockContentLines];
+          } else if (
+            additiveAfter &&
+            typeof additiveAfter === "object" &&
+            "test" in additiveAfter
+          ) {
+            let insertIndex = blockContentLines.findIndex((l) => additiveAfter.test(l));
+            if (insertIndex === -1) insertIndex = blockContentLines.length;
+            newContentLines = [
+              ...blockContentLines.slice(0, insertIndex + 1),
+              ...missingLines,
+              ...blockContentLines.slice(insertIndex + 1),
+            ];
+          } else if (
+            additiveBefore &&
+            typeof additiveBefore === "object" &&
+            "test" in additiveBefore
+          ) {
+            let insertIndex = blockContentLines.findIndex((l) => additiveBefore.test(l));
+            if (insertIndex === -1) insertIndex = 0;
+            newContentLines = [
+              ...blockContentLines.slice(0, insertIndex),
+              ...missingLines,
+              ...blockContentLines.slice(insertIndex),
+            ];
+          } else {
+            newContentLines = [...blockContentLines, ...missingLines];
+          }
+
+          outputs.push(outputOpener, ...newContentLines, outputCloser);
+        } else {
+          outputs.push(outputOpener, ...blockContentLines, outputCloser);
+        }
+      } else {
+        outputs.push(outputOpener, ...inputLines, outputCloser);
+      }
+
+      if (appendNewline) {
+        outputs.push("");
+      }
+      done = true;
+    } else {
+      outputs.push(line);
+
+      if (!done && matched === -1 && typeof match === "object" && match?.test?.(line)) {
+        matched = i;
+      }
+    }
+  }
+
+  if (opened !== undefined) {
+    outputs.push(outputOpener, ...inputLines, outputCloser);
+    if (appendNewline) {
+      outputs.push("");
+    }
+    done = true;
+  }
+
+  if (!done) {
+    if (matched === -1) {
+      matched = i;
+    }
+    outputs.splice(matched + (after ? 1 : 0), 0, outputOpener, ...inputLines, outputCloser);
+    if (appendNewline) {
+      outputs.splice(matched + (after ? 1 : 0) + inputLines.length + 2, 0, "");
+    }
+  }
+
+  return { outputs, matched, opened };
+}

package/src/block-remover.ts

@@ -0,0 +1,128 @@
+import type { LoggerExtension } from "./plugins/logger.ts";
+import { stripTagsForMatching } from "./tags/tags.ts";
+
+export interface RemovedBlock {
+  blockName: string;
+  startLine: number;
+  endLine: number;
+  content: string;
+}
+
+export interface RemovalStats {
+  removed: number;
+  orphans: number;
+  totalLinesRemoved: number;
+  blocks: RemovedBlock[];
+}
+
+export interface BlockRemoverOptions {
+  fileContent: string;
+  blockNames: string[];
+  comment: string;
+  markerStart: string;
+  markerEnd: string;
+  removeOrphans: boolean;
+  debug: boolean;
+  logger: LoggerExtension;
+}
+
+export function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function removeBlocks(opts: BlockRemoverOptions): { content: string; stats: RemovalStats } {
+  const { fileContent, blockNames, comment, markerStart, markerEnd, removeOrphans, debug, logger } =
+    opts;
+
+  const lines = fileContent.split("\n");
+  const stats: RemovalStats = {
+    removed: 0,
+    orphans: 0,
+    totalLinesRemoved: 0,
+    blocks: [],
+  };
+
+  let newLines: string[] = [];
+  let inBlock = false;
+  let blockStartLine = 0;
+  let blockContent: string[] = [];
+  let currentBlockName: string | null = null;
+
+  const openerRegex = new RegExp(
+    `^${escapeRegex(comment)}\\s+(\\S+)\\s+${escapeRegex(markerStart)}(\\s+.*)?$`,
+  );
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (inBlock) {
+      const isCloser =
+        line.trim() === `${comment} ${currentBlockName || ""} ${markerEnd}` ||
+        stripTagsForMatching(line.trim()) === `${comment} ${currentBlockName || ""} ${markerEnd}`;
+
+      if (isCloser) {
+        const isTargetBlock = currentBlockName && blockNames.includes(currentBlockName);
+        const contentStr = blockContent.join("\n");
+        const isOrphan = contentStr.trim() === "" || contentStr.trim().length === 0;
+
+        if (isTargetBlock || (isOrphan && removeOrphans)) {
+          stats.removed++;
+          stats.totalLinesRemoved += i - blockStartLine + 1;
+          stats.blocks.push({
+            blockName: currentBlockName || "orphan",
+            startLine: blockStartLine + 1,
+            endLine: i + 1,
+            content: contentStr,
+          });
+
+          if (isOrphan && removeOrphans) {
+            stats.orphans++;
+          }
+
+          if (debug) {
+            logger.debug(
+              `Removed block at lines ${blockStartLine + 1}-${i + 1}: ${currentBlockName || "orphan"}`,
+            );
+          }
+
+          inBlock = false;
+          currentBlockName = null;
+          blockContent = [];
+          continue;
+        }
+
+        newLines.push(...blockContent);
+        newLines.push(line);
+        inBlock = false;
+        currentBlockName = null;
+        blockContent = [];
+      } else {
+        blockContent.push(line);
+      }
+    } else {
+      const openerMatch = line.match(openerRegex);
+      if (
+        openerMatch &&
+        (line.trim() === `${comment} ${openerMatch[1] || ""} ${markerStart}` ||
+          stripTagsForMatching(line.trim()) === `${comment} ${openerMatch[1] || ""} ${markerStart}`)
+      ) {
+        inBlock = true;
+        blockStartLine = i;
+        currentBlockName = openerMatch[1] || "";
+        blockContent = [];
+      } else {
+        newLines.push(line);
+      }
+    }
+  }
+
+  if (inBlock) {
+    newLines.push(...blockContent);
+    if (debug) {
+      logger.warn(`Warning: Unclosed block starting at line ${blockStartLine + 1}`);
+    }
+  }
+
+  const content = newLines.join("\n");
+  return { content, stats };
+}

package/src/conflict-detection.ts

@@ -0,0 +1,179 @@
+import type { LoggerExtension } from "./plugins/logger.ts";
+import { stripTagsForMatching } from "./tags/tags.ts";
+
+export interface Conflict {
+  type: "duplicate" | "nested" | "mismatched";
+  line: number;
+  message: string;
+}
+
+export interface ConflictDetectionResult {
+  hasConflicts: boolean;
+  conflicts: Conflict[];
+}
+
+export function detectConflicts(
+  fileContent: string,
+  opener: string,
+  closer: string,
+  logger?: LoggerExtension,
+): ConflictDetectionResult {
+  const lines = fileContent.split("\n");
+  const conflicts: Conflict[] = [];
+  const openerPositions: number[] = [];
+  const closerPositions: number[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = stripTagsForMatching(lines[i].trim());
+    if (line === opener) {
+      openerPositions.push(i);
+    } else if (line === closer) {
+      closerPositions.push(i);
+    }
+  }
+
+  if (openerPositions.length > 1) {
+    for (const pos of openerPositions) {
+      conflicts.push({
+        type: "duplicate",
+        line: pos + 1,
+        message: `Duplicate block opener found at line ${pos + 1}`,
+      });
+    }
+  }
+
+  if (closerPositions.length > 1) {
+    for (const pos of closerPositions) {
+      conflicts.push({
+        type: "duplicate",
+        line: pos + 1,
+        message: `Duplicate block closer found at line ${pos + 1}`,
+      });
+    }
+  }
+
+  let depth = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = stripTagsForMatching(lines[i].trim());
+    if (line === opener) {
+      depth++;
+      if (depth > 1) {
+        conflicts.push({
+          type: "nested",
+          line: i + 1,
+          message: `Nested block detected at line ${i + 1}`,
+        });
+      }
+    } else if (line === closer) {
+      depth--;
+    }
+  }
+
+  if (depth !== 0) {
+    const lastOpener = openerPositions[openerPositions.length - 1];
+    if (lastOpener !== undefined) {
+      conflicts.push({
+        type: "mismatched",
+        line: lastOpener + 1,
+        message: `Unmatched block opener at line ${lastOpener + 1} (missing closer)`,
+      });
+    }
+  }
+
+  const result: ConflictDetectionResult = {
+    hasConflicts: conflicts.length > 0,
+    conflicts,
+  };
+
+  if (result.hasConflicts && logger) {
+    for (const conflict of conflicts) {
+      logger.log(`Conflict: ${conflict.message}`);
+    }
+  }
+
+  return result;
+}
+
+export function detectConflictsWithPattern(
+  fileContent: string,
+  opener: string,
+  closer: string,
+  openerPattern: RegExp,
+  closerPattern: RegExp,
+  logger?: LoggerExtension,
+): ConflictDetectionResult {
+  const lines = fileContent.split("\n");
+  const conflicts: Conflict[] = [];
+  const openerPositions: number[] = [];
+  const closerPositions: number[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = stripTagsForMatching(lines[i].trim());
+    if (openerPattern.test(line)) {
+      openerPositions.push(i);
+    } else if (closerPattern.test(line)) {
+      closerPositions.push(i);
+    }
+  }
+
+  if (openerPositions.length > 1) {
+    for (const pos of openerPositions) {
+      conflicts.push({
+        type: "duplicate",
+        line: pos + 1,
+        message: `Duplicate block opener found at line ${pos + 1}`,
+      });
+    }
+  }
+
+  if (closerPositions.length > 1) {
+    for (const pos of closerPositions) {
+      conflicts.push({
+        type: "duplicate",
+        line: pos + 1,
+        message: `Duplicate block closer found at line ${pos + 1}`,
+      });
+    }
+  }
+
+  let depth = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = stripTagsForMatching(lines[i].trim());
+    if (openerPattern.test(line)) {
+      depth++;
+      if (depth > 1) {
+        conflicts.push({
+          type: "nested",
+          line: i + 1,
+          message: `Nested block detected at line ${i + 1}`,
+        });
+      }
+    } else if (closerPattern.test(line)) {
+      depth--;
+    }
+  }
+
+  if (depth !== 0) {
+    const lastOpener = openerPositions[openerPositions.length - 1];
+    if (lastOpener !== undefined) {
+      conflicts.push({
+        type: "mismatched",
+        line: lastOpener + 1,
+        message: `Unmatched block opener at line ${lastOpener + 1} (missing closer)`,
+      });
+    }
+  }
+
+  const result: ConflictDetectionResult = {
+    hasConflicts: conflicts.length > 0,
+    conflicts,
+  };
+
+  if (result.hasConflicts && logger) {
+    for (const conflict of conflicts) {
+      logger.log(`Conflict: ${conflict.message}`);
+    }
+  }
+
+  return result;
+}

package/src/defaults.ts

@@ -0,0 +1,23 @@
+import type { BlockInFileOptions } from "./types.ts";
+
+const defaultOptions: Readonly<BlockInFileOptions> = Object.freeze({
+  after: undefined,
+  before: undefined,
+  comment: "#",
+  create: false,
+  debug: false,
+  diff: undefined,
+  dos: false,
+  envsubst: false,
+  input: undefined,
+  markerStart: "start",
+  markerEnd: "end",
+  name: "blockinfile",
+  output: undefined,
+});
+
+export function getDefaultOptions(): BlockInFileOptions {
+  return { ...defaultOptions };
+}
+
+export { defaultOptions };

package/src/envsubst.ts

@@ -0,0 +1,59 @@
+const MAX_ITERATIONS = 100;
+const VAR_PATTERN_BRACES = /\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+const VAR_PATTERN_SIMPLE = /\$([a-zA-Z_][a-zA-Z0-9_]*)/g;
+
+export type EnvsubstMode = "recursive" | "non-recursive" | false;
+
+export interface EnvsubstOptions {
+  mode: EnvsubstMode;
+}
+
+export function substitute(text: string, options: EnvsubstOptions): string {
+  const { mode } = options;
+
+  if (mode === false) {
+    return text;
+  }
+
+  if (mode === "non-recursive") {
+    return substituteOnce(text);
+  }
+
+  return substituteUntilStable(text, MAX_ITERATIONS);
+}
+
+function substituteUntilStable(text: string, maxIterations: number): string {
+  let current = text;
+  let previous = "";
+  let iterations = 0;
+
+  while (current !== previous && iterations < maxIterations) {
+    previous = current;
+    current = substituteOnce(current);
+    iterations++;
+  }
+
+  return current;
+}
+
+function substituteOnce(text: string): string {
+  let result = text;
+
+  result = result.replace(VAR_PATTERN_BRACES, (match, varName) => {
+    const value = process.env[varName];
+    if (value === undefined) {
+      return "";
+    }
+    return value;
+  });
+
+  result = result.replace(VAR_PATTERN_SIMPLE, (match, varName) => {
+    const value = process.env[varName];
+    if (value === undefined) {
+      return "";
+    }
+    return value;
+  });
+
+  return result;
+}