@weborigami/language 0.3.3-jse.3 → 0.3.3

package/test/runtime/evaluate.test.js

@@ -8,7 +8,7 @@ import { createCode } from "../compiler/codeHelpers.js";
 
 describe("evaluate", () => {
   test("can retrieve values from scope", async () => {
-    const code = createCode([[ops.scope], "message"]);
+    const code = createCode([ops.scope, "message"]);
     const parent = new ObjectTree({
       message: "Hello",
     });
@@ -21,8 +21,8 @@ describe("evaluate", () => {
   test("can invoke functions in scope", async () => {
     // Match the array representation of code generated by the parser.
     const code = createCode([
-      [[ops.scope], "greet"],
-      [[ops.scope], "name"],
+      [ops.scope, "greet"],
+      [ops.scope, "name"],
     ]);
 
     const tree = new ObjectTree({
@@ -37,7 +37,7 @@ describe("evaluate", () => {
   });
 
   test("passes context to invoked functions", async () => {
-    const code = createCode([[ops.scope], "fn"]);
+    const code = createCode([ops.scope, "fn"]);
     const tree = new ObjectTree({
       async fn() {
         assert.equal(this, tree);
@@ -46,6 +46,14 @@ describe("evaluate", () => {
     await evaluate.call(tree, code);
   });
 
+  test("evaluates a function with fixed number of arguments", async () => {
+    const fn = (x, y) => ({
+      c: `${x}${y}c`,
+    });
+    const code = createCode([ops.traverse, fn, "a", "b", "c"]);
+    assert.equal(await evaluate.call(null, code), "abc");
+  });
+
   test("if object in function position isn't a function, can unpack it", async () => {
     const fn = (...args) => args.join(",");
     const packed = new String();
@@ -54,4 +62,12 @@ describe("evaluate", () => {
     const result = await evaluate.call(null, code);
     assert.equal(result, "a,b,c");
   });
+
+  test("by defalut sets the parent of a returned tree to the current tree", async () => {
+    const fn = () => new ObjectTree({});
+    const code = createCode([fn]);
+    const tree = new ObjectTree({});
+    const result = await evaluate.call(tree, code);
+    assert.equal(result.parent, tree);
+  });
 });

package/test/runtime/expressionObject.test.js

@@ -12,8 +12,8 @@ describe("expressionObject", () => {
     });
 
     const entries = [
-      ["hello", [[[ops.scope], "upper"], "hello"]],
-      ["world", [[[ops.scope], "upper"], "world"]],
+      ["hello", [[ops.scope, "upper"], "hello"]],
+      ["world", [[ops.scope, "upper"], "world"]],
     ];
 
     const object = await expressionObject(entries, scope);
@@ -40,7 +40,7 @@ describe("expressionObject", () => {
   test("can instantiate an Origami tree", async () => {
     const entries = [
       ["name", "world"],
-      ["message", [ops.concat, "Hello, ", [[ops.scope], "name"], "!"]],
+      ["message", [ops.concat, "Hello, ", [ops.scope, "name"], "!"]],
     ];
     const parent = new ObjectTree({});
     const object = await expressionObject(entries, parent);
@@ -53,8 +53,7 @@ describe("expressionObject", () => {
 
   test("returned object values can be unpacked", async () => {
     const entries = [["data.json", `{ "a": 1 }`]];
-    const parent = new ObjectTree({});
-    parent.handlers = new ObjectTree({
+    const parent = new ObjectTree({
       "json.handler": {
         unpack: JSON.parse,
       },

package/test/runtime/handlers.test.js

@@ -3,12 +3,6 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import { handleExtension } from "../../src/runtime/handlers.js";
 
-const handlers = new ObjectTree({
-  "json.handler": {
-    unpack: (buffer) => JSON.parse(String(buffer)),
-  },
-});
-
 describe("handlers", () => {
   test("attaches an unpack method to a value with an extension", async () => {
     const fixture = createFixture();
@@ -16,12 +10,7 @@ describe("handlers", () => {
     assert(typeof numberValue === "number");
     assert.equal(numberValue, 1);
     const jsonFile = await fixture.get("bar.json");
-    const withHandler = await handleExtension(
-      fixture,
-      jsonFile,
-      "bar.json",
-      handlers
-    );
+    const withHandler = await handleExtension(fixture, jsonFile, "bar.json");
     assert.equal(String(withHandler), `{ "bar": 2 }`);
     const data = await withHandler.unpack();
     assert.deepEqual(data, { bar: 2 });
@@ -30,19 +19,21 @@ describe("handlers", () => {
   test("immediately unpacks if key ends in slash", async () => {
     const fixture = createFixture();
     const jsonFile = await fixture.get("bar.json");
-    const data = await handleExtension(
-      fixture,
-      jsonFile,
-      "bar.json/",
-      handlers
-    );
+    const data = await handleExtension(fixture, jsonFile, "bar.json/");
     assert.deepEqual(data, { bar: 2 });
   });
 });
 
 function createFixture() {
-  return new ObjectTree({
+  const parent = new ObjectTree({
+    "json.handler": {
+      unpack: (buffer) => JSON.parse(String(buffer)),
+    },
+  });
+  let tree = new ObjectTree({
     foo: 1, // No extension, should be left alone
     "bar.json": `{ "bar": 2 }`,
   });
+  tree.parent = parent;
+  return tree;
 }

package/test/runtime/mergeTrees.test.js

@@ -41,6 +41,11 @@ describe("mergeTrees", () => {
     });
   });
 
+  test("if all arguments are arrays, result is an array", async () => {
+    const result = await mergeTrees.call(null, [1, 2], [3, 4]);
+    assert.deepEqual(result, [1, 2, 3, 4]);
+  });
+
   test("merges heterogenous arguments as trees", async () => {
     const tree = await mergeTrees.call(
       null,

package/test/runtime/ops.test.js

@@ -1,4 +1,4 @@
-import { DeepObjectTree, ObjectTree, Tree } from "@weborigami/async-tree";
+import { DeepObjectTree, ObjectTree } from "@weborigami/async-tree";
 import assert from "node:assert";
 import { describe, test } from "node:test";
 
@@ -42,6 +42,17 @@ describe("ops", () => {
     assert.strictEqual(ops.bitwiseXor(5, 3), 6);
   });
 
+  test("ops.builtin gets a value from the top of the scope chain", async () => {
+    const root = new ObjectTree({
+      a: 1,
+    });
+    const tree = new ObjectTree({});
+    tree.parent = root;
+    const code = createCode([ops.builtin, "a"]);
+    const result = await evaluate.call(tree, code);
+    assert.strictEqual(result, 1);
+  });
+
   test("ops.comma returns the last value", async () => {
     const code = createCode([ops.comma, 1, 2, 3]);
     const result = await evaluate.call(null, code);
@@ -53,12 +64,7 @@ describe("ops", () => {
       name: "world",
     });
 
-    const code = createCode([
-      ops.concat,
-      "Hello, ",
-      [[ops.scope], "name"],
-      ".",
-    ]);
+    const code = createCode([ops.concat, "Hello, ", [ops.scope, "name"], "."]);
 
     const result = await evaluate.call(scope, code);
     assert.strictEqual(result, "Hello, world.");
@@ -74,22 +80,27 @@ describe("ops", () => {
     assert.strictEqual(await ops.conditional(false, errorFn, trueFn), true);
   });
 
-  test("ops.construct", async () => {
-    assert.equal(await ops.construct(String, "hello"), "hello");
-  });
-
-  test("ops.context", async () => {
-    const tree = new DeepObjectTree({
-      a: {
-        b: {
-          c: {},
-        },
+  test("ops.documentFunction", async () => {
+    const code = createCode([
+      ops.document,
+      {
+        a: 1,
       },
+      [
+        ops.lambda,
+        [["_"]],
+        [
+          ops.template,
+          [ops.literal, ["a = ", ""]],
+          [ops.concat, [ops.scope, "a"]],
+        ],
+      ],
+    ]);
+    const result = await evaluate.call(null, code);
+    assert.deepEqual(result, {
+      a: 1,
+      "@text": "a = 1",
     });
-    const b = await Tree.traverse(tree, "a", "b");
-    const c = await b.get("c");
-    assert.equal(ops.context.call(c), c);
-    assert.equal(ops.context.call(c, 1), b);
   });
 
   test("ops.division divides two numbers", async () => {
@@ -112,21 +123,20 @@ describe("ops", () => {
     assert.strictEqual(ops.exponentiation(2, 0), 1);
   });
 
-  test("ops.cache evaluates code and cache its result", async () => {
+  test("ops.external evaluates code and cache its result", async () => {
     let count = 0;
     const tree = new DeepObjectTree({
       group: {
         get count() {
-          // Use promise to test async behavior
-          return Promise.resolve(++count);
+          return ++count;
         },
       },
     });
     const code = createCode([
-      ops.cache,
-      {},
+      ops.external,
       "group/count",
-      [[ops.scope], [ops.literal, "group"], [ops.literal, "count"]],
+      [ops.traverse, [ops.scope, "group"], [ops.literal, "count"]],
+      {},
     ]);
     const result = await evaluate.call(tree, code);
     assert.strictEqual(result, 1);
@@ -134,26 +144,6 @@ describe("ops", () => {
     assert.strictEqual(result2, 1);
   });
 
-  describe("ops.flat", () => {
-    test("flattens arrays", async () => {
-      assert.deepEqual(await ops.flat(1, 2, [3]), [1, 2, 3]);
-    });
-
-    test("flattens treelike objects", async () => {
-      const object = {
-        a: 1,
-        b: 2,
-      };
-      const tree = new ObjectTree({
-        c: 3,
-        d: 4,
-      });
-      const array = [5, 6];
-      const result = await ops.flat(object, tree, array);
-      assert.deepEqual(result, [1, 2, 3, 4, 5, 6]);
-    });
-  });
-
   test("ops.greaterThan", () => {
     assert(ops.greaterThan(5, 3));
     assert(!ops.greaterThan(3, 3));
@@ -166,6 +156,20 @@ describe("ops", () => {
     assert(ops.greaterThanOrEqual("ab", "aa"));
   });
 
+  test("ops.inherited searches inherited scope", async () => {
+    const parent = new ObjectTree({
+      a: 1, // This is the inherited value we want
+    });
+    /** @type {any} */
+    const child = new ObjectTree({
+      a: 2, // Should be ignored
+    });
+    child.parent = parent;
+    const code = createCode([ops.inherited, "a"]);
+    const result = await evaluate.call(child, code);
+    assert.strictEqual(result, 1);
+  });
+
   test("ops.lambda defines a function with no inputs", async () => {
     const code = createCode([ops.lambda, [], [ops.literal, "result"]]);
     const fn = await evaluate.call(null, code);
@@ -178,7 +182,7 @@ describe("ops", () => {
       message: "Hello",
     });
 
-    const code = createCode([ops.lambda, ["_"], [[ops.scope], "message"]]);
+    const code = createCode([ops.lambda, ["_"], [ops.scope, "message"]]);
 
     const fn = await evaluate.call(scope, code);
     const result = await fn.call(scope);
@@ -192,7 +196,7 @@ describe("ops", () => {
         [ops.literal, "a"],
         [ops.literal, "b"],
       ],
-      [ops.concat, [[ops.scope], "b"], [[ops.scope], "a"]],
+      [ops.concat, [ops.scope, "b"], [ops.scope, "a"]],
     ]);
     const fn = await evaluate.call(null, code);
     const result = await fn("x", "y");
@@ -246,31 +250,40 @@ describe("ops", () => {
   test("ops.merge", async () => {
     // {
     //   a: 1
-    //   …more
-    //   c: a
+    //   …fn(a)
     // }
     const scope = new ObjectTree({
-      more: { b: 2 },
+      fn: (a) => ({ b: 2 * a }),
     });
     const code = createCode([
+      ops.merge,
+      [ops.object, ["a", [ops.literal, 1]]],
       [
-        ops.object,
-        ["a", [ops.literal, 1]],
-        ["c", [[ops.context], "a"]],
-        [
-          "_result",
-          [
-            ops.merge,
-            [ops.object, ["a", [ops.getter, [[ops.context, 1], "a"]]]],
-            [[ops.scope], "more"],
-            [ops.object, ["c", [ops.getter, [[ops.context, 1], "c"]]]],
-          ],
-        ],
+        [ops.builtin, "fn"],
+        [ops.scope, "a"],
       ],
-      "_result",
     ]);
     const result = await evaluate.call(scope, code);
-    assert.deepEqual(await Tree.plain(result), { a: 1, b: 2, c: 1 });
+    assert.deepEqual(result, { a: 1, b: 2 });
+  });
+
+  test("ops.merge lets all direct properties see each other", async () => {
+    // {
+    //   a: 1
+    //   ...more
+    //   c: a
+    // }
+    const scope = new ObjectTree({
+      more: { b: 2 },
+    });
+    const code = createCode([
+      ops.merge,
+      [ops.object, ["a", [ops.literal, 1]]],
+      [ops.scope, "more"],
+      [ops.object, ["c", [ops.scope, "a"]]],
+    ]);
+    const result = await evaluate.call(scope, code);
+    assert.deepEqual(result, { a: 1, b: 2, c: 1 });
   });
 
   test("ops.multiplication multiplies two numbers", async () => {
@@ -280,11 +293,6 @@ describe("ops", () => {
     assert.strictEqual(ops.multiplication("foo", 2), NaN);
   });
 
-  test("ops.optionalTraverse", async () => {
-    assert.equal(await ops.optionalTraverse(null, "a"), undefined);
-    assert.equal(await ops.optionalTraverse({ a: 1 }, "a"), 1);
-  });
-
   test("ops.notEqual", () => {
     assert(!ops.notEqual(1, 1));
     assert(ops.notEqual(1, 2));
@@ -317,8 +325,8 @@ describe("ops", () => {
 
     const code = createCode([
       ops.object,
-      ["hello", [[[ops.scope], "upper"], "hello"]],
-      ["world", [[[ops.scope], "upper"], "world"]],
+      ["hello", [[ops.scope, "upper"], "hello"]],
+      ["world", [[ops.scope, "upper"], "world"]],
     ]);
 
     const result = await evaluate.call(scope, code);
@@ -334,7 +342,7 @@ describe("ops", () => {
       ops.array,
       "Hello",
       1,
-      [[[ops.scope], "upper"], "world"],
+      [[ops.scope, "upper"], "world"],
     ]);
     const result = await evaluate.call(scope, code);
     assert.deepEqual(result, ["Hello", 1, "WORLD"]);
@@ -347,35 +355,6 @@ describe("ops", () => {
     assert.strictEqual(ops.remainder(-4, 2), -0);
   });
 
-  describe("ops.scope", () => {
-    test("returns the scope of the current tree", async () => {
-      const tree = new DeepObjectTree({
-        a: {
-          b: {},
-        },
-        c: 1,
-      });
-      const a = await tree.get("a");
-      const b = await a.get("b");
-      const scope = await ops.scope.call(b);
-      assert.equal(await scope.get("c"), 1);
-    });
-
-    test("accepts an optional context", async () => {
-      const tree = new DeepObjectTree({
-        a: {
-          b: {},
-          c: 0, // shouldn't get this
-        },
-        c: 1,
-      });
-      const a = await tree.get("a");
-      const b = await a.get("b");
-      const scope = await ops.scope.call(b, tree);
-      assert.equal(await scope.get("c"), 1);
-    });
-  });
-
   test("ops.shiftLeft", () => {
     assert.strictEqual(ops.shiftLeft(5, 2), 20);
   });

package/test/runtime/taggedTemplateIndent.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { describe, test } from "node:test";
-import indent from "../../src/runtime/templateIndent.js";
+import indent from "../../src/runtime/taggedTemplateIndent.js";
 
 describe("taggedTemplateIndent", () => {
   test("joins strings and values together if template isn't a block template", async () => {

package/src/runtime/getHandlers.js

@@ -1,10 +0,0 @@
-import { Tree } from "@weborigami/async-tree";
-
-// Return the extension handlers for the given tree
-export default function getHandlers(tree) {
-  if (!tree) {
-    return null;
-  }
-  const root = Tree.root(tree);
-  return root.handlers;
-}

package/src/runtime/jsGlobals.js

@@ -1,99 +0,0 @@
-import path from "node:path";
-
-/**
- * The complete set of support JavaScript globals and global-like values.
- *
- * See
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects.
- * That page lists some things like `TypedArrays` which are not globals so are
- * omitted here.
- */
-export default {
-  AggregateError,
-  Array,
-  ArrayBuffer,
-  Atomics,
-  BigInt,
-  BigInt64Array,
-  BigUint64Array,
-  Boolean,
-  DataView,
-  Date,
-  Error,
-  EvalError,
-  FinalizationRegistry,
-  Float32Array,
-  Float64Array,
-  Function,
-  Infinity,
-  Int16Array,
-  Int32Array,
-  Int8Array,
-  Intl,
-  // @ts-ignore Iterator does exist despite what TypeScript thinks
-  Iterator,
-  JSON,
-  Map,
-  Math,
-  NaN,
-  Number,
-  Object,
-  Promise,
-  Proxy,
-  RangeError,
-  ReferenceError,
-  Reflect,
-  RegExp,
-  Set,
-  SharedArrayBuffer,
-  String,
-  Symbol,
-  SyntaxError,
-  TypeError,
-  URIError,
-  Uint16Array,
-  Uint32Array,
-  Uint8Array,
-  Uint8ClampedArray,
-  WeakMap,
-  WeakRef,
-  WeakSet,
-  decodeURI,
-  decodeURIComponent,
-  encodeURI,
-  encodeURIComponent,
-  eval,
-  false: false, // treat like a global
-  fetch: fetchWrapper, // special case
-  globalThis,
-  import: importWrapper, // not a function in JS but acts like one
-  isFinite,
-  isNaN,
-  null: null, // treat like a global
-  parseFloat,
-  parseInt,
-  true: true, // treat like a global
-  undefined,
-};
-
-async function fetchWrapper(resource, options) {
-  const response = await fetch(resource, options);
-  return response.ok ? await response.arrayBuffer() : undefined;
-}
-
-/** @this {import("@weborigami/types").AsyncTree|null|undefined} */
-async function importWrapper(modulePath) {
-  // Walk up parent tree looking for a FileTree or other object with a `path`
-  /** @type {any} */
-  let current = this;
-  while (current && !("path" in current)) {
-    current = current.parent;
-  }
-  if (!current) {
-    throw new TypeError(
-      "Modules can only be imported from a folder or other object with a path property."
-    );
-  }
-  const filePath = path.resolve(current.path, modulePath);
-  return import(filePath);
-}

package/src/runtime/templateStandard.js

@@ -1,13 +0,0 @@
-/**
- * Concatenate the strings with a standard tagged template function that works
- * just like normal JavaScript templates. This is: a) synchronous, b) does not
- * convert treelike objects to strings.
- */
-export default function standardTemplate(strings, ...values) {
-  let result = strings[0];
-  for (let i = 0; i < values.length; i++) {
-    result += values[i];
-    result += strings[i + 1];
-  }
-  return result;
-}

package/test/runtime/templateText.test.js

@@ -1,18 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import templateText from "../../src/runtime/templateStandard.js";
-
-describe("templateText", () => {
-  test("joins strings and values together like JavaScript", async () => {
-    const a = 1;
-    const b = 2;
-    const result = await templateText`-${a} ${b}-`;
-    assert.equal(result, "-1 2-");
-  });
-
-  test("renders an object like JavaScript", async () => {
-    const object = { a: 1 };
-    const result = await templateText`-${object}-`;
-    assert.equal(result, "-[object Object]-");
-  });
-});