@weborigami/language 0.3.3-jse.3 → 0.3.4-jse.4

package/src/compiler/parserHelpers.js

@@ -1,5 +1,5 @@
-import { trailingSlash } from "@weborigami/async-tree";
 import * as YAMLModule from "yaml";
+import trailingSlash from "../../../origami/src/origami/slash.js";
 import codeFragment from "../runtime/codeFragment.js";
 import * as ops from "../runtime/ops.js";
 
@@ -18,12 +18,12 @@ const YAML = YAMLModule.default ?? YAMLModule.YAML;
 // Markers in compiled output, will get optimized away
 export const markers = {
   global: Symbol("global"), // Global reference
-  traverse: Symbol("traverse"), // Continuation of path traversal
+  external: Symbol("external"), // External reference
+  property: Symbol("property"), // Property access
   reference: Symbol("reference"), // Reference to local, scope, or global
+  traverse: Symbol("traverse"), // Path traversal
 };
 
-const builtinRegex = /^[A-Za-z][A-Za-z0-9]*$/;
-
 /**
  * If a parse result is an object that will be evaluated at runtime, attach the
  * location of the source code that produced it for debugging and error messages.
@@ -54,69 +54,21 @@ export function applyMacro(code, name, macro) {
   }
 
   // We're looking for a function call with the given name.
-  // For `foo`, the call would be: [[reference, [ops.literal, "foo"]], undefined]
+  // For `foo`, the call would be: [[markers.traverse, [markers.reference,  "foo"]], undefined]
   if (
-    code[0] &&
-    code[0][0] === markers.reference &&
-    code[0][1] instanceof Array &&
-    code[0][1][0] === ops.literal &&
-    code[0][1][1] === name &&
-    code[1] === undefined
+    code[0] instanceof Array &&
+    code[0][0] === markers.traverse &&
+    code[0][1][0] === markers.reference &&
+    code[0][1][1] === name
   ) {
-    return macro;
+    // Replace the call with the macro
+    return annotate(macro, code.location);
   }
 
   const applied = code.map((child) => applyMacro(child, name, macro));
   return annotate(applied, code.location);
 }
 
-/**
- * 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 {AnnotatedCode} code
- * @param {string} key
- */
-function avoidRecursivePropertyCalls(code, key) {
-  if (!(code instanceof Array)) {
-    return code;
-  }
-  /** @type {Code} */
-  let modified;
-  if (
-    code[0] instanceof Array &&
-    code[0][0] === ops.scope &&
-    trailingSlash.remove(code[1][1]) === trailingSlash.remove(key)
-  ) {
-    // Rewrite to avoid recursion
-    modified = [ops.inherited, code[1][1]];
-  } else if (
-    code[0] === ops.lambda &&
-    code[1].some((param) => param[1] === key)
-  ) {
-    // Lambda that defines the key; don't rewrite
-    return code;
-  } else {
-    // Process any nested code
-    modified = code.map((value) => avoidRecursivePropertyCalls(value, key));
-  }
-  return annotate(modified, code.location);
-}
-
-/**
- * Downgrade a potential global reference to a reference.
- *
- * @param {AnnotatedCode} code
- */
-export function downgradeReference(code) {
-  if (code && code.length === 2 && code[0] === markers.reference) {
-    return annotate([markers.reference, code[1]], code.location);
-  } else {
-    return code;
-  }
-}
-
 /**
  * Create an array
  *
@@ -209,7 +161,7 @@ export function makeBinaryOperation(left, [operatorToken, right]) {
  * @param {AnnotatedCode} target
  * @param {any[]} args
  */
-export function makeCall(target, args, mode) {
+export function makeCall(target, args, location) {
   if (!(target instanceof Array)) {
     const error = new SyntaxError(`Can't call this like a function: ${target}`);
     /** @type {any} */ (error).location = /** @type {any} */ (target).location;
@@ -219,69 +171,21 @@ export function makeCall(target, args, mode) {
   let fnCall;
   const op = args[0];
   if (op === markers.traverse || op === ops.optionalTraverse) {
-    let tree = target;
-
-    if (tree[0] === markers.reference && !trailingSlash.has(tree[1][1])) {
-      // Target didn't parse with a trailing slash; add one
-      tree[1][1] = trailingSlash.add(tree[1][1]);
-    }
-
-    // Is the target an existing traversal that can be extended? It should be a
-    // reference or global where all the args are literals.
-    const extend =
-      (tree[0] === markers.reference ||
-        (tree[0] instanceof Array && tree[0][0] === markers.global)) &&
-      !tree
-        .slice(1)
-        .some((arg) => !(arg instanceof Array && arg[0] === ops.literal));
-    if (extend) {
-      fnCall = tree;
-      // If last key doesn't end with slash, add one
-      const last = tree.at(-1);
-      if (last instanceof Array && last[0] === ops.literal) {
-        last[1] = trailingSlash.add(last[1]);
-      }
-    } else {
-      fnCall = [tree];
-    }
-
-    if (args.length > 1) {
-      // Regular traverse
-      const keys = args.slice(1);
-      fnCall.push(...keys);
-    } else if (tree[0] !== ops.rootDirectory) {
-      // Traverse without arguments equates to unpack
-      fnCall = [ops.unpack, tree];
-    } else {
-      fnCall = tree;
-    }
-  } else if (op === ops.templateStandard || op === ops.templateTree) {
+    // Traverse
+    const keys = args.slice(1);
+    fnCall = [target, ...keys];
+  } else if (op === markers.property) {
+    // Property access
+    const property = args[1];
+    fnCall = [target, property];
+  } else if (op === ops.templateTree) {
     // Tagged template
     const strings = args[1];
     const values = args.slice(2);
-    fnCall = makeTaggedTemplateCall(
-      upgradeReference(target, mode),
-      strings,
-      ...values
-    );
+    fnCall = makeTaggedTemplateCall(target, strings, ...values);
   } else {
     // Function call with explicit or implicit parentheses
-    fnCall = [upgradeReference(target, mode), ...args];
-  }
-
-  // Create a location spanning the newly-constructed function call.
-  const location = { ...target.location };
-  if (args instanceof Array) {
-    let end;
-    if ("location" in args) {
-      end = /** @type {any} */ (args).location.end;
-    } else if ("location" in args.at(-1)) {
-      end = args.at(-1).location.end;
-    }
-    if (end === undefined) {
-      throw "Internal parser error: no location for function call argument";
-    }
-    location.end = end;
+    fnCall = [target, ...args];
   }
 
   return annotate(fnCall, location);
@@ -306,7 +210,7 @@ export function makeDeferredArguments(args) {
   });
 }
 
-export function makeDocument(mode, front, body, location) {
+export function makeDocument(front, body, location) {
   // In order for template expressions to see the front matter properties,
   // we translate the top-level front properties to object entries.
   const entries = Object.entries(front).map(([key, value]) =>
@@ -314,22 +218,14 @@ export function makeDocument(mode, front, body, location) {
   );
 
   // Add an entry for the body
-  const bodyKey = mode === "jse" ? "_body" : "@text";
-  entries.push(annotate([bodyKey, body], location));
+  // TODO: Deprecate @text
+  entries.push(annotate(["(@text)", body], location));
+  entries.push(annotate(["_body", body], location));
 
   // Return the code for the document object
   return annotate([ops.object, ...entries], location);
 }
 
-export function makeJsPropertyAccess(expression, property) {
-  const location = {
-    source: expression.location.source,
-    start: expression.location.start,
-    end: property.location.end,
-  };
-  return annotate([expression, property], location);
-}
-
 /**
  * From the given spreads within an object spread, return the merge.
  *
@@ -462,28 +358,47 @@ export function makeObject(entries, location) {
   return annotate(code, location);
 }
 
+/**
+ * Handle a path with one or more segments separated by slashes.
+ *
+ * @param {AnnotatedCode} keys
+ */
+export function makePath(keys) {
+  // Remove empty segments
+  const args = keys.filter(
+    (key, index) => index === 0 || (key[1] !== "" && key[1] !== "/")
+  );
+
+  // Upgrade head to a reference
+  const [head, ...tail] = args;
+  const headKey = head[1];
+  const reference = annotate([markers.reference, headKey], head.location);
+
+  let code = [markers.traverse, reference, ...tail];
+  code.location = spanLocations(code);
+
+  // Last key has trailing slash implies unpack operation
+  if (trailingSlash.has(args.at(-1)[1])) {
+    code = annotate([ops.unpack, code], code.location);
+  }
+
+  return code;
+}
+
 /**
  * Make a pipline: similar to a function call, but the order is reversed.
  *
  * @param {AnnotatedCode} arg
  * @param {AnnotatedCode} fn
- * @param {string} mode
  */
-export function makePipeline(arg, fn, mode) {
-  const upgraded = upgradeReference(fn, mode);
-  const result = makeCall(upgraded, [arg], mode);
+export function makePipeline(arg, fn, location) {
+  const result = makeCall(fn, [arg], location);
   const source = fn.location.source;
   let start = arg.location.start;
   let end = fn.location.end;
   return annotate(result, { start, source, end });
 }
 
-// Define a property on an object.
-export function makeProperty(key, value) {
-  const modified = avoidRecursivePropertyCalls(value, key);
-  return [key, modified];
-}
-
 /**
  * Make a tagged template call
  *
@@ -594,21 +509,14 @@ export function makeYamlObject(text, location) {
   return parsed;
 }
 
-/**
- * Upgrade a potential builtin reference to an actual builtin reference.
- *
- * @param {AnnotatedCode} code
- */
-export function upgradeReference(code, mode) {
-  if (
-    mode === "shell" &&
-    code.length === 2 &&
-    code[0] === markers.reference &&
-    builtinRegex.exec(code[1][1])
-  ) {
-    const result = [markers.global, code[1][1]];
-    return annotate(result, code.location);
-  } else {
-    return code;
-  }
+// Create a locations that spans those in the array. This assumes the locations
+// are in order and non-overlapping.
+function spanLocations(code) {
+  const first = code.find((item) => item.location).location;
+  const last = code[code.findLastIndex((item) => item.location)].location;
+  return {
+    source: first.source,
+    start: first.start,
+    end: last.end,
+  };
 }

package/src/runtime/expressionObject.js

@@ -136,17 +136,23 @@ export default async function expressionObject(entries, parent) {
   return object;
 }
 
-function entryKey(object, eagerProperties, entry) {
-  const [key, value] = entry;
+export function entryKey(entry, object = null, eagerProperties = []) {
+  let [key, value] = entry;
 
-  const hasExplicitSlash = trailingSlash.has(key);
-  if (hasExplicitSlash) {
-    // Return key as is
+  if (key[0] === "(" && key[key.length - 1] === ")") {
+    // Non-enumerable property, remove parentheses. This doesn't come up in the
+    // constructor, but can happen in situations encountered by the compiler's
+    // optimizer.
+    key = key.slice(1, -1);
+  }
+
+  if (trailingSlash.has(key)) {
+    // Explicit trailing slash, return as is
     return key;
   }
 
   // If eager property value is treelike, add slash to the key
-  if (eagerProperties.includes(key) && Tree.isTreelike(object[key])) {
+  if (eagerProperties.includes(key) && Tree.isTreelike(object?.[key])) {
     return trailingSlash.add(key);
   }
 
@@ -163,5 +169,5 @@ function entryKey(object, eagerProperties, entry) {
 function keys(object, eagerProperties, propertyIsEnumerable, entries) {
   return entries
     .filter(([key]) => propertyIsEnumerable[key])
-    .map((entry) => entryKey(object, eagerProperties, entry));
+    .map((entry) => entryKey(entry, object, eagerProperties));
 }

package/src/runtime/handlers.js

@@ -38,7 +38,7 @@ export async function handleExtension(parent, value, key, handlers) {
       : extension.extname(key);
     if (extname) {
       const handlerName = `${extname.slice(1)}.handler`;
-      let handler = await handlers.get(handlerName);
+      let handler = await handlers[handlerName];
       if (handler) {
         if (isUnpackable(handler)) {
           // The extension handler itself needs to be unpacked

package/src/runtime/jsGlobals.js

@@ -7,6 +7,10 @@ import path from "node:path";
  * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects.
  * That page lists some things like `TypedArrays` which are not globals so are
  * omitted here.
+ *
+ * Also includes
+ * Fetch API
+ * URL API
  */
 export default {
   AggregateError,
@@ -25,6 +29,7 @@ export default {
   Float32Array,
   Float64Array,
   Function,
+  Headers,
   Infinity,
   Int16Array,
   Int32Array,
@@ -44,6 +49,8 @@ export default {
   ReferenceError,
   Reflect,
   RegExp,
+  Request,
+  Response,
   Set,
   SharedArrayBuffer,
   String,

package/src/runtime/ops.js

@@ -21,7 +21,6 @@ import mergeTrees from "./mergeTrees.js";
 import OrigamiFiles from "./OrigamiFiles.js";
 import { codeSymbol } from "./symbols.js";
 import templateFunctionIndent from "./templateIndent.js";
-import templateFunctionStandard from "./templateStandard.js";
 
 function addOpLabel(op, label) {
   Object.defineProperty(op, "toString", {
@@ -181,11 +180,6 @@ export async function flat(...args) {
 }
 addOpLabel(flat, "«ops.flat»");
 
-/**
- * This op is only used during parsing for an explicit to a global.
- */
-export const global = new String("«global");
-
 /**
  * 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.
@@ -207,11 +201,11 @@ addOpLabel(greaterThanOrEqual, "«ops.greaterThanOrEqual»");
  *
  * @this {AsyncTree|null}
  */
-export async function homeDirectory() {
+export async function homeDirectory(...keys) {
   const tree = new OrigamiFiles(os.homedir());
   // Use the same handlers as the current tree
   tree.handlers = getHandlers(this);
-  return tree;
+  return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(homeDirectory, "«ops.homeDirectory»");
 
@@ -427,11 +421,11 @@ addOpLabel(remainder, "«ops.remainder»");
  *
  * @this {AsyncTree|null}
  */
-export async function rootDirectory() {
+export async function rootDirectory(...keys) {
   const tree = new OrigamiFiles("/");
   // Use the same handlers as the current tree
   tree.handlers = getHandlers(this);
-  return tree;
+  return keys.length > 0 ? Tree.traverse(tree, ...keys) : tree;
 }
 addOpLabel(rootDirectory, "«ops.rootDirectory»");
 
@@ -496,14 +490,6 @@ export async function templateIndent(strings, ...values) {
 }
 addOpLabel(templateIndent, "«ops.templateIndent»");
 
-/**
- * Apply the default tagged template function.
- */
-export function templateStandard(strings, ...values) {
-  return templateFunctionStandard(strings, ...values);
-}
-addOpLabel(templateStandard, "«ops.templateStandard»");
-
 /**
  * Apply the tree tagged template function.
  */

package/test/compiler/compile.test.js

@@ -4,10 +4,10 @@ import { describe, test } from "node:test";
 import * as compile from "../../src/compiler/compile.js";
 import { assertCodeEqual } from "./codeHelpers.js";
 
-const shared = new ObjectTree({
+const sharedGlobals = {
   greet: (name) => `Hello, ${name}!`,
   name: "Alice",
-});
+};
 
 describe("compile", () => {
   test("array", async () => {
@@ -24,7 +24,11 @@ describe("compile", () => {
   });
 
   test("angle bracket path", async () => {
-    await assertCompile("<name>", "Alice", { mode: "jse", target: shared });
+    await assertCompile("<data>", "Bob", {
+      target: {
+        data: "Bob",
+      },
+    });
   });
 
   test("object literal", async () => {
@@ -75,7 +79,9 @@ describe("compile", () => {
   });
 
   test("async object", async () => {
-    const fn = compile.expression("{ a: { b = name }}", { globals: shared });
+    const fn = compile.expression("{ a: { b = name }}", {
+      globals: sharedGlobals,
+    });
     const object = await fn.call(null);
     assert.deepEqual(await object.a.b, "Alice");
   });
@@ -99,7 +105,7 @@ describe("compile", () => {
 
   test("tagged template string array is identical across calls", async () => {
     let saved;
-    const globals = new ObjectTree({
+    const globals = {
       tag: (strings, ...values) => {
         assertCodeEqual(strings, ["Hello, ", "!"]);
         if (saved) {
@@ -109,7 +115,7 @@ describe("compile", () => {
         }
         return strings[0] + values[0] + strings[1];
       },
-    });
+    };
     const program = compile.expression("=tag`Hello, ${_}!`", { globals });
     const lambda = await program.call(null);
     const alice = await lambda("Alice");
@@ -121,9 +127,8 @@ describe("compile", () => {
 
 async function assertCompile(text, expected, options = {}) {
   const mode = options.mode ?? "shell";
-  const fn = compile.expression(text, { globals: shared, mode });
-  // For shell mode, use globals as scope too
-  const target = options.target ?? mode === "shell" ? shared : null;
+  const fn = compile.expression(text, { globals: sharedGlobals, mode });
+  const target = options.target ?? null;
   let result = await fn.call(target);
   if (Tree.isTreelike(result)) {
     result = await Tree.plain(result);