@fraczak/k 7.2.0 → 8.1.0

package/tests/test-djson-methods.mjs

@@ -0,0 +1,285 @@
+// tests/test-djson-methods.mjs
+// Test suite for standard dynamic JSON methods working on json? type.
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import k from "../index.mjs";
+import { Value } from "../Value.mjs";
+import {
+  fromJsonValue,
+  toJsonValue
+} from "../codecs/djson.mjs";
+import {
+  textToStringValue,
+  stringValueToText
+} from "../codecs/runtime/unicode-string.mjs";
+
+const root = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  ".."
+);
+const libPath = path.join(root, "Examples", "djson.k");
+const djsonK = readFileSync(libPath, "utf8");
+
+function compileOp(op) {
+  return k.compile(`${djsonK}\n${op}\n`);
+}
+
+function makeIndex(n) {
+  if (n === 0) {
+    return Value.variant(
+      "0",
+      Value.variant("_", Value.product({}))
+    );
+  }
+  const s = n.toString(2);
+  let v = Value.variant("_", Value.product({}));
+  for (let i = s.length - 1; i >= 0; i--) {
+    v = Value.variant(s[i], v);
+  }
+  return v;
+}
+
+console.log("==> Running Dynamic JSON (json?) Methods Test Suite");
+
+// Test 1: Object Accessors (get, has?, set, del)
+console.log("--> Test 1: Object Accessors (get, has?, set, del)");
+{
+  const fnGet = compileOp("get");
+  const fnHas = compileOp("has?");
+  const fnSet = compileOp("set");
+  const fnDel = compileOp("del");
+
+  const doc = {
+    name: "Alice",
+    age: 30,
+    tags: ["developer", "k"]
+  };
+  const kDoc = fromJsonValue(doc);
+
+  // get "name"
+  const resName = fnGet(Value.product({
+    key: textToStringValue("name"),
+    json: kDoc
+  }));
+  assert.equal(toJsonValue(resName), "Alice");
+
+  // get "age"
+  const resAge = fnGet(Value.product({
+    key: textToStringValue("age"),
+    json: kDoc
+  }));
+  assert.equal(toJsonValue(resAge), 30);
+
+  // has? hit
+  const hit = fnHas(Value.product({
+    key: textToStringValue("name"),
+    json: kDoc
+  }));
+  assert.ok(hit);
+
+  // has? miss
+  const miss = fnHas(Value.product({
+    key: textToStringValue("missing"),
+    json: kDoc
+  }));
+  assert.equal(miss, undefined);
+
+  // set "city" = "Paris"
+  const withCity = fnSet(Value.product({
+    key: textToStringValue("city"),
+    val: fromJsonValue("Paris"),
+    json: kDoc
+  }));
+  assert.equal(toJsonValue(withCity).city, "Paris");
+  assert.equal(toJsonValue(withCity).name, "Alice");
+
+  // del "age"
+  const withoutAge = fnDel(Value.product({
+    key: textToStringValue("age"),
+    json: withCity
+  }));
+  assert.equal(toJsonValue(withoutAge).age, undefined);
+  assert.equal(toJsonValue(withoutAge).city, "Paris");
+
+  console.log("    Passed: Object get, has?, set, del on json?.");
+}
+
+// Test 2: List Accessors (nth, has_index?, set_nth, del_nth, push)
+console.log("--> Test 2: List Accessors (nth, set_nth, del_nth, push)");
+{
+  const fnNth = compileOp("nth");
+  const fnHasIdx = compileOp("has_index?");
+  const fnSetNth = compileOp("set_nth");
+  const fnDelNth = compileOp("del_nth");
+  const fnPush = compileOp("push");
+
+  const list = [10, 20, 30];
+  const kList = fromJsonValue(list);
+
+  // nth 0, 1, 2
+  assert.equal(
+    toJsonValue(fnNth(Value.product({
+      index: makeIndex(0),
+      json: kList
+    }))),
+    10
+  );
+  assert.equal(
+    toJsonValue(fnNth(Value.product({
+      index: makeIndex(1),
+      json: kList
+    }))),
+    20
+  );
+  assert.equal(
+    toJsonValue(fnNth(Value.product({
+      index: makeIndex(2),
+      json: kList
+    }))),
+    30
+  );
+
+  // has_index? hit and miss
+  assert.ok(fnHasIdx(Value.product({
+    index: makeIndex(1),
+    json: kList
+  })));
+  assert.equal(
+    fnHasIdx(Value.product({
+      index: makeIndex(99),
+      json: kList
+    })),
+    undefined
+  );
+
+  // set_nth 1 -> 99
+  const updatedList = fnSetNth(Value.product({
+    index: makeIndex(1),
+    val: fromJsonValue(99),
+    json: kList
+  }));
+  assert.deepEqual(toJsonValue(updatedList), [10, 99, 30]);
+
+  // del_nth 1
+  const delList = fnDelNth(Value.product({
+    index: makeIndex(1),
+    json: updatedList
+  }));
+  assert.deepEqual(toJsonValue(delList), [10, 30]);
+  assert.equal(
+    fnHasIdx(Value.product({
+      index: makeIndex(1),
+      json: delList
+    })),
+    undefined
+  );
+
+  // push 40
+  const pushed = fnPush(Value.product({
+    val: fromJsonValue(40),
+    json: kList
+  }));
+  assert.deepEqual(toJsonValue(pushed), [10, 20, 30, 40]);
+
+  console.log("    Passed: List nth, set_nth, del_nth, push on json?.");
+}
+
+// Test 3: Keys and Values (keys, keys_raw, values, values_raw)
+console.log("--> Test 3: Keys and Values (keys, values)");
+{
+  const fnKeys = compileOp("keys");
+  const fnKeysRaw = compileOp("keys_raw");
+  const fnValues = compileOp("values");
+  const fnValuesRaw = compileOp("values_raw");
+
+  const doc = { b: 2, a: 1, c: 3 };
+  const kDoc = fromJsonValue(doc);
+
+  // keys (json? list of string)
+  const resKeys = fnKeys(kDoc);
+  assert.deepEqual(toJsonValue(resKeys), ["a", "b", "c"]);
+
+  // keys_raw (raw K cons-list of strings)
+  const resKeysRaw = fnKeysRaw(kDoc);
+  const rawKeyStrings = [];
+  let curr = resKeysRaw;
+  while (curr && curr.type === "<>" && curr.tag === "cons") {
+    rawKeyStrings.push(stringValueToText(curr.value.product.car));
+    curr = curr.value.product.cdr;
+  }
+  assert.deepEqual(rawKeyStrings, ["a", "b", "c"]);
+
+  // values on object (json? list of values)
+  const resValues = fnValues(kDoc);
+  assert.deepEqual(toJsonValue(resValues), [1, 2, 3]);
+
+  // values on list (json? identity)
+  const listJson = fromJsonValue([100, 200]);
+  assert.deepEqual(toJsonValue(fnValues(listJson)), [100, 200]);
+
+  console.log("    Passed: Keys and values extraction on json?.");
+}
+
+// Test 4: Cardinality and Length (length, length_nat)
+console.log("--> Test 4: Cardinality and Length (length, length_nat)");
+{
+  const fnLength = compileOp("length");
+
+  const kObj = fromJsonValue({ x: 1, y: 2, z: 3, w: 4 });
+  const kArr = fromJsonValue(["a", "b", "c"]);
+  const kStr = fromJsonValue("hello");
+
+  // length returns json? number (float64)
+  assert.equal(toJsonValue(fnLength(kObj)), 4);
+  assert.equal(toJsonValue(fnLength(kArr)), 3);
+  assert.equal(toJsonValue(fnLength(kStr)), 5);
+
+  console.log(
+    "    Passed: Length queries on json? object, list, string."
+  );
+}
+
+// Test 5: Type Predicates and type_of
+console.log("--> Test 5: Type Predicates and type_of");
+{
+  const fnTypeOf = compileOp("type_of");
+  const fnIsObj = compileOp("is_object?");
+  const fnIsList = compileOp("is_list?");
+  const fnIsStr = compileOp("is_string?");
+  const fnIsNum = compileOp("is_number?");
+  const fnIsBool = compileOp("is_bool?");
+  const fnIsNull = compileOp("is_null?");
+
+  const kObj = fromJsonValue({ a: 1 });
+  const kArr = fromJsonValue([1, 2]);
+  const kStr = fromJsonValue("hi");
+  const kNum = fromJsonValue(3.14);
+  const kBool = fromJsonValue(true);
+  const kNull = fromJsonValue(null);
+
+  assert.equal(fnTypeOf(kObj).tag, "object");
+  assert.equal(fnTypeOf(kArr).tag, "list");
+  assert.equal(fnTypeOf(kStr).tag, "string");
+  assert.equal(fnTypeOf(kNum).tag, "number");
+  assert.equal(fnTypeOf(kBool).tag, "bool");
+  assert.equal(fnTypeOf(kNull).tag, "null");
+
+  assert.ok(fnIsObj(kObj));
+  assert.equal(fnIsObj(kArr), undefined);
+
+  assert.ok(fnIsList(kArr));
+  assert.equal(fnIsList(kObj), undefined);
+
+  assert.ok(fnIsStr(kStr));
+  assert.ok(fnIsNum(kNum));
+  assert.ok(fnIsBool(kBool));
+  assert.ok(fnIsNull(kNull));
+
+  console.log("    Passed: Type predicates and type_of inspection.");
+}
+
+console.log("==> All Dynamic JSON Methods Tests Passed Successfully!");

package/tests/test-named-patterns.mjs

@@ -0,0 +1,189 @@
+// tests/test-named-patterns.mjs
+// Comprehensive test suite for named patterns and type schemes.
+
+import assert from "node:assert/strict";
+import k from "../index.mjs";
+import { Value } from "../Value.mjs";
+
+console.log("==> Running Named Patterns Test Suite");
+
+// Test 1: 0-arity pattern and composite product
+console.log("--> Test 1: 0-arity pattern (bit[]) and product (byte[])");
+{
+  const script = `
+    bit[] = < {}0, {}1 >;
+    byte[] = {
+      bit[] b0, bit[] b1, bit[] b2, bit[] b3,
+      bit[] b4, bit[] b5, bit[] b6, bit[] b7
+    };
+
+    is_byte = ? byte[];
+
+    sample = {
+      {}|0 b0, {}|1 b1, {}|0 b2, {}|1 b3,
+      {}|0 b4, {}|1 b5, {}|0 b6, {}|1 b7
+    };
+
+    sample is_byte
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.type, "{}");
+  assert.equal(out.product.b0.tag, "0");
+  assert.equal(out.product.b1.tag, "1");
+  console.log("    Passed: 0-arity patterns and composition.");
+}
+
+// Test 2: Parameterized list pattern
+console.log("--> Test 2: Parameterized pattern (list[X])");
+{
+  const script = `
+    bit[] = < {}0, {}1 >;
+    list[X] = < {}nil, { X car, Y cdr } cons > = Y;
+
+    is_bit_list = ? list[bit[]];
+
+    empty = {}|nil is_bit_list;
+    one = { {}|1 car, {}|nil cdr }|cons is_bit_list;
+    two = {
+      {}|0 car,
+      { {}|1 car, {}|nil cdr }|cons cdr
+    }|cons is_bit_list;
+
+    { empty empty, one one, two two }
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.product.empty.tag, "nil");
+  assert.equal(out.product.one.tag, "cons");
+  assert.equal(out.product.one.value.product.car.tag, "1");
+  assert.equal(out.product.two.tag, "cons");
+  assert.equal(out.product.two.value.product.car.tag, "0");
+  console.log("    Passed: Parameterized list pattern.");
+}
+
+// Test 3: Multi-parameter templates and composition
+console.log("--> Test 3: Multi-parameter templates (pair, dict)");
+{
+  const script = `
+    bit[] = < {}0, {}1 >;
+    pair[A, B] = { A key, B val };
+    list[X] = < {}nil, { X car, Y cdr } cons > = Y;
+    dict[K, V] = list[pair[K, V]];
+
+    is_dict = ? dict[bit[], bit[]];
+
+    entry = { {}|0 key, {}|1 val };
+    d = { entry car, {}|nil cdr }|cons is_dict;
+
+    d
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.tag, "cons");
+  assert.equal(out.value.product.car.product.key.tag, "0");
+  assert.equal(out.value.product.car.product.val.tag, "1");
+  console.log("    Passed: Multi-parameter template composition.");
+}
+
+// Test 4: Existential internal variables (type unification across fields)
+console.log("--> Test 4: Existential variables (same_pair[])");
+{
+  const scriptOk = `
+    same_pair[] = { T first, T second };
+    check = ? same_pair[];
+    { {}|0 first, {}|1 second } check
+  `;
+  const fnOk = k.compile(scriptOk);
+  const outOk = fnOk(Value.product({}));
+  assert.equal(outOk.product.first.tag, "0");
+  assert.equal(outOk.product.second.tag, "1");
+
+  const scriptBad = `
+    same_pair[] = { T first, T second };
+    check = ? same_pair[];
+    { {} first, {}|0 second } check
+  `;
+  assert.throws(
+    () => k.compile(scriptBad),
+    /Cannot unify/
+  );
+  console.log("    Passed: Existential variables unified across fields.");
+}
+
+// Test 5: Recursive tree with internal knot and list
+console.log("--> Test 5: Recursive tree with knot T (tree[X])");
+{
+  const script = `
+    list[X] = < {}nil, { X car, Y cdr } cons > = Y;
+    tree[X] = < {}nil, { X val, list[T] children } node > = T;
+
+    bit[] = < {}0, {}1 >;
+    is_tree = ? tree[bit[]];
+
+    leaf = { {}|1 val, {}|nil children }|node is_tree;
+    root = {
+      {}|0 val,
+      { leaf car, {}|nil cdr }|cons children
+    }|node is_tree;
+
+    { leaf leaf, root root }
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.product.leaf.tag, "node");
+  assert.equal(out.product.leaf.value.product.val.tag, "1");
+  assert.equal(out.product.root.tag, "node");
+  assert.equal(out.product.root.value.product.val.tag, "0");
+  console.log("    Passed: Recursive tree template with list port.");
+}
+
+// Test 6: Polymorphic relation with shared type variable
+console.log("--> Test 6: Polymorphic relation ({ X car, list[X] cdr })");
+{
+  const script = `
+    list[X] = < {}nil, { X car, Y cdr } cons > = Y;
+    head = ? { X car, list[X] cdr } .car;
+
+    bit[] = < {}0, {}1 >;
+    h1 = { {}|1 car, {}|nil cdr } head;
+
+    h1
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.tag, "1");
+  console.log("    Passed: Polymorphic relation head with list[X].");
+}
+
+// Test 7: Error handling for templates
+console.log("--> Test 7: Error handling (unknown, arity, cycles, dupes)");
+{
+  assert.throws(
+    () => k.compile("check = ? missing[]; ()"),
+    /Unknown pattern template 'missing\[\]'/
+  );
+
+  assert.throws(
+    () => k.compile("list[X] = {}; check = ? list[]; ()"),
+    /Pattern 'list' expects 1 argument, got 0/
+  );
+
+  assert.throws(
+    () => k.compile("pair[A, B] = {}; check = ? pair[{}]; ()"),
+    /Pattern 'pair' expects 2 arguments, got 1/
+  );
+
+  assert.throws(
+    () => k.compile("a[] = b[]; b[] = a[]; check = ? a[]; ()"),
+    /Cyclic pattern template dependency detected/
+  );
+
+  assert.throws(
+    () => k.compile("dupe[X, X] = {}; ()"),
+    /Duplicate parameter 'X' in pattern 'dupe'/
+  );
+  console.log("    Passed: Error conditions correctly handled.");
+}
+
+console.log("==> All Named Patterns Tests Passed Successfully!");

package/tests/test-repl-html.mjs

@@ -140,6 +140,7 @@ if (chromiumBin) {
     const expectedFiles = [
       "arithmetics.k",
       "core.k",
+      "djson.k",
       "djson.mjs",
       "ieee.k",
       "ieee.mjs",
@@ -522,9 +523,9 @@ if (chromiumBin) {
       const v4Collapsed = v4 ? !v4.open : false;
 
       // Click Expand All
-      const actionBtns = lastEntry.querySelectorAll(".k-btn-action");
-      const expandBtn = actionBtns[0];
-      const collapseBtn = actionBtns[1];
+      const toolbarActionBtns = lastEntry.querySelectorAll(".k-output-toolbar .k-btn-action");
+      const expandBtn = toolbarActionBtns[0];
+      const collapseBtn = toolbarActionBtns[1];
 
       expandBtn.click();
       const allOpenAfterExpand = v4.open;
@@ -536,13 +537,48 @@ if (chromiumBin) {
       );
       const v4CollapsedAgain = newV4 ? !newV4.open : false;
 
+      // Verify Copy buttons on Value and Pattern section headers
+      const patSection = lastEntry.querySelector(".k-tree-pat-section");
+      const copyValBtn = valSection?.querySelector("summary.k-tree-section-summary > .k-btn-copy-value");
+      const copyPatBtn = patSection?.querySelector("summary.k-tree-section-summary > .k-btn-copy-pattern");
+
+      const copiedTexts = [];
+      const origWriteText = navigator.clipboard?.writeText;
+      if (navigator.clipboard) {
+        navigator.clipboard.writeText = async (txt) => { copiedTexts.push(txt); };
+      } else {
+        Object.defineProperty(navigator, "clipboard", {
+          value: { writeText: async (txt) => { copiedTexts.push(txt); } },
+          configurable: true
+        });
+      }
+
+      const valOpenBefore = valSection?.open;
+      copyValBtn?.click();
+      const valOpenAfter = valSection?.open;
+
+      const patOpenBefore = patSection?.open;
+      copyPatBtn?.click();
+      const patOpenAfter = patSection?.open;
+
+      if (origWriteText && navigator.clipboard) {
+        navigator.clipboard.writeText = origWriteText;
+      }
+
       return {
         v1Open,
         v2Open,
         v3Open,
         v4Collapsed,
         allOpenAfterExpand,
-        v4CollapsedAgain
+        v4CollapsedAgain,
+        toolbarBtnCount: toolbarActionBtns.length,
+        hasCopyValBtn: !!copyValBtn,
+        hasCopyPatBtn: !!copyPatBtn,
+        valDidNotToggle: valOpenBefore === valOpenAfter,
+        patDidNotToggle: patOpenBefore === patOpenAfter,
+        copiedValText: copiedTexts[0] || "",
+        copiedPatText: copiedTexts[1] || ""
       };
     })()`);
 
@@ -552,6 +588,13 @@ if (chromiumBin) {
     assert.strictEqual(variantDepthAndActionsCheck.v4Collapsed, true, "Variant level 4 must be collapsed by default");
     assert.strictEqual(variantDepthAndActionsCheck.allOpenAfterExpand, true, "Expand button should expand collapsed nodes");
     assert.strictEqual(variantDepthAndActionsCheck.v4CollapsedAgain, true, "Collapse button should reset deeper nodes to collapsed");
+    assert.strictEqual(variantDepthAndActionsCheck.toolbarBtnCount, 2, "Toolbar action group should only have Expand and Collapse buttons");
+    assert.strictEqual(variantDepthAndActionsCheck.hasCopyValBtn, true, "Value section summary should have Copy button");
+    assert.strictEqual(variantDepthAndActionsCheck.hasCopyPatBtn, true, "Pattern section summary should have Copy button");
+    assert.strictEqual(variantDepthAndActionsCheck.valDidNotToggle, true, "Clicking Value Copy button should not toggle Value details");
+    assert.strictEqual(variantDepthAndActionsCheck.patDidNotToggle, true, "Clicking Pattern Copy button should not toggle Pattern details");
+    assert.strictEqual(variantDepthAndActionsCheck.copiedValText, "{}|_|0|1|0|1", "Value Copy button should copy K value definition");
+    assert(variantDepthAndActionsCheck.copiedPatText.startsWith("?<"), `Pattern Copy button should copy K pattern filter definition, got: ${variantDepthAndActionsCheck.copiedPatText}`);
 
     // 4. Verify shortened welcome banner
     const bannerCheck = await evaluateAsync(`(() => {