@weborigami/language 0.1.0 → 0.2.1

package/src/runtime/ops.js

@@ -27,6 +27,31 @@ function addOpLabel(op, label) {
   });
 }
 
+export function addition(a, b) {
+  return a + b;
+}
+addOpLabel(addition, "«ops.addition»");
+
+export function bitwiseAnd(a, b) {
+  return a & b;
+}
+addOpLabel(bitwiseAnd, "«ops.bitwiseAnd»");
+
+export function bitwiseNot(a) {
+  return ~a;
+}
+addOpLabel(bitwiseNot, "«ops.bitwiseNot»");
+
+export function bitwiseOr(a, b) {
+  return a | b;
+}
+addOpLabel(bitwiseOr, "«ops.bitwiseOr»");
+
+export function bitwiseXor(a, b) {
+  return a ^ b;
+}
+addOpLabel(bitwiseXor, "«ops.bitwiseXor»");
+
 /**
  * Construct an array.
  *
@@ -48,37 +73,26 @@ export async function builtin(key) {
   if (!this) {
     throw new Error("Tried to get the scope of a null or undefined tree.");
   }
-  let current = this;
-  while (current.parent) {
-    current = current.parent;
-  }
 
-  const value = await current.get(key);
+  const builtins = Tree.root(this);
+  const value = await builtins.get(key);
   if (value === undefined) {
-    throw await builtinReferenceError(this, current, key);
+    throw await builtinReferenceError(this, builtins, key);
   }
 
   return value;
 }
 
 /**
- * Look up the given key in the scope for the current tree the first time
- * the key is requested, holding on to the value for future requests.
+ * JavaScript comma operator, returns the last argument.
  *
- * @this {AsyncTree|null}
+ * @param  {...any} args
+ * @returns
  */
-export async function cache(key, cache) {
-  if (key in cache) {
-    return cache[key];
-  }
-  // First save a promise for the value
-  const promise = scope.call(this, key);
-  cache[key] = promise;
-  const value = await promise;
-  // Now update with the actual value
-  cache[key] = value;
-  return value;
+export function comma(...args) {
+  return args.at(-1);
 }
+addOpLabel(comma, "«ops.comma»");
 
 /**
  * Concatenate the given arguments.
@@ -91,31 +105,68 @@ export async function concat(...args) {
 }
 addOpLabel(concat, "«ops.concat»");
 
+export async function conditional(condition, truthy, falsy) {
+  return condition ? truthy() : falsy();
+}
+
+export function division(a, b) {
+  return a / b;
+}
+addOpLabel(division, "«ops.division»");
+
+export function equal(a, b) {
+  return a == b;
+}
+addOpLabel(equal, "«ops.equal»");
+
+export function exponentiation(a, b) {
+  return a ** b;
+}
+addOpLabel(exponentiation, "«ops.exponentiation»");
+
+/**
+ * Look up the given key as an external reference and cache the value for future
+ * requests.
+ *
+ * @this {AsyncTree|null}
+ */
+export async function external(key, cache) {
+  if (key in cache) {
+    return cache[key];
+  }
+  // First save a promise for the value
+  const promise = scope.call(this, key);
+  cache[key] = promise;
+  const value = await promise;
+  // Now update with the actual value
+  cache[key] = value;
+  return value;
+}
+
 /**
  * This op is only used during parsing. It signals to ops.object that the
  * "arguments" of the expression should be used to define a property getter.
  */
 export const getter = new String("«ops.getter»");
 
-/**
- * Files tree for the filesystem root.
- *
- * @this {AsyncTree|null}
- */
-export async function filesRoot() {
-  let tree = new OrigamiFiles("/");
-  tree.parent = root(this);
-  return tree;
+export function greaterThan(a, b) {
+  return a > b;
 }
+addOpLabel(greaterThan, "«ops.greaterThan»");
+
+export function greaterThanOrEqual(a, b) {
+  return a >= b;
+}
+addOpLabel(greaterThanOrEqual, "«ops.greaterThanOrEqual»");
 
 /**
  * Files tree for the user's home directory.
  *
  * @this {AsyncTree|null}
  */
-export async function homeTree() {
+export async function homeDirectory() {
   const tree = new OrigamiFiles(os.homedir());
-  tree.parent = root(this);
+  tree.parent = this ? Tree.root(this) : null;
   return tree;
 }
 
@@ -143,31 +194,37 @@ addOpLabel(inherited, "«ops.inherited»");
  * @param {string[]} parameters
  * @param {Code} code
  */
-
 export function lambda(parameters, code) {
   const context = this;
 
   /** @this {Treelike|null} */
   async function invoke(...args) {
-    // Add arguments to scope.
-    const ambients = {};
-    for (const parameter of parameters) {
-      ambients[parameter] = args.shift();
+    let target;
+    if (parameters.length === 0) {
+      // No parameters
+      target = context;
+    } else {
+      // Add arguments to scope.
+      const ambients = {};
+      for (const parameter of parameters) {
+        ambients[parameter] = args.shift();
+      }
+      Object.defineProperty(ambients, codeSymbol, {
+        value: code,
+        enumerable: false,
+      });
+      const ambientTree = new ObjectTree(ambients);
+      ambientTree.parent = context;
+      target = ambientTree;
     }
-    Object.defineProperty(ambients, codeSymbol, {
-      value: code,
-      enumerable: false,
-    });
-    const ambientTree = new ObjectTree(ambients);
-    ambientTree.parent = context;
 
-    let result = await evaluate.call(ambientTree, code);
+    let result = await evaluate.call(target, code);
 
     // Bind a function result to the ambients so that it has access to the
     // parameter values -- i.e., like a closure.
     if (result instanceof Function) {
       const resultCode = result.code;
-      result = result.bind(ambientTree);
+      result = result.bind(target);
       if (code) {
         // Copy over Origami code
         result.code = resultCode;
@@ -190,6 +247,16 @@ export function lambda(parameters, code) {
 }
 addOpLabel(lambda, "«ops.lambda");
 
+export function lessThan(a, b) {
+  return a < b;
+}
+addOpLabel(lessThan, "«ops.lessThan»");
+
+export function lessThanOrEqual(a, b) {
+  return a <= b;
+}
+addOpLabel(lessThanOrEqual, "«ops.lessThanOrEqual»");
+
 /**
  * Return a primitive value
  */
@@ -198,6 +265,53 @@ export async function literal(value) {
 }
 addOpLabel(literal, "«ops.literal»");
 
+/**
+ * Logical AND operator
+ */
+export async function logicalAnd(head, ...tail) {
+  if (!head) {
+    return head;
+  }
+  // Evaluate the tail arguments in order, short-circuiting if any are falsy.
+  let lastValue;
+  for (const arg of tail) {
+    lastValue = arg instanceof Function ? await arg() : arg;
+    if (!lastValue) {
+      return lastValue;
+    }
+  }
+
+  // Return the last value (not `true`)
+  return lastValue;
+}
+
+/**
+ * Logical NOT operator
+ */
+export async function logicalNot(value) {
+  return !value;
+}
+
+/**
+ * Logical OR operator
+ */
+export async function logicalOr(head, ...tail) {
+  if (head) {
+    return head;
+  }
+
+  // Evaluate the tail arguments in order, short-circuiting if any are truthy.
+  let lastValue;
+  for (const arg of tail) {
+    lastValue = arg instanceof Function ? await arg() : arg;
+    if (lastValue) {
+      return lastValue;
+    }
+  }
+
+  return lastValue;
+}
+
 /**
  * Merge the given trees. If they are all plain objects, return a plain object.
  *
@@ -209,6 +323,40 @@ export async function merge(...trees) {
 }
 addOpLabel(merge, "«ops.merge»");
 
+export function multiplication(a, b) {
+  return a * b;
+}
+addOpLabel(multiplication, "«ops.multiplication»");
+
+export function notEqual(a, b) {
+  return a != b;
+}
+addOpLabel(notEqual, "«ops.notEqual»");
+
+export function notStrictEqual(a, b) {
+  return a !== b;
+}
+addOpLabel(notStrictEqual, "«ops.notStrictEqual»");
+
+/**
+ * Nullish coalescing operator
+ */
+export async function nullishCoalescing(head, ...tail) {
+  if (head != null) {
+    return head;
+  }
+
+  let lastValue;
+  for (const arg of tail) {
+    lastValue = arg instanceof Function ? await arg() : arg;
+    if (lastValue != null) {
+      return lastValue;
+    }
+  }
+
+  return lastValue;
+}
+
 /**
  * Construct an object. The keys will be the same as the given `obj`
  * parameter's, and the values will be the results of evaluating the
@@ -222,14 +370,23 @@ export async function object(...entries) {
 }
 addOpLabel(object, "«ops.object»");
 
-// Return the root of the given tree. For an Origami tree, this gives us
-// a way of acessing the builtins.
-function root(tree) {
-  let current = tree;
-  while (current.parent) {
-    current = current.parent;
-  }
-  return current;
+export function remainder(a, b) {
+  return a % b;
+}
+addOpLabel(remainder, "«ops.remainder»");
+
+/**
+ * Files tree for the filesystem root.
+ *
+ * @this {AsyncTree|null}
+ */
+export async function rootDirectory(key) {
+  let tree = new OrigamiFiles("/");
+  // We set the builtins as the parent because logically the filesystem root is
+  // outside the project. This ignores the edge case where the project itself is
+  // the root of the filesystem and has a config file.
+  tree.parent = this ? Tree.root(this) : null;
+  return key ? tree.get(key) : tree;
 }
 
 /**
@@ -243,24 +400,49 @@ export async function scope(key) {
   }
   const scope = scopeFn(this);
   const value = await scope.get(key);
-  if (value === undefined) {
+  if (value === undefined && key !== "undefined") {
     throw await scopeReferenceError(scope, key);
   }
   return value;
 }
 addOpLabel(scope, "«ops.scope»");
 
+export function shiftLeft(a, b) {
+  return a << b;
+}
+addOpLabel(shiftLeft, "«ops.shiftLeft»");
+
+export function shiftRightSigned(a, b) {
+  return a >> b;
+}
+addOpLabel(shiftRightSigned, "«ops.shiftRightSigned»");
+
+export function shiftRightUnsigned(a, b) {
+  return a >>> b;
+}
+addOpLabel(shiftRightUnsigned, "«ops.shiftRightUnsigned»");
+
 /**
  * The spread operator is a placeholder during parsing. It should be replaced
  * with an object merge.
  */
 export function spread(...args) {
   throw new Error(
-    "A compile-time spread operator wasn't converted to an object merge."
+    "Internal error: a spread operation wasn't compiled correctly."
   );
 }
 addOpLabel(spread, "«ops.spread»");
 
+export function strictEqual(a, b) {
+  return a === b;
+}
+addOpLabel(strictEqual, "«ops.strictEqual»");
+
+export function subtraction(a, b) {
+  return a - b;
+}
+addOpLabel(subtraction, "«ops.subtraction»");
+
 /**
  * Apply the default tagged template function.
  */
@@ -274,6 +456,16 @@ addOpLabel(template, "«ops.template»");
  */
 export const traverse = Tree.traverseOrThrow;
 
+export function unaryMinus(a) {
+  return -a;
+}
+addOpLabel(unaryMinus, "«ops.unaryMinus»");
+
+export function unaryPlus(a) {
+  return +a;
+}
+addOpLabel(unaryPlus, "«ops.unaryPlus»");
+
 /**
  * If the value is packed but has an unpack method, call it and return that as
  * the result; otherwise, return the value as is.

package/test/cases/ReadMe.md

@@ -0,0 +1 @@
+This folder defines expression tests in YAML files so that we can programmatically test the evaluation of the expressions in both JavaScript and Origami.

package/test/cases/conditionalExpression.yaml

@@ -0,0 +1,101 @@
+# Conditional (ternary) expression tests
+
+- source: "true ? 42 : 0"
+  expected: 42
+  description: "Condition is true, evaluates and returns the first operand"
+
+- source: "false ? 42 : 0"
+  expected: 0
+  description: "Condition is false, evaluates and returns the second operand"
+
+- source: "1 ? 'yes' : 'no'"
+  expected: "yes"
+  description: "Truthy condition with string operands"
+
+- source: "0 ? 'yes' : 'no'"
+  expected: "no"
+  description: "Falsy condition with string operands"
+
+- source: "'non-empty' ? 1 : 2"
+  expected: 1
+  description: "Truthy string condition with numeric operands"
+
+- source: "'' ? 1 : 2"
+  expected: 2
+  description: "Falsy string condition with numeric operands"
+
+- source: "null ? 'a' : 'b'"
+  expected: "b"
+  description: "Falsy null condition"
+
+- source: "undefined ? 'a' : 'b'"
+  expected: "b"
+  description: "Falsy undefined condition"
+
+- source: "NaN ? 'a' : 'b'"
+  expected: "b"
+  description: "Falsy NaN condition"
+
+- source: "42 ? true : false"
+  expected: true
+  description: "Truthy numeric condition with boolean operands"
+
+- source: "0 ? true : false"
+  expected: false
+  description: "Falsy numeric condition with boolean operands"
+
+- source: "[] ? 'array' : 'no array'"
+  expected: "array"
+  description: "Truthy array condition"
+
+- source: "{} ? 'object' : 'no object'"
+  expected: "object"
+  description: "Truthy object condition"
+
+- source: "false ? null : undefined"
+  expected: __undefined__
+  description: "Condition is false, returns undefined"
+
+- source: "null ? null : null"
+  expected: __null__
+  description: "Condition is falsy, returns null"
+
+- source: "true ? NaN : 42"
+  expected: __NaN__
+  description: "Condition is true, evaluates and returns NaN"
+
+- source: "(true ? 1 : 2) ? 3 : 4"
+  expected: 3
+  description: "Nested ternary where first expression evaluates to 1, which is truthy"
+
+- source: "(false ? 1 : 2) ? 3 : 4"
+  expected: 3
+  description: "Nested ternary where first expression evaluates to 2, which is truthy"
+
+- source: "(false ? 1 : 0) ? 3 : 4"
+  expected: 4
+  description: "Nested ternary where first expression evaluates to 0, which is falsy"
+
+- source: "true ? (false ? 10 : 20) : 30"
+  expected: 20
+  description: "Nested ternary in the true branch of outer ternary"
+
+- source: "false ? (false ? 10 : 20) : 30"
+  expected: 30
+  description: "Nested ternary in the false branch of outer ternary"
+
+# - source: "'truthy' ? 1 + 2 : 3 + 4"
+#   expected: 3
+#   description: "Evaluates and returns the true branch with an arithmetic expression"
+
+# - source: "'' ? 1 + 2 : 3 + 4"
+#   expected: 7
+#   description: "Evaluates and returns the false branch with an arithmetic expression"
+
+- source: "undefined ? undefined : null"
+  expected: __null__
+  description: "Condition is falsy, returns null"
+
+- source: "null ? undefined : undefined"
+  expected: __undefined__
+  description: "Condition is falsy, returns undefined"

package/test/cases/logicalAndExpression.yaml

@@ -0,0 +1,146 @@
+# Logical AND expression tests
+
+- source: "true && true"
+  expected: true
+  description: "Both operands are true"
+
+- source: "true && false"
+  expected: false
+  description: "First operand is true, second is false"
+
+- source: "false && true"
+  expected: false
+  description: "First operand is false, second is true"
+
+- source: "false && false"
+  expected: false
+  description: "Both operands are false"
+
+- source: "false && (1 / 0)"
+  expected: false
+  description: "Short-circuit evaluation: first operand false, second not evaluated"
+
+- source: "true && 42"
+  expected: 42
+  description: "Short-circuit evaluation: first operand true, evaluates second"
+
+- source: "0 && true"
+  expected: 0
+  description: "Short-circuiting with falsy value (0)"
+
+- source: "true && 'string'"
+  expected: "string"
+  description: "Truthy value with string"
+
+- source: "false && 'string'"
+  expected: false
+  description: "Falsy value with string"
+
+- source: "1 && 0"
+  expected: 0
+  description: "Truthy numeric value with falsy numeric value"
+
+- source: "0 && 1"
+  expected: 0
+  description: "Falsy numeric value with truthy numeric value"
+
+- source: "'' && 'non-empty string'"
+  expected: ""
+  description: "Falsy string value with truthy string"
+
+- source: "'non-empty string' && ''"
+  expected: ""
+  description: "Truthy string with falsy string"
+
+- source: "{} && true"
+  expected: true
+  description: "Empty object as first operand"
+
+- source: "true && {}"
+  expected: {}
+  description: "Empty object as second operand"
+
+- source: "[] && true"
+  expected: true
+  description: "Array as first operand"
+
+- source: "true && []"
+  expected: []
+  description: "Array as second operand"
+
+- source: "null && true"
+  expected: null
+  description: "Null as first operand"
+
+- source: "true && null"
+  expected: null
+  description: "Null as second operand"
+
+- source: "undefined && true"
+  expected: __undefined__
+  description: "Undefined as first operand"
+
+- source: "true && undefined"
+  expected: __undefined__
+  description: "Undefined as second operand"
+
+- source: "NaN && true"
+  expected: __NaN__
+  description: "NaN as first operand"
+
+- source: "true && NaN"
+  expected: __NaN__
+  description: "NaN as second operand"
+
+- source: "(true && false) && true"
+  expected: false
+  description: "Nested logical ANDs with a false in the middle"
+
+- source: "(true && true) && true"
+  expected: true
+  description: "Nested logical ANDs with all true"
+
+- source: "true && (true && false)"
+  expected: false
+  description: "Nested logical ANDs with false in inner"
+
+- source: "(true && (false && true))"
+  expected: false
+  description: "Complex nesting with false at inner-most"
+
+# TODO: Uncomment when we can do math
+# - source: "true && (1 + 1 === 2)"
+#   expected: true
+#   description: "Combines logical AND with equality comparison"
+
+# - source: "false && (5 > 2)"
+#   expected: false
+#   description: "Logical AND with greater-than comparison"
+
+- source: "true && (3 || 0)"
+  expected: 3
+  description: "Logical AND with logical OR"
+
+- source: "true && (0 || 3)"
+  expected: 3
+  description: "Logical AND with logical OR and falsy values"
+
+- source: "'' && false"
+  expected: ""
+  description: "Falsy string and false"
+
+- source: "false && ''"
+  expected: false
+  description: "False and falsy string"
+
+- source: "undefined && null"
+  expected: __undefined__
+  description: "Undefined and null"
+
+- source: "null && undefined"
+  expected: null
+  description: "Null and undefined"
+
+- source: "(false && true) && undefined"
+  expected: false
+  description: "Short-circuiting nested AND with undefined"