@weborigami/language 0.0.73 → 0.2.0

package/src/runtime/ops.js

@@ -1,30 +1,25 @@
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
  * @typedef {import("@weborigami/async-tree").PlainObject} PlainObject
+ * @typedef {import("@weborigami/async-tree").Treelike} Treelike
  */
 
 import {
-  ExplorableSiteTree,
   ObjectTree,
-  SiteTree,
   Tree,
   isUnpackable,
-  pathFromKeys,
   scope as scopeFn,
-  trailingSlash,
   concat as treeConcat,
 } from "@weborigami/async-tree";
+import os from "node:os";
+import { builtinReferenceError, scopeReferenceError } from "./errors.js";
 import expressionObject from "./expressionObject.js";
-import { handleExtension } from "./extensions.js";
-import HandleExtensionsTransform from "./HandleExtensionsTransform.js";
 import { evaluate } from "./internal.js";
 import mergeTrees from "./mergeTrees.js";
 import OrigamiFiles from "./OrigamiFiles.js";
+import { codeSymbol } from "./symbols.js";
 import taggedTemplate from "./taggedTemplate.js";
 
-// For memoizing lambda functions
-const lambdaFnMap = new Map();
-
 function addOpLabel(op, label) {
   Object.defineProperty(op, "toString", {
     value: () => label,
@@ -44,21 +39,22 @@ export async function array(...items) {
 addOpLabel(array, "«ops.array»");
 
 /**
- * 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.
+ * Like ops.scope, but only searches for a builtin at the top of the scope
+ * chain.
  *
  * @this {AsyncTree|null}
  */
-export async function cache(key, cache) {
-  if (key in cache) {
-    return cache[key];
+export async function builtin(key) {
+  if (!this) {
+    throw new Error("Tried to get the scope of a null or undefined tree.");
   }
-  // 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;
+
+  const builtins = Tree.root(this);
+  const value = await builtins.get(key);
+  if (value === undefined) {
+    throw await builtinReferenceError(this, builtins, key);
+  }
+
   return value;
 }
 
@@ -73,104 +69,31 @@ export async function concat(...args) {
 }
 addOpLabel(concat, "«ops.concat»");
 
-/**
- * Find the indicated constructor in scope, then return a function which invokes
- * it with `new`.
- *
- * @this {AsyncTree}
- * @param  {...any} keys
- */
-export async function constructor(...keys) {
-  const tree = this;
-  const scope = scopeFn(tree);
-  let constructor = await Tree.traverseOrThrow(scope, ...keys);
-  if (isUnpackable(constructor)) {
-    constructor = await constructor.unpack();
-  }
-  // Origami may pass `undefined` as the first argument to the constructor. We
-  // don't pass that along, because constructors like `Date` don't like it.
-  return (...args) =>
-    args.length === 1 && args[0] === undefined
-      ? new constructor()
-      : new constructor(...args);
-}
-addOpLabel(constructor, "«ops.constructor»");
-
-/**
- * Given a protocol, a host, and a list of keys, construct an href.
- *
- * @param {string} protocol
- * @param {string} host
- * @param  {string[]} keys
- */
-function constructHref(protocol, host, ...keys) {
-  const path = pathFromKeys(keys);
-  let href = [host, path].join("/");
-  if (!href.startsWith(protocol)) {
-    if (!href.startsWith("//")) {
-      href = `//${href}`;
-    }
-    href = `${protocol}${href}`;
-  }
-  return href;
-}
-
-/**
- * Given a protocol, a host, and a list of keys, construct an href.
- *
- * @param {string} protocol
- * @param {import("../../index.ts").Constructor<AsyncTree>} treeClass
- * @param {AsyncTree|null} parent
- * @param {string} host
- * @param  {string[]} keys
- */
-async function constructSiteTree(protocol, treeClass, parent, host, ...keys) {
-  // If the last key doesn't end in a slash, remove it for now.
-  let lastKey;
-  if (keys.length > 0 && keys.at(-1) && !trailingSlash.has(keys.at(-1))) {
-    lastKey = keys.pop();
-  }
-
-  const href = constructHref(protocol, host, ...keys);
-  let result = new (HandleExtensionsTransform(treeClass))(href);
-  result.parent = parent;
-
-  return lastKey ? result.get(lastKey) : result;
+export async function conditional(condition, truthy, falsy) {
+  return condition ? truthy() : falsy();
 }
 
-/**
- * A site tree with JSON Keys via HTTPS.
- *
- * @this {AsyncTree|null}
- * @param {string} host
- * @param  {...string} keys
- */
-export function explorableSite(host, ...keys) {
-  return constructSiteTree("https:", ExplorableSiteTree, this, host, ...keys);
+export async function equal(a, b) {
+  return a == b;
 }
-addOpLabel(explorableSite, "«ops.explorableSite»");
 
 /**
- * Fetch the resource at the given href.
+ * Look up the given key as an external reference and cache the value for future
+ * requests.
  *
  * @this {AsyncTree|null}
- * @param {string} href
  */
-async function fetchResponse(href) {
-  const response = await fetch(href);
-  if (!response.ok) {
-    return undefined;
-  }
-  let buffer = await response.arrayBuffer();
-
-  // Attach any loader defined for the file type.
-  const url = new URL(href);
-  const filename = url.pathname.split("/").pop();
-  if (this && filename) {
-    buffer = await handleExtension(this, buffer, filename);
+export async function external(key, cache) {
+  if (key in cache) {
+    return cache[key];
   }
-
-  return buffer;
+  // 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;
 }
 
 /**
@@ -180,47 +103,16 @@ async function fetchResponse(href) {
 export const getter = new String("«ops.getter»");
 
 /**
- * Construct a files tree for the filesystem root.
+ * Files tree for the user's home directory.
  *
  * @this {AsyncTree|null}
  */
-export async function filesRoot() {
-  let root = new OrigamiFiles("/");
-
-  // The root itself needs a parent so that expressions evaluated within it
-  // (e.g., Origami expressions loaded from .ori files) will have access to
-  // things like the built-in functions.
-  root.parent = this;
-
-  return root;
+export async function homeDirectory() {
+  const tree = new OrigamiFiles(os.homedir());
+  tree.parent = this ? Tree.root(this) : null;
+  return tree;
 }
 
-/**
- * Retrieve a web resource via HTTP.
- *
- * @this {AsyncTree|null}
- * @param {string} host
- * @param  {...string} keys
- */
-export async function http(host, ...keys) {
-  const href = constructHref("http:", host, ...keys);
-  return fetchResponse.call(this, href);
-}
-addOpLabel(http, "«ops.http»");
-
-/**
- * Retrieve a web resource via HTTPS.
- *
- * @this {AsyncTree|null}
- * @param {string} host
- * @param  {...string} keys
- */
-export function https(host, ...keys) {
-  const href = constructHref("https:", host, ...keys);
-  return fetchResponse.call(this, href);
-}
-addOpLabel(https, "«ops.https»");
-
 /**
  * Search the parent's scope -- i.e., exclude the current tree -- for the given
  * key.
@@ -245,29 +137,37 @@ addOpLabel(inherited, "«ops.inherited»");
  * @param {string[]} parameters
  * @param {Code} code
  */
-
 export function lambda(parameters, code) {
-  if (lambdaFnMap.has(code)) {
-    return lambdaFnMap.get(code);
-  }
+  const context = this;
 
-  /** @this {AsyncTree|null} */
+  /** @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;
     }
-    const ambientTree = new ObjectTree(ambients);
-    ambientTree.parent = this;
 
-    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;
@@ -286,7 +186,6 @@ export function lambda(parameters, code) {
   });
 
   invoke.code = code;
-  lambdaFnMap.set(code, invoke);
   return invoke;
 }
 addOpLabel(lambda, "«ops.lambda");
@@ -299,6 +198,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.
  *
@@ -323,6 +269,47 @@ export async function object(...entries) {
 }
 addOpLabel(object, "«ops.object»");
 
+export async function notEqual(a, b) {
+  return a != b;
+}
+
+export async function notStrictEqual(a, b) {
+  return a !== b;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
 /**
  * Look up the given key in the scope for the current tree.
  *
@@ -333,7 +320,11 @@ export async function scope(key) {
     throw new Error("Tried to get the scope of a null or undefined tree.");
   }
   const scope = scopeFn(this);
-  return scope.get(key);
+  const value = await scope.get(key);
+  if (value === undefined && key !== "undefined") {
+    throw await scopeReferenceError(scope, key);
+  }
+  return value;
 }
 addOpLabel(scope, "«ops.scope»");
 
@@ -343,11 +334,15 @@ addOpLabel(scope, "«ops.scope»");
  */
 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 async function strictEqual(a, b) {
+  return a === b;
+}
+
 /**
  * Apply the default tagged template function.
  */
@@ -361,30 +356,6 @@ addOpLabel(template, "«ops.template»");
  */
 export const traverse = Tree.traverseOrThrow;
 
-/**
- * A website tree via HTTP.
- *
- * @this {AsyncTree|null}
- * @param {string} host
- * @param  {...string} keys
- */
-export function treeHttp(host, ...keys) {
-  return constructSiteTree("http:", SiteTree, this, host, ...keys);
-}
-addOpLabel(treeHttp, "«ops.treeHttp»");
-
-/**
- * A website tree via HTTPS.
- *
- * @this {AsyncTree|null}
- * @param {string} host
- * @param  {...string} keys
- */
-export function treeHttps(host, ...keys) {
-  return constructSiteTree("https:", SiteTree, this, host, ...keys);
-}
-addOpLabel(treeHttps, "«ops.treeHttps»");
-
 /**
  * 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/src/runtime/typos.js

@@ -0,0 +1,71 @@
+/**
+ * Returns true if the two strings have a Damerau-Levenshtein distance of 1.
+ * This will be true if the strings differ by a single insertion, deletion,
+ * substitution, or transposition.
+ *
+ * @param {string} s1
+ * @param {string} s2
+ */
+export function isTypo(s1, s2) {
+  const length1 = s1.length;
+  const length2 = s2.length;
+
+  // If the strings are identical, distance is 0
+  if (s1 === s2) {
+    return false;
+  }
+
+  // If length difference is more than 1, distance can't be 1
+  if (Math.abs(length1 - length2) > 1) {
+    return false;
+  }
+
+  if (length1 === length2) {
+    // Check for one substitution
+    let differences = 0;
+    for (let i = 0; i < length1; i++) {
+      if (s1[i] !== s2[i]) {
+        differences++;
+        if (differences > 1) {
+          break;
+        }
+      }
+    }
+    if (differences === 1) {
+      return true;
+    }
+
+    // Check for one transposition
+    for (let i = 0; i < length1 - 1; i++) {
+      if (s1[i] !== s2[i]) {
+        // Check if swapping s1[i] and s1[i+1] matches s2
+        if (s1[i] === s2[i + 1] && s1[i + 1] === s2[i]) {
+          return s1.slice(i + 2) === s2.slice(i + 2);
+        } else {
+          return false;
+        }
+      }
+    }
+  }
+
+  // Check for one insertion/deletion
+  const longer = length1 > length2 ? s1 : s2;
+  const shorter = length1 > length2 ? s2 : s1;
+  for (let i = 0; i < shorter.length; i++) {
+    if (shorter[i] !== longer[i]) {
+      // If we skip this character, do the rest match?
+      return shorter.slice(i) === longer.slice(i + 1);
+    }
+  }
+  return shorter === longer.slice(0, shorter.length);
+}
+
+/**
+ * Return any strings that could be a typo of s
+ *
+ * @param {string} s
+ * @param {string[]} strings
+ */
+export function typos(s, strings) {
+  return strings.filter((str) => isTypo(s, str));
+}

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"