@featurevisor/core 2.7.0 → 2.9.0

package/src/parsers/yml.spec.ts

@@ -0,0 +1,174 @@
+import { ymlParser } from "./yml";
+
+describe("core :: parser :: ymlParser", () => {
+  it("should parse YAML string into object", () => {
+    const yamlString = `
+foo: 1
+bar: baz
+arr:
+  - 1
+  - 2
+`;
+    const result = ymlParser.parse<{ foo: number; bar: string; arr: number[] }>(yamlString);
+    expect(result).toEqual({ foo: 1, bar: "baz", arr: [1, 2] });
+  });
+
+  it("should stringify object into YAML string", () => {
+    const obj = { foo: 1, bar: "baz", arr: [1, 2] };
+    const yamlString = ymlParser.stringify(obj);
+    expect(yamlString.trim()).toBe(`foo: 1
+bar: baz
+arr:
+  - 1
+  - 2`);
+  });
+
+  it("should parse and then stringify to preserve YAML content semantically", () => {
+    const original = {
+      alpha: "a",
+      num: 42,
+      bool: true,
+      nullish: null,
+      nested: { z: "x", y: [1, 2] },
+    };
+    const str = ymlParser.stringify(original);
+    const reparsed = ymlParser.parse<typeof original>(str);
+    expect(reparsed).toEqual(original);
+  });
+
+  it("should throw if invalid YAML string is provided to parse", () => {
+    expect(() => {
+      ymlParser.parse("foo: : bar");
+    }).toThrow();
+  });
+
+  describe("stringify() with filePath argument (existing file for ordering/comments only)", () => {
+    const fs = require("fs");
+    const path = require("path");
+    const os = require("os");
+
+    let tempFile: string;
+
+    beforeEach(() => {
+      tempFile = path.join(os.tmpdir(), `test_${Math.random()}.yml`);
+    });
+
+    afterEach(() => {
+      if (fs.existsSync(tempFile)) {
+        fs.unlinkSync(tempFile);
+      }
+    });
+
+    it("should save exactly the new object; existing file is only for ordering/comments", () => {
+      const beforeYaml =
+        `
+foo: 1 # foo comment here
+extra: blah
+
+##
+# Comment above nested
+#
+nested:
+  a: x
+  b: y # b comment
+array:
+  - one # one
+  - two # two
+  - three # three
+`.trim() + "\n";
+
+      const newContent = {
+        foo: 42,
+        bar: "new",
+        nested: { b: "updated", c: "added" },
+        array: ["two", "three", "four"],
+      };
+
+      const afterYaml =
+        `
+foo: 42 # foo comment here
+bar: new
+##
+# Comment above nested
+#
+nested:
+  b: updated # b comment
+  c: added
+array:
+  - two # two
+  - three # three
+  - four
+`.trim() + "\n";
+
+      fs.writeFileSync(tempFile, beforeYaml);
+
+      const output = ymlParser.stringify(newContent, tempFile);
+
+      expect(output).toBe(afterYaml);
+    });
+
+    it("should replace the root if YAML file is empty", () => {
+      const beforeYaml = "";
+      const afterYaml =
+        `
+hello: world
+test:
+  - 1
+  - 2
+  - 3
+`.trim() + "\n";
+
+      fs.writeFileSync(tempFile, beforeYaml);
+
+      const obj = { hello: "world", test: [1, 2, 3] };
+      const output = ymlParser.stringify(obj, tempFile);
+
+      expect(output).toBe(afterYaml);
+    });
+
+    it("should throw if trying to set YAML document root to a primitive", () => {
+      const beforeYaml =
+        `
+foo: bar
+`.trim() + "\n";
+
+      fs.writeFileSync(tempFile, beforeYaml);
+
+      // Root must be an object when using filePath; primitives throw
+      expect(() => {
+        ymlParser.stringify("primitive", tempFile);
+      }).toThrow(/Cannot set root document to a primitive value/);
+    });
+
+    it("should fall back to simple stringify if filePath does not exist", () => {
+      const fakeFilePath = path.join(os.tmpdir(), `notfound_${Math.random()}.yml`);
+      const afterYaml =
+        `
+only: in-memory
+`.trim() + "\n";
+
+      const obj = { only: "in-memory" };
+      const output = ymlParser.stringify(obj, fakeFilePath);
+
+      expect(output).toBe(afterYaml);
+      expect(fs.existsSync(fakeFilePath)).toBe(false); // should not create the file
+    });
+
+    it("should not mutate the original YAML file", () => {
+      const beforeYaml =
+        `
+foo: unchanged
+bar: before
+`.trim() + "\n";
+
+      fs.writeFileSync(tempFile, beforeYaml);
+      const onDiskBefore = fs.readFileSync(tempFile, "utf8");
+
+      const obj = { bar: "after" };
+      ymlParser.stringify(obj, tempFile);
+
+      const onDiskAfter = fs.readFileSync(tempFile, "utf8");
+      expect(onDiskAfter).toBe(onDiskBefore); // file on disk unchanged
+    });
+  });
+});

package/src/parsers/yml.ts

@@ -0,0 +1,168 @@
+import * as fs from "fs";
+
+import { parse, parseDocument, stringify } from "yaml";
+import type { Pair, YAMLMap, YAMLSeq } from "yaml/types";
+import { Scalar as ScalarCtor } from "yaml/types";
+
+import type { CustomParser } from "./index";
+
+function getKeyString(keyNode: unknown): string | undefined {
+  if (keyNode == null) return undefined;
+  if (typeof (keyNode as { value?: unknown }).value !== "undefined") {
+    return String((keyNode as { value: unknown }).value);
+  }
+  return typeof keyNode === "string" ? keyNode : undefined;
+}
+
+function copyComments(source: Pair, target: Pair): void {
+  if (source.comment != null) target.comment = source.comment;
+  if (source.commentBefore != null) target.commentBefore = source.commentBefore;
+  const srcVal = source.value as
+    | { comment?: string | null; commentBefore?: string | null }
+    | undefined;
+  const tgtVal = target.value;
+  if (srcVal && tgtVal && typeof tgtVal === "object" && tgtVal !== null) {
+    const t = tgtVal as { comment?: string | null; commentBefore?: string | null };
+    if (srcVal.comment != null) t.comment = srcVal.comment;
+    if (srcVal.commentBefore != null) t.commentBefore = srcVal.commentBefore;
+  }
+}
+
+function isYamlMap(node: unknown): node is YAMLMap {
+  return node != null && typeof node === "object" && Array.isArray((node as YAMLMap).items);
+}
+
+function isYamlSeq(node: unknown): node is YAMLSeq {
+  return node != null && typeof node === "object" && Array.isArray((node as YAMLSeq).items);
+}
+
+function seqItemValueKey(item: unknown): string {
+  if (item == null) return String(item);
+  const n = item as { value?: unknown; toJSON?: () => unknown };
+  if (typeof n.value !== "undefined") return JSON.stringify(n.value);
+  if (typeof n.toJSON === "function") return JSON.stringify(n.toJSON());
+  return JSON.stringify(item);
+}
+
+function primitiveValueKey(v: unknown): string {
+  return JSON.stringify(v);
+}
+
+function createValueWithComments(
+  schema: { createNode: (v: unknown) => unknown; createPair: (k: unknown, v: unknown) => Pair },
+  oldNode: unknown,
+  newValue: unknown,
+): unknown {
+  if (newValue === null || typeof newValue !== "object") {
+    const node = new ScalarCtor(newValue);
+    const old = oldNode as { comment?: string | null; commentBefore?: string | null } | undefined;
+    if (old) {
+      if (old.comment != null) node.comment = old.comment;
+      if (old.commentBefore != null) node.commentBefore = old.commentBefore;
+    }
+    return node;
+  }
+  if (Array.isArray(newValue)) {
+    const oldSeq = isYamlSeq(oldNode) ? (oldNode as YAMLSeq) : null;
+    const oldItemsByValue = new Map<string, unknown>();
+    if (oldSeq && oldSeq.items) {
+      for (const item of oldSeq.items) {
+        oldItemsByValue.set(seqItemValueKey(item), item);
+      }
+    }
+    const newSeq = schema.createNode([]) as YAMLSeq;
+    for (const el of newValue) {
+      const oldItem = oldItemsByValue.get(primitiveValueKey(el));
+      const itemNode = createValueWithComments(schema, oldItem, el);
+      newSeq.add(itemNode);
+    }
+    return newSeq;
+  }
+  // newValue is a plain object; preserve comments from old map if present
+  const oldMap = isYamlMap(oldNode) ? (oldNode as YAMLMap) : null;
+  const oldPairsByKey = new Map<string, Pair>();
+  if (oldMap) {
+    for (const pair of (oldMap.items || []) as Pair[]) {
+      const keyStr = getKeyString(pair.key);
+      if (keyStr !== undefined) oldPairsByKey.set(keyStr, pair);
+    }
+  }
+  const newMap = schema.createNode({}) as YAMLMap;
+  const obj = newValue as Record<string, unknown>;
+  for (const k of Object.keys(obj)) {
+    const oldPair = oldPairsByKey.get(k);
+    const childOldNode = oldPair ? oldPair.value : undefined;
+    const childNewValue = createValueWithComments(schema, childOldNode, obj[k]);
+    const newPair = schema.createPair(k, childNewValue);
+    if (oldPair) copyComments(oldPair, newPair);
+    newMap.add(newPair);
+  }
+  const result = newMap as { comment?: string | null; commentBefore?: string | null };
+  const oldVal = oldNode as { comment?: string | null; commentBefore?: string | null } | undefined;
+  if (oldVal && result) {
+    if (oldVal.comment != null) result.comment = oldVal.comment;
+    if (oldVal.commentBefore != null) result.commentBefore = oldVal.commentBefore;
+  }
+  return result;
+}
+
+function replaceContentsPreservingComments(
+  doc: {
+    contents: unknown;
+    schema: { createNode: (v: unknown) => unknown; createPair: (k: unknown, v: unknown) => Pair };
+  },
+  newContent: Record<string, unknown>,
+): void {
+  const oldRoot = doc.contents as YAMLMap | null | undefined;
+  if (!oldRoot || !Array.isArray((oldRoot as YAMLMap).items)) {
+    doc.contents = doc.schema.createNode(newContent) as typeof doc.contents;
+    return;
+  }
+
+  const schema = doc.schema;
+  const oldPairsByKey = new Map<string, Pair>();
+  for (const pair of (oldRoot as YAMLMap).items as Pair[]) {
+    const keyStr = getKeyString(pair.key);
+    if (keyStr !== undefined) oldPairsByKey.set(keyStr, pair);
+  }
+
+  const newMap = schema.createNode({}) as YAMLMap;
+  for (const key of Object.keys(newContent)) {
+    const oldPair = oldPairsByKey.get(key);
+    const valueNode = createValueWithComments(schema, oldPair?.value, newContent[key]);
+    const newPair = schema.createPair(key, valueNode);
+    if (oldPair) copyComments(oldPair, newPair);
+    newMap.add(newPair);
+  }
+
+  (doc as { contents: unknown }).contents = newMap;
+}
+
+export const ymlParser: CustomParser = {
+  extension: "yml",
+  parse: function <T>(content: string): T {
+    return parse(content) as T;
+  },
+  stringify: function (content: any, filePath?: string) {
+    if (!filePath || !fs.existsSync(filePath)) {
+      return stringify(content);
+    }
+
+    const fileContent = fs.readFileSync(filePath, "utf8");
+    if (!fileContent.trim()) {
+      return stringify(content);
+    }
+
+    // newObject is the final saved object; existing file is only for ordering/comments
+    if (content === null || typeof content !== "object" || Array.isArray(content)) {
+      throw new Error("Cannot set root document to a primitive value");
+    }
+
+    const doc = parseDocument(fileContent) as {
+      contents: unknown;
+      schema: { createNode: (v: unknown) => unknown; createPair: (k: unknown, v: unknown) => Pair };
+    };
+    replaceContentsPreservingComments(doc, content);
+    return doc.toString();
+  },
+};

package/src/utils/git.ts

@@ -2,7 +2,8 @@ import * as path from "path";
 
 import type { Commit, EntityDiff, EntityType } from "@featurevisor/types";
 
-import { CustomParser, ProjectConfig } from "../config";
+import { ProjectConfig } from "../config";
+import { CustomParser } from "../parsers";
 
 function parseGitCommitShowOutput(gitShowOutput: string) {
   const result = {

package/tsconfig.cjs.json

@@ -2,7 +2,8 @@
   "extends": "../../tsconfig.cjs.json",
   "compilerOptions": {
     "target": "es2020",
-    "outDir": "./lib"
+    "outDir": "./lib",
+    "skipLibCheck": true
   },
   "include": ["./src/**/*.ts"]
 }

package/coverage/lcov-report/lib/builder/allocator.js.html

@@ -1,196 +0,0 @@
-
-<!doctype html>
-<html lang="en">
-
-<head>
-    <title>Code coverage report for lib/builder/allocator.js</title>
-    <meta charset="utf-8" />
-    <link rel="stylesheet" href="../../prettify.css" />
-    <link rel="stylesheet" href="../../base.css" />
-    <link rel="shortcut icon" type="image/x-icon" href="../../favicon.png" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <style type='text/css'>
-        .coverage-summary .sorter {
-            background-image: url(../../sort-arrow-sprite.png);
-        }
-    </style>
-</head>
-    
-<body>
-<div class='wrapper'>
-    <div class='pad1'>
-        <h1><a href="../../index.html">All files</a> / <a href="index.html">lib/builder</a> allocator.js</h1>
-        <div class='clearfix'>
-            
-            <div class='fl pad1y space-right2'>
-                <span class="strong">100% </span>
-                <span class="quiet">Statements</span>
-                <span class='fraction'>28/28</span>
-            </div>
-        
-            
-            <div class='fl pad1y space-right2'>
-                <span class="strong">100% </span>
-                <span class="quiet">Branches</span>
-                <span class='fraction'>8/8</span>
-            </div>
-        
-            
-            <div class='fl pad1y space-right2'>
-                <span class="strong">100% </span>
-                <span class="quiet">Functions</span>
-                <span class='fraction'>2/2</span>
-            </div>
-        
-            
-            <div class='fl pad1y space-right2'>
-                <span class="strong">100% </span>
-                <span class="quiet">Lines</span>
-                <span class='fraction'>28/28</span>
-            </div>
-        
-            
-        </div>
-        <p class="quiet">
-            Press <em>n</em> or <em>j</em> to go to the next uncovered block, <em>b</em>, <em>p</em> or <em>k</em> for the previous block.
-        </p>
-        <template id="filterTemplate">
-            <div class="quiet">
-                Filter:
-                <input oninput="onInput()" type="search" id="fileSearch">
-            </div>
-        </template>
-    </div>
-    <div class='status-line high'></div>
-    <pre><table class="coverage">
-<tr><td class="line-count quiet"><a name='L1'></a><a href='#L1'>1</a>
-<a name='L2'></a><a href='#L2'>2</a>
-<a name='L3'></a><a href='#L3'>3</a>
-<a name='L4'></a><a href='#L4'>4</a>
-<a name='L5'></a><a href='#L5'>5</a>
-<a name='L6'></a><a href='#L6'>6</a>
-<a name='L7'></a><a href='#L7'>7</a>
-<a name='L8'></a><a href='#L8'>8</a>
-<a name='L9'></a><a href='#L9'>9</a>
-<a name='L10'></a><a href='#L10'>10</a>
-<a name='L11'></a><a href='#L11'>11</a>
-<a name='L12'></a><a href='#L12'>12</a>
-<a name='L13'></a><a href='#L13'>13</a>
-<a name='L14'></a><a href='#L14'>14</a>
-<a name='L15'></a><a href='#L15'>15</a>
-<a name='L16'></a><a href='#L16'>16</a>
-<a name='L17'></a><a href='#L17'>17</a>
-<a name='L18'></a><a href='#L18'>18</a>
-<a name='L19'></a><a href='#L19'>19</a>
-<a name='L20'></a><a href='#L20'>20</a>
-<a name='L21'></a><a href='#L21'>21</a>
-<a name='L22'></a><a href='#L22'>22</a>
-<a name='L23'></a><a href='#L23'>23</a>
-<a name='L24'></a><a href='#L24'>24</a>
-<a name='L25'></a><a href='#L25'>25</a>
-<a name='L26'></a><a href='#L26'>26</a>
-<a name='L27'></a><a href='#L27'>27</a>
-<a name='L28'></a><a href='#L28'>28</a>
-<a name='L29'></a><a href='#L29'>29</a>
-<a name='L30'></a><a href='#L30'>30</a>
-<a name='L31'></a><a href='#L31'>31</a>
-<a name='L32'></a><a href='#L32'>32</a>
-<a name='L33'></a><a href='#L33'>33</a>
-<a name='L34'></a><a href='#L34'>34</a>
-<a name='L35'></a><a href='#L35'>35</a>
-<a name='L36'></a><a href='#L36'>36</a>
-<a name='L37'></a><a href='#L37'>37</a>
-<a name='L38'></a><a href='#L38'>38</a></td><td class="line-coverage quiet"><span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">2x</span>
-<span class="cline-any cline-yes">2x</span>
-<span class="cline-any cline-yes">2x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">37x</span>
-<span class="cline-any cline-yes">37x</span>
-<span class="cline-any cline-yes">37x</span>
-<span class="cline-any cline-yes">37x</span>
-<span class="cline-any cline-yes">39x</span>
-<span class="cline-any cline-yes">39x</span>
-<span class="cline-any cline-yes">39x</span>
-<span class="cline-any cline-yes">39x</span>
-<span class="cline-any cline-yes">39x</span>
-<span class="cline-any cline-yes">39x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">37x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">38x</span>
-<span class="cline-any cline-yes">4x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">34x</span>
-<span class="cline-any cline-yes">34x</span>
-<span class="cline-any cline-yes">34x</span>
-<span class="cline-any cline-yes">34x</span>
-<span class="cline-any cline-yes">40x</span>
-<span class="cline-any cline-yes">40x</span>
-<span class="cline-any cline-yes">40x</span>
-<span class="cline-any cline-yes">40x</span>
-<span class="cline-any cline-yes">27x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">40x</span>
-<span class="cline-any cline-yes">40x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-yes">34x</span>
-<span class="cline-any cline-neutral">&nbsp;</span>
-<span class="cline-any cline-neutral">&nbsp;</span></td><td class="text"><pre class="prettyprint lang-js">"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllocation = getAllocation;
-exports.getUpdatedAvailableRangesAfterFilling = getUpdatedAvailableRangesAfterFilling;
-function getAllocation(availableRanges, fill) {
-    const result = [];
-    let remaining = fill;
-    let i = 0;
-    while (remaining &gt; 0 &amp;&amp; i &lt; availableRanges.length) {
-        const range = availableRanges[i];
-        const [start, end] = range;
-        const rangeFill = Math.min(remaining, end - start);
-        result.push([start, start + rangeFill]);
-        remaining -= rangeFill;
-        i++;
-    }
-    return result;
-}
-function getUpdatedAvailableRangesAfterFilling(availableRanges, fill) {
-    if (fill === 0) {
-        return availableRanges;
-    }
-    const result = [];
-    let remaining = fill;
-    let i = 0;
-    while (remaining &gt; 0 &amp;&amp; i &lt; availableRanges.length) {
-        const range = availableRanges[i];
-        const [start, end] = range;
-        const rangeFill = Math.min(remaining, end - start);
-        if (rangeFill &lt; end - start) {
-            result.push([start + rangeFill, end]);
-        }
-        remaining -= rangeFill;
-        i++;
-    }
-    return result;
-}
-//# sourceMappingURL=allocator.js.map</pre></td></tr></table></pre>
-
-                <div class='push'></div><!-- for sticky footer -->
-            </div><!-- /wrapper -->
-            <div class='footer quiet pad2 space-top1 center small'>
-                Code coverage generated by
-                <a href="https://istanbul.js.org/" target="_blank" rel="noopener noreferrer">istanbul</a>
-                at 2026-02-05T22:56:40.793Z
-            </div>
-        <script src="../../prettify.js"></script>
-        <script>
-            window.onload = function () {
-                prettyPrint();
-            };
-        </script>
-        <script src="../../sorter.js"></script>
-        <script src="../../block-navigation.js"></script>
-    </body>
-</html>
-