Merge branch 'json-logic:master' into master

Author: codetiger

asLogic.test.js

@@ -70,9 +70,14 @@ describe('asLogicAsync', () => {
 
   it('Should not allow you to create a builder with methods that do not exist', async () => {
     const builder = asLogicAsync(module)
-    expect(builder({
-      hello: { '+': [1, 2] }
-    })).rejects.toThrow()
+    try {
+      await builder({
+        hello: { '+': [1, 2] }
+      })
+    } catch (e) {
+      return
+    }
+    throw new Error('Should have thrown an error')
   })
 
   it('Should let you select logic kept', async () => {

asyncLogic.js

@@ -69,12 +69,13 @@ class AsyncLogicEngine {
    * @param {*} above The context above (can be used for handlebars-style data traversal.)
    * @returns {Promise<*>}
    */
-  async _parse (logic, context, above) {
-    const [func] = Object.keys(logic)
+  async _parse (logic, context, above, func, length) {
     const data = logic[func]
 
     if (this.isData(logic, func)) return logic
-    if (!this.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+
+    // eslint-disable-next-line no-throw-literal
+    if (!this.methods[func] || length > 1) throw { type: 'Unknown Operator', key: func }
 
     // A small but useful micro-optimization for some of the most common functions.
     // Later on, I could define something to shut this off if var / val are redefined.
@@ -182,7 +183,13 @@ class AsyncLogicEngine {
       return res
     }
 
-    if (logic && typeof logic === 'object' && Object.keys(logic).length > 0) return this._parse(logic, data, above)
+    if (logic && typeof logic === 'object' && Object.keys(logic).length > 0) {
+      const keys = Object.keys(logic)
+      if (keys.length > 0) {
+        const func = keys[0]
+        return this._parse(logic, data, above, func, keys.length)
+      }
+    }
 
     return logic
   }

async_optimizer.js

@@ -85,9 +85,14 @@ export function optimize (logic, engine, above = []) {
     const keys = Object.keys(logic)
     const methodName = keys[0]
 
+    if (keys.length === 0) return logic
+
     const isData = engine.isData(logic, methodName)
     if (isData) return () => logic
 
+    // eslint-disable-next-line no-throw-literal
+    if (keys.length > 1) throw { type: 'Unknown Operator' }
+
     // If we have a deterministic function, we can just return the result of the evaluation,
     // basically inlining the operation.
     const deterministic = !engine.disableInline && isDeterministic(logic, engine, { engine })
@@ -113,6 +118,9 @@ export function optimize (logic, engine, above = []) {
       }
       return result
     }
+
+    // eslint-disable-next-line no-throw-literal
+    throw { type: 'Unknown Operator', key: methodName }
   }
 
   return logic

compiler.js

@@ -86,7 +86,9 @@ export function isDeterministic (method, engine, buildState) {
 
     if (engine.isData(method, func)) return true
     if (lower === undefined) return true
-    if (!engine.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+
+    // eslint-disable-next-line no-throw-literal
+    if (!engine.methods[func]) throw { type: 'Unknown Operator', key: func }
 
     if (engine.methods[func].lazy) {
       return typeof engine.methods[func].deterministic === 'function'
@@ -169,14 +171,16 @@ function buildString (method, buildState = {}) {
     return result
   }
 
-  const func = method && Object.keys(method)[0]
-
   if (method && typeof method === 'object') {
+    const keys = Object.keys(method)
+    const func = keys[0]
+
     if (!func) return pushValue(method)
-    if (!engine.methods[func]) {
+    if (!engine.methods[func] || keys.length > 1) {
       // Check if this is supposed to be "data" rather than a function.
       if (engine.isData(method, func)) return pushValue(method, true)
-      throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+      // eslint-disable-next-line no-throw-literal
+      throw { type: 'Unknown Operator', key: func }
     }
 
     if (

defaultMethods.js

@@ -20,7 +20,8 @@ function isDeterministic (method, engine, buildState) {
     const lower = method[func]
 
     if (engine.isData(method, func) || func === undefined) return true
-    if (!engine.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+    // eslint-disable-next-line no-throw-literal
+    if (!engine.methods[func]) throw { type: 'Unknown Operator', key: func }
 
     if (engine.methods[func].lazy) {
       return typeof engine.methods[func].deterministic === 'function'
@@ -45,7 +46,8 @@ function isSyncDeep (method, engine, buildState) {
     const func = Object.keys(method)[0]
     const lower = method[func]
     if (engine.isData(method, func) || func === undefined) return true
-    if (!engine.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+    // eslint-disable-next-line no-throw-literal
+    if (!engine.methods[func]) throw { type: 'Unknown Operator', key: func }
     if (engine.methods[func].lazy) return typeof engine.methods[func][Sync] === 'function' ? engine.methods[func][Sync](lower, buildState) : engine.methods[func][Sync]
     return typeof engine.methods[func][Sync] === 'function' ? engine.methods[func][Sync](lower, buildState) : engine.methods[func][Sync] && isSyncDeep(lower, engine, buildState)
   }
@@ -147,15 +149,32 @@ const defaultMethods = {
     // eslint-disable-next-line no-throw-literal
     throw { type }
   },
-  max: (data) => Math.max(...data),
-  min: (data) => Math.min(...data),
+  max: (data) => {
+    if (!data.length || typeof data[0] !== 'number') throw INVALID_ARGUMENTS
+    let max = data[0]
+    for (let i = 1; i < data.length; i++) {
+      if (typeof data[i] !== 'number') throw INVALID_ARGUMENTS
+      if (data[i] > max) max = data[i]
+    }
+    return max
+  },
+  min: (data) => {
+    if (!data.length || typeof data[0] !== 'number') throw INVALID_ARGUMENTS
+    let min = data[0]
+    for (let i = 1; i < data.length; i++) {
+      if (typeof data[i] !== 'number') throw INVALID_ARGUMENTS
+      if (data[i] < min) min = data[i]
+    }
+    return min
+  },
   in: ([item, array]) => (array || []).includes(item),
   preserve: {
     lazy: true,
     method: declareSync((i) => i, true),
     [Sync]: () => true
   },
   if: {
+    [OriginalImpl]: true,
     method: (input, context, above, engine) => {
       if (!Array.isArray(input)) throw INVALID_ARGUMENTS
 
@@ -228,7 +247,7 @@ const defaultMethods = {
     [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     method: (arr, context, above, engine) => {
       if (!Array.isArray(arr)) throw INVALID_ARGUMENTS
-      if (!arr.length) return false
+      if (!arr.length) return null
 
       let item
       for (let i = 0; i < arr.length; i++) {
@@ -240,7 +259,7 @@ const defaultMethods = {
     },
     asyncMethod: async (arr, _1, _2, engine) => {
       if (!Array.isArray(arr)) throw INVALID_ARGUMENTS
-      if (!arr.length) return false
+      if (!arr.length) return null
 
       let item
       for (let i = 0; i < arr.length; i++) {
@@ -254,7 +273,7 @@ const defaultMethods = {
     compile: (data, buildState) => {
       let res = buildState.compile``
       if (Array.isArray(data)) {
-        if (!data.length) return buildState.compile`false`
+        if (!data.length) return buildState.compile`null`
         for (let i = 0; i < data.length; i++) res = buildState.compile`${res} engine.truthy(prev = ${data[i]}) ? prev : `
         res = buildState.compile`${res} prev`
         return res
@@ -386,7 +405,7 @@ const defaultMethods = {
     [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     method: (arr, context, above, engine) => {
       if (!Array.isArray(arr)) throw INVALID_ARGUMENTS
-      if (!arr.length) return false
+      if (!arr.length) return null
 
       let item
       for (let i = 0; i < arr.length; i++) {
@@ -397,7 +416,7 @@ const defaultMethods = {
     },
     asyncMethod: async (arr, _1, _2, engine) => {
       if (!Array.isArray(arr)) throw INVALID_ARGUMENTS
-      if (!arr.length) return false
+      if (!arr.length) return null
       let item
       for (let i = 0; i < arr.length; i++) {
         item = await engine.run(arr[i], _1, { above: _2 })
@@ -410,7 +429,7 @@ const defaultMethods = {
     compile: (data, buildState) => {
       let res = buildState.compile``
       if (Array.isArray(data)) {
-        if (!data.length) return buildState.compile`false`
+        if (!data.length) return buildState.compile`null`
         for (let i = 0; i < data.length; i++) res = buildState.compile`${res} !engine.truthy(prev = ${data[i]}) ? prev : `
         res = buildState.compile`${res} prev`
         return res
@@ -866,6 +885,7 @@ function createArrayIterativeMethod (name, useTruthy = false) {
         })
       )
     },
+    [OriginalImpl]: true,
     [Sync]: (data, buildState) => isSyncDeep(data, buildState.engine, buildState),
     method: (input, context, above, engine) => {
       if (!Array.isArray(input)) throw INVALID_ARGUMENTS
@@ -933,21 +953,6 @@ Object.keys(defaultMethods).forEach((item) => {
       : defaultMethods[item].deterministic
 })
 
-// @ts-ignore Allow custom attribute
-defaultMethods.min.compile = function (data, buildState) {
-  if (!Array.isArray(data)) return false
-  return `Math.min(${data
-    .map((i) => buildString(i, buildState))
-    .join(', ')})`
-}
-// @ts-ignore Allow custom attribute
-defaultMethods.max.compile = function (data, buildState) {
-  if (!Array.isArray(data)) return false
-  return `Math.max(${data
-    .map((i) => buildString(i, buildState))
-    .join(', ')})`
-}
-
 // @ts-ignore Allow custom attribute
 defaultMethods.if.compile = function (data, buildState) {
   if (!Array.isArray(data)) return false

logic.js

@@ -60,12 +60,13 @@ class LogicEngine {
    * @param {*} above The context above (can be used for handlebars-style data traversal.)
    * @returns {{ result: *, func: string }}
    */
-  _parse (logic, context, above, func) {
+  _parse (logic, context, above, func, length) {
     const data = logic[func]
 
     if (this.isData(logic, func)) return logic
 
-    if (!this.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+    // eslint-disable-next-line no-throw-literal
+    if (!this.methods[func] || length > 1) throw { type: 'Unknown Operator', key: func }
 
     // A small but useful micro-optimization for some of the most common functions.
     // Later on, I could define something to shut this off if var / val are redefined.
@@ -161,7 +162,7 @@ class LogicEngine {
       const keys = Object.keys(logic)
       if (keys.length > 0) {
         const func = keys[0]
-        return this._parse(logic, data, above, func)
+        return this._parse(logic, data, above, func, keys.length)
       }
     }
 

optimizer.js

@@ -115,6 +115,27 @@ function checkIdioms (logic, engine, above) {
     }
   }
 
+  if ((logic.if || logic['?:']) && engine.methods.if[OriginalImpl] && Array.isArray(logic.if || logic['?:']) && (logic.if || logic['?:']).length === 3) {
+    const [condition, truthy, falsy] = logic.if || logic['?:']
+    const C = optimize(condition, engine, above)
+    const T = optimize(truthy, engine, above)
+    const F = optimize(falsy, engine, above)
+
+    if (typeof C === 'function' && typeof T === 'function' && typeof F === 'function') return (data, abv) => engine.truthy(C(data, abv)) ? T(data, abv) : F(data, abv)
+    if (typeof C === 'function' && typeof T === 'function') return (data, abv) => engine.truthy(C(data, abv)) ? T(data, abv) : F
+    if (typeof C === 'function' && typeof F === 'function') return (data, abv) => engine.truthy(C(data, abv)) ? T : F(data, abv)
+    if (typeof C === 'function') return (data, abv) => engine.truthy(C(data, abv)) ? T : F
+
+    // Otherwise, C is not a function, and we can just return the result of the evaluation.
+    return engine.truthy(C) ? T : F
+  }
+
+  if (logic.filter && engine.methods.filter[OriginalImpl] && Array.isArray(logic.filter) && logic.filter.length === 2) {
+    const [collection, filter] = logic.filter
+    const filterF = optimize(filter, engine, above)
+    if (typeof filterF !== 'function') return engine.truthy(filterF) ? optimize(collection, engine, above) : []
+  }
+
   // Hyper-Optimizations for Comparison Operators.
   for (const comparison in comparisons) {
     if (logic[comparison] && Array.isArray(logic[comparison]) && engine.methods[comparison][OriginalImpl]) {
@@ -195,9 +216,14 @@ export function optimize (logic, engine, above = []) {
     const keys = Object.keys(logic)
     const methodName = keys[0]
 
+    if (keys.length === 0) return logic
+
     const isData = engine.isData(logic, methodName)
     if (isData) return () => logic
 
+    // eslint-disable-next-line no-throw-literal
+    if (keys.length > 1) throw { type: 'Unknown Operator' }
+
     // If we have a deterministic function, we can just return the result of the evaluation,
     // basically inlining the operation.
     const deterministic = !engine.disableInline && isDeterministic(logic, engine, { engine })
@@ -207,6 +233,9 @@ export function optimize (logic, engine, above = []) {
       if (deterministic) return result()
       return result
     }
+
+    // eslint-disable-next-line no-throw-literal
+    throw { type: 'Unknown Operator', key: methodName }
   }
 
   return logic