craft-ai/lib/reducer.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _OPERATORS$IN, _OPERATORS$GTE, _OPERATORS$LT, _REDUCER_FROM_DECISIO;

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

exports.reduceDecisionRules = reduceDecisionRules;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _formatter = require('./formatter');

var _constants = require('./constants');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var REDUCER_FROM_DECISION_RULE = (_REDUCER_FROM_DECISIO = {}, _defineProperty(_REDUCER_FROM_DECISIO, _constants.OPERATORS.IS, _defineProperty({}, _constants.OPERATORS.IS, function (decisionRule1, decisionRule2) {
  if (decisionRule1.operand && decisionRule1.operand != decisionRule2.operand) {
    throw new Error('Operator "' + _constants.OPERATORS.IS + '" can\'t have different value. Set to "' + decisionRule1.operand + '" and receive "' + decisionRule2.operand + '"');
  }
  return {
    property: decisionRule1.property,
    operator: _constants.OPERATORS.IS,
    operand: decisionRule2.operand
  };
})), _defineProperty(_REDUCER_FROM_DECISIO, _constants.OPERATORS.IN, (_OPERATORS$IN = {}, _defineProperty(_OPERATORS$IN, _constants.OPERATORS.IN, function (decisionRule1, decisionRule2) {
  var _decisionRule1$operan = _slicedToArray(decisionRule1.operand, 2),
      o1From = _decisionRule1$operan[0],
      o1To = _decisionRule1$operan[1];

  var _decisionRule2$operan = _slicedToArray(decisionRule2.operand, 2),
      o2From = _decisionRule2$operan[0],
      o2To = _decisionRule2$operan[1];

  var o1IsCyclic = o1From > o1To;
  var o2IsCyclic = o2From > o2To;
  var o2FromInO1 = o1IsCyclic ? o2From >= o1From || o2From <= o1To : o2From >= o1From && o2From <= o1To;
  var o2ToInO1 = o1IsCyclic ? o2To >= o1From || o2To <= o1To : o2To >= o1From && o2To <= o1To;
  var o1FromInO2 = o2IsCyclic ? o1From >= o2From || o1From <= o2To : o1From >= o2From && o1From <= o2To;
  var o1ToInO2 = o2IsCyclic ? o1To >= o2From || o1To <= o2To : o1To >= o2From && o1To <= o2To;

  if (o1FromInO2 && o1ToInO2) {
    // o1 belongs to o2
    //    |    o1    |
    //   |       o2       |
    return decisionRule1;
  }

  if (o2FromInO1 && o2ToInO1) {
    // o2 belongs to o1
    //    |    o1    |
    //      |  o2  |
    return decisionRule2;
  }

  if (o2FromInO1 && o1ToInO2) {
    // overlap 1
    //    |    o1    |
    //             |   o2   |
    return {
      property: decisionRule1.property,
      operator: _constants.OPERATORS.IN,
      operand: [o2From, o1To]
    };
  }

  if (o2ToInO1 && o1FromInO2) {
    // overlap 2
    //        |    o1    |
    //     |   o2   |
    return {
      property: decisionRule1.property,
      operator: _constants.OPERATORS.IN,
      operand: [o1From, o2To]
    };
  }

  // disjointed
  //    |    o1    |
  //                  |   o2   |
  throw new Error('Unable to reduce decision rules \'' + (0, _formatter.formatDecisionRules)([decisionRule1]) + '\' and \'' + (0, _formatter.formatDecisionRules)([decisionRule2]) + '\': the resulting rule is not fulfillable.');
}), _defineProperty(_OPERATORS$IN, _constants.OPERATORS.GTE, function (decisionRule1, decisionRule2) {
  var _decisionRule1$operan2 = _slicedToArray(decisionRule1.operand, 2),
      o1From = _decisionRule1$operan2[0],
      o1To = _decisionRule1$operan2[1];

  var o2 = decisionRule2.operand;

  var o1IsCyclic = o1From > o1To;

  if (o1IsCyclic) {
    // Cyclics makes no sense with single bound limits
    throw new Error('Unable to reduce decision rules \'' + (0, _formatter.formatDecisionRules)([decisionRule1]) + '\' and \'' + (0, _formatter.formatDecisionRules)([decisionRule2]) + '\': the resulting rule is not fulfillable.');
  }

  if (o2 >= o1To) {
    // o2 after o1, disjointed
    //    |    o1    |
    //                  |o2
    throw new Error('Unable to reduce decision rules \'' + (0, _formatter.formatDecisionRules)([decisionRule1]) + '\' and \'' + (0, _formatter.formatDecisionRules)([decisionRule2]) + '\': the resulting rule is not fulfillable.');
  }

  if (o2 >= o1From && o2 < o1To) {
    // o2 belongs to o1
    //    |    o1    |
    //           |o2
    return {
      property: decisionRule1.property,
      operator: _constants.OPERATORS.IN,
      operand: [o2, o1To]
    };
  }

  // o2 before o1
  //    |    o1    |
  //   |o2
  return decisionRule1;
}), _defineProperty(_OPERATORS$IN, _constants.OPERATORS.LT, function (decisionRule1, decisionRule2) {
  var _decisionRule1$operan3 = _slicedToArray(decisionRule1.operand, 2),
      o1From = _decisionRule1$operan3[0],
      o1To = _decisionRule1$operan3[1];

  var o2 = decisionRule2.operand;

  var o1IsCyclic = o1From > o1To;

  if (o1IsCyclic) {
    // Cyclics makes no sense with single bound limits
    throw new Error('Unable to reduce decision rules \'' + (0, _formatter.formatDecisionRules)([decisionRule1]) + '\' and \'' + (0, _formatter.formatDecisionRules)([decisionRule2]) + '\': the resulting rule is not fulfillable.');
  }

  if (o2 < o1From) {
    // o2 before o1, disjointed
    //      |    o1    |
    // o2|
    throw new Error('Unable to reduce decision rules \'' + (0, _formatter.formatDecisionRules)([decisionRule1]) + '\' and \'' + (0, _formatter.formatDecisionRules)([decisionRule2]) + '\': the resulting rule is not fulfillable.');
  }

  if (o2 >= o1From && o2 < o1To) {
    // o2 belongs to o1
    //    |    o1    |
    //         o2|
    return {
      property: decisionRule1.property,
      operator: _constants.OPERATORS.IN,
      operand: [o1From, o2]
    };
  }

  // o2 after o1
  //    |    o1    |
  //                 o2|
  return decisionRule1;
}), _OPERATORS$IN)), _defineProperty(_REDUCER_FROM_DECISIO, _constants.OPERATORS.GTE, (_OPERATORS$GTE = {}, _defineProperty(_OPERATORS$GTE, _constants.OPERATORS.IN, function (decisionRule1, decisionRule2) {
  return REDUCER_FROM_DECISION_RULE[_constants.OPERATORS.IN][_constants.OPERATORS.GTE](decisionRule2, decisionRule1);
}), _defineProperty(_OPERATORS$GTE, _constants.OPERATORS.GTE, function (decisionRule1, decisionRule2) {
  return {
    property: decisionRule1.property,
    operator: _constants.OPERATORS.GTE,
    operand: Math.max(decisionRule1.operand, decisionRule2.operand)
  };
}), _defineProperty(_OPERATORS$GTE, _constants.OPERATORS.LT, function (decisionRule1, decisionRule2) {
  var newLowerBound = decisionRule1.operand;
  var newUpperBound = decisionRule2.operand;
  if (newUpperBound < newLowerBound) {
    throw new Error('Unable to reduce decision rules \'' + (0, _formatter.formatDecisionRules)([decisionRule1]) + '\' and \'' + (0, _formatter.formatDecisionRules)([decisionRule2]) + '\': the resulting rule is not fulfillable.');
  }
  return {
    property: decisionRule1.property,
    operator: _constants.OPERATORS.IN,
    operand: [newLowerBound, newUpperBound]
  };
}), _OPERATORS$GTE)), _defineProperty(_REDUCER_FROM_DECISIO, _constants.OPERATORS.LT, (_OPERATORS$LT = {}, _defineProperty(_OPERATORS$LT, _constants.OPERATORS.IN, function (decisionRule1, decisionRule2) {
  return REDUCER_FROM_DECISION_RULE[_constants.OPERATORS.IN][_constants.OPERATORS.LT](decisionRule2, decisionRule1);
}), _defineProperty(_OPERATORS$LT, _constants.OPERATORS.GTE, function (decisionRule1, decisionRule2) {
  return REDUCER_FROM_DECISION_RULE[_constants.OPERATORS.GTE][_constants.OPERATORS.LT](decisionRule2, decisionRule1);
}), _defineProperty(_OPERATORS$LT, _constants.OPERATORS.LT, function (decisionRule1, decisionRule2) {
  return {
    property: decisionRule1.property,
    operator: _constants.OPERATORS.LT,
    operand: Math.min(decisionRule1.operand, decisionRule2.operand)
  };
}), _OPERATORS$LT)), _REDUCER_FROM_DECISIO);

function decisionRuleReducer(decisionRule1, decisionRule2) {
  if (!decisionRule1 || !decisionRule2) {
    return decisionRule1 || decisionRule2;
  }
  var reducer = REDUCER_FROM_DECISION_RULE[decisionRule1.operator][decisionRule2.operator];
  if (!reducer) {
    throw new Error('Unable to reduce decision rules \'' + (0, _formatter.formatDecisionRules)([decisionRule1]) + '\' and \'' + (0, _formatter.formatDecisionRules)([decisionRule2]) + '\': incompatible operators.');
  }
  return reducer(decisionRule1, decisionRule2);
}

function reduceDecisionRules(decisionRules) {
  var properties = _lodash2.default.uniq(_lodash2.default.map(decisionRules, function (_ref) {
    var property = _ref.property;
    return property;
  }));
  return _lodash2.default.map(properties, function (currentPropery) {
    return (0, _lodash2.default)(decisionRules).filter(function (_ref2) {
      var property = _ref2.property;
      return property == currentPropery;
    }).reduce(decisionRuleReducer, undefined);
  });
}