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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/language",
-  "version": "0.3.3-jse.3",
+  "version": "0.3.4-jse.4",
   "description": "Web Origami expression language compiler and runtime",
   "type": "module",
   "main": "./main.js",
@@ -11,8 +11,8 @@
     "typescript": "5.8.2"
   },
   "dependencies": {
-    "@weborigami/async-tree": "0.3.3-jse.3",
-    "@weborigami/types": "0.3.3-jse.3",
+    "@weborigami/async-tree": "0.3.4-jse.4",
+    "@weborigami/types": "0.3.4-jse.4",
     "watcher": "2.3.1",
     "yaml": "2.7.0"
   },

package/src/compiler/compile.js

@@ -4,20 +4,22 @@ import optimize from "./optimize.js";
 import { parse } from "./parse.js";
 
 function compile(source, options) {
-  const { startRule } = options;
+  const { front, startRule } = options;
   const mode = options.mode ?? "shell";
   const globals = options.globals ?? jsGlobals;
   const enableCaching = options.scopeCaching ?? true;
   if (typeof source === "string") {
     source = { text: source };
   }
-  const code = parse(source.text, {
+  let code = parse(source.text, {
+    front,
     grammarSource: source,
     mode,
     startRule,
   });
+  const cache = enableCaching ? {} : null;
   const optimized = optimize(code, {
-    enableCaching,
+    cache,
     globals,
     mode,
   });

package/src/compiler/isOrigamiFrontMatter.js

@@ -3,14 +3,15 @@
  *
  * Our heurstic is to see skip any initial alphanumeric or underscore
  * characters, then see if the next character is a parenthesis, dot, slash,
- * curly brace, or equals sign. If so, we assume this is an Origami expression.
+ * curly brace, left angle bracket, or equals sign. If so, we assume this is an
+ * Origami expression.
  *
  * The goal is to identify Origami front matter like:
  *
  * ```
  *   fn(x)              function call
  *   index.ori()        file extension
- *   src/data.json      file path
+ *   <src/data.json>    file path
  *   // Hello           comment
  *   { a: 1 }           object literal
  * ```
@@ -22,5 +23,5 @@
  * @param {string} text
  */
 export default function isOrigamiFrontMatter(text) {
-  return /^[ \t\r\n]*[A-Za-z0-9_]*[\(\.\/\{=]/.test(text);
+  return /^[ \t\r\n]*[A-Za-z0-9_]*[\(\.\/\{<=]/.test(text);
 }

package/src/compiler/optimize.js

@@ -1,15 +1,21 @@
 import { pathFromKeys, trailingSlash } from "@weborigami/async-tree";
+import { entryKey } from "../runtime/expressionObject.js";
 import { ops } from "../runtime/internal.js";
 import jsGlobals from "../runtime/jsGlobals.js";
 import { annotate, markers } from "./parserHelpers.js";
 
+const REFERENCE_LOCAL = 1;
+const REFERENCE_GLOBAL = 2;
+const REFERENCE_EXTERNAL = 3;
+
 /**
  * Optimize an Origami code instruction:
  *
- * - Transform any remaining reference references to scope references.
- * - Transform those or explicit ops.scope calls to ops.external calls unless
- *   they refer to local variables (variables defined by object literals or
- *   lambda parameters).
+ * - Resolve local references to the appropriate context
+ * - Resolve global references to the globals object
+ * - Resolve other references to external values
+ * - Determine whether x.y is a file name or property access
+ * - Determine whether x/y is a file path or division operation
  *
  * @typedef {import("./parserHelpers.js").AnnotatedCode} AnnotatedCode
  * @typedef {import("./parserHelpers.js").Code} Code
@@ -19,9 +25,7 @@ import { annotate, markers } from "./parserHelpers.js";
  * @returns {AnnotatedCode}
  */
 export default function optimize(code, options = {}) {
-  const enableCaching = options.enableCaching ?? true;
   const globals = options.globals ?? jsGlobals;
-  const mode = options.mode ?? "shell";
   const cache = options.cache ?? {};
 
   // The locals is an array, one item for each function or object context that
@@ -29,25 +33,15 @@ export default function optimize(code, options = {}) {
   // subarrays containing the names of local variables defined in that context.
   const locals = options.locals ? options.locals.slice() : [];
 
-  const externalScope =
-    mode === "shell"
-      ? // External scope is parent scope + globals
-        annotate(
-          [ops.merge, globals, annotate([ops.scope], code.location)],
-          code.location
-        )
-      : annotate([ops.scope], code.location);
-
   // See if we can optimize this level of the code
-  const [fn, ...args] = code;
-  let optimized = code;
-  let externalReference = fn instanceof Array && fn[0] === ops.scope;
-  let depth;
-  switch (fn) {
+  const [op, ...args] = code;
+  switch (op) {
     case markers.global:
       // Replace global op with the globals
-      optimized = annotate([globals, args[0]], code.location);
-      break;
+      return annotate([globals, args[0]], code.location);
+
+    case markers.traverse:
+      return resolvePath(code, globals, locals, cache);
 
     case ops.lambda:
       const parameters = args[0];
@@ -58,79 +52,24 @@ export default function optimize(code, options = {}) {
       break;
 
     case ops.literal:
-      const value = args[0];
-      if (!(value instanceof Array)) {
-        return value;
-      }
-      break;
+      return inlineLiteral(code);
 
     case ops.object:
       const entries = args;
-      const keys = entries.map(([key]) => propertyName(key));
+      const keys = entries.map(entryKey);
       locals.push(keys);
       break;
-
-    case markers.reference:
-      // Determine whether reference is local and, if so, transform to
-      // ops.local call. Otherwise transform to ops.scope call.
-      let key = args[0];
-      if (key instanceof Array && key[0] === ops.literal) {
-        key = key[1];
-      }
-      const normalizedKey = trailingSlash.remove(key);
-      let target;
-      depth = getLocalReferenceDepth(locals, normalizedKey);
-      if (depth >= 0) {
-        // Transform local reference
-        const contextCode = [ops.context];
-        if (depth > 0) {
-          contextCode.push(depth);
-        }
-        target = annotate(contextCode, code.location);
-      } else if (mode === "shell") {
-        // Transform non-local reference
-        target = externalScope;
-        externalReference = true;
-      } else if (mode === "jse") {
-        target = globals;
-      }
-      optimized = annotate([target, ...args], code.location);
-      break;
-
-    case ops.scope:
-      depth = locals.length;
-      if (depth === 0) {
-        // Use scope call as is
-        optimized = code;
-      } else {
-        // Add context for appropriate depth to scope call
-        const contextCode = annotate([ops.context, depth], code.location);
-        optimized = annotate([ops.scope, contextCode], code.location);
-      }
-      break;
   }
 
   // Optimize children
-  optimized = annotate(
-    optimized.map((child, index) => {
+  const optimized = annotate(
+    code.map((child, index) => {
       // Don't optimize lambda parameter names
-      if (fn === ops.lambda && index === 1) {
+      if (op === ops.lambda && index === 1) {
         return child;
-      } else if (fn === ops.object && index > 0) {
-        // Code that defines a property `x` that contains references to `x`
-        // shouldn't find this context but look further up.
+      } else if (op === ops.object && index > 0) {
         const [key, value] = child;
-        const normalizedKey = trailingSlash.remove(key);
-        let adjustedLocals;
-        if (locals.at(-1)?.includes(normalizedKey)) {
-          adjustedLocals = locals.slice();
-          // Remove the key from the current context's locals
-          adjustedLocals[adjustedLocals.length - 1] = locals
-            .at(-1)
-            .filter((name) => name !== normalizedKey);
-        } else {
-          adjustedLocals = locals;
-        }
+        const adjustedLocals = avoidLocalRecursion(locals, key);
         return [
           key,
           optimize(/** @type {AnnotatedCode} */ (value), {
@@ -149,37 +88,88 @@ export default function optimize(code, options = {}) {
         return child;
       }
     }),
-    optimized.location
+    code.location
   );
 
-  // Cache external scope or merged globals + scope references
-  if (enableCaching && externalReference) {
-    // Get all the keys so we can construct a path as a cache key
-    const keys = optimized
-      .slice(1)
-      .map((arg) =>
-        typeof arg === "string" || typeof arg === "number"
-          ? arg
-          : arg instanceof Array && arg[0] === ops.literal
-          ? arg[1]
-          : null
-      );
-    if (keys.some((key) => key === null)) {
-      throw new Error("Internal error: scope reference with non-literal key");
-    }
-    const path = pathFromKeys(keys);
-    optimized = annotate(
-      [ops.cache, cache, path, optimized],
-      optimized.location
-    );
+  return annotate(optimized, code.location);
+}
+
+// When defining a property named `key` (or `key/` or `(key)`), we need to
+// remove any local variable with that name from the stack of locals to avoid a
+// recursive reference.
+function avoidLocalRecursion(locals, key) {
+  if (key[0] === "(" && key[key.length - 1] === ")") {
+    // Non-enumerable property, remove parentheses
+    key = key.slice(1, -1);
   }
 
-  return annotate(optimized, code.location);
+  const currentFrame = locals.length - 1;
+  const matchingKeyIndex = locals[currentFrame].findIndex(
+    (localKey) =>
+      // Ignore trailing slashes when comparing keys
+      trailingSlash.remove(localKey) === trailingSlash.remove(key)
+  );
+
+  if (matchingKeyIndex >= 0) {
+    // Remove the key from the current context's locals
+    const adjustedLocals = locals.slice();
+    adjustedLocals[currentFrame] = adjustedLocals[currentFrame].slice();
+    adjustedLocals[currentFrame].splice(matchingKeyIndex, 1);
+    return adjustedLocals;
+  } else {
+    return locals;
+  }
+}
+
+function cachePath(code, cache) {
+  const keys = code.map(keyFromCode).filter((key) => key !== null);
+  const path = pathFromKeys(keys);
+  return annotate([ops.cache, cache, path, code], code.location);
+}
+
+// A reference with periods like x.y.z
+function compoundReference(key, globals, locals, location) {
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    // Not a compound reference
+    return { type: REFERENCE_EXTERNAL, result: null };
+  }
+
+  // Check first part to see if it's a global or local reference
+  const [head, ...tail] = parts;
+  const type = referenceType(head, globals, locals);
+  let result;
+  if (type === REFERENCE_GLOBAL) {
+    result = globalReference(head, globals, location);
+  } else if (type === REFERENCE_LOCAL) {
+    result = localReference(head, locals, location);
+  } else {
+    // Not a compound reference
+    return { type: REFERENCE_EXTERNAL, result: null };
+  }
+
+  // Process the remaining parts as property accesses
+  while (tail.length > 0) {
+    const part = tail.shift();
+    result = annotate([result, part], location);
+  }
+
+  return { type, result };
+}
+
+function externalReference(key, locals, location) {
+  const scope = scopeCall(locals, location);
+  const literal = annotate([ops.literal, key], location);
+  return annotate([scope, literal], location);
 }
 
 // Determine how many contexts up we need to go for a local
 function getLocalReferenceDepth(locals, key) {
-  const contextIndex = locals.findLastIndex((names) => names.includes(key));
+  const contextIndex = locals.findLastIndex((names) =>
+    names.some(
+      (name) => trailingSlash.remove(name) === trailingSlash.remove(key)
+    )
+  );
   if (contextIndex < 0) {
     return -1; // Not a local reference
   }
@@ -187,10 +177,133 @@ function getLocalReferenceDepth(locals, key) {
   return depth;
 }
 
-function propertyName(key) {
-  if (key[0] === "(" && key[key.length - 1] === ")") {
-    // Non-enumerable property, remove parentheses
-    key = key.slice(1, -1);
+function globalReference(key, globals, location) {
+  const normalized = trailingSlash.remove(key);
+  return annotate([globals, normalized], location);
+}
+
+function inlineLiteral(code) {
+  // If the literal value is an array, it's likely the strings array
+  // of a template literal, so return it as is.
+  return code[0] === ops.literal && !Array.isArray(code[1]) ? code[1] : code;
+}
+
+function localReference(key, locals, location) {
+  const normalized = trailingSlash.remove(key);
+  const depth = getLocalReferenceDepth(locals, normalized);
+  const context = [ops.context];
+  if (depth > 0) {
+    context.push(depth);
+  }
+  const contextCall = annotate(context, location);
+  const literal = annotate([ops.literal, key], location);
+  return annotate([contextCall, literal], location);
+}
+
+function keyFromCode(code) {
+  const op = code instanceof Array ? code[0] : code;
+  switch (op) {
+    case ops.homeDirectory:
+      return "~";
+
+    case markers.external:
+    case markers.global:
+    case markers.reference:
+    case ops.literal:
+      return code[1];
+
+    case ops.rootDirectory:
+      return "/";
+
+    default:
+      return null;
+  }
+}
+
+function reference(code, globals, locals) {
+  const key = keyFromCode(code);
+  const normalized = trailingSlash.remove(key);
+  const location = code.location;
+
+  if (normalized === "~") {
+    // Special case for home directory
+    return {
+      type: REFERENCE_EXTERNAL,
+      result: annotate([ops.homeDirectory], location),
+    };
+  } else if (normalized === "") {
+    // Special case for root directory
+    return {
+      type: REFERENCE_EXTERNAL,
+      result: annotate([ops.rootDirectory], location),
+    };
+  }
+
+  if (code[0] === markers.external) {
+    // Explicit external reference
+    return {
+      type: REFERENCE_EXTERNAL,
+      result: externalReference(key, locals, location),
+    };
+  }
+
+  // See if the whole key is a global or local variable
+  let type = referenceType(key, globals, locals);
+  let result;
+  if (type === REFERENCE_GLOBAL) {
+    result = globalReference(key, globals, location);
+  } else if (type === REFERENCE_LOCAL) {
+    result = localReference(key, locals, location);
+  } else {
+    // Try key as a compound reference x.y.z
+    const compound = compoundReference(key, globals, locals, location);
+    result = compound?.result;
+    type = compound?.type;
+  }
+
+  if (!result) {
+    // If none of the above worked, it must be an external reference
+    result = externalReference(key, locals, location);
+  }
+
+  return { type, result };
+}
+
+function referenceType(key, globals, locals) {
+  // Check if the key is a global variable
+  const normalized = trailingSlash.remove(key);
+  if (getLocalReferenceDepth(locals, normalized) >= 0) {
+    return REFERENCE_LOCAL;
+  } else if (normalized in globals) {
+    return REFERENCE_GLOBAL;
+  } else {
+    return REFERENCE_EXTERNAL;
+  }
+}
+
+function resolvePath(code, globals, locals, cache) {
+  const args = code.slice(1);
+  const [head, ...tail] = args;
+
+  let { type, result } = reference(head, globals, locals);
+
+  result.push(...tail);
+
+  if (type === REFERENCE_EXTERNAL && cache !== null) {
+    // Cache external path
+    return cachePath(result, cache);
+  }
+
+  return result;
+}
+
+function scopeCall(locals, location) {
+  const depth = locals.length;
+  const code = [ops.scope];
+  if (depth > 0) {
+    // Add context for appropriate depth to scope call
+    const contextCode = annotate([ops.context, depth], location);
+    code.push(contextCode);
   }
-  return trailingSlash.remove(key);
+  return annotate(code, location);
 }