@weborigami/language 0.5.5 → 0.5.7

package/test/compiler/optimize.test.js

@@ -1,7 +1,11 @@
 import { ObjectTree } from "@weborigami/async-tree";
 import { describe, test } from "node:test";
 import * as compile from "../../src/compiler/compile.js";
-import optimize from "../../src/compiler/optimize.js";
+import {
+  REFERENCE_INHERITED,
+  REFERENCE_PARAM,
+  default as optimize,
+} from "../../src/compiler/optimize.js";
 import { markers } from "../../src/compiler/parserHelpers.js";
 import { ops } from "../../src/runtime/internal.js";
 import {
@@ -24,11 +28,17 @@ describe("optimize", () => {
         [
           "a",
           [
-            [ops.context, 1],
+            [ops.params, 0],
             [ops.literal, "name"],
           ],
         ],
-        ["b", [[ops.context], [ops.literal, "a"]]],
+        [
+          "b",
+          [
+            [ops.inherited, 0],
+            [ops.literal, "a"],
+          ],
+        ],
       ],
     ];
     assertCompile(expression, expected);
@@ -54,7 +64,7 @@ describe("optimize", () => {
           [
             "a",
             [
-              [ops.context, 1],
+              [ops.inherited, 1],
               [ops.literal, "a"],
             ],
           ],
@@ -81,7 +91,7 @@ describe("optimize", () => {
           [
             "name",
             [
-              [ops.context, 1],
+              [ops.inherited, 1],
               [ops.literal, "name"],
             ],
           ],
@@ -99,14 +109,18 @@ describe("optimize", () => {
         markers.traverse,
         [markers.reference, "folder"],
       ]);
+      const parent = {};
       const expected = [
         ops.cache,
         {},
         "folder",
-        [[ops.scope], [ops.literal, "folder"]],
+        [
+          [ops.scope, parent],
+          [ops.literal, "folder"],
+        ],
       ];
       const globals = {};
-      assertCodeEqual(optimize(code, { globals }), expected);
+      assertCodeEqual(optimize(code, { globals, parent }), expected);
     });
 
     test("external reference", () => {
@@ -115,14 +129,18 @@ describe("optimize", () => {
         markers.traverse,
         [markers.reference, "index.html"],
       ]);
+      const parent = {};
       const expected = [
         ops.cache,
         {},
         "index.html",
-        [[ops.scope], [ops.literal, "index.html"]],
+        [
+          [ops.scope, parent],
+          [ops.literal, "index.html"],
+        ],
       ];
       const globals = {};
-      assertCodeEqual(optimize(code, { globals }), expected);
+      assertCodeEqual(optimize(code, { globals, parent }), expected);
     });
 
     test("external reference inside object with matching key", () => {
@@ -134,6 +152,7 @@ describe("optimize", () => {
           [ops.getter, [markers.traverse, [markers.reference, "posts.txt"]]],
         ],
       ]);
+      const parent = {};
       const expected = [
         ops.object,
         [
@@ -145,7 +164,7 @@ describe("optimize", () => {
               {},
               "posts.txt",
               [
-                [ops.scope, [ops.context, 1]],
+                [ops.scope, parent],
                 [ops.literal, "posts.txt"],
               ],
             ],
@@ -153,7 +172,7 @@ describe("optimize", () => {
         ],
       ];
       const globals = {};
-      assertCodeEqual(optimize(code, { globals }), expected);
+      assertCodeEqual(optimize(code, { globals, parent }), expected);
     });
 
     test("global reference", () => {
@@ -176,27 +195,37 @@ describe("optimize", () => {
     });
 
     test("local reference", () => {
-      // Compilation of `post` where post is a local variable
+      // Compilation of `post` where post is a local parameter
       const code = createCode([markers.traverse, [markers.reference, "post"]]);
       const globals = { post: {} }; // local should take precedence
-      const locals = [["post"]];
+      const locals = [{ type: REFERENCE_PARAM, names: ["post"] }];
       const actual = optimize(code, { globals, locals });
-      const expected = [[ops.context], [ops.literal, "post"]];
+      const expected = [
+        [ops.params, 0],
+        [ops.literal, "post"],
+      ];
       assertCodeEqual(actual, expected);
     });
 
     test("local reference and property", () => {
-      // Compilation of `post.author.name` where `post` is a local variable
+      // Compilation of `post.author.name` where `post` is a local inherited property
       const code = createCode([
         markers.traverse,
         [markers.reference, "post.author.name"],
       ]);
       const globals = { post: {} }; // local should take precedence
-      const locals = [["post"]];
+      const locals = [{ type: REFERENCE_INHERITED, names: ["post"] }];
       const actual = optimize(code, { globals, locals });
       const expected = [
         ops.property,
-        [ops.property, [[ops.context], [ops.literal, "post"]], "author"],
+        [
+          ops.property,
+          [
+            [ops.inherited, 0],
+            [ops.literal, "post"],
+          ],
+          "author",
+        ],
         "name",
       ];
       assertCodeEqual(actual, expected);
@@ -226,18 +255,19 @@ describe("optimize", () => {
         [ops.literal, "to/"],
         [ops.literal, "file"],
       ]);
+      const parent = {};
       const expected = [
         ops.cache,
         {},
         "path/to/file",
         [
-          [ops.scope],
+          [ops.scope, parent],
           [ops.literal, "path/"],
           [ops.literal, "to/"],
           [ops.literal, "file"],
         ],
       ];
-      assertCodeEqual(optimize(code), expected);
+      assertCodeEqual(optimize(code, { parent }), expected);
     });
 
     test("implicit external path", () => {
@@ -248,27 +278,32 @@ describe("optimize", () => {
         [ops.literal, "name"],
       ]);
       const globals = {};
+      const parent = {};
       const expected = [
         ops.cache,
         {},
         "package.json/name",
-        [[ops.scope], [ops.literal, "package.json/"], [ops.literal, "name"]],
+        [
+          [ops.scope, parent],
+          [ops.literal, "package.json/"],
+          [ops.literal, "name"],
+        ],
       ];
-      assertCodeEqual(optimize(code, { globals }), expected);
+      assertCodeEqual(optimize(code, { globals, parent }), expected);
     });
 
     test("local path", () => {
-      // Compilation of `page/title` where page is a local variable
+      // Compilation of `page/title` where page is a local parameter
       const code = createCode([
         markers.traverse,
         [markers.reference, "page/"],
         [ops.literal, "title"],
       ]);
       const globals = {};
-      const locals = [["page"]];
+      const locals = [{ type: REFERENCE_PARAM, names: ["page"] }];
       const actual = optimize(code, { globals, locals });
       const expected = [
-        [ops.context],
+        [ops.params, 0],
         [ops.literal, "page/"],
         [ops.literal, "title"],
       ];
@@ -279,7 +314,7 @@ describe("optimize", () => {
 
 function assertCompile(expression, expected, mode = "shell") {
   const parent = new ObjectTree({});
-  const globals = new ObjectTree({});
+  const globals = {};
   const fn = compile.expression(expression, { globals, mode, parent });
   const actual = fn.code;
   assertCodeLocations(actual);

package/test/compiler/parse.test.js

@@ -347,10 +347,10 @@ describe("Origami parser", () => {
       [ops.lambda, [], [ops.lambda, [], [ops.literal, 1]]],
       [ops.literal, 0],
     ]);
-    assertParse("conditionalExpression", "false ? =1 : 0", [
+    assertParse("conditionalExpression", "false ? () => 1 : 0", [
       ops.conditional,
       [markers.traverse, [markers.reference, "false"]],
-      [ops.lambda, [], [ops.lambda, [[ops.literal, "_"]], [ops.literal, 1]]],
+      [ops.lambda, [], [ops.lambda, [], [ops.literal, 1]]],
       [ops.literal, 0],
     ]);
   });
@@ -1008,9 +1008,9 @@ Body`,
             "_result",
             [
               ops.merge,
-              [ops.object, ["a", [ops.getter, [[ops.context, 1], "a"]]]],
+              [ops.object, ["a", [ops.getter, [[ops.inherited, 1], "a"]]]],
               [markers.traverse, [markers.reference, "more"]],
-              [ops.object, ["c", [ops.getter, [[ops.context, 1], "c"]]]],
+              [ops.object, ["c", [ops.getter, [[ops.inherited, 1], "c"]]]],
             ],
           ],
         ],

package/test/generator/oriEval.js

@@ -1,15 +1,14 @@
-import { ObjectTree } from "@weborigami/async-tree";
 import * as compile from "../../src/compiler/compile.js";
 
 export default async function oriEval(source) {
-  const builtins = new ObjectTree({
+  const globals = {
     false: false,
     NaN: NaN,
     null: null,
     true: true,
     undefined: undefined,
-  });
-  const compiled = compile.program(source);
-  const result = await compiled.call(builtins);
+  };
+  const compiled = compile.program(source, { globals });
+  const result = await compiled();
   return result;
 }

package/test/handlers/csv.handler.test.js

@@ -0,0 +1,36 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import csv_handler from "../../src/handlers/csv_handler.js";
+
+describe(".csv handler", () => {
+  test("parses CSV text into array of objects", () => {
+    const csvText = `name,age,city
+Alice,30,"New York, NY"
+Bob,25,Los Angeles
+"Carol ""CJ""",22,Chicago`;
+    const result = csv_handler.unpack(csvText);
+    assert.deepStrictEqual(result, [
+      { name: "Alice", age: "30", city: "New York, NY" },
+      { name: "Bob", age: "25", city: "Los Angeles" },
+      { name: 'Carol "CJ"', age: "22", city: "Chicago" },
+    ]);
+  });
+
+  test("handles CRLF line endings", () => {
+    const textCRLF = `name,age,city\r\nAlice,30,"New York, NY"\r\nBob,25,Los Angeles\r\n`;
+    const expected = [
+      { name: "Alice", age: "30", city: "New York, NY" },
+      { name: "Bob", age: "25", city: "Los Angeles" },
+    ];
+    const result = csv_handler.unpack(textCRLF);
+    assert.deepStrictEqual(result, expected);
+  });
+
+  test("throws an error for unmatched quotes", () => {
+    // Provide a CSV string with an unmatched quote.
+    const badCSV = `name,age\r\nAlice,30\r\nBob,"25\r\n`;
+    assert.throws(() => {
+      csv_handler.unpack(badCSV);
+    }, /unmatched quote/);
+  });
+});

package/test/handlers/fixtures/frontMatter.md

@@ -0,0 +1,5 @@
+---
+a: 1
+---
+
+Body **text**

package/test/handlers/fixtures/list.js

@@ -0,0 +1,4 @@
+// A function with a spread parameter
+export default function list(...args) {
+  return args.join(",");
+}

package/test/handlers/fixtures/multiple.js

@@ -0,0 +1,4 @@
+// Exports multiple things
+
+export const n = 1;
+export const s = "string";

package/test/handlers/fixtures/obj.js

@@ -0,0 +1,3 @@
+export default {
+  a: 1,
+};

package/test/handlers/fixtures/site.ori

@@ -0,0 +1,5 @@
+{
+  index.html = index.ori()
+  index.ori = () => `Hello, ${ name }!`
+  name = "world"
+}

package/test/handlers/fixtures/string.js

@@ -0,0 +1 @@
+export default "This is a string.";

package/test/handlers/fixtures/tag.yaml

@@ -0,0 +1,5 @@
+names:
+  - Alice
+  - Bob
+  - Carol
+greetings: !ori "@map(names, =`Hello, {{ _ }}!`)"

package/test/handlers/fixtures/test.ori

@@ -0,0 +1,9 @@
+{
+  names = [
+    'Alice',
+    'Bob',
+    'Carol'
+  ]
+
+  greetings = map(=`Hello, ${ _ }!`)(names)
+}

package/test/handlers/jpeg.handler.test.js

@@ -0,0 +1,18 @@
+import assert from "node:assert";
+import fs from "node:fs/promises";
+import { describe, test } from "node:test";
+import jpeg_handler from "../../src/handlers/jpeg_handler.js";
+
+describe(".jpeg handler", () => {
+  test("loads Exif metadata", async () => {
+    const fixturePath = new URL("fixtures/exif.jpeg", import.meta.url);
+    const image = await fs.readFile(fixturePath);
+    const data = await jpeg_handler.unpack(image);
+    assert.equal(data.exif.LensMake, "Apple");
+    assert.equal(
+      data.exif.ModifyDate.toISOString(),
+      "2023-11-13T18:44:11.000Z"
+    );
+    assert.equal(data.exif.Orientation, 1);
+  });
+});

package/test/handlers/js.handler.test.js

@@ -0,0 +1,46 @@
+import { FileTree } from "@weborigami/async-tree";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import js_handler from "../../src/handlers/js_handler.js";
+import ImportModulesMixin from "../../src/runtime/ImportModulesMixin.js";
+
+const fixturesUrl = new URL("fixtures", import.meta.url);
+const fixturesTree = new (ImportModulesMixin(FileTree))(fixturesUrl);
+
+describe(".js handler", () => {
+  test("loads .js file that exports a string", async () => {
+    const buffer = await fixturesTree.get("string.js");
+    const text = await js_handler.unpack(buffer, {
+      key: "string.js",
+      parent: fixturesTree,
+    });
+    assert.equal(text, "This is a string.");
+  });
+
+  test("loads .js file that exports a function", async () => {
+    const buffer = await fixturesTree.get("list.js");
+    const list = await js_handler.unpack(buffer, {
+      key: "list.js",
+      parent: fixturesTree,
+    });
+    assert.equal(await list("a", "b", "c"), "a,b,c");
+  });
+
+  test("loads .js file that exports an object", async () => {
+    const buffer = await fixturesTree.get("obj.js");
+    const obj = await js_handler.unpack(buffer, {
+      key: "obj.js",
+      parent: fixturesTree,
+    });
+    assert.deepEqual(obj, { a: 1 });
+  });
+
+  test("returns multiple exports as an object", async () => {
+    const buffer = await fixturesTree.get("multiple.js");
+    const obj = await js_handler.unpack(buffer, {
+      key: "multiple.js",
+      parent: fixturesTree,
+    });
+    assert.deepEqual(obj, { n: 1, s: "string" });
+  });
+});

package/test/handlers/json.handler.test.js

@@ -0,0 +1,14 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import json_handler from "../../src/handlers/json_handler.js";
+
+describe(".json handler", () => {
+  test("loads input as a JSON file", async () => {
+    const text = `{ "a": 1, "b": 2 }`;
+    const obj = await json_handler.unpack(text);
+    assert.deepEqual(obj, {
+      a: 1,
+      b: 2,
+    });
+  });
+});

package/test/handlers/ori.handler.test.js

@@ -0,0 +1,87 @@
+import { ObjectTree, Tree } from "@weborigami/async-tree";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import ori_handler from "../../src/handlers/ori_handler.js";
+import OrigamiFiles from "../../src/runtime/OrigamiFiles.js";
+
+const fixturesUrl = new URL("fixtures", import.meta.url);
+const fixtures = new OrigamiFiles(fixturesUrl);
+
+describe(".ori handler", async () => {
+  test("loads a string expression", async () => {
+    const source = `"Hello"`;
+    const text = await ori_handler.unpack(source);
+    assert.equal(text, "Hello");
+  });
+
+  test("loads a tree expression", async () => {
+    const parent = new ObjectTree({
+      name: "world",
+    });
+    const source = `{
+      message = \`Hello, \${name}!\`
+    }`;
+    const tree = await ori_handler.unpack(source, { parent });
+    assert.deepEqual(await Tree.plain(tree), {
+      message: "Hello, world!",
+    });
+    assert.equal(await tree.message, "Hello, world!");
+  });
+
+  test("loads a tree with a nested tree", async () => {
+    const source = `{
+      name = "world",
+      public = {
+        message = \`Hello, \${name}!\`
+      }
+    }`;
+    const tree = await ori_handler.unpack(source);
+    assert.deepEqual(
+      await Tree.traverse(tree, "public", "message"),
+      "Hello, world!"
+    );
+  });
+
+  test("loads an object containing an object shorthand", async () => {
+    const assets = new ObjectTree({});
+    const parent = new ObjectTree({ assets });
+    const source = `{ assets }`;
+    const object = await ori_handler.unpack(source, { parent });
+    assert.equal(object.assets, assets);
+  });
+
+  test("loads a template literal", async () => {
+    const scope = new ObjectTree({
+      name: "Alice",
+    });
+    const source = `\`Hello, \${name}!\``;
+    const unpackedText = await ori_handler.unpack(source, {
+      parent: scope,
+    });
+    assert.deepEqual(unpackedText, "Hello, Alice!");
+  });
+
+  test("loads a template lambda that reads from parent scope", async () => {
+    const parent = new ObjectTree({
+      name: "Alice",
+    });
+    const source = `() => \`Hello, \${name}!\``;
+    const templateFn = await ori_handler.unpack(source, { parent });
+    const value = await templateFn();
+    assert.equal(value, "Hello, Alice!");
+  });
+
+  test("loads a template lambda that accepts input", async () => {
+    const source = `(_) => \`Hello, \${ _.name }!\``;
+    const templateFn = await ori_handler.unpack(source);
+    const value = await templateFn({ name: "Alice" });
+    assert.deepEqual(value, "Hello, Alice!");
+  });
+
+  test("loads a tree that includes a template", async () => {
+    const source = await fixtures.get("site.ori");
+    const tree = await ori_handler.unpack(source);
+    const indexHtml = await tree["index.html"];
+    assert.equal(indexHtml, "Hello, world!");
+  });
+});

package/test/handlers/oridocument.handler.test.js

@@ -0,0 +1,68 @@
+import { ObjectTree } from "@weborigami/async-tree";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import oridocument_handler from "../../src/handlers/oridocument_handler.js";
+
+describe("Origami document handler", () => {
+  test("unpacks text with Origami expressions", async () => {
+    const parent = new ObjectTree({
+      name: "world",
+    });
+    const text = "Hello, ${ name }!";
+    const fn = await oridocument_handler.unpack(text, {
+      key: "test.ori.txt",
+      parent,
+    });
+    const result = await fn();
+    assert.equal(result, "Hello, world!");
+
+    // Test sidecar keyFn
+    assert.equal(fn.key(null, "data.json"), "data.txt");
+  });
+
+  test("Argument to template document available as underscore", async () => {
+    const text = "<h1>${ _ }</h1>";
+    const fn = await oridocument_handler.unpack(text);
+    const result = await fn("Home");
+    assert.equal(result, "<h1>Home</h1>");
+  });
+
+  test("YAML front matter is returned with _body", async () => {
+    const parent = new ObjectTree({
+      message: "Hello",
+    });
+    const text = `---
+name: world
+---
+\${ message }, \${ name }!`;
+    const result = await oridocument_handler.unpack(text, { parent });
+    assert.deepEqual(result.name, "world");
+    assert.equal(result._body, "Hello, world!");
+  });
+
+  test("unpacks a document with Origami front matter", async () => {
+    const text = `---
+{
+  sum: 1 + 1
+  _body: _template()
+}
+---
+Body text`;
+    const result = await oridocument_handler.unpack(text);
+    assert.deepEqual(result, {
+      sum: 2,
+      _body: "Body text",
+    });
+  });
+
+  test("Origami front matter can refer to _template as a macro", async () => {
+    const text = `---
+(name) => _template()
+---
+Hello, \${ name }!
+`;
+    const fn = await oridocument_handler.unpack(text);
+    const result = await fn("world");
+    assert.equal(result, "Hello, world!\n");
+  });
+});

package/test/handlers/txt.handler.test.js

@@ -0,0 +1,41 @@
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import txt_handler from "../../src/handlers/txt_handler.js";
+
+describe("text handler", () => {
+  test("packs an object as YAML with front matter", async () => {
+    const object = {
+      _body: "Body text",
+      a: 1,
+    };
+    const packed = await txt_handler.pack(object);
+    assert.equal(packed, "---\na: 1\n---\nBody text");
+  });
+
+  test("unpacks text without data", async () => {
+    const text = "Body text";
+    const result = await txt_handler.unpack(text);
+    assert.equal(result, text);
+  });
+
+  test("unpacks a document with YAML/JSON front matter", async () => {
+    const text = "---\na: 1\n---\nBody text";
+    const document = await txt_handler.unpack(text);
+    assert.deepEqual(document, {
+      a: 1,
+      _body: "Body text",
+    });
+  });
+
+  test("unpacks a document with Origami front matter", async () => {
+    const text = `---
+{ sum: 1 + 1 }
+---
+Body text`;
+    const document = await txt_handler.unpack(text);
+    assert.deepEqual(document, {
+      sum: 2,
+      _body: "Body text",
+    });
+  });
+});

package/test/handlers/wasm.handler.test.js

@@ -0,0 +1,20 @@
+import { FileTree } from "@weborigami/async-tree";
+import assert from "node:assert";
+import { describe, test } from "node:test";
+import wasm_handler from "../../src/handlers/wasm_handler.js";
+import ImportModulesMixin from "../../src/runtime/ImportModulesMixin.js";
+
+const fixturesUrl = new URL("fixtures", import.meta.url);
+const fixturesTree = new (ImportModulesMixin(FileTree))(fixturesUrl);
+
+describe(".wasm handler", () => {
+  test("loads .wasm file that exports a function", async () => {
+    const buffer = await fixturesTree.get("add.wasm");
+    const { add } = await wasm_handler.unpack(buffer, {
+      key: "add.wasm",
+      parent: fixturesTree,
+    });
+    const sum = add(1, 2);
+    assert.strictEqual(sum, 3);
+  });
+});