@weborigami/language 0.0.73 → 0.1.0

package/src/compiler/parserHelpers.js

@@ -1,4 +1,5 @@
 import { trailingSlash } from "@weborigami/async-tree";
+import codeFragment from "../runtime/codeFragment.js";
 import * as ops from "../runtime/ops.js";
 
 // Parser helpers
@@ -8,15 +9,21 @@ import * as ops from "../runtime/ops.js";
  * location of the source code that produced it for debugging and error messages.
  */
 export function annotate(parseResult, location) {
-  if (typeof parseResult === "object" && parseResult !== null) {
+  if (typeof parseResult === "object" && parseResult !== null && location) {
     parseResult.location = location;
+    parseResult.source = codeFragment(location);
   }
   return parseResult;
 }
 
-// The indicated code is being used to define a property named by the given key.
-// Rewrite any [ops.scope, key] calls to be [ops.inherited, key] to avoid
-// infinite recursion.
+/**
+ * The indicated code is being used to define a property named by the given key.
+ * Rewrite any [ops.scope, key] calls to be [ops.inherited, key] to avoid
+ * infinite recursion.
+ *
+ * @param {import("../../index.ts").Code} code
+ * @param {string} key
+ */
 function avoidRecursivePropertyCalls(code, key) {
   if (!(code instanceof Array)) {
     return code;
@@ -35,8 +42,7 @@ function avoidRecursivePropertyCalls(code, key) {
     // Process any nested code
     modified = code.map((value) => avoidRecursivePropertyCalls(value, key));
   }
-  // @ts-ignore
-  modified.location = code.location;
+  annotate(modified, code.location);
   return modified;
 }
 
@@ -133,7 +139,7 @@ export function makeFunctionCall(target, chain, location) {
       }
     }
 
-    fnCall.location = { start, source, end };
+    annotate(fnCall, { start, source, end });
 
     value = fnCall;
   }

package/src/runtime/HandleExtensionsTransform.js

@@ -1,4 +1,4 @@
-import { handleExtension } from "./extensions.js";
+import { handleExtension } from "./handlers.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree

package/src/runtime/ImportModulesMixin.js

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import { maybeOrigamiSourceCode } from "./formatError.js";
+import { maybeOrigamiSourceCode } from "./errors.js";
 
 /**
  * @typedef {import("@weborigami/types").AsyncTree} AsyncTree

package/src/runtime/codeFragment.js

@@ -7,8 +7,8 @@ export default function codeFragment(location) {
       : // Use entire source
         source.text;
 
-  // Remove newlines and whitespace runs.
-  fragment = fragment.replace(/(\n|\s\s+)+/g, "");
+  // Replace newlines and whitespace runs with a single space.
+  fragment = fragment.replace(/(\n|\s\s+)+/g, " ");
 
   // If longer than 80 characters, truncate with an ellipsis.
   if (fragment.length > 80) {

package/src/runtime/errors.js

@@ -0,0 +1,104 @@
+// Text we look for in an error stack to guess whether a given line represents a
+
+import { scope as scopeFn, trailingSlash } from "@weborigami/async-tree";
+import codeFragment from "./codeFragment.js";
+import { typos } from "./typos.js";
+
+// function in the Origami source code.
+const origamiSourceSignals = [
+  "async-tree/src/",
+  "language/src/",
+  "origami/src/",
+  "at Scope.evaluate",
+];
+
+export async function builtinReferenceError(tree, builtins, key) {
+  const messages = [
+    `"${key}" is being called as if it were a builtin function, but it's not.`,
+  ];
+  // See if the key is in scope (but not as a builtin)
+  const scope = scopeFn(tree);
+  const value = await scope.get(key);
+  if (value === undefined) {
+    const typos = await formatScopeTypos(builtins, key);
+    messages.push(typos);
+  } else {
+    messages.push(`Use "${key}/" instead.`);
+  }
+  const message = messages.join(" ");
+  return new ReferenceError(message);
+}
+
+/**
+ * Format an error for display in the console.
+ *
+ * @param {Error} error
+ */
+export function formatError(error) {
+  let message;
+  if (error.stack) {
+    // Display the stack only until we reach the Origami source code.
+    message = "";
+    let lines = error.stack.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (maybeOrigamiSourceCode(line)) {
+        break;
+      }
+      if (message) {
+        message += "\n";
+      }
+      message += lines[i];
+    }
+  } else {
+    message = error.toString();
+  }
+
+  // Add location
+  let location = /** @type {any} */ (error).location;
+  if (location) {
+    const fragment = codeFragment(location);
+    let { source, start } = location;
+
+    message += `\nevaluating: ${fragment}`;
+    if (typeof source === "object" && source.url) {
+      message += `\n    at ${source.url.href}:${start.line}:${start.column}`;
+    } else if (source.text.includes("\n")) {
+      message += `\n    at line ${start.line}, column ${start.column}`;
+    }
+  }
+  return message;
+}
+
+export async function formatScopeTypos(scope, key) {
+  const keys = await scopeTypos(scope, key);
+  // Don't match deprecated keys
+  const filtered = keys.filter((key) => !key.startsWith("@"));
+  if (filtered.length === 0) {
+    return "";
+  }
+  const quoted = filtered.map((key) => `"${key}"`);
+  const list = quoted.join(", ");
+  return `Maybe you meant ${list}?`;
+}
+
+export function maybeOrigamiSourceCode(text) {
+  return origamiSourceSignals.some((signal) => text.includes(signal));
+}
+
+export async function scopeReferenceError(scope, key) {
+  const messages = [
+    `"${key}" is not in scope.`,
+    await formatScopeTypos(scope, key),
+  ];
+  const message = messages.join(" ");
+  return new ReferenceError(message);
+}
+
+// Return all possible typos for `key` in scope
+async function scopeTypos(scope, key) {
+  const scopeKeys = [...(await scope.keys())];
+  const normalizedScopeKeys = scopeKeys.map((key) => trailingSlash.remove(key));
+  const normalizedKey = trailingSlash.remove(key);
+  return typos(normalizedKey, normalizedScopeKeys);
+}

package/src/runtime/evaluate.js

@@ -68,10 +68,10 @@ export default async function evaluate(code) {
     if (!error.location) {
       // Attach the location of the code we tried to evaluate.
       error.location =
-        error.position !== undefined
+        error.position !== undefined && code[error.position + 1]?.location
           ? // Use location of the argument with the given position (need to
             // offset by 1 to skip the function).
-            code[error.position + 1].location
+            code[error.position + 1]?.location
           : // Use overall location.
             code.location;
     }
@@ -85,7 +85,7 @@ export default async function evaluate(code) {
   }
 
   // To aid debugging, add the code to the result.
-  if (Object.isExtensible(result) /* && !isPlainObject(result) */) {
+  if (Object.isExtensible(result)) {
     try {
       if (code.location && !result[sourceSymbol]) {
         Object.defineProperty(result, sourceSymbol, {

package/src/runtime/expressionObject.js

@@ -1,5 +1,5 @@
-import { ObjectTree, symbols } from "@weborigami/async-tree";
-import { extname, handleExtension } from "./extensions.js";
+import { extension, ObjectTree, symbols, Tree } from "@weborigami/async-tree";
+import { handleExtension } from "./handlers.js";
 import { evaluate, ops } from "./internal.js";
 
 /**
@@ -22,6 +22,9 @@ import { evaluate, ops } from "./internal.js";
 export default async function expressionObject(entries, parent) {
   // Create the object and set its parent
   const object = {};
+  if (parent !== null && !Tree.isAsyncTree(parent)) {
+    throw new TypeError(`Parent must be an AsyncTree or null`);
+  }
   Object.defineProperty(object, symbols.parent, {
     configurable: true,
     enumerable: false,
@@ -37,8 +40,8 @@ export default async function expressionObject(entries, parent) {
     // array), we need to define a getter -- but if that code takes the form
     // [ops.getter, <primitive>], we can define a regular property.
     let defineProperty;
-    const extension = extname(key);
-    if (extension) {
+    const extname = extension.extname(key);
+    if (extname) {
       defineProperty = false;
     } else if (!(value instanceof Array)) {
       defineProperty = true;
@@ -76,7 +79,7 @@ export default async function expressionObject(entries, parent) {
       }
 
       let get;
-      if (extension) {
+      if (extname) {
         // Key has extension, getter will invoke code then attach unpack method
         get = async () => {
           tree ??= new ObjectTree(object);

package/src/runtime/{extensions.js → handlers.js}

@@ -1,5 +1,6 @@
 import {
   box,
+  extension,
   isPacked,
   isStringLike,
   isUnpackable,
@@ -13,27 +14,6 @@ import {
 // Track extensions handlers for a given containing tree.
 const handlersForContainer = new Map();
 
-/**
- * If the given path ends in an extension, return it. Otherwise, return the
- * empty string.
- *
- * This is meant as a basic replacement for the standard Node `path.extname`.
- * That standard function inaccurately returns an extension for a path that
- * includes a near-final extension but ends in a final slash, like `foo.txt/`.
- * Node thinks that path has a ".txt" extension, but for our purposes it
- * doesn't.
- *
- * @param {string} path
- */
-export function extname(path) {
-  // We want at least one character before the dot, then a dot, then a non-empty
-  // sequence of characters after the dot that aren't slahes or dots.
-  const extnameRegex = /[^/](?<ext>\.[^/\.]+)$/;
-  const match = String(path).match(extnameRegex);
-  const extension = match?.groups?.ext.toLowerCase() ?? "";
-  return extension;
-}
-
 /**
  * Find an extension handler for a file in the given container.
  *
@@ -95,9 +75,11 @@ export async function handleExtension(parent, value, key) {
     }
 
     // Special case: `.ori.<ext>` extensions are Origami documents.
-    const extension = key.match(/\.ori\.\S+$/) ? ".oridocument" : extname(key);
-    if (extension) {
-      const handler = await getExtensionHandler(parent, extension);
+    const extname = key.match(/\.ori\.\S+$/)
+      ? ".oridocument"
+      : extension.extname(key);
+    if (extname) {
+      const handler = await getExtensionHandler(parent, extname);
       if (handler) {
         if (hasSlash && handler.unpack) {
           // Key like `data.json/` ends in slash -- unpack immediately

package/src/runtime/internal.js

@@ -6,6 +6,7 @@
 //
 // About this pattern: https://medium.com/visual-development/how-to-fix-nasty-circular-dependency-issues-once-and-for-all-in-javascript-typescript-a04c987cf0de
 //
+// Note: to avoid having VS Code auto-sort the imports, keep lines between them.
 
 export * as ops from "./ops.js";
 

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,
@@ -43,6 +38,29 @@ export async function array(...items) {
 }
 addOpLabel(array, "«ops.array»");
 
+/**
+ * Like ops.scope, but only searches for a builtin at the top of the scope
+ * chain.
+ *
+ * @this {AsyncTree|null}
+ */
+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);
+  if (value === undefined) {
+    throw await builtinReferenceError(this, current, 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.
@@ -73,106 +91,6 @@ 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;
-}
-
-/**
- * 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);
-}
-addOpLabel(explorableSite, "«ops.explorableSite»");
-
-/**
- * Fetch the resource at the given href.
- *
- * @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);
-  }
-
-  return buffer;
-}
-
 /**
  * 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.
@@ -180,46 +98,26 @@ async function fetchResponse(href) {
 export const getter = new String("«ops.getter»");
 
 /**
- * Construct a files tree for the filesystem root.
+ * Files tree for the filesystem root.
  *
  * @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;
+  let tree = new OrigamiFiles("/");
+  tree.parent = root(this);
+  return tree;
 }
 
 /**
- * Retrieve a web resource via HTTP.
+ * Files tree for the user's home directory.
  *
  * @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);
+export async function homeTree() {
+  const tree = new OrigamiFiles(os.homedir());
+  tree.parent = root(this);
+  return tree;
 }
-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
@@ -247,19 +145,21 @@ addOpLabel(inherited, "«ops.inherited»");
  */
 
 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();
     }
+    Object.defineProperty(ambients, codeSymbol, {
+      value: code,
+      enumerable: false,
+    });
     const ambientTree = new ObjectTree(ambients);
-    ambientTree.parent = this;
+    ambientTree.parent = context;
 
     let result = await evaluate.call(ambientTree, code);
 
@@ -286,7 +186,6 @@ export function lambda(parameters, code) {
   });
 
   invoke.code = code;
-  lambdaFnMap.set(code, invoke);
   return invoke;
 }
 addOpLabel(lambda, "«ops.lambda");
@@ -323,6 +222,16 @@ 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;
+}
+
 /**
  * Look up the given key in the scope for the current tree.
  *
@@ -333,7 +242,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) {
+    throw await scopeReferenceError(scope, key);
+  }
+  return value;
 }
 addOpLabel(scope, "«ops.scope»");
 
@@ -361,30 +274,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));
+}