addContext addContext

Adds the new context to genie's current context. Genie's context will maintain uniqueness, so don't worry about overloading genie's context with duplicates.

function addContext(newContext) { /*...*/ }

function addContext(newContext) {
  if (newContext && newContext.length) {
    _previousContext = _context;
    _addUniqueItems(_context, newContext);
  }
  return _context;
}

addPathContext addPathContext

Add a path context to genie's pathContexts

function addPathContext(pathContexts) { /*...*/ }

function addPathContext(pathContexts) {
  _each(pathContexts, function(pathContext) {
    if (pathContext.paths) {
      pathContext.paths = _arrayify(pathContext.paths);
    }

    if (pathContext.regexes) {
      pathContext.regexes = _arrayify(pathContext.regexes);
    }

    if (pathContext.contexts) {
      pathContext.contexts = _arrayify(pathContext.contexts);
    }
  });
  _addUniqueItems(_pathContexts, pathContexts);
  return _pathContexts;
}

context context

Set's then returns genie's current context. If no context is provided, simply acts as getter. If a context is provided, genie's previous context is set to the context before it is assigned to the given context.

function context(newContext) { /*...*/ }

function context(newContext) {
  if (!_isUndefined(newContext)) {
    _previousContext = _context;
    if (!_isArray(newContext)) {
      newContext = [newContext];
    }
    _context = newContext;
  }
  return _context;
}

deregisterWish deregisterWish

Deregisters the given wish. Removes it from the registry and from the _enteredMagicWords map. This will delete an _enteredMagicWords listing if this is the only wish in the list.

function deregisterWish(wish) { /*...*/ }

function deregisterWish(wish) {
  var indexOfWish = _wishes.indexOf(wish);
  if (!indexOfWish) {
    _each(_wishes, function(aWish, index) {
      // the given parameter could be an id.
      if (wish === aWish.id || wish.id === aWish.id) {
        indexOfWish = index;
        wish = aWish;
        return false;
      }
    });
  }

  _wishes.splice(indexOfWish, 1);
  _removeWishIdFromEnteredMagicWords(wish.id);
  return wish;
}

getWish getWish

Get a specific wish by an id. If the id is an array, returns an array of wishes with the same order as the given array. Note: If the id does not correspond to a registered wish, it will be undefined

function getWish(id) { /*...*/ }

function getWish(id) {
  if (_isArray(id)) {
    var wishes = [];
    _each(_getWishIndexById(id), function(index) {
      wishes.push(_wishes[index]);
    });
    return wishes;
  } else {
    var index = _getWishIndexById(id);
    if (index > -1) {
      return _wishes[index];
    } else {
      return null;
    }
  }
}

getWishesInContext getWishesInContext

Get wishes in a specific context. If no context is provided, all wishes are returned. Think of this as, if genie were in the given context, what would be returned if I called genie.getMatchingWishes()?

function getWishesInContext(context) { /*...*/ }

function getWishesInContext(context) {
  context = context || _defaultContext;
  var wishesInContext = [];
  _each(_wishes, function(wish) {
    if (_contextIsDefault(context) ||
      _contextIsDefault(wish.context) ||
      _wishInThisContext(wish, context)) {
      wishesInContext.push(wish);
    }
  });
  return wishesInContext;
}

mergeWishes mergeWishes

Merges the given wishes with genie's current wishes. Iterates through the wishes: If the wish does not have an action, and the wish's id is registered with genie, genie will assign the registered wish's action to the new wish's action property. Next, if the new wish has an action, it is registered with genie based on its wishId

function mergeWishes(wishes) { /*...*/ }

function mergeWishes(wishes) {
  _each(wishes, function(newWish) {
    var wishIndex = -1;
    var existingWish = null;
    _each(_wishes, function(aWish, aWishIndex) {
      if (aWish.id === newWish.id) {
        existingWish = aWish;
        wishIndex = aWishIndex;
        return false;
      }
    });
    if (!newWish.action && existingWish) {
      newWish.action = existingWish.action;
    }
    if (newWish.action) {
      _wishes[wishIndex] = newWish;
    }
  });
  return _wishes;
}

overrideMatchingAlgorithm overrideMatchingAlgorithm

This will override the matching algorithm (#getMatchingWishes) You wont need to change how you interface with #getMatchingWishes at all by using this.

function overrideMatchingAlgorithm(fn) { /*...*/ }

function overrideMatchingAlgorithm(fn) {
  genie.getMatchingWishes = _passThrough(function(magicWord) {
    return fn(_wishes, magicWord, _context, _enteredMagicWords);
  }, []);
}

registerWish registerWish

Note: This is actually assigned to the genie variable, so it is called like so: genie({wish: object});

Creates and registers a new wish with the given pseudo wish(es).

function registerWish(wish) { /*...*/ }

function registerWish(wish) {
  if (_isArray(wish)) {
    var wishesRegistered = [];
    _each(wish, function(w) {
      wishesRegistered.push(registerWish(w));
    });
    return wishesRegistered;
  } else {
    var newWish = _createWish(wish);
    var existingWishIndex = _getWishIndexById(newWish.id);
    if (existingWishIndex < 0) {
      _wishes.push(newWish);
    } else {
      _wishes[existingWishIndex] = newWish;
    }

    return newWish;
  }
}

removeContext removeContext

Removes the given context

function removeContext(contextToRemove) { /*...*/ }

function removeContext(contextToRemove) {
  if (contextToRemove && contextToRemove.length) {
    _previousContext = _context;
    _removeItems(_context, contextToRemove);
    if (_isEmpty(context)) {
      _context = _defaultContext;
    }
  }
  return _context;
}

removePathContext removePathContext

Removes the given path contexts from genie's path contexts

function removePathContext(pathContext) { /*...*/ }

function removePathContext(pathContext) {
  _removeItems(_pathContexts, pathContext);
  return _pathContexts;
}

reset reset

Sets genie's options to the default options

function reset() { /*...*/ }

function reset() {
  var oldOptions = options();
  options({
    wishes: [],
    noWishMerge: true,
    previousId: 0,
    enteredMagicWords: {},
    context: _defaultContext,
    previousContext: _defaultContext,
    enabled: true
  });
  return oldOptions;
}

restoreContext restoreContext

Changes context to _defaultContext

function restoreContext() { /*...*/ }

function restoreContext() {
  return context(_defaultContext);
}

restoreMatchingAlgorithm restoreMatchingAlgorithm

This will set the matching algorithm back to the original

function restoreMatchingAlgorithm() { /*...*/ }

function restoreMatchingAlgorithm() {
  var oldMatchingAlgorithm = genie.getMatchingWishes;
  genie.getMatchingWishes = _originalMatchingAlgorithm;
  return oldMatchingAlgorithm;
}

revertContext revertContext

Changes genie's context to _previousContext

function revertContext() { /*...*/ }

function revertContext() {
  return context(_previousContext);
}