[Lens] Add conditional operations in Formula

packages/kbn-tinymath/README.md

@@ -66,7 +66,10 @@ parse('1 + random()')
 
 This package is rebuilt when running `yarn kbn bootstrap`, but can also be build directly
 using `yarn build` from the `packages/kbn-tinymath` directory.
+
 ### Running tests
 
-To test `@kbn/tinymath` from Kibana, run `yarn run jest --watch packages/kbn-tinymath` from
+To test `@kbn/tinymath` from Kibana, run `node scripts/jest --config packages/kbn-tinymath/jest.config.js` from
 the top level of Kibana.
+
+To test grammar changes it is required to run a build task before the test suite.

packages/kbn-tinymath/grammar/grammar.peggy

@@ -11,6 +11,32 @@
       max: location.end.offset
     }
   }
+
+  const symbolsToFn = {
+    '+': 'add', '-': 'subtract',
+    '*': 'multiply', '/': 'divide',
+    '<': 'lt', '>': 'gt', '==': 'eq',
+    '<=': 'lte', '>=': 'gte',
+  }
+
+  // Shared function for AST operations
+  function parseSymbol(left, rest){
+    const topLevel = rest.reduce((acc, [name, right]) => ({
+      type: 'function',
+      name: symbolsToFn[name],
+      args: [acc, right],
+    }), left);
+    if (typeof topLevel === 'object') {
+      topLevel.location = simpleLocation(location());
+      topLevel.text = text();
+    }
+    return topLevel;
+  }
+
+  // op is always defined, while eq can be null for gt and lt cases
+  function getComparisonSymbol([op, eq]){
+    return symbolsToFn[op+(eq || '')];
+  }
 }
 
 start
@@ -70,45 +96,55 @@ Variable
 
 // expressions
 
+// An Expression can be of 3 different types:
+// * a Comparison operation, which can contain recursive MathOperations inside
+// * a MathOperation, which can contain other MathOperations, but not Comparison types
+// * an ExpressionGroup, which is a generic Grouping that contains also Comparison operations (i.e. ( 5 > 1))
 Expression
+  = Comparison 
+  / MathOperation
+  / ExpressionGroup
+
+Comparison
+  = _ left:MathOperation op:(('>' / '<')('=')? / '=''=') right:MathOperation _ {
+    return {
+      type: 'function',
+      name: getComparisonSymbol(op),
+      args: [left, right],
+      location: simpleLocation(location()),
+      text: text()
+    };
+  }
+
+MathOperation 
   = AddSubtract
+  / MultiplyDivide
+  / Factor
 
 AddSubtract
   = _ left:MultiplyDivide rest:(('+' / '-') MultiplyDivide)+ _ {
-    const topLevel = rest.reduce((acc, curr) => ({
-      type: 'function',
-      name: curr[0] === '+' ? 'add' : 'subtract',
-      args: [acc, curr[1]],
-    }), left);
-    if (typeof topLevel === 'object') {
-      topLevel.location = simpleLocation(location());
-      topLevel.text = text();
-    }
-    return topLevel;
+    return parseSymbol(left, rest, {'+': 'add', '-': 'subtract'});
   }
-  / MultiplyDivide
 
 MultiplyDivide
   = _ left:Factor rest:(('*' / '/') Factor)* _ {
-    const topLevel = rest.reduce((acc, curr) => ({
-      type: 'function',
-      name: curr[0] === '*' ? 'multiply' : 'divide',
-      args: [acc, curr[1]],
-    }), left);
-    if (typeof topLevel === 'object') {
-      topLevel.location = simpleLocation(location());
-      topLevel.text = text();
-    }
-    return topLevel;
+    return parseSymbol(left, rest, {'*': 'multiply', '/': 'divide'});
   }
-  / Factor
 
 Factor
   = Group
   / Function
   / Literal
 
+// Because of the new Comparison syntax it is required a new Group type
+// the previous Group has been renamed into ExpressionGroup while
+// a new Group type has been defined to exclude the Comparison type from it
 Group
+  = _ '(' _ expr:MathOperation _ ')' _ {
+    return expr
+  }
+
+ExpressionGroup
   = _ '(' _ expr:Expression _ ')' _ {
     return expr
   }

packages/kbn-tinymath/src/functions/comparison/eq.js

@@ -0,0 +1,40 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+/**
+ * Performs an equality comparison between two values.
+ * @param {number|number[]} a a number or an array of numbers
+ * @param {number|number[]} b a number or an array of numbers
+ * @return {boolean} Returns true if `a` and `b` are equal, false otherwise.  Returns an array with the equality comparison of each element if `a` is an array.
+ * @throws `'Missing b value'` if `b` is not provided
+ * @throws `'Array length mismatch'` if `args` contains arrays of different lengths
+ * @example
+ * eq(1, 1) // returns true
+ * eq(1, 2) // returns false
+ * eq([1, 2], 1) // returns [true, false]
+ * eq([1, 2], [1, 2]) // returns [true, true]
+ */
+
+module.exports = { eq };
+
+function eq(a, b) {
+  if (b == null) {
+    throw new Error('Missing b value');
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) {
+      return a.every((v) => v === b);
+    }
+    if (a.length !== b.length) {
+      throw new Error('Array length mismatch');
+    }
+    return a.every((v, i) => v === b[i]);
+  }
+
+  return a === b;
+}

packages/kbn-tinymath/src/functions/comparison/gt.js

@@ -0,0 +1,40 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+/**
+ * Performs a greater than comparison between two values.
+ * @param {number|number[]} a a number or an array of numbers
+ * @param {number|number[]} b a number or an array of numbers
+ * @return {boolean} Returns true if `a` is greater than `b`, false otherwise.  Returns an array with the greater than comparison of each element if `a` is an array.
+ * @throws `'Missing b value'` if `b` is not provided
+ * @throws `'Array length mismatch'` if `args` contains arrays of different lengths
+ * @example
+ * gt(1, 1) // returns false
+ * gt(2, 1) // returns true
+ * gt([1, 2], 1) // returns [true, false]
+ * gt([1, 2], [2, 1]) // returns [false, true]
+ */
+
+module.exports = { gt };
+
+function gt(a, b) {
+  if (b == null) {
+    throw new Error('Missing b value');
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) {
+      return a.every((v) => v > b);
+    }
+    if (a.length !== b.length) {
+      throw new Error('Array length mismatch');
+    }
+    return a.every((v, i) => v > b[i]);
+  }
+
+  return a > b;
+}

packages/kbn-tinymath/src/functions/comparison/gte.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+const { eq } = require('./eq');
+const { gt } = require('./gt');
+
+/**
+ * Performs a greater than or equal comparison between two values.
+ * @param {number|number[]} a a number or an array of numbers
+ * @param {number|number[]} b a number or an array of numbers
+ * @return {boolean} Returns true if `a` is greater than or equal to `b`, false otherwise.  Returns an array with the greater than or equal comparison of each element if `a` is an array.
+ * @throws `'Array length mismatch'` if `args` contains arrays of different lengths
+ * @example
+ * gte(1, 1) // returns true
+ * gte(1, 2) // returns false
+ * gte([1, 2], 2) // returns [false, true]
+ * gte([1, 2], [1, 1]) // returns [true, true]
+ */
+
+module.exports = { gte };
+
+function gte(a, b) {
+  return eq(a, b) || gt(a, b);
+}

packages/kbn-tinymath/src/functions/comparison/ifelse.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+/**
+ * Evaluates the a conditional argument and returns one of the two values based on that.
+ * @param {(boolean)} cond a boolean value
+ * @param {(any|any[])} a a value or an array of any values
+ * @param {(any|any[])} b a value or an array of any values
+ * @return {(any|any[])} if the value of cond is truthy, return `a`, otherwise return `b`.
+ * @throws `'Condition clause is of the wrong type'` if the `cond` provided is not of boolean type
+ * @throws `'Missing a value'` if `a` is not provided
+ * @throws `'Missing b value'` if `b` is not provided
+ * @example
+ * ifelse( 5 > 6, 1, 0) // returns 0
+ * ifelse( 1 == 1, [1, 2, 3], 5) // returns [1, 2, 3]
+ * ifelse( 1 < 2, [1, 2, 3], [2, 3, 4]) // returns [1, 2, 3]
+ */
+
+module.exports = { ifelse };
+
+function ifelse(cond, a, b) {
+  if (typeof cond !== 'boolean') {
+    throw Error('Condition clause is of the wrong type');
+  }
+  if (a == null) {
+    throw new Error('Missing a value');
+  }
+  if (b == null) {
+    throw new Error('Missing b value');
+  }
+  return cond ? a : b;
+}
+
+ifelse.skipNumberValidation = true;

packages/kbn-tinymath/src/functions/comparison/index.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+const { eq } = require('./eq');
+const { lt } = require('./lt');
+const { gt } = require('./gt');
+const { lte } = require('./lte');
+const { gte } = require('./gte');
+const { ifelse } = require('./ifelse');
+
+module.exports = { eq, lt, gt, lte, gte, ifelse };

packages/kbn-tinymath/src/functions/comparison/lt.js

@@ -0,0 +1,40 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+/**
+ * Performs a lower than comparison between two values.
+ * @param {number|number[]} a a number or an array of numbers
+ * @param {number|number[]} b a number or an array of numbers
+ * @return {boolean} Returns true if `a` is lower than `b`, false otherwise.  Returns an array with the lower than comparison of each element if `a` is an array.
+ * @throws `'Missing b value'` if `b` is not provided
+ * @throws `'Array length mismatch'` if `args` contains arrays of different lengths
+ * @example
+ * lt(1, 1) // returns false
+ * lt(1, 2) // returns true
+ * lt([1, 2], 2) // returns [true, false]
+ * lt([1, 2], [1, 2]) // returns [false, false]
+ */
+
+module.exports = { lt };
+
+function lt(a, b) {
+  if (b == null) {
+    throw new Error('Missing b value');
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) {
+      return a.every((v) => v < b);
+    }
+    if (a.length !== b.length) {
+      throw new Error('Array length mismatch');
+    }
+    return a.every((v, i) => v < b[i]);
+  }
+
+  return a < b;
+}

packages/kbn-tinymath/src/functions/comparison/lte.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+const { eq } = require('./eq');
+const { lt } = require('./lt');
+
+/**
+ * Performs a lower than or equal comparison between two values.
+ * @param {number|number[]} a a number or an array of numbers
+ * @param {number|number[]} b a number or an array of numbers
+ * @return {boolean} Returns true if `a` is lower than or equal to `b`, false otherwise.  Returns an array with the lower than or equal comparison of each element if `a` is an array.
+ * @throws `'Array length mismatch'` if `args` contains arrays of different lengths
+ * @example
+ * lte(1, 1) // returns true
+ * lte(1, 2) // returns true
+ * lte([1, 2], 2) // returns [true, true]
+ * lte([1, 2], [1, 1]) // returns [true, false]
+ */
+
+module.exports = { lte };
+
+function lte(a, b) {
+  return eq(a, b) || lt(a, b);
+}

packages/kbn-tinymath/src/functions/divide.js

@@ -30,7 +30,12 @@ function divide(a, b) {
       return val / b[i];
     });
   }
-  if (Array.isArray(b)) return b.map((b) => a / b);
+  if (Array.isArray(b)) {
+    return b.map((bi) => {
+      if (bi === 0) throw new Error('Cannot divide by 0');
+      return a / bi;
+    });
+  }
   if (b === 0) throw new Error('Cannot divide by 0');
   if (Array.isArray(a)) return a.map((a) => a / b);
   return a / b;