Method evaluate

src/rule.js:196–397

* Evaluates the rule, starting with the root boolean operator and recursing down * All evaluation is done within the context of an almanac * @return {Promise(RuleResult)} rule evaluation result

(almanac)

   * @return {Promise(RuleResult)} rule evaluation result
   */
  evaluate (almanac) {
    const ruleResult = new RuleResult(
      this.conditions,
      this.ruleEvent,
      this.priority,
      this.name
    )

    /**
     * Evaluates the rule conditions
     * @param  {Condition} condition - condition to evaluate
     * @return {Promise(true|false)} - resolves with the result of the condition evaluation
     */
    const evaluateCondition = (condition) => {
      if (condition.isConditionReference()) {
        return realize(condition)
      } else if (condition.isBooleanOperator()) {
        const subConditions = condition[condition.operator]
        let comparisonPromise
        if (condition.operator === 'all') {
          comparisonPromise = all(subConditions)
        } else if (condition.operator === 'any') {
          comparisonPromise = any(subConditions)
        } else {
          comparisonPromise = not(subConditions)
        }
        // for booleans, rule passing is determined by the all/any/not result
        return comparisonPromise.then((comparisonValue) => {
          const passes = comparisonValue === true
          condition.result = passes
          return passes
        })
      } else {
        return condition
          .evaluate(almanac, this.engine.operators)
          .then((evaluationResult) => {
            const passes = evaluationResult.result
            condition.factResult = evaluationResult.leftHandSideValue
            condition.result = passes
            return passes
          })
      }
    }

    /**
     * Evalutes an array of conditions, using an 'every' or 'some' array operation
     * @param  {Condition[]} conditions
     * @param  {string(every|some)} array method to call for determining result
     * @return {Promise(boolean)} whether conditions evaluated truthy or falsey based on condition evaluation + method
     */
    const evaluateConditions = (conditions, method) => {
      if (!Array.isArray(conditions)) conditions = [conditions]

      return Promise.all(
        conditions.map((condition) => evaluateCondition(condition))
      ).then((conditionResults) => {
        debug('rule::evaluateConditions results', conditionResults)
        return method.call(conditionResults, (result) => result === true)