/*! * Chai - addMethod utility * Copyright(c) 2012-2014 Jake Luer * MIT Licensed */ import {addLengthGuard} from './addLengthGuard.js'; import {flag} from './flag.js'; import {proxify} from './proxify.js'; import {transferFlags} from './transferFlags.js'; import {Assertion} from '../assertion.js'; /** * ### .addMethod(ctx, name, method) * * Adds a method to the prototype of an object. * * utils.addMethod(chai.Assertion.prototype, 'foo', function (str) { * var obj = utils.flag(this, 'object'); * new chai.Assertion(obj).to.be.equal(str); * }); * * Can also be accessed directly from `chai.Assertion`. * * chai.Assertion.addMethod('foo', fn); * * Then can be used as any other assertion. * * expect(fooStr).to.be.foo('bar'); * * @param {object} ctx object to which the method is added * @param {string} name of method to add * @param {Function} method function to be used for name * @namespace Utils * @name addMethod * @public */ export function addMethod(ctx, name, method) { var methodWrapper = function () { // Setting the `ssfi` flag to `methodWrapper` causes this function to be the // starting point for removing implementation frames from the stack trace of // a failed assertion. // // However, we only want to use this function as the starting point if the // `lockSsfi` flag isn't set. // // If the `lockSsfi` flag is set, then either this assertion has been // overwritten by another assertion, or this assertion is being invoked from // inside of another assertion. In the first case, the `ssfi` flag has // already been set by the overwriting assertion. In the second case, the // `ssfi` flag has already been set by the outer assertion. if (!flag(this, 'lockSsfi')) { flag(this, 'ssfi', methodWrapper); } var result = method.apply(this, arguments); if (result !== undefined) return result; var newAssertion = new Assertion(); transferFlags(this, newAssertion); return newAssertion; }; addLengthGuard(methodWrapper, name, false); ctx[name] = proxify(methodWrapper, name); }