compiled sources for 1.4.0

Author: Cache Hamm

dist/almanac.js

@@ -12,6 +12,8 @@ var _fact = require('./fact');
 
 var _fact2 = _interopRequireDefault(_fact);
 
+var _errors = require('./errors');
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
@@ -60,7 +62,7 @@ var Almanac = function () {
     value: function _getFact(factId) {
       var fact = this.factMap.get(factId);
       if (fact === undefined) {
-        throw new Error('Undefined fact: ' + factId);
+        throw new _errors.UndefinedFactError('Undefined fact: ' + factId);
       }
       return fact;
     }

dist/engine.js

@@ -60,12 +60,14 @@ var Engine = function (_EventEmitter) {
    */
   function Engine() {
     var rules = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
     _classCallCheck(this, Engine);
 
     var _this = _possibleConstructorReturn(this, (Engine.__proto__ || Object.getPrototypeOf(Engine)).call(this));
 
     _this.rules = [];
+    _this.allowUndefinedFacts = options.allowUndefinedFacts || false;
     _this.operators = new Map();
     _this.facts = new Map();
     _this.status = READY;
@@ -245,7 +247,7 @@ var Engine = function (_EventEmitter) {
         }, _callee, this);
       }));
 
-      function evaluateRules(_x2, _x3) {
+      function evaluateRules(_x3, _x4) {
         return _ref.apply(this, arguments);
       }
 

dist/errors.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var UndefinedFactError = exports.UndefinedFactError = function (_Error) {
+  _inherits(UndefinedFactError, _Error);
+
+  function UndefinedFactError() {
+    var _ref;
+
+    _classCallCheck(this, UndefinedFactError);
+
+    for (var _len = arguments.length, props = Array(_len), _key = 0; _key < _len; _key++) {
+      props[_key] = arguments[_key];
+    }
+
+    var _this = _possibleConstructorReturn(this, (_ref = UndefinedFactError.__proto__ || Object.getPrototypeOf(UndefinedFactError)).call.apply(_ref, [this].concat(props)));
+
+    _this.code = 'UNDEFINED_FACT';
+    return _this;
+  }
+
+  return UndefinedFactError;
+}(Error);

dist/json-rules-engine.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Engine = exports.Operator = exports.Rule = exports.Fact = undefined;
 
-exports.default = function (rules) {
-  return new _engine2.default(rules);
+exports.default = function (rules, options) {
+  return new _engine2.default(rules, options);
 };
 
 var _engine = require('./engine');

dist/rule.js

@@ -196,71 +196,97 @@ var Rule = function (_EventEmitter) {
                  */
                 evaluateCondition = function () {
                   var _ref2 = _asyncToGenerator(regeneratorRuntime.mark(function _callee(condition) {
-                    var comparisonValue, subConditions, passes;
+                    var comparisonValue, passes, subConditions;
                     return regeneratorRuntime.wrap(function _callee$(_context) {
                       while (1) {
                         switch (_context.prev = _context.next) {
                           case 0:
                             comparisonValue = void 0;
+                            passes = void 0;
 
                             if (!condition.isBooleanOperator()) {
-                              _context.next = 14;
+                              _context.next = 15;
                               break;
                             }
 
                             subConditions = condition[condition.operator];
 
                             if (!(condition.operator === 'all')) {
-                              _context.next = 9;
+                              _context.next = 10;
                               break;
                             }
 
-                            _context.next = 6;
+                            _context.next = 7;
                             return all(subConditions);
 
-                          case 6:
+                          case 7:
                             comparisonValue = _context.sent;
-                            _context.next = 12;
+                            _context.next = 13;
                             break;
 
-                          case 9:
-                            _context.next = 11;
+                          case 10:
+                            _context.next = 12;
                             return any(subConditions);
 
-                          case 11:
+                          case 12:
                             comparisonValue = _context.sent;
 
-                          case 12:
-                            _context.next = 17;
+                          case 13:
+                            _context.next = 28;
                             break;
 
-                          case 14:
-                            _context.next = 16;
+                          case 15:
+                            _context.prev = 15;
+                            _context.next = 18;
                             return almanac.factValue(condition.fact, condition.params);
 
-                          case 16:
+                          case 18:
                             comparisonValue = _context.sent;
+                            _context.next = 28;
+                            break;
+
+                          case 21:
+                            _context.prev = 21;
+                            _context.t0 = _context['catch'](15);
+
+                            if (!(_this3.engine.allowUndefinedFacts && _context.t0.code === 'UNDEFINED_FACT')) {
+                              _context.next = 27;
+                              break;
+                            }
+
+                            passes = false;
+                            _context.next = 28;
+                            break;
+
+                          case 27:
+                            throw _context.t0;
+
+                          case 28:
+                            if (!(passes === undefined)) {
+                              _context.next = 32;
+                              break;
+                            }
 
-                          case 17:
-                            _context.next = 19;
+                            _context.next = 31;
                             return condition.evaluate(comparisonValue, _this3.engine.operators);
 
-                          case 19:
+                          case 31:
                             passes = _context.sent;
 
+                          case 32:
                             if (passes) {
                               _this3.emit('success', _this3.event, almanac);
                             } else {
                               _this3.emit('failure', _this3.event, almanac);
                             }
                             return _context.abrupt('return', passes);
 
-                          case 22:
+                          case 34:
                           case 'end':
                             return _context.stop();
                         }
                       }
-                    }, _callee, _this3);
+                    }, _callee, _this3, [[15, 21]]);
                   }));
 
                   return function evaluateCondition(_x3) {