objection/lib/queryBuilder/graphInserter/DependencyGraph.js

An SQL-friendly ORM for Node.js

'use strict';

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

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

var _create = require('babel-runtime/core-js/object/create');

var _create2 = _interopRequireDefault(_create);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _Model = require('../../model/Model');

var _Model2 = _interopRequireDefault(_Model);

var _HasManyRelation = require('../../relations/hasMany/HasManyRelation');

var _HasManyRelation2 = _interopRequireDefault(_HasManyRelation);

var _RelationExpression = require('../RelationExpression');

var _RelationExpression2 = _interopRequireDefault(_RelationExpression);

var _ManyToManyRelation = require('../../relations/manyToMany/ManyToManyRelation');

var _ManyToManyRelation2 = _interopRequireDefault(_ManyToManyRelation);

var _BelongsToOneRelation = require('../../relations/belongsToOne/BelongsToOneRelation');

var _BelongsToOneRelation2 = _interopRequireDefault(_BelongsToOneRelation);

var _ValidationError = require('../../model/ValidationError');

var _ValidationError2 = _interopRequireDefault(_ValidationError);

var _DependencyNode = require('./DependencyNode');

var _DependencyNode2 = _interopRequireDefault(_DependencyNode);

var _HasManyDependency = require('./HasManyDependency');

var _HasManyDependency2 = _interopRequireDefault(_HasManyDependency);

var _ManyToManyConnection = require('./ManyToManyConnection');

var _ManyToManyConnection2 = _interopRequireDefault(_ManyToManyConnection);

var _ReplaceValueDependency = require('./ReplaceValueDependency');

var _ReplaceValueDependency2 = _interopRequireDefault(_ReplaceValueDependency);

var _BelongsToOneDependency = require('./BelongsToOneDependency');

var _BelongsToOneDependency2 = _interopRequireDefault(_BelongsToOneDependency);

var _InterpolateValueDependency = require('./InterpolateValueDependency');

var _InterpolateValueDependency2 = _interopRequireDefault(_InterpolateValueDependency);

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

var DependencyGraph = function () {
  function DependencyGraph(allowedRelations) {
    (0, _classCallCheck3.default)(this, DependencyGraph);

    /**
     * @type {RelationExpression}
     */
    this.allowedRelations = allowedRelations;

    /**
     * @type {Object.<string, DependencyNode>}
     */
    this.nodesById = (0, _create2.default)(null);

    /**
     * @type {Object.<string, DependencyNode>}
     */
    this.inputNodesById = (0, _create2.default)(null);

    /**
     * @type {Array.<DependencyNode>}
     */
    this.nodes = [];

    /**
     * @type {number}
     */
    this.uid = 0;
  }

  DependencyGraph.prototype.build = function build(modelClass, models) {
    this.nodesById = (0, _create2.default)(null);
    this.nodes = [];

    if (Array.isArray(models)) {
      for (var i = 0, l = models.length; i < l; ++i) {
        this.buildForModel(modelClass, models[i], null, null, this.allowedRelations);
      }
    } else {
      this.buildForModel(modelClass, models, null, null, this.allowedRelations);
    }

    this.solveReferences();
    this.createNonRelationDeps();

    if (this.isCyclic(this.nodes)) {
      throw new _ValidationError2.default({ cyclic: 'the object graph contains cyclic references' });
    }

    return this.nodes;
  };

  DependencyGraph.prototype.buildForModel = function buildForModel(modelClass, model, parentNode, rel, allowedRelations) {
    if (!(model instanceof _Model2.default)) {
      throw new _ValidationError2.default({ notModel: 'not a model' });
    }

    if (!model[modelClass.uidProp]) {
      model[modelClass.uidProp] = this.createUid();
    }

    var node = new _DependencyNode2.default(model, modelClass);

    this.nodesById[node.id] = node;
    this.nodes.push(node);

    if (!parentNode) {
      this.inputNodesById[node.id] = node;
    }

    if (rel instanceof _HasManyRelation2.default) {

      node.needs.push(new _HasManyDependency2.default(parentNode, rel));
      parentNode.isNeededBy.push(new _HasManyDependency2.default(node, rel));
    } else if (rel instanceof _BelongsToOneRelation2.default) {

      node.isNeededBy.push(new _BelongsToOneDependency2.default(parentNode, rel));
      parentNode.needs.push(new _BelongsToOneDependency2.default(node, rel));
    } else if (rel instanceof _ManyToManyRelation2.default) {

      // ManyToManyRelations create no dependencies since we can create the
      // join table rows after everything else has been inserted.
      parentNode.manyToManyConnections.push(new _ManyToManyConnection2.default(node, rel));
    }

    this.buildForRelations(modelClass, model, node, allowedRelations);
  };

  DependencyGraph.prototype.buildForRelations = function buildForRelations(modelClass, model, node, allowedRelations) {
    var relations = modelClass.getRelationArray();

    for (var i = 0, l = relations.length; i < l; ++i) {
      var rel = relations[i];
      var relName = rel.name;
      var relModels = model[relName];

      var nextAllowed = null;

      if (relModels && allowedRelations instanceof _RelationExpression2.default) {
        nextAllowed = allowedRelations.childExpression(relName);

        if (!nextAllowed) {
          throw new _ValidationError2.default({ allowedRelations: 'trying to insert an unallowed relation' });
        }
      }

      if (Array.isArray(relModels)) {
        for (var _i = 0, _l = relModels.length; _i < _l; ++_i) {
          this.buildForItem(rel.relatedModelClass, relModels[_i], node, rel, nextAllowed);
        }
      } else if (relModels) {
        this.buildForItem(rel.relatedModelClass, relModels, node, rel, nextAllowed);
      }
    }
  };

  DependencyGraph.prototype.buildForItem = function buildForItem(modelClass, item, parentNode, rel, allowedRelations) {
    if (rel instanceof _ManyToManyRelation2.default && item[modelClass.dbRefProp]) {
      this.buildForId(modelClass, item, parentNode, rel, allowedRelations);
    } else {
      this.buildForModel(modelClass, item, parentNode, rel, allowedRelations);
    }
  };

  DependencyGraph.prototype.buildForId = function buildForId(modelClass, item, parentNode, rel) {
    var node = new _DependencyNode2.default(item, modelClass);
    node.handled = true;

    item.$id(item[modelClass.dbRefProp]);
    parentNode.manyToManyConnections.push(new _ManyToManyConnection2.default(node, rel));
  };

  DependencyGraph.prototype.solveReferences = function solveReferences() {
    var refMap = (0, _create2.default)(null);

    // First merge all reference nodes into the actual node.
    this.mergeReferences(refMap);

    // Replace all reference nodes with the actual nodes.
    this.replaceReferenceNodes(refMap);
  };

  DependencyGraph.prototype.mergeReferences = function mergeReferences(refMap) {
    for (var n = 0, ln = this.nodes.length; n < ln; ++n) {
      var refNode = this.nodes[n];

      if (refNode.handled) {
        continue;
      }

      var ref = refNode.model[refNode.modelClass.uidRefProp];

      if (ref) {
        var actualNode = this.nodesById[ref];

        if (!actualNode) {
          throw new _ValidationError2.default({ ref: 'could not resolve reference "' + ref + '"' });
        }

        var d = void 0,
            ld = void 0;

        for (d = 0, ld = refNode.needs.length; d < ld; ++d) {
          actualNode.needs.push(refNode.needs[d]);
        }

        for (d = 0, ld = refNode.isNeededBy.length; d < ld; ++d) {
          actualNode.isNeededBy.push(refNode.isNeededBy[d]);
        }

        for (var m = 0, lm = refNode.manyToManyConnections.length; m < lm; ++m) {
          actualNode.manyToManyConnections.push(refNode.manyToManyConnections[m]);
        }

        refMap[refNode.id] = actualNode;
        refNode.handled = true;
      }
    }
  };

  DependencyGraph.prototype.replaceReferenceNodes = function replaceReferenceNodes(refMap) {
    for (var n = 0, ln = this.nodes.length; n < ln; ++n) {
      var node = this.nodes[n];
      var d = void 0,
          ld = void 0,
          dep = void 0,
          actualNode = void 0;

      for (d = 0, ld = node.needs.length; d < ld; ++d) {
        dep = node.needs[d];
        actualNode = refMap[dep.node.id];

        if (actualNode) {
          dep.node = actualNode;
        }
      }

      for (d = 0, ld = node.isNeededBy.length; d < ld; ++d) {
        dep = node.isNeededBy[d];
        actualNode = refMap[dep.node.id];

        if (actualNode) {
          dep.node = actualNode;
        }
      }

      for (var m = 0, lm = node.manyToManyConnections.length; m < lm; ++m) {
        var conn = node.manyToManyConnections[m];
        actualNode = refMap[conn.node.id];

        if (actualNode) {
          conn.refNode = conn.node;
          conn.node = actualNode;
        }
      }
    }
  };

  DependencyGraph.prototype.createNonRelationDeps = function createNonRelationDeps() {
    for (var n = 0, ln = this.nodes.length; n < ln; ++n) {
      var node = this.nodes[n];

      if (!node.handled) {
        this.createNonRelationDepsForObject(node.model, node, []);
      }
    }
  };

  DependencyGraph.prototype.createNonRelationDepsForObject = function createNonRelationDepsForObject(obj, node, path) {
    var _this = this;

    var propRefRegex = node.modelClass.propRefRegex;
    var relations = node.modelClass.getRelations();
    var isModel = obj instanceof _Model2.default;
    var keys = (0, _keys2.default)(obj);

    var _loop = function _loop(i, l) {
      var key = keys[i];
      var value = obj[key];

      if (isModel && relations[key]) {
        // Don't traverse the relations of model instances.
        return {
          v: void 0
        };
      }

      path.push(key);

      if (typeof value === 'string') {
        allMatches(propRefRegex, value, function (matchResult) {
          var match = matchResult[0];
          var refId = matchResult[1];
          var refProp = matchResult[2];
          var refNode = _this.nodesById[refId];

          if (!refNode) {
            throw new _ValidationError2.default({ ref: 'could not resolve reference "' + value + '"' });
          }

          if (value === match) {
            // If the match is the whole string, replace the value with the resolved value.
            // This means that the value will have the same type as the resolved value
            // (date, number, etc).
            node.needs.push(new _ReplaceValueDependency2.default(refNode, path, refProp, false));
            refNode.isNeededBy.push(new _ReplaceValueDependency2.default(node, path, refProp, true));
          } else {
            // If the match is inside a string, replace the reference inside the string with
            // the resolved value.
            node.needs.push(new _InterpolateValueDependency2.default(refNode, path, refProp, match, false));
            refNode.isNeededBy.push(new _InterpolateValueDependency2.default(node, path, refProp, match, true));
          }
        });
      } else if (value && (typeof value === 'undefined' ? 'undefined' : (0, _typeof3.default)(value)) === 'object') {
        _this.createNonRelationDepsForObject(value, node, path);
      }

      path.pop();
    };

    for (var i = 0, l = keys.length; i < l; ++i) {
      var _ret = _loop(i, l);

      if ((typeof _ret === 'undefined' ? 'undefined' : (0, _typeof3.default)(_ret)) === "object") return _ret.v;
    }
  };

  DependencyGraph.prototype.isCyclic = function isCyclic(nodes) {
    var isCyclic = false;

    for (var n = 0, ln = nodes.length; n < ln; ++n) {
      var node = nodes[n];

      if (node.handled) {
        continue;
      }

      if (this.isCyclicNode(node)) {
        isCyclic = true;
        break;
      }
    }

    this.clearFlags(this.nodes);
    return isCyclic;
  };

  DependencyGraph.prototype.isCyclicNode = function isCyclicNode(node) {
    if (!node.visited) {
      node.visited = true;
      node.recursion = true;

      for (var d = 0, ld = node.needs.length; d < ld; ++d) {
        var dep = node.needs[d];

        if (!dep.node.visited && this.isCyclicNode(dep.node)) {
          return true;
        } else if (dep.node.recursion) {
          return true;
        }
      }
    }

    node.recursion = false;
    return false;
  };

  DependencyGraph.prototype.clearFlags = function clearFlags(nodes) {
    for (var n = 0, ln = nodes.length; n < ln; ++n) {
      var node = nodes[n];

      node.visited = false;
      node.recursion = false;
    }
  };

  DependencyGraph.prototype.createUid = function createUid() {
    return '__objection_uid(' + ++this.uid + ')__';
  };

  return DependencyGraph;
}();

exports.default = DependencyGraph;


function allMatches(regex, str, cb) {
  var matchResult = regex.exec(str);

  while (matchResult) {
    cb(matchResult);
    matchResult = regex.exec(str);
  }
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["DependencyGraph.js"],"names":["DependencyGraph","allowedRelations","nodesById","inputNodesById","nodes","uid","build","modelClass","models","Array","isArray","i","l","length","buildForModel","solveReferences","createNonRelationDeps","isCyclic","cyclic","model","parentNode","rel","notModel","uidProp","createUid","node","id","push","needs","isNeededBy","manyToManyConnections","buildForRelations","relations","getRelationArray","relName","name","relModels","nextAllowed","childExpression","buildForItem","relatedModelClass","item","dbRefProp","buildForId","handled","$id","refMap","mergeReferences","replaceReferenceNodes","n","ln","refNode","ref","uidRefProp","actualNode","d","ld","m","lm","dep","conn","createNonRelationDepsForObject","obj","path","propRefRegex","getRelations","isModel","keys","key","value","allMatches","match","matchResult","refId","refProp","pop","isCyclicNode","clearFlags","visited","recursion","regex","str","cb","exec"],"mappings":"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","file":"DependencyGraph.js","sourcesContent":["import Model from '../../model/Model';\nimport HasManyRelation from '../../relations/hasMany/HasManyRelation';\nimport RelationExpression from '../RelationExpression';\nimport ManyToManyRelation from '../../relations/manyToMany/ManyToManyRelation';\nimport BelongsToOneRelation from '../../relations/belongsToOne/BelongsToOneRelation';\nimport ValidationError from '../../model/ValidationError';\n\nimport DependencyNode from './DependencyNode';\nimport HasManyDependency from './HasManyDependency';\nimport ManyToManyConnection from './ManyToManyConnection';\nimport ReplaceValueDependency from './ReplaceValueDependency';\nimport BelongsToOneDependency from './BelongsToOneDependency';\nimport InterpolateValueDependency from './InterpolateValueDependency';\n\nexport default class DependencyGraph {\n\n  constructor(allowedRelations) {\n    /**\n     * @type {RelationExpression}\n     */\n    this.allowedRelations = allowedRelations;\n\n    /**\n     * @type {Object.<string, DependencyNode>}\n     */\n    this.nodesById = Object.create(null);\n\n    /**\n     * @type {Object.<string, DependencyNode>}\n     */\n    this.inputNodesById = Object.create(null);\n\n    /**\n     * @type {Array.<DependencyNode>}\n     */\n    this.nodes = [];\n\n    /**\n     * @type {number}\n     */\n    this.uid = 0;\n  }\n\n  build(modelClass, models) {\n    this.nodesById = Object.create(null);\n    this.nodes = [];\n\n    if (Array.isArray(models)) {\n      for (let i = 0, l = models.length; i < l; ++i) {\n        this.buildForModel(modelClass, models[i], null, null, this.allowedRelations);\n      }\n    } else {\n      this.buildForModel(modelClass, models, null, null, this.allowedRelations);\n    }\n\n    this.solveReferences();\n    this.createNonRelationDeps();\n\n    if (this.isCyclic(this.nodes)) {\n      throw new ValidationError({cyclic: 'the object graph contains cyclic references'});\n    }\n\n    return this.nodes;\n  };\n\n  buildForModel(modelClass, model, parentNode, rel, allowedRelations) {\n    if (!(model instanceof Model)) {\n      throw new ValidationError({notModel: 'not a model'});\n    }\n\n    if (!model[modelClass.uidProp]) {\n      model[modelClass.uidProp] = this.createUid();\n    }\n\n    const node = new DependencyNode(model, modelClass);\n\n    this.nodesById[node.id] = node;\n    this.nodes.push(node);\n\n    if (!parentNode) {\n      this.inputNodesById[node.id] = node;\n    }\n\n    if (rel instanceof HasManyRelation) {\n\n      node.needs.push(new HasManyDependency(parentNode, rel));\n      parentNode.isNeededBy.push(new HasManyDependency(node, rel));\n\n    } else if (rel instanceof BelongsToOneRelation) {\n\n      node.isNeededBy.push(new BelongsToOneDependency(parentNode, rel));\n      parentNode.needs.push(new BelongsToOneDependency(node, rel));\n\n    } else if (rel instanceof ManyToManyRelation) {\n\n      // ManyToManyRelations create no dependencies since we can create the\n      // join table rows after everything else has been inserted.\n      parentNode.manyToManyConnections.push(new ManyToManyConnection(node, rel));\n\n    }\n\n    this.buildForRelations(modelClass, model, node, allowedRelations);\n  }\n\n  buildForRelations(modelClass, model, node, allowedRelations) {\n    const relations = modelClass.getRelationArray();\n\n    for (let i = 0, l = relations.length; i < l; ++i) {\n      const rel = relations[i];\n      const relName = rel.name;\n      const relModels = model[relName];\n\n      let nextAllowed = null;\n\n      if (relModels && allowedRelations instanceof RelationExpression) {\n        nextAllowed = allowedRelations.childExpression(relName);\n\n        if (!nextAllowed) {\n          throw new ValidationError({allowedRelations: 'trying to insert an unallowed relation'});\n        }\n      }\n\n      if (Array.isArray(relModels)) {\n        for (let i = 0, l = relModels.length; i < l; ++i) {\n          this.buildForItem(rel.relatedModelClass, relModels[i], node, rel, nextAllowed);\n        }\n      } else if (relModels) {\n        this.buildForItem(rel.relatedModelClass, relModels, node, rel, nextAllowed);\n      }\n    }\n  }\n\n  buildForItem(modelClass, item, parentNode, rel, allowedRelations) {\n    if (rel instanceof ManyToManyRelation && item[modelClass.dbRefProp]) {\n      this.buildForId(modelClass, item, parentNode, rel, allowedRelations);\n    } else {\n      this.buildForModel(modelClass, item, parentNode, rel, allowedRelations);\n    }\n  }\n\n  buildForId(modelClass, item, parentNode, rel) {\n    const node = new DependencyNode(item, modelClass);\n    node.handled = true;\n\n    item.$id(item[modelClass.dbRefProp]);\n    parentNode.manyToManyConnections.push(new ManyToManyConnection(node, rel));\n  }\n\n  solveReferences() {\n    let refMap = Object.create(null);\n\n    // First merge all reference nodes into the actual node.\n    this.mergeReferences(refMap);\n\n    // Replace all reference nodes with the actual nodes.\n    this.replaceReferenceNodes(refMap);\n  }\n\n  mergeReferences(refMap) {\n    for (let n = 0, ln = this.nodes.length; n < ln; ++n) {\n      let refNode = this.nodes[n];\n\n      if (refNode.handled) {\n        continue;\n      }\n\n      let ref = refNode.model[refNode.modelClass.uidRefProp];\n\n      if (ref) {\n        let actualNode = this.nodesById[ref];\n\n        if (!actualNode) {\n          throw new ValidationError({ref: `could not resolve reference \"${ref}\"`});\n        }\n\n        let d, ld;\n\n        for (d = 0, ld = refNode.needs.length; d < ld; ++d) {\n          actualNode.needs.push(refNode.needs[d]);\n        }\n\n        for (d = 0, ld = refNode.isNeededBy.length; d < ld; ++d) {\n          actualNode.isNeededBy.push(refNode.isNeededBy[d]);\n        }\n\n        for (let m = 0, lm = refNode.manyToManyConnections.length; m < lm; ++m) {\n          actualNode.manyToManyConnections.push(refNode.manyToManyConnections[m]);\n        }\n\n        refMap[refNode.id] = actualNode;\n        refNode.handled = true;\n      }\n    }\n  }\n\n  replaceReferenceNodes(refMap) {\n    for (let n = 0, ln = this.nodes.length; n < ln; ++n) {\n      let node = this.nodes[n];\n      let d, ld, dep, actualNode;\n\n      for (d = 0, ld = node.needs.length; d < ld; ++d) {\n        dep = node.needs[d];\n        actualNode = refMap[dep.node.id];\n\n        if (actualNode) {\n          dep.node = actualNode;\n        }\n      }\n\n      for (d = 0, ld = node.isNeededBy.length; d < ld; ++d) {\n        dep = node.isNeededBy[d];\n        actualNode = refMap[dep.node.id];\n\n        if (actualNode) {\n          dep.node = actualNode;\n        }\n      }\n\n      for (let m = 0, lm = node.manyToManyConnections.length; m < lm; ++m) {\n        let conn = node.manyToManyConnections[m];\n        actualNode = refMap[conn.node.id];\n\n        if (actualNode) {\n          conn.refNode = conn.node;\n          conn.node = actualNode;\n        }\n      }\n    }\n  }\n\n  createNonRelationDeps() {\n    for (let n = 0, ln = this.nodes.length; n < ln; ++n) {\n      let node = this.nodes[n];\n\n      if (!node.handled) {\n        this.createNonRelationDepsForObject(node.model, node, []);\n      }\n    }\n  }\n\n  createNonRelationDepsForObject(obj, node, path) {\n    const propRefRegex = node.modelClass.propRefRegex;\n    const relations = node.modelClass.getRelations();\n    const isModel = obj instanceof Model;\n    const keys = Object.keys(obj);\n\n    for (let i = 0, l = keys.length; i < l; ++i) {\n      const key = keys[i];\n      const value = obj[key];\n\n      if (isModel && relations[key]) {\n        // Don't traverse the relations of model instances.\n        return;\n      }\n\n      path.push(key);\n\n      if (typeof value === 'string') {\n        allMatches(propRefRegex, value, matchResult => {\n          let match = matchResult[0];\n          let refId = matchResult[1];\n          let refProp = matchResult[2];\n          let refNode = this.nodesById[refId];\n\n          if (!refNode) {\n            throw new ValidationError({ref: `could not resolve reference \"${value}\"`});\n          }\n\n          if (value === match) {\n            // If the match is the whole string, replace the value with the resolved value.\n            // This means that the value will have the same type as the resolved value\n            // (date, number, etc).\n            node.needs.push(new ReplaceValueDependency(refNode, path, refProp, false));\n            refNode.isNeededBy.push(new ReplaceValueDependency(node, path, refProp, true));\n          } else {\n            // If the match is inside a string, replace the reference inside the string with\n            // the resolved value.\n            node.needs.push(new InterpolateValueDependency(refNode, path, refProp, match, false));\n            refNode.isNeededBy.push(new InterpolateValueDependency(node, path, refProp, match, true));\n          }\n        });\n      } else if (value && typeof value === 'object') {\n        this.createNonRelationDepsForObject(value, node, path);\n      }\n\n      path.pop();\n    }\n  }\n\n  isCyclic(nodes) {\n    let isCyclic = false;\n\n    for (let n = 0, ln = nodes.length; n < ln; ++n) {\n      let node = nodes[n];\n\n      if (node.handled) {\n        continue;\n      }\n\n      if (this.isCyclicNode(node)) {\n        isCyclic = true;\n        break;\n      }\n    }\n\n    this.clearFlags(this.nodes);\n    return isCyclic;\n  }\n\n  isCyclicNode(node) {\n    if (!node.visited) {\n      node.visited = true;\n      node.recursion = true;\n\n      for (let d = 0, ld = node.needs.length; d < ld; ++d) {\n        let dep = node.needs[d];\n\n        if (!dep.node.visited && this.isCyclicNode(dep.node)) {\n          return true;\n        } else if (dep.node.recursion) {\n          return true;\n        }\n      }\n    }\n\n    node.recursion = false;\n    return false;\n  }\n\n  clearFlags(nodes) {\n    for (let n = 0, ln = nodes.length; n < ln; ++n) {\n      let node = nodes[n];\n\n      node.visited = false;\n      node.recursion = false;\n    }\n  }\n\n  createUid() {\n    return `__objection_uid(${++this.uid})__`;\n  }\n}\n\nfunction allMatches(regex, str, cb) {\n  let matchResult = regex.exec(str);\n\n  while (matchResult) {\n    cb(matchResult);\n    matchResult = regex.exec(str);\n  }\n}"]}