groupster-engine/dist/buildRuleMap.js

Randomly group objects using do-group and don't-group rules.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.validateSchemas = validateSchemas;
exports.validateGroupSizes = validateGroupSizes;
exports.validateIds = validateIds;
exports["default"] = buildRuleMap;

var _joiBrowser = _interopRequireDefault(require("joi-browser"));

var _lodash = require("lodash");

var _schema = require("./schema");

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

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

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; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

// Verify parameters conform to schema
function validateSchemas(IDs, groupSizes, rules) {
  [[IDs, _schema.IDsSchema], [groupSizes, _schema.GroupSizesSchema], [rules, _schema.RulesSchema]].forEach(function (pair) {
    return _joiBrowser["default"].assert.apply(_joiBrowser["default"], _toConsumableArray(pair));
  });
} // Verify group sizes add up to IDs count


function validateGroupSizes(IDs, groupSizes) {
  var totalOfGroupSizes = groupSizes.reduce(function (sum, size) {
    return sum + size;
  }, 0);

  if (IDs.length !== totalOfGroupSizes) {
    throw new Error("Total of group sizes (".concat(totalOfGroupSizes, ") did not equal member count (").concat(IDs.length, ")."));
  }
} // Verify Ids are unique


function validateIds(IDs) {
  var uniqueIds = (0, _lodash.uniq)(IDs);

  if (IDs.length !== uniqueIds.length) {
    var duplicateIds = (0, _lodash.difference)(IDs, uniqueIds);
    throw new Error("One or more IDs had the same ID: [".concat(duplicateIds.join(', '), "]"));
  }
} // Build rules map


function buildRuleMap(IDs, groupSizes, rules) {
  validateSchemas(IDs, groupSizes, rules);
  validateIds(IDs);
  validateGroupSizes(IDs, groupSizes);
  var ruleMap = IDs.reduce(function (acc, id) {
    return _objectSpread({}, acc, _defineProperty({}, id, {}));
  }, {});

  if (rules) {
    // For each rule...
    rules.forEach(function (rule) {
      var shouldGroup = rule.shouldGroup,
          ruleIDs = rule.IDs; // Ensure ruleIDs correspond to actual IDs

      ruleIDs.forEach(function (ruleID) {
        if (!ruleMap[ruleID]) {
          throw new Error("Rule ".concat(JSON.stringify(rule), " contained id not present in base IDs array ").concat(JSON.stringify(Object.keys(ruleMap))));
        }
      }); // For each pairing within the rule's IDs...

      for (var i = 0; i < ruleIDs.length - 1; i += 1) {
        for (var j = i + 1; j < ruleIDs.length; j += 1) {
          var m1 = ruleIDs[i];
          var m2 = ruleIDs[j]; // Check that rule doesn't conflict with previous rules

          var ruleExisted = ruleMap[m1][m2] !== undefined;

          if (ruleExisted && (!shouldGroup && ruleMap[m1][m2] || shouldGroup && ruleMap[m1][m2] === false)) {
            throw new Error("Rules conflicted, the following IDs were instructed to both group and not group with eachother: [".concat(m1, ", ").concat(m2, "]"));
          } // And add rule into map (both ways)


          ruleMap[m1][m2] = shouldGroup;
          ruleMap[m2][m1] = shouldGroup;
        }
      }
    });
  }

  return ruleMap;
} // {
//   a: {
//     b: true,
//     c: true,
//   },
//   b: {
//     a: true,
//     c: false,
//   },
//   c: {
//     a: true,
//     b: false,
//   },
//   d: {},
// }