chainableMethodWrapper = function () {
          // Setting the `ssfi` flag to `chainableMethodWrapper` 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 this assertion is being
          // invoked from inside of another assertion. In this case, the `ssfi`
          // flag has already been set by the outer assertion.
          //
          // Note that overwriting a chainable method merely replaces the saved
          // methods in `ctx.__methods` instead of completely replacing the
          // overwritten assertion. Therefore, an overwriting assertion won't
          // set the `ssfi` or `lockSsfi` flags.
          if (!flag(this, 'lockSsfi')) {
            flag(this, 'ssfi', chainableMethodWrapper);
          }

          var result = chainableBehavior.method.apply(this, arguments);
          if (result !== undefined) {
            return result;
          }

          var newAssertion = new chai.Assertion();
          transferFlags(this, newAssertion);
          return newAssertion;
        }
### .addChainableMethod(ctx, name, method, chainingBehavior)

Adds a method to an object, such that the method can also be chained.

    utils.addChainableMethod(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.addChainableMethod('foo', fn, chainingBehavior);

The result can then be used as both a method assertion, executing both `method` and
`chainingBehavior`, or as a language chain, which only executes `chainingBehavior`.

    expect(fooStr).to.be.foo('bar');
    expect(fooStr).to.be.foo.equal('foo');

@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`, when called
@param {Function} chainingBehavior function to be called every time the property is accessed
@namespace Utils
@name addChainableMethod
@api public