@weborigami/language 0.0.35

package/test/compiler/parse.test.js

@@ -0,0 +1,389 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import { parse } from "../../src/compiler/parse.js";
+import * as ops from "../../src/runtime/ops.js";
+
+describe("Origami parser", () => {
+  test("absoluteFilePath", () => {
+    assertParse("absoluteFilePath", "/foo/bar", [
+      [ops.filesRoot],
+      "foo",
+      "bar",
+    ]);
+  });
+
+  test("argsChain", () => {
+    assertParse("argsChain", "(a)(b)(c)", [
+      [[ops.scope, "a"]],
+      [[ops.scope, "b"]],
+      [[ops.scope, "c"]],
+    ]);
+    assertParse("argsChain", "(a)/b(c)", [
+      [[ops.scope, "a"]],
+      ["b"],
+      [[ops.scope, "c"]],
+    ]);
+  });
+
+  test("array", () => {
+    assertParse("array", "[]", [ops.array]);
+    assertParse("array", "[1, 2, 3]", [ops.array, 1, 2, 3]);
+  });
+
+  test("assignment", () => {
+    assertParse("assignment", "data = obj.json", [
+      "data",
+      [ops.scope, "obj.json"],
+    ]);
+    assertParse("assignment", "foo = fn 'bar'", [
+      "foo",
+      [[ops.scope, "fn"], "bar"],
+    ]);
+  });
+
+  test("assignmentOrShorthand", () => {
+    assertParse("assignmentOrShorthand", "foo", [
+      "foo",
+      [ops.inherited, "foo"],
+    ]);
+    assertParse("assignmentOrShorthand", "foo = 1", ["foo", 1]);
+  });
+
+  test("expr", () => {
+    assertParse("expr", "obj.json", [ops.scope, "obj.json"]);
+    assertParse("expr", "(fn a, b, c)", [
+      [ops.scope, "fn"],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+      [ops.scope, "c"],
+    ]);
+    assertParse("expr", "foo.bar('hello', 'world')", [
+      [ops.scope, "foo.bar"],
+      "hello",
+      "world",
+    ]);
+    assertParse("expr", "(fn)('a')", [[ops.scope, "fn"], "a"]);
+    assertParse("expr", "1", 1);
+    assertParse("expr", "{ a: 1, b: 2 }", [ops.object, ["a", 1], ["b", 2]]);
+    assertParse("expr", "serve { index.html: 'hello' }", [
+      [ops.scope, "serve"],
+      [ops.object, ["index.html", "hello"]],
+    ]);
+    assertParse("expr", "fn =`x`", [
+      [ops.scope, "fn"],
+      [ops.lambda, "x"],
+    ]);
+    assertParse("expr", "copy app(formulas), files 'snapshot'", [
+      [ops.scope, "copy"],
+      [
+        [ops.scope, "app"],
+        [ops.scope, "formulas"],
+      ],
+      [[ops.scope, "files"], "snapshot"],
+    ]);
+    assertParse("expr", "@map =`<li>{{_}}</li>`", [
+      [ops.scope, "@map"],
+      [ops.lambda, [ops.concat, "<li>", [ops.scope, "_"], "</li>"]],
+    ]);
+    assertParse("expr", `"https://example.com"`, "https://example.com");
+  });
+
+  test("expression", () => {
+    assertParse(
+      "expression",
+      `
+        {
+          index.html = index.orit(teamData.yaml)
+          thumbnails = @map(images, { valueMap: thumbnail.js })
+        }
+      `,
+      [
+        ops.tree,
+        [
+          "index.html",
+          [
+            [ops.scope, "index.orit"],
+            [ops.scope, "teamData.yaml"],
+          ],
+        ],
+        [
+          "thumbnails",
+          [
+            [ops.scope, "@map"],
+            [ops.scope, "images"],
+            [ops.object, ["valueMap", [ops.scope, "thumbnail.js"]]],
+          ],
+        ],
+      ]
+    );
+  });
+
+  test("functionComposition", () => {
+    assertParse("functionComposition", "fn()", [[ops.scope, "fn"], undefined]);
+    assertParse("functionComposition", "fn(arg)", [
+      [ops.scope, "fn"],
+      [ops.scope, "arg"],
+    ]);
+    assertParse("functionComposition", "fn(a, b)", [
+      [ops.scope, "fn"],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+    ]);
+    assertParse("functionComposition", "fn()(arg)", [
+      [[ops.scope, "fn"], undefined],
+      [ops.scope, "arg"],
+    ]);
+    assertParse("functionComposition", "fn()/key", [
+      [[ops.scope, "fn"], undefined],
+      "key",
+    ]);
+    assertParse("functionComposition", "tree/", [[ops.scope, "tree"], ""]);
+    assertParse("functionComposition", "tree/key", [
+      [ops.scope, "tree"],
+      "key",
+    ]);
+    assertParse("functionComposition", "tree/foo/bar", [
+      [ops.scope, "tree"],
+      "foo",
+      "bar",
+    ]);
+    assertParse("functionComposition", "tree/key()", [
+      [[ops.scope, "tree"], "key"],
+      undefined,
+    ]);
+    assertParse("functionComposition", "fn()/key()", [
+      [[[ops.scope, "fn"], undefined], "key"],
+      undefined,
+    ]);
+    assertParse("functionComposition", "(fn())('arg')", [
+      [[ops.scope, "fn"], undefined],
+      "arg",
+    ]);
+    assertParse("functionComposition", "fn('a')('b')", [
+      [[ops.scope, "fn"], "a"],
+      "b",
+    ]);
+    assertParse("functionComposition", "(fn())(a, b)", [
+      [[ops.scope, "fn"], undefined],
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+    ]);
+    assertParse("functionComposition", "{ a: 1, b: 2}/b", [
+      [ops.object, ["a", 1], ["b", 2]],
+      "b",
+    ]);
+  });
+
+  test("group", () => {
+    assertParse("group", "(hello)", [ops.scope, "hello"]);
+    assertParse("group", "(((nested)))", [ops.scope, "nested"]);
+    assertParse("group", "(fn())", [[ops.scope, "fn"], undefined]);
+  });
+
+  test("host", () => {
+    assertParse("host", "abc", "abc");
+    assertParse("host", "abc:123", "abc:123");
+  });
+
+  test("identifier", () => {
+    assertParse("identifier", "abc", "abc");
+    assertParse("identifier", "index.html", "index.html");
+    assertParse("identifier", "foo\\ bar", "foo bar");
+  });
+
+  test("implicitParensCall", () => {
+    assertParse("implicitParensCall", "fn arg", [
+      [ops.scope, "fn"],
+      [ops.scope, "arg"],
+    ]);
+    assertParse("implicitParensCall", "fn 'a', 'b'", [
+      [ops.scope, "fn"],
+      "a",
+      "b",
+    ]);
+    assertParse("implicitParensCall", "fn a(b), c", [
+      [ops.scope, "fn"],
+      [
+        [ops.scope, "a"],
+        [ops.scope, "b"],
+      ],
+      [ops.scope, "c"],
+    ]);
+    assertParse("implicitParensCall", "fn1 fn2 'arg'", [
+      [ops.scope, "fn1"],
+      [[ops.scope, "fn2"], "arg"],
+    ]);
+    assertParse("implicitParensCall", "(fn()) 'arg'", [
+      [[ops.scope, "fn"], undefined],
+      "arg",
+    ]);
+    assertParse("implicitParensCall", "https://example.com/tree.yaml 'key'", [
+      [ops.https, "example.com", "tree.yaml"],
+      "key",
+    ]);
+  });
+
+  test("lambda", () => {
+    assertParse("lambda", "=message", [ops.lambda, [ops.scope, "message"]]);
+    assertParse("lambda", "=`Hello, {{name}}.`", [
+      ops.lambda,
+      [ops.concat, "Hello, ", [ops.scope, "name"], "."],
+    ]);
+  });
+
+  test("leadingSlashPath", () => {
+    assertParse("leadingSlashPath", "/tree/", ["tree", ""]);
+  });
+
+  describe("list", () => {
+    assertParse("list", "1", [1]);
+    assertParse("list", "1,2,3", [1, 2, 3]);
+    assertParse("list", "1, 2, 3,", [1, 2, 3]);
+    assertParse("list", "1 , 2 , 3", [1, 2, 3]);
+    assertParse("list", "1\n2\n3", [1, 2, 3]);
+    assertParse("list", "'a' , 'b' , 'c'", ["a", "b", "c"]);
+  });
+
+  test("number", () => {
+    assertParse("number", "123", 123);
+    assertParse("number", "-456", -456);
+    assertParse("number", ".5", 0.5);
+    assertParse("number", "123.45", 123.45);
+    assertParse("number", "-678.90", -678.9);
+    assertParse("number", "+123", 123);
+    assertParse("number", "+456.78", 456.78);
+  });
+
+  test("object", () => {
+    assertParse("object", "{}", [ops.object]);
+    assertParse("object", "{ a: 1, b }", [
+      ops.object,
+      ["a", 1],
+      ["b", [ops.inherited, "b"]],
+    ]);
+  });
+
+  test("objectProperty", () => {
+    assertParse("objectProperty", "a: 1", ["a", 1]);
+    assertParse("objectProperty", "name: 'Alice'", ["name", "Alice"]);
+    assertParse("objectProperty", "x: fn('a')", [
+      "x",
+      [[ops.scope, "fn"], "a"],
+    ]);
+  });
+
+  test("objectPropertyOrShorthand", () => {
+    assertParse("objectPropertyOrShorthand", "foo", [
+      "foo",
+      [ops.inherited, "foo"],
+    ]);
+    assertParse("objectPropertyOrShorthand", "x: y", ["x", [ops.scope, "y"]]);
+  });
+
+  test("parensArgs", () => {
+    assertParse("parensArgs", "()", [undefined]);
+    assertParse("parensArgs", "(a, b, c)", [
+      [ops.scope, "a"],
+      [ops.scope, "b"],
+      [ops.scope, "c"],
+    ]);
+  });
+
+  test("path", () => {
+    assertParse("path", "tree/", ["tree", ""]);
+    assertParse("path", "month/12", ["month", "12"]);
+    assertParse("path", "tree/foo/bar", ["tree", "foo", "bar"]);
+  });
+
+  test("protocolCall", () => {
+    assertParse("protocolCall", "foo://bar", [[ops.scope, "foo"], "bar"]);
+    assertParse("protocolCall", "https://example.com/foo/", [
+      ops.https,
+      "example.com",
+      "foo",
+      "",
+    ]);
+    assertParse("protocolCall", "http:example.com", [ops.http, "example.com"]);
+    assertParse("protocolCall", "http://localhost:5000/foo", [
+      ops.http,
+      "localhost:5000",
+      "foo",
+    ]);
+  });
+
+  test("scopeReference", () => {
+    assertParse("scopeReference", "x", [ops.scope, "x"]);
+  });
+
+  test("string", () => {
+    assertParse("string", '"foo"', "foo");
+    assertParse("string", "'bar'", "bar");
+    assertParse("string", '"foo bar"', "foo bar");
+    assertParse("string", "'bar baz'", "bar baz");
+    assertParse("string", `"foo\\"s bar"`, `foo"s bar`);
+    assertParse("string", `'bar\\'s baz'`, `bar's baz`);
+  });
+
+  test("templateDocument", () => {
+    assertParse("templateDocument", "hello{{foo}}world", [
+      ops.lambda,
+      [ops.concat, "hello", [ops.scope, "foo"], "world"],
+    ]);
+    assertParse("templateDocument", "Documents can contain ` backticks", [
+      ops.lambda,
+      "Documents can contain ` backticks",
+    ]);
+  });
+
+  test("templateLiteral", () => {
+    assertParse("templateLiteral", "`Hello, world.`", "Hello, world.");
+    assertParse("templateLiteral", "`foo {{x}} bar`", [
+      ops.concat,
+      "foo ",
+      [ops.scope, "x"],
+      " bar",
+    ]);
+    assertParse("templateLiteral", "`{{`nested`}}`", "nested");
+    assertParse("templateLiteral", "`{{map(people, =`{{name}}`)}}`", [
+      ops.concat,
+      [
+        [ops.scope, "map"],
+        [ops.scope, "people"],
+        [ops.lambda, [ops.concat, [ops.scope, "name"]]],
+      ],
+    ]);
+  });
+
+  test("templateSubstitution", () => {
+    assertParse("templateSubstitution", "{{foo}}", [ops.scope, "foo"]);
+  });
+
+  test("tree", () => {
+    assertParse("tree", "{}", [ops.tree]);
+    assertParse("tree", "{ a = 1, b }", [
+      ops.tree,
+      ["a", 1],
+      ["b", [ops.inherited, "b"]],
+    ]);
+    assertParse("tree", "{ x = fn('a') }", [
+      ops.tree,
+      ["x", [[ops.scope, "fn"], "a"]],
+    ]);
+  });
+
+  test("whitespace block", () => {
+    assertParse(
+      "__",
+      `  
+  # First line of comment
+  # Second line of comment
+     `,
+      ""
+    );
+  });
+});
+
+function assertParse(startRule, source, expected) {
+  const actual = parse(source, { startRule });
+  assert.deepEqual(actual, expected);
+}

package/test/runtime/EventTargetMixin.test.js

@@ -0,0 +1,68 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import EventTargetMixin from "../../src/runtime/EventTargetMixin.js";
+
+class EventTargetTest extends EventTargetMixin(Object) {}
+
+describe("EventTargetMixin", () => {
+  test("add and dispatch event", () => {
+    const fixture = new EventTargetTest();
+    const event = new Event("test");
+    let callCount = 0;
+    const callback = () => {
+      callCount++;
+    };
+    fixture.addEventListener("test", callback);
+    // Add twice, ensure that the callback is only called once.
+    fixture.addEventListener("test", callback);
+    const dispatched = fixture.dispatchEvent(event);
+    assert(dispatched);
+    assert.equal(callCount, 1);
+  });
+
+  test("dispatch event with no listeners", () => {
+    const fixture = new EventTargetTest();
+    const event = new Event("test");
+    const takeDefaultAction = fixture.dispatchEvent(event);
+    assert(takeDefaultAction);
+  });
+
+  test("remove event listener", () => {
+    const fixture = new EventTargetTest();
+    const event = new Event("test");
+    let callCount = 0;
+    const callback = () => {
+      callCount++;
+    };
+    fixture.addEventListener("test", callback);
+    fixture.removeEventListener("test", callback);
+    fixture.dispatchEvent(event);
+    assert.equal(callCount, 0);
+  });
+
+  test("stop immediate propagation", () => {
+    const fixture = new EventTargetTest();
+    const event = new Event("test");
+    let callCount = 0;
+    fixture.addEventListener("test", (event) => {
+      callCount++;
+      event.stopImmediatePropagation();
+    });
+    fixture.addEventListener("test", () => {
+      callCount++;
+    });
+    fixture.dispatchEvent(event);
+    assert.equal(callCount, 1);
+  });
+
+  test("prevent default", () => {
+    const fixture = new EventTargetTest();
+    const event = new Event("test");
+    fixture.addEventListener("test", (event) => {
+      event.preventDefault();
+    });
+    const takeDefaultAction = fixture.dispatchEvent(event);
+    assert(!takeDefaultAction);
+    assert(event.defaultPrevented);
+  });
+});

package/test/runtime/ExpressionTree.test.js

@@ -0,0 +1,27 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+
+import { Tree } from "@weborigami/async-tree";
+import {
+  ExpressionTree,
+  expressionFunction,
+  ops,
+} from "../../src/runtime/internal.js";
+
+describe("ExpressionTree", () => {
+  test("evaluates expressions, returns other values as is", async () => {
+    const tree = new ExpressionTree({
+      name: "Alice",
+      message: expressionFunction.createExpressionFunction([
+        ops.concat,
+        "Hello, ",
+        [ops.scope, "name"],
+        "!",
+      ]),
+    });
+    assert.deepEqual(await Tree.plain(tree), {
+      name: "Alice",
+      message: "Hello, Alice!",
+    });
+  });
+});

package/test/runtime/FileLoadersTransform.test.js

@@ -0,0 +1,41 @@
+import { ObjectTree, Tree } from "@weborigami/async-tree";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import FileLoadersTransform from "../../src/runtime/FileLoadersTransform.js";
+import Scope from "../../src/runtime/Scope.js";
+
+describe("FileLoadersTransform", () => {
+  test("invokes an appropriate loader for a .json file extension", async () => {
+    const fixture = createFixture();
+    const numberValue = await fixture.get("foo");
+    assert(typeof numberValue === "number");
+    assert.equal(numberValue, 1);
+    const jsonFile = await fixture.get("bar.json");
+    assert.equal(String(jsonFile), `{ "bar": 2 }`);
+    const data = await jsonFile.unpack();
+    assert.deepEqual(data, { bar: 2 });
+  });
+
+  test("input that isn't string-like is returned as is", async () => {
+    const obj = { bar: 2 };
+    const fixture = createFixture();
+    const jsonFile = await fixture.get("bar.json");
+    assert.deepEqual(await Tree.plain(jsonFile), obj);
+  });
+});
+
+function createFixture() {
+  /** @type {import("@weborigami/types").AsyncTree} */
+  let tree = new (FileLoadersTransform(ObjectTree))({
+    foo: 1, // No extension, should be left alone
+    "bar.json": `{ "bar": 2 }`,
+  });
+  /** @type {any} */
+  const scope = {
+    "@loaders": {
+      json: (input) => JSON.parse(input),
+    },
+  };
+  tree = Scope.treeWithScope(tree, scope);
+  return tree;
+}

package/test/runtime/InheritScopeMixin.test.js

@@ -0,0 +1,29 @@
+import { ObjectTree } from "@weborigami/async-tree";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import InheritScopeMixin from "../../src/runtime/InheritScopeMixin.js";
+
+describe("InheritScopeMixin", () => {
+  test("creates a scope that includes a tree and its parent", async () => {
+    const fixture = new (InheritScopeMixin(ObjectTree))({
+      b: 2,
+    });
+    fixture.parent = new ObjectTree({
+      a: 1,
+    });
+    assert.deepEqual(await fixture.scope?.get("b"), 2);
+    assert.deepEqual(await fixture.scope?.get("a"), 1);
+  });
+
+  test("adds a subtree's parent to the subtrees's scope", async () => {
+    const fixture = new (InheritScopeMixin(ObjectTree))({
+      a: 1,
+      subtree: {
+        b: 2,
+      },
+    });
+    const subtree = await fixture.get("subtree");
+    assert.deepEqual(await subtree.scope.get("b"), 2);
+    assert.deepEqual(await subtree.scope.get("a"), 1);
+  });
+});

package/test/runtime/OrigamiFiles.test.js

@@ -0,0 +1,37 @@
+import assert from "node:assert";
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { describe, test } from "node:test";
+import { fileURLToPath } from "node:url";
+import OrigamiFiles from "../../src/runtime/OrigamiFiles.js";
+
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+const tempDirectory = path.join(dirname, "fixtures/temp");
+
+describe("OrigamiFiles", () => {
+  test("can watch its folder for changes", { timeout: 2000 }, async () => {
+    await createTempDirectory();
+    const tempFiles = new OrigamiFiles(tempDirectory);
+    const changedFileName = await new Promise(async (resolve) => {
+      // @ts-ignore
+      tempFiles.addEventListener("change", (event) => {
+        resolve(/** @type {any} */ (event).options.key);
+      });
+      // @ts-ignore
+      await tempFiles.set(
+        "foo.txt",
+        "This file is left over from testing and can be removed."
+      );
+    });
+    await removeTempDirectory();
+    assert.equal(changedFileName, "foo.txt");
+  });
+});
+
+async function createTempDirectory() {
+  await fs.mkdir(tempDirectory, { recursive: true });
+}
+
+async function removeTempDirectory() {
+  await fs.rm(tempDirectory, { recursive: true });
+}

package/test/runtime/Scope.test.js

@@ -0,0 +1,37 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import Scope from "../../src/runtime/Scope.js";
+
+describe("Scope", () => {
+  test("composes and flattens scopes and trees passed to it", async () => {
+    const treeA = {
+      a: 1,
+    };
+    const treeB = {
+      b: 2,
+    };
+    const treeC = {
+      c: 3,
+    };
+    const scope1 = new Scope(treeA, treeB);
+    const scope2 = new Scope(scope1, treeC);
+    const objects = scope2.trees.map(
+      (tree) => /** @type {any} */ (tree).object
+    );
+    assert.deepEqual(objects, [treeA, treeB, treeC]);
+  });
+
+  test("gets the first defined value from the scope trees", async () => {
+    const scope = new Scope(
+      {
+        a: 1,
+      },
+      {
+        a: 2,
+        b: 3,
+      }
+    );
+    assert.equal(await scope.get("a"), 1);
+    assert.equal(await scope.get("b"), 3);
+  });
+});

package/test/runtime/concatTreeValues.js

@@ -0,0 +1,20 @@
+import { Tree } from "@weborigami/async-tree";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import concatTreeValues from "../../src/runtime/concatTreeValues.js";
+
+describe("concatTreeValues", () => {
+  test("concatenates deep tree values", async () => {
+    const tree = Tree.from({
+      a: "A",
+      b: "B",
+      c: "C",
+      more: {
+        d: "D",
+        e: "E",
+      },
+    });
+    const result = await concatTreeValues.call(null, tree);
+    assert.equal(result, "ABCDE");
+  });
+});