@intentius/chant 0.52.0 → 0.52.2

package/src/yaml.test.ts

@@ -484,3 +484,57 @@ describe("parseYAML — sibling keys after a nested block in a sequence item (#1
     });
   });
 });
+
+// #2013 — a colon opens a mapping only when whitespace or the end of the line
+// follows it (YAML 1.2 §7.4.2). The item/key disambiguation used to accept a
+// colon anywhere, which turned a bare URL in a sequence into a single-key
+// object and made the CRD-schema check reject a string list the emitter here
+// had written itself.
+describe("parseYAML — a colon without following space is not a mapping (#2013)", () => {
+  test("a bare URL in a sequence is a string", () => {
+    expect(parseYAML("sourceRepos:\n- https://github.com/INTENTIUS/behold\n")).toEqual({
+      sourceRepos: ["https://github.com/INTENTIUS/behold"],
+    });
+  });
+
+  test("an AppProject's sourceRepos round-trips through emit and parse", () => {
+    const repos = ["https://github.com/INTENTIUS/behold", "ssh://git@github.com:22/INTENTIUS/behold.git"];
+    expect(parseYAML(`spec:${emitYAML({ sourceRepos: repos }, 1)}\n`)).toEqual({ spec: { sourceRepos: repos } });
+  });
+
+  test("a real `- key: value` item is still a mapping", () => {
+    expect(parseYAML("items:\n- name: x\n  url: https://example.com/a\n")).toEqual({
+      items: [{ name: "x", url: "https://example.com/a" }],
+    });
+  });
+
+  test("a mapping item whose first value is a URL keeps its siblings", () => {
+    expect(parseYAML("sources:\n- repoURL: https://github.com/o/r\n  path: ./chart\n")).toEqual({
+      sources: [{ repoURL: "https://github.com/o/r", path: "./chart" }],
+    });
+  });
+
+  test("a quoted URL in a sequence still works", () => {
+    expect(parseYAML("sourceRepos:\n- 'https://github.com/o/r'\n- \"https://github.com/o/s\"\n")).toEqual({
+      sourceRepos: ["https://github.com/o/r", "https://github.com/o/s"],
+    });
+  });
+
+  test("`- key:value` with no space after the colon is a scalar, per the spec", () => {
+    expect(parseYAML("items:\n- key:value\n")).toEqual({ items: ["key:value"] });
+  });
+
+  test("`- key:` with nothing after the colon is still a mapping with a null value", () => {
+    expect(parseYAML("items:\n- key:\n")).toEqual({ items: [{ key: null }] });
+  });
+
+  test("a URL on a mapping line, not a sequence item, is unaffected", () => {
+    expect(parseYAML("url: https://example.com/a\n")).toEqual({ url: "https://example.com/a" });
+  });
+
+  test("a bare URL among mapping-shaped siblings inside one item", () => {
+    expect(parseYAML("items:\n- name: x\n  args:\n  - --endpoint\n  - https://example.com/a\n  image: nginx\n")).toEqual({
+      items: [{ name: "x", args: ["--endpoint", "https://example.com/a"], image: "nginx" }],
+    });
+  });
+});

package/src/yaml.ts

@@ -155,6 +155,27 @@ export interface ParseResult {
   endIndex: number;
 }
 
+/**
+ * `key: value` on a line of its own (`KEY_LINE`, capturing the indent) and the
+ * same after a sequence item's `- ` (`ITEM_KEY`).
+ *
+ * The lookahead is the rule both patterns used to miss: a `:` opens a mapping
+ * only when what follows it is whitespace or the end of the line, and a plain
+ * scalar may carry any other colon (YAML 1.2 §7.4.2). Written as `:\s*`, which
+ * matches zero whitespace, EVERY colon opened one — so a bare URL in a
+ * sequence,
+ *
+ *     sourceRepos:
+ *     - https://github.com/INTENTIUS/behold
+ *
+ * came back as `{ https: "//github.com/INTENTIUS/behold" }`, and the CRD-schema
+ * post-synth check (#1372) re-reading emitted YAML reported the string list
+ * this file's own emitter had just written as a list of objects (#2013). By the
+ * same rule `- key:value` is the scalar `"key:value"`, not a mapping.
+ */
+const KEY_LINE = /^(\s*)([^\s:][^:]*?):(?=\s|$)\s*(.*)$/;
+const ITEM_KEY = /^([^\s:][^:]*?):(?=\s|$)\s*(.*)$/;
+
 /**
  * Parse a YAML document (or JSON document) into a plain object.
  *
@@ -274,7 +295,7 @@ export function parseYAMLLines(
     if (indent < baseIndent) break; // Dedented — done with this block
     if (indent > baseIndent && startIndex > 0) break; // Unexpected indent
 
-    const keyMatch = line.match(/^(\s*)([^\s:][^:]*?):\s*(.*)$/);
+    const keyMatch = line.match(KEY_LINE);
     if (keyMatch) {
       const key = keyMatch[2].trim();
       const inlineValue = keyMatch[3].trim();
@@ -472,7 +493,7 @@ export function parseYAMLArray(
       const isQuotedScalar =
         (itemValue.startsWith('"') && itemValue.endsWith('"')) ||
         (itemValue.startsWith("'") && itemValue.endsWith("'"));
-      const kvMatch = !isQuotedScalar && itemValue.match(/^([^\s:][^:]*?):\s*(.*)$/);
+      const kvMatch = !isQuotedScalar && itemValue.match(ITEM_KEY);
       if (kvMatch) {
         const obj: Record<string, unknown> = {};
         obj[kvMatch[1].trim()] = parseArrayItemValue(kvMatch[2].trim(), lines, i, indent + 2);
@@ -506,7 +527,7 @@ export function parseYAMLArray(
           const ni = nextLine.search(/\S/);
           if (ni < nextIndent) break;
           if (ni > nextIndent) break; // belongs to a nested block already consumed
-          const nextKV = nextLine.match(/^(\s*)([^\s:][^:]*?):\s*(.*)$/);
+          const nextKV = nextLine.match(KEY_LINE);
           if (nextKV) {
             const nextVal = nextKV[3].trim();
             obj[nextKV[2].trim()] = parseArrayItemValue(nextVal, lines, j, ni);