temml 0.9.1

package/src/Namespace.js

@@ -0,0 +1,107 @@
+/**
+ * A `Namespace` refers to a space of nameable things like macros or lengths,
+ * which can be `set` either globally or local to a nested group, using an
+ * undo stack similar to how TeX implements this functionality.
+ * Performance-wise, `get` and local `set` take constant time, while global
+ * `set` takes time proportional to the depth of group nesting.
+ */
+
+import ParseError from "./ParseError";
+
+export default class Namespace {
+  /**
+   * Both arguments are optional.  The first argument is an object of
+   * built-in mappings which never change.  The second argument is an object
+   * of initial (global-level) mappings, which will constantly change
+   * according to any global/top-level `set`s done.
+   */
+  constructor(builtins = {}, globalMacros = {}) {
+    this.current = globalMacros;
+    this.builtins = builtins;
+    this.undefStack = [];
+  }
+
+  /**
+   * Start a new nested group, affecting future local `set`s.
+   */
+  beginGroup() {
+    this.undefStack.push({});
+  }
+
+  /**
+   * End current nested group, restoring values before the group began.
+   */
+  endGroup() {
+    if (this.undefStack.length === 0) {
+      throw new ParseError(
+        "Unbalanced namespace destruction: attempt " +
+          "to pop global namespace; please report this as a bug"
+      );
+    }
+    const undefs = this.undefStack.pop();
+    for (const undef in undefs) {
+      if (Object.prototype.hasOwnProperty.call(undefs, undef )) {
+        if (undefs[undef] === undefined) {
+          delete this.current[undef];
+        } else {
+          this.current[undef] = undefs[undef];
+        }
+      }
+    }
+  }
+
+  /**
+   * Detect whether `name` has a definition.  Equivalent to
+   * `get(name) != null`.
+   */
+  has(name) {
+    return Object.prototype.hasOwnProperty.call(this.current, name ) ||
+    Object.prototype.hasOwnProperty.call(this.builtins, name );
+  }
+
+  /**
+   * Get the current value of a name, or `undefined` if there is no value.
+   *
+   * Note: Do not use `if (namespace.get(...))` to detect whether a macro
+   * is defined, as the definition may be the empty string which evaluates
+   * to `false` in JavaScript.  Use `if (namespace.get(...) != null)` or
+   * `if (namespace.has(...))`.
+   */
+  get(name) {
+    if (Object.prototype.hasOwnProperty.call(this.current, name )) {
+      return this.current[name];
+    } else {
+      return this.builtins[name];
+    }
+  }
+
+  /**
+   * Set the current value of a name, and optionally set it globally too.
+   * Local set() sets the current value and (when appropriate) adds an undo
+   * operation to the undo stack.  Global set() may change the undo
+   * operation at every level, so takes time linear in their number.
+   */
+  set(name, value, global = false) {
+    if (global) {
+      // Global set is equivalent to setting in all groups.  Simulate this
+      // by destroying any undos currently scheduled for this name,
+      // and adding an undo with the *new* value (in case it later gets
+      // locally reset within this environment).
+      for (let i = 0; i < this.undefStack.length; i++) {
+        delete this.undefStack[i][name];
+      }
+      if (this.undefStack.length > 0) {
+        this.undefStack[this.undefStack.length - 1][name] = value;
+      }
+    } else {
+      // Undo this set at end of this group (possibly to `undefined`),
+      // unless an undo is already in place, in which case that older
+      // value is the correct one.
+      const top = this.undefStack[this.undefStack.length - 1];
+      if (top && !Object.prototype.hasOwnProperty.call(top, name )) {
+        top[name] = this.current[name];
+      }
+    }
+    this.current[name] = value;
+  }
+}

package/src/ParseError.js

@@ -0,0 +1,64 @@
+/**
+ * This is the ParseError class, which is the main error thrown by Temml
+ * functions when something has gone wrong. This is used to distinguish internal
+ * errors from errors in the expression that the user provided.
+ *
+ * If possible, a caller should provide a Token or ParseNode with information
+ * about where in the source string the problem occurred.
+ */
+class ParseError {
+  constructor(
+    message, // The error message
+    token // An object providing position information
+  ) {
+    let error = " " + message;
+    let start;
+
+    const loc = token && token.loc;
+    if (loc && loc.start <= loc.end) {
+      // If we have the input and a position, make the error a bit fancier
+
+      // Get the input
+      const input = loc.lexer.input;
+
+      // Prepend some information
+      start = loc.start;
+      const end = loc.end;
+      if (start === input.length) {
+        error += " at end of input: ";
+      } else {
+        error += " at position " + (start + 1) + ": ";
+      }
+
+      // Underline token in question using combining underscores
+      const underlined = input.slice(start, end).replace(/[^]/g, "$&\u0332");
+
+      // Extract some context from the input and add it to the error
+      let left;
+      if (start > 15) {
+        left = "…" + input.slice(start - 15, start);
+      } else {
+        left = input.slice(0, start);
+      }
+      let right;
+      if (end + 15 < input.length) {
+        right = input.slice(end, end + 15) + "…";
+      } else {
+        right = input.slice(end);
+      }
+      error += left + underlined + right;
+    }
+
+    // Some hackery to make ParseError a prototype of Error
+    // See http://stackoverflow.com/a/8460753
+    const self = new Error(error);
+    self.name = "ParseError";
+    self.__proto__ = ParseError.prototype;
+    self.position = start;
+    return self;
+  }
+}
+
+ParseError.prototype.__proto__ = Error.prototype;
+
+export default ParseError;