@weborigami/language 0.2.6 → 0.2.8

package/src/runtime/ops.js

@@ -1,7 +1,8 @@
 /**
- * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @typedef {import("../../index.ts").AnnotatedCode} AnnotatedCode
  * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
  * @typedef {import("@weborigami/async-tree").Treelike} Treelike
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  */
 
 import {
@@ -33,6 +34,17 @@ export function addition(a, b) {
 }
 addOpLabel(addition, "«ops.addition»");
 
+/**
+ * Construct an array.
+ *
+ * @this {AsyncTree|null}
+ * @param {any[]} items
+ */
+export async function array(...items) {
+  return items;
+}
+addOpLabel(array, "«ops.array»");
+
 export function bitwiseAnd(a, b) {
   return a & b;
 }
@@ -53,17 +65,6 @@ export function bitwiseXor(a, b) {
 }
 addOpLabel(bitwiseXor, "«ops.bitwiseXor»");
 
-/**
- * Construct an array.
- *
- * @this {AsyncTree|null}
- * @param {any[]} items
- */
-export async function array(...items) {
-  return items;
-}
-addOpLabel(array, "«ops.array»");
-
 /**
  * Like ops.scope, but only searches for a builtin at the top of the scope
  * chain.
@@ -83,6 +84,7 @@ export async function builtin(key) {
 
   return value;
 }
+addOpLabel(builtin, "«ops.builtin»");
 
 /**
  * JavaScript comma operator, returns the last argument.
@@ -107,7 +109,8 @@ export async function concat(...args) {
 addOpLabel(concat, "«ops.concat»");
 
 export async function conditional(condition, truthy, falsy) {
-  return condition ? truthy() : falsy();
+  const value = condition ? truthy : falsy;
+  return value instanceof Function ? await value() : value;
 }
 
 export function division(a, b) {
@@ -154,6 +157,7 @@ export async function external(path, code, cache) {
 
   return value;
 }
+addOpLabel(external, "«ops.external»");
 
 /**
  * This op is only used during parsing. It signals to ops.object that the
@@ -181,6 +185,7 @@ export async function homeDirectory() {
   tree.parent = this ? Tree.root(this) : null;
   return tree;
 }
+addOpLabel(homeDirectory, "«ops.homeDirectory»");
 
 /**
  * Search the parent's scope -- i.e., exclude the current tree -- for the given
@@ -201,10 +206,9 @@ addOpLabel(inherited, "«ops.inherited»");
 /**
  * Return a function that will invoke the given code.
  *
- * @typedef {import("../../index.ts").Code} Code
  * @this {AsyncTree|null}
  * @param {string[]} parameters
- * @param {Code} code
+ * @param {AnnotatedCode} code
  */
 export function lambda(parameters, code) {
   const context = this;
@@ -271,6 +275,9 @@ addOpLabel(lessThanOrEqual, "«ops.lessThanOrEqual»");
 
 /**
  * Return a primitive value
+ *
+ * This op is optimized away during compilation, with the exception of array
+ * literals.
  */
 export async function literal(value) {
   return value;
@@ -296,6 +303,7 @@ export async function logicalAnd(head, ...tail) {
   // Return the last value (not `true`)
   return lastValue;
 }
+addOpLabel(logicalAnd, "«ops.logicalAnd»");
 
 /**
  * Logical NOT operator
@@ -303,6 +311,7 @@ export async function logicalAnd(head, ...tail) {
 export async function logicalNot(value) {
   return !value;
 }
+addOpLabel(logicalNot, "«ops.logicalNot»");
 
 /**
  * Logical OR operator
@@ -323,14 +332,47 @@ export async function logicalOr(head, ...tail) {
 
   return lastValue;
 }
+addOpLabel(logicalOr, "«ops.logicalOr»");
 
 /**
  * Merge the given trees. If they are all plain objects, return a plain object.
  *
  * @this {AsyncTree|null}
- * @param {import("@weborigami/async-tree").Treelike[]} trees
+ * @param {AnnotatedCode[]} codes
  */
-export async function merge(...trees) {
+export async function merge(...codes) {
+  // First pass: evaluate the direct property entries in a single object
+  let treeSpreads = false;
+  const directEntries = [];
+  for (const code of codes) {
+    if (code[0] === object) {
+      directEntries.push(...code.slice(1));
+    } else {
+      treeSpreads = true;
+    }
+  }
+
+  const directObject = directEntries
+    ? await expressionObject(directEntries, this)
+    : null;
+  if (!treeSpreads) {
+    // No tree spreads, we're done
+    return directObject;
+  }
+
+  // Second pass: evaluate the trees with the direct properties object in scope
+  let context;
+  if (directObject) {
+    context = Tree.from(directObject);
+    context.parent = this;
+  } else {
+    context = this;
+  }
+
+  const trees = await Promise.all(
+    codes.map(async (code) => evaluate.call(context, code))
+  );
+
   return mergeTrees.call(this, ...trees);
 }
 addOpLabel(merge, "«ops.merge»");
@@ -368,6 +410,7 @@ export async function nullishCoalescing(head, ...tail) {
 
   return lastValue;
 }
+addOpLabel(nullishCoalescing, "«ops.nullishCoalescing»");
 
 /**
  * Construct an object. The keys will be the same as the given `obj`
@@ -400,6 +443,7 @@ export async function rootDirectory(key) {
   tree.parent = this ? Tree.root(this) : null;
   return key ? tree.get(key) : tree;
 }
+addOpLabel(rootDirectory, "«ops.rootDirectory»");
 
 /**
  * Look up the given key in the scope for the current tree.
@@ -438,7 +482,7 @@ addOpLabel(shiftRightUnsigned, "«ops.shiftRightUnsigned»");
  * The spread operator is a placeholder during parsing. It should be replaced
  * with an object merge.
  */
-export function spread(...args) {
+export function spread(arg) {
   throw new Error(
     "Internal error: a spread operation wasn't compiled correctly."
   );
@@ -495,3 +539,4 @@ addOpLabel(unaryPlus, "«ops.unaryPlus»");
 export async function unpack(value) {
   return isUnpackable(value) ? value.unpack() : value;
 }
+addOpLabel(unpack, "«ops.unpack»");

package/src/runtime/typos.js

@@ -15,6 +15,12 @@ export function isTypo(s1, s2) {
     return false;
   }
 
+  // If strings are both a single character, we don't want to consider them
+  // typos.
+  if (length1 === 1 && length2 === 1) {
+    return false;
+  }
+
   // If length difference is more than 1, distance can't be 1
   if (Math.abs(length1 - length2) > 1) {
     return false;

package/test/compiler/{stripCodeLocations.js → codeHelpers.js}

@@ -1,4 +1,28 @@
 import { isPlainObject } from "@weborigami/async-tree";
+import assert from "node:assert";
+
+export function assertCodeEqual(actual, expected) {
+  const actualStripped = stripCodeLocations(actual);
+  const expectedStripped = stripCodeLocations(expected);
+  assert.deepEqual(actualStripped, expectedStripped);
+}
+
+/**
+ * Adds a fake source to code.
+ *
+ * @returns {import("../../index.ts").AnnotatedCode}
+ */
+export function createCode(array) {
+  const code = array;
+  /** @type {any} */ (code).location = {
+    end: 0,
+    source: {
+      text: "",
+    },
+    start: 0,
+  };
+  return code;
+}
 
 // For comparison purposes, strip the `location` property added by the parser.
 export function stripCodeLocations(parseResult) {

package/test/compiler/compile.test.js

@@ -3,7 +3,7 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 import * as compile from "../../src/compiler/compile.js";
 import { ops } from "../../src/runtime/internal.js";
-import { stripCodeLocations } from "./stripCodeLocations.js";
+import { assertCodeEqual } from "./codeHelpers.js";
 
 const shared = new ObjectTree({
   greet: (name) => `Hello, ${name}!`,
@@ -70,7 +70,7 @@ describe("compile", () => {
     let saved;
     const scope = new ObjectTree({
       tag: (strings, ...values) => {
-        assert.deepEqual(strings, ["Hello, ", "!"]);
+        assertCodeEqual(strings, ["Hello, ", "!"]);
         if (saved) {
           assert.equal(strings, saved);
         } else {
@@ -96,7 +96,7 @@ describe("compile", () => {
       },
     });
     const code = fn.code;
-    assert.deepEqual(stripCodeLocations(code), [ops.object, ["a", literal]]);
+    assertCodeEqual(code, [ops.object, ["a", 1]]);
   });
 });
 

package/test/compiler/optimize.test.js

@@ -1,9 +1,8 @@
-import assert from "node:assert";
 import { describe, test } from "node:test";
 import * as compile from "../../src/compiler/compile.js";
 import optimize from "../../src/compiler/optimize.js";
 import { ops } from "../../src/runtime/internal.js";
-import { stripCodeLocations } from "./stripCodeLocations.js";
+import { assertCodeEqual, createCode } from "./codeHelpers.js";
 
 describe("optimize", () => {
   test("optimize non-local ops.scope calls to ops.external", async () => {
@@ -17,12 +16,12 @@ describe("optimize", () => {
     `;
     const fn = compile.expression(expression);
     const code = fn.code;
-    assert.deepEqual(stripCodeLocations(code), [
+    assertCodeEqual(code, [
       ops.lambda,
       ["name"],
       [
         ops.object,
-        ["a", [ops.literal, 1]],
+        ["a", 1],
         ["b", [ops.scope, "a"]],
         ["c", [ops.external, "elsewhere", [ops.scope, "elsewhere"], {}]],
         ["d", [ops.scope, "name"]],
@@ -32,13 +31,12 @@ describe("optimize", () => {
 
   test("optimize scope traversals with all literal keys", async () => {
     // Compilation of `x/y.js`
-    const code = [ops.traverse, [ops.scope, "x/"], [ops.literal, "y.js"]];
-    const optimized = optimize(code);
-    assert.deepEqual(stripCodeLocations(optimized), [
-      ops.external,
-      "x/y.js",
-      code,
-      {},
+    const code = createCode([
+      ops.traverse,
+      [ops.scope, "x/"],
+      [ops.literal, "y.js"],
     ]);
+    const optimized = optimize(code);
+    assertCodeEqual(optimized, [ops.external, "x/y.js", code, {}]);
   });
 });

package/test/compiler/parse.test.js

@@ -3,7 +3,7 @@ import { describe, test } from "node:test";
 import { parse } from "../../src/compiler/parse.js";
 import { undetermined } from "../../src/compiler/parserHelpers.js";
 import * as ops from "../../src/runtime/ops.js";
-import { stripCodeLocations } from "./stripCodeLocations.js";
+import { assertCodeEqual } from "./codeHelpers.js";
 
 describe("Origami parser", () => {
   test("additiveExpression", () => {
@@ -247,20 +247,20 @@ describe("Origami parser", () => {
     assertParse("conditionalExpression", "true ? 1 : 0", [
       ops.conditional,
       [ops.scope, "true"],
-      [ops.lambda, [], [ops.literal, "1"]],
-      [ops.lambda, [], [ops.literal, "0"]],
+      [ops.literal, "1"],
+      [ops.literal, "0"],
     ]);
     assertParse("conditionalExpression", "false ? () => 1 : 0", [
       ops.conditional,
       [ops.scope, "false"],
       [ops.lambda, [], [ops.lambda, [], [ops.literal, "1"]]],
-      [ops.lambda, [], [ops.literal, "0"]],
+      [ops.literal, "0"],
     ]);
     assertParse("conditionalExpression", "false ? =1 : 0", [
       ops.conditional,
       [ops.scope, "false"],
       [ops.lambda, [], [ops.lambda, ["_"], [ops.literal, "1"]]],
-      [ops.lambda, [], [ops.literal, "0"]],
+      [ops.literal, "0"],
     ]);
   });
 
@@ -701,6 +701,11 @@ describe("Origami parser", () => {
       [ops.object, ["a", [ops.literal, 1]]],
       [ops.scope, "b"],
     ]);
+    assertParse("objectLiteral", "{ a: 1, ...{ b: 2 } }", [
+      ops.object,
+      ["a", [ops.literal, 1]],
+      ["b", [ops.literal, 2]],
+    ]);
     assertParse("objectLiteral", "{ (a): 1 }", [
       ops.object,
       ["(a)", [ops.literal, 1]],
@@ -868,6 +873,12 @@ describe("Origami parser", () => {
       [ops.literal, "localhost:5000/"],
       [ops.literal, "foo"],
     ]);
+    assertParse("protocolExpression", "files:///foo/bar.txt", [
+      [ops.builtin, "files:"],
+      [ops.literal, "/"],
+      [ops.literal, "foo/"],
+      [ops.literal, "bar.txt"],
+    ]);
   });
 
   test("qualifiedReference", () => {
@@ -1071,7 +1082,7 @@ function assertParse(startRule, source, expected, checkLocation = true) {
   // entire source. We skip this check in cases where the source starts or ends
   // with a comment; the parser will strip those.
   if (checkLocation) {
-    assert(code.location, "no location");
+    assertCodeLocations(code);
     const resultSource = code.location.source.text.slice(
       code.location.start.offset,
       code.location.end.offset
@@ -1079,6 +1090,14 @@ function assertParse(startRule, source, expected, checkLocation = true) {
     assert.equal(resultSource, source.trim());
   }
 
-  const actual = stripCodeLocations(code);
-  assert.deepEqual(actual, expected);
+  assertCodeEqual(code, expected);
+}
+
+function assertCodeLocations(code) {
+  assert(code.location, "no location");
+  for (const item of code) {
+    if (Array.isArray(item)) {
+      assertCodeLocations(item);
+    }
+  }
 }

package/test/runtime/OrigamiFiles.test.js

@@ -13,11 +13,9 @@ describe("OrigamiFiles", () => {
     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."

package/test/runtime/evaluate.test.js

@@ -4,6 +4,7 @@ import { describe, test } from "node:test";
 import * as ops from "../../src/runtime/ops.js";
 
 import evaluate from "../../src/runtime/evaluate.js";
+import { createCode } from "../compiler/codeHelpers.js";
 
 describe("evaluate", () => {
   test("can retrieve values from scope", async () => {
@@ -70,16 +71,3 @@ describe("evaluate", () => {
     assert.equal(result.parent, tree);
   });
 });
-
-/**
- * @returns {import("../../index.ts").Code}
- */
-function createCode(array) {
-  const code = array;
-  /** @type {any} */ (code).location = {
-    source: {
-      text: "",
-    },
-  };
-  return code;
-}

package/test/runtime/mergeTrees.test.js

@@ -58,7 +58,6 @@ describe("mergeTrees", () => {
         c: 4,
       }
     );
-    // @ts-ignore
     assert.deepEqual(await Tree.plain(tree), {
       a: 1,
       b: 3,

package/test/runtime/ops.test.js

@@ -3,6 +3,7 @@ import assert from "node:assert";
 import { describe, test } from "node:test";
 
 import { evaluate, ops } from "../../src/runtime/internal.js";
+import { createCode } from "../compiler/codeHelpers.js";
 
 describe("ops", () => {
   test("ops.addition adds two numbers", async () => {
@@ -220,6 +221,45 @@ describe("ops", () => {
     assert.strictEqual(await ops.logicalOr(true, errorFn), true);
   });
 
+  test("ops.merge", async () => {
+    // {
+    //   a: 1
+    //   …fn(a)
+    // }
+    const scope = new ObjectTree({
+      fn: (a) => ({ b: 2 * a }),
+    });
+    const code = createCode([
+      ops.merge,
+      [ops.object, ["a", [ops.literal, 1]]],
+      [
+        [ops.builtin, "fn"],
+        [ops.scope, "a"],
+      ],
+    ]);
+    const result = await evaluate.call(scope, code);
+    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 () => {
     assert.strictEqual(ops.multiplication(3, 4), 12);
     assert.strictEqual(ops.multiplication(-3, 4), -12);
@@ -339,19 +379,6 @@ describe("ops", () => {
   });
 });
 
-/**
- * @returns {import("../../index.ts").Code}
- */
-function createCode(array) {
-  const code = array;
-  /** @type {any} */ (code).location = {
-    source: {
-      text: "",
-    },
-  };
-  return code;
-}
-
 function errorFn() {
   throw new Error("This should not be called");
 }

package/test/runtime/typos.test.js

@@ -12,6 +12,7 @@ describe("typos", () => {
     assert(isTypo("cat", "cta")); // transposition
     assert(isTypo("cat", "act")); // transposition
     assert(!isTypo("cat", "dog")); // more than 1 edit
+    assert(!isTypo("a", "b")); // single character
   });
 
   test("typos", () => {