@jbrowse/jexl 3.3.0 → 4.0.1

package/src/parser/Parser.ts

@@ -32,7 +32,7 @@ const tokenHandlers: Record<
 /**
  * The Parser is a state machine that converts tokens from the {@link Lexer}
  * into an Abstract Syntax Tree (AST), capable of being evaluated in any
- * context by the {@link Evaluator}.  The Parser expects that all tokens
+ * context by {@link compileAst}.  The Parser expects that all tokens
  * provided to it are legal and typed properly according to the grammar, but
  * accepts that the tokens may still be in an invalid order or in some other
  * unparsable configuration that requires it to throw an Error.
@@ -52,13 +52,11 @@ class Parser {
   _state: string
   _tree: AstNode | null
   _exprStr: string
-  _relative: boolean
   _stopMap: Record<string, string>
   _cursor?: AstNode | null
   _subParser?: Parser
   _parentStop?: boolean
   _nextIdentEncapsulate?: boolean
-  _nextIdentRelative?: boolean
   _curObjKey?: string
   _sequenceExpressions?: AstNode[]
 
@@ -73,7 +71,6 @@ class Parser {
     this._state = 'expectOperand'
     this._tree = null
     this._exprStr = prefix || ''
-    this._relative = false
     this._stopMap = stopMap || {}
   }
 
@@ -143,7 +140,7 @@ class Parser {
   /**
    * Marks this Parser instance as completed and retrieves the full AST.
    * @returns {{}|null} a full expression tree, ready for evaluation by the
-   *      {@link Evaluator#eval} function, or null if no tokens were passed to
+   *      {@link compileAst} function, or null if no tokens were passed to
    *      the parser before complete was called
    * @throws {Error} if the parser is not in a state where it's legal to end
    *      the expression, indicating that the expression is incomplete
@@ -179,14 +176,6 @@ class Parser {
     return this._cursor ? this._tree : null
   }
 
-  /**
-   * Indicates whether the expression tree contains a relative path identifier.
-   * @returns {boolean} true if a relative identifier exists false otherwise.
-   */
-  isRelative() {
-    return this._relative
-  }
-
   /**
    * Ends a subexpression by completing the subParser and passing its result
    * to the subHandler configured in the current state.

package/src/parser/handlers.ts

@@ -64,7 +64,7 @@ export function arrayVal(this: Parser, ast: AstNode | null) {
 export function binaryOp(this: Parser, token: Token) {
   if (token.value === '=') {
     // `from` marks a member access such as `a.b`; only a bare name can be
-    // assigned to, since the Evaluator writes straight into the context
+    // assigned to, since the compiled closure writes straight into the context
     if (
       this._cursor?.type !== 'Identifier' ||
       (this._cursor as Identifier).from
@@ -90,9 +90,15 @@ export function binaryOp(this: Parser, token: Token) {
     if (!parentExpr.operator) {
       break
     }
-    if (
-      precedenceOf(this._grammar.elements[parentExpr.operator]) < precedence
-    ) {
+    // a prefix operator binds tighter than any binary one, so `-x ^ 2` groups
+    // as `(-x) ^ 2` — the same way `-2 ^ 2` already does, since the Lexer folds
+    // that sign into the literal. Looking `-` up in the grammar finds its
+    // binary precedence instead, which is lower than `^`'s and gave `-(x ^ 2)`
+    const parentPrecedence =
+      parent.type === 'UnaryExpression'
+        ? Infinity
+        : precedenceOf(this._grammar.elements[parentExpr.operator])
+    if (parentPrecedence < precedence) {
       break
     }
     this._cursor = parent
@@ -115,18 +121,20 @@ export function binaryOp(this: Parser, token: Token) {
  */
 export function dot(this: Parser) {
   const cursor = this._cursor
-  // the dot continues an identifier chain unless the cursor is an operator
-  // still waiting on its right-hand side, in which case it opens a relative
-  // path instead — as in the leading dot of `list[.price > 5]`
-  this._nextIdentEncapsulate =
-    !!cursor &&
-    cursor.type !== 'UnaryExpression' &&
-    (cursor.type !== 'BinaryExpression' || !!cursor.right)
-
-  this._nextIdentRelative = !this._nextIdentEncapsulate
-  if (this._nextIdentRelative) {
-    this._relative = true
+  // a dot continues an identifier chain. With nothing to continue — no cursor,
+  // or an operator still waiting on its right-hand side — it would instead open
+  // a relative path, the leading dot of `list[.price > 5]`. This fork removed
+  // array filtering expressions, which are the only construct that gives a
+  // relative path a root to resolve against, so it is rejected here rather than
+  // parsed into a tree that can only fail once it is evaluated.
+  if (
+    !cursor ||
+    cursor.type === 'UnaryExpression' ||
+    (cursor.type === 'BinaryExpression' && !cursor.right)
+  ) {
+    throw new Error(`Relative paths are not supported: ${this._exprStr}`)
   }
+  this._nextIdentEncapsulate = true
 }
 
 /**
@@ -138,7 +146,6 @@ export function filter(this: Parser, ast: AstNode | null) {
   const node: FilterExpression = {
     type: 'FilterExpression',
     expr: ast!,
-    relative: this._subParser!.isRelative(),
     subject: this._cursor!
   }
   this._placeBeforeCursor(node)
@@ -162,12 +169,11 @@ export function functionCall(this: Parser) {
     // there is nothing to look up in the function pool
     throw new Error(`Functions must be called by name: ${this._exprStr}`)
   }
-  const { from } = cursor as Identifier
+  const { from, value } = cursor as Identifier
   const node: FunctionCall = {
     type: 'FunctionCall',
-    name: (cursor as Identifier).value,
-    args: from ? [from] : [],
-    pool: 'functions'
+    name: value,
+    args: from ? [from] : []
   }
   this._placeBeforeCursor(node)
 }
@@ -186,10 +192,6 @@ export function identifier(this: Parser, token: Token) {
     this._placeBeforeCursor(node)
     this._nextIdentEncapsulate = false
   } else {
-    if (this._nextIdentRelative) {
-      node.relative = true
-      this._nextIdentRelative = false
-    }
     this._placeAtCursor(node)
   }
 }
@@ -274,7 +276,7 @@ export function objStart(this: Parser) {
 export function objVal(this: Parser, ast: AstNode | null) {
   // defined rather than assigned so that the key "__proto__" becomes an
   // ordinary entry of the node's key map instead of re-pointing its prototype,
-  // which dropped the entry before the Evaluator ever saw it
+  // which dropped the entry before it could be compiled
   Object.defineProperty(
     (this._cursor as ObjectLiteral).value,
     this._curObjKey!,
@@ -313,17 +315,32 @@ export function ternaryMid(this: Parser, ast: AstNode | null) {
 }
 
 /**
- * Handles the start of a new ternary expression by encapsulating the entire
- * AST in a ConditionalExpression node, and using the existing tree as the
- * test element.
+ * Handles the start of a new ternary expression by encapsulating the tree so
+ * far in a ConditionalExpression node, and using it as the test element.
+ *
+ * Every operator binds tighter than the conditional and so belongs in the test
+ * — except `=`, which binds looser. `x = a ? b : c` therefore assigns the
+ * conditional rather than testing the assignment, which had stored `a` in `x`.
  */
 export function ternaryStart(this: Parser) {
+  let assignment: AstNode | undefined
+  let test = this._tree!
+  while (test.type === 'AssignmentExpression' && test.right) {
+    assignment = test
+    test = test.right
+  }
+
   const node: ConditionalExpression = {
     type: 'ConditionalExpression',
-    test: this._tree!
+    test
+  }
+  if (assignment) {
+    assignment.right = node
+    this._setParent(node, assignment)
+  } else {
+    this._tree = node
   }
-  this._tree = node
-  this._cursor = this._tree
+  this._cursor = node
 }
 
 /**

package/src/parser/states.ts

@@ -97,10 +97,6 @@ export const states: States = {
       colon: { toState: 'objVal' }
     }
   },
-  postArgs: {
-    tokenTypes: afterOperand,
-    completable: true
-  },
   identifier: {
     tokenTypes: {
       ...afterOperand,
@@ -131,7 +127,9 @@ export const states: States = {
     subHandler: h.argVal,
     endStates: {
       comma: 'argVal',
-      closeParen: 'postArgs'
+      // a call's result is an ordinary operand: it can be operated on or
+      // drilled into, but not called again, since only a name can be called
+      closeParen: 'expectBinOp'
     }
   },
   objVal: {

package/src/types.ts

@@ -38,7 +38,6 @@ export interface Identifier extends AstNode {
   type: 'Identifier'
   value: string
   from?: AstNode
-  relative?: boolean
 }
 
 export interface BinaryExpression extends AstNode {
@@ -77,13 +76,11 @@ export interface FunctionCall extends AstNode {
   type: 'FunctionCall'
   name: string
   args: AstNode[]
-  pool: 'functions'
 }
 
 export interface FilterExpression extends AstNode {
   type: 'FilterExpression'
   expr: AstNode
-  relative: boolean
   subject: AstNode
 }
 

package/dist/evaluator/Evaluator.d.ts

@@ -1,37 +0,0 @@
-import type { Grammar } from '../grammar.ts';
-import type { AstNode, JexlValue } from '../types.ts';
-/**
- * The Evaluator carries everything an expression is evaluated against: the
- * grammar, the context, and a relative context to be used as the root for
- * relative identifiers. When any of these change, a new instance is required.
- * However, a single instance can be used to evaluate many different
- * expressions, and does not have to be reinstantiated for each.
- *
- * The work of evaluation itself lives in {@link compileAst}, which lowers a
- * tree to closures. Prefer compiling once and reusing the result — that is what
- * {@link Expression} does — over calling {@link #eval}, which compiles the tree
- * it is given every time.
- *
- * @param {{}} grammar A grammar object against which to evaluate the expression
- *      tree
- * @param {{}} [context] A map of variable keys to their values. This will be
- *      accessed to resolve the value of each non-relative identifier.
- * @param {{}|Array<{}|Array>} [relativeContext] A map or array to be accessed
- *      to resolve the value of a relative identifier.
- */
-declare class Evaluator {
-    _grammar: Grammar;
-    _context: Record<string, JexlValue>;
-    _relContext: Record<string, JexlValue>;
-    constructor(grammar: Grammar, context?: Record<string, JexlValue>, relativeContext?: Record<string, JexlValue>);
-    /**
-     * Compiles and evaluates an expression tree within the configured context.
-     * Convenient for a one-shot evaluation; for repeated evaluation of the same
-     * tree, hold onto the closure from {@link compileAst} instead so the tree is
-     * only lowered once.
-     * @param {{}} ast An expression tree object
-     * @returns {*} the resulting value of the expression.
-     */
-    eval(ast: AstNode): JexlValue;
-}
-export default Evaluator;

package/dist/evaluator/Evaluator.js

@@ -1,49 +0,0 @@
-"use strict";
-/*
- * Jexl
- * Copyright 2020 Tom Shawver
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const compile_ts_1 = require("./compile.js");
-/**
- * The Evaluator carries everything an expression is evaluated against: the
- * grammar, the context, and a relative context to be used as the root for
- * relative identifiers. When any of these change, a new instance is required.
- * However, a single instance can be used to evaluate many different
- * expressions, and does not have to be reinstantiated for each.
- *
- * The work of evaluation itself lives in {@link compileAst}, which lowers a
- * tree to closures. Prefer compiling once and reusing the result — that is what
- * {@link Expression} does — over calling {@link #eval}, which compiles the tree
- * it is given every time.
- *
- * @param {{}} grammar A grammar object against which to evaluate the expression
- *      tree
- * @param {{}} [context] A map of variable keys to their values. This will be
- *      accessed to resolve the value of each non-relative identifier.
- * @param {{}|Array<{}|Array>} [relativeContext] A map or array to be accessed
- *      to resolve the value of a relative identifier.
- */
-class Evaluator {
-    _grammar;
-    _context;
-    _relContext;
-    constructor(grammar, context, relativeContext) {
-        this._grammar = grammar;
-        this._context = context || {};
-        this._relContext = relativeContext || this._context;
-    }
-    /**
-     * Compiles and evaluates an expression tree within the configured context.
-     * Convenient for a one-shot evaluation; for repeated evaluation of the same
-     * tree, hold onto the closure from {@link compileAst} instead so the tree is
-     * only lowered once.
-     * @param {{}} ast An expression tree object
-     * @returns {*} the resulting value of the expression.
-     */
-    eval(ast) {
-        return (0, compile_ts_1.compileAst)(ast, this._grammar)(this);
-    }
-}
-exports.default = Evaluator;
-//# sourceMappingURL=Evaluator.js.map

package/dist/evaluator/Evaluator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Evaluator.js","sourceRoot":"","sources":["../../src/evaluator/Evaluator.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AAEH,6CAAyC;AAKzC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,SAAS;IACb,QAAQ,CAAS;IACjB,QAAQ,CAA2B;IACnC,WAAW,CAA2B;IAEtC,YACE,OAAgB,EAChB,OAAmC,EACnC,eAA2C;QAE3C,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;QACvB,IAAI,CAAC,QAAQ,GAAG,OAAO,IAAI,EAAE,CAAA;QAC7B,IAAI,CAAC,WAAW,GAAG,eAAe,IAAI,IAAI,CAAC,QAAQ,CAAA;IACrD,CAAC;IAED;;;;;;;OAOG;IACH,IAAI,CAAC,GAAY;QACf,OAAO,IAAA,uBAAU,EAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAA;IAC7C,CAAC;CACF;AAED,kBAAe,SAAS,CAAA"}

package/esm/evaluator/Evaluator.d.ts

@@ -1,37 +0,0 @@
-import type { Grammar } from '../grammar.ts';
-import type { AstNode, JexlValue } from '../types.ts';
-/**
- * The Evaluator carries everything an expression is evaluated against: the
- * grammar, the context, and a relative context to be used as the root for
- * relative identifiers. When any of these change, a new instance is required.
- * However, a single instance can be used to evaluate many different
- * expressions, and does not have to be reinstantiated for each.
- *
- * The work of evaluation itself lives in {@link compileAst}, which lowers a
- * tree to closures. Prefer compiling once and reusing the result — that is what
- * {@link Expression} does — over calling {@link #eval}, which compiles the tree
- * it is given every time.
- *
- * @param {{}} grammar A grammar object against which to evaluate the expression
- *      tree
- * @param {{}} [context] A map of variable keys to their values. This will be
- *      accessed to resolve the value of each non-relative identifier.
- * @param {{}|Array<{}|Array>} [relativeContext] A map or array to be accessed
- *      to resolve the value of a relative identifier.
- */
-declare class Evaluator {
-    _grammar: Grammar;
-    _context: Record<string, JexlValue>;
-    _relContext: Record<string, JexlValue>;
-    constructor(grammar: Grammar, context?: Record<string, JexlValue>, relativeContext?: Record<string, JexlValue>);
-    /**
-     * Compiles and evaluates an expression tree within the configured context.
-     * Convenient for a one-shot evaluation; for repeated evaluation of the same
-     * tree, hold onto the closure from {@link compileAst} instead so the tree is
-     * only lowered once.
-     * @param {{}} ast An expression tree object
-     * @returns {*} the resulting value of the expression.
-     */
-    eval(ast: AstNode): JexlValue;
-}
-export default Evaluator;

package/esm/evaluator/Evaluator.js

@@ -1,47 +0,0 @@
-/*
- * Jexl
- * Copyright 2020 Tom Shawver
- */
-import { compileAst } from "./compile.js";
-/**
- * The Evaluator carries everything an expression is evaluated against: the
- * grammar, the context, and a relative context to be used as the root for
- * relative identifiers. When any of these change, a new instance is required.
- * However, a single instance can be used to evaluate many different
- * expressions, and does not have to be reinstantiated for each.
- *
- * The work of evaluation itself lives in {@link compileAst}, which lowers a
- * tree to closures. Prefer compiling once and reusing the result — that is what
- * {@link Expression} does — over calling {@link #eval}, which compiles the tree
- * it is given every time.
- *
- * @param {{}} grammar A grammar object against which to evaluate the expression
- *      tree
- * @param {{}} [context] A map of variable keys to their values. This will be
- *      accessed to resolve the value of each non-relative identifier.
- * @param {{}|Array<{}|Array>} [relativeContext] A map or array to be accessed
- *      to resolve the value of a relative identifier.
- */
-class Evaluator {
-    _grammar;
-    _context;
-    _relContext;
-    constructor(grammar, context, relativeContext) {
-        this._grammar = grammar;
-        this._context = context || {};
-        this._relContext = relativeContext || this._context;
-    }
-    /**
-     * Compiles and evaluates an expression tree within the configured context.
-     * Convenient for a one-shot evaluation; for repeated evaluation of the same
-     * tree, hold onto the closure from {@link compileAst} instead so the tree is
-     * only lowered once.
-     * @param {{}} ast An expression tree object
-     * @returns {*} the resulting value of the expression.
-     */
-    eval(ast) {
-        return compileAst(ast, this._grammar)(this);
-    }
-}
-export default Evaluator;
-//# sourceMappingURL=Evaluator.js.map

package/esm/evaluator/Evaluator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Evaluator.js","sourceRoot":"","sources":["../../src/evaluator/Evaluator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAKzC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,SAAS;IACb,QAAQ,CAAS;IACjB,QAAQ,CAA2B;IACnC,WAAW,CAA2B;IAEtC,YACE,OAAgB,EAChB,OAAmC,EACnC,eAA2C;QAE3C,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;QACvB,IAAI,CAAC,QAAQ,GAAG,OAAO,IAAI,EAAE,CAAA;QAC7B,IAAI,CAAC,WAAW,GAAG,eAAe,IAAI,IAAI,CAAC,QAAQ,CAAA;IACrD,CAAC;IAED;;;;;;;OAOG;IACH,IAAI,CAAC,GAAY;QACf,OAAO,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAA;IAC7C,CAAC;CACF;AAED,eAAe,SAAS,CAAA"}

package/src/evaluator/Evaluator.ts

@@ -1,58 +0,0 @@
-/*
- * Jexl
- * Copyright 2020 Tom Shawver
- */
-
-import { compileAst } from './compile.ts'
-
-import type { Grammar } from '../grammar.ts'
-import type { AstNode, JexlValue } from '../types.ts'
-
-/**
- * The Evaluator carries everything an expression is evaluated against: the
- * grammar, the context, and a relative context to be used as the root for
- * relative identifiers. When any of these change, a new instance is required.
- * However, a single instance can be used to evaluate many different
- * expressions, and does not have to be reinstantiated for each.
- *
- * The work of evaluation itself lives in {@link compileAst}, which lowers a
- * tree to closures. Prefer compiling once and reusing the result — that is what
- * {@link Expression} does — over calling {@link #eval}, which compiles the tree
- * it is given every time.
- *
- * @param {{}} grammar A grammar object against which to evaluate the expression
- *      tree
- * @param {{}} [context] A map of variable keys to their values. This will be
- *      accessed to resolve the value of each non-relative identifier.
- * @param {{}|Array<{}|Array>} [relativeContext] A map or array to be accessed
- *      to resolve the value of a relative identifier.
- */
-class Evaluator {
-  _grammar: Grammar
-  _context: Record<string, JexlValue>
-  _relContext: Record<string, JexlValue>
-
-  constructor(
-    grammar: Grammar,
-    context?: Record<string, JexlValue>,
-    relativeContext?: Record<string, JexlValue>
-  ) {
-    this._grammar = grammar
-    this._context = context || {}
-    this._relContext = relativeContext || this._context
-  }
-
-  /**
-   * Compiles and evaluates an expression tree within the configured context.
-   * Convenient for a one-shot evaluation; for repeated evaluation of the same
-   * tree, hold onto the closure from {@link compileAst} instead so the tree is
-   * only lowered once.
-   * @param {{}} ast An expression tree object
-   * @returns {*} the resulting value of the expression.
-   */
-  eval(ast: AstNode): JexlValue {
-    return compileAst(ast, this._grammar)(this)
-  }
-}
-
-export default Evaluator