teabag 0.7.1 → 0.7.2

data/vendor/assets/javascripts/support/jasmine-jquery.js

@@ -1,5 +1,31 @@
-// https://github.com/velesin/jasmine-jquery/commit/f65c78fb83775bd1f0ce3dc13fe9a82dc2b4e889
-
+/*!
+ Jasmine-jQuery: a set of jQuery helpers for Jasmine tests.
+
+ Version 1.5.0
+
+ https://github.com/velesin/jasmine-jquery
+
+ Copyright (c) 2010-2013 Wojciech Zawistowski, Travis Jeffery
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
 var readFixtures = function() {
   return jasmine.getFixtures().proxyCallTo_('read', arguments)
 }

data/vendor/assets/javascripts/support/sinon.js

@@ -1,12 +1,12 @@
 /**
- * Sinon.JS 1.5.2, 2012/11/27
+ * Sinon.JS 1.7.1, 2013/05/07
  *
  * @author Christian Johansen (christian@cjohansen.no)
  * @author Contributors: https://github.com/cjohansen/Sinon.JS/blob/master/AUTHORS
  *
  * (The BSD License)
  *
- * Copyright (c) 2010-2012, Christian Johansen, christian@cjohansen.no
+ * Copyright (c) 2010-2013, Christian Johansen, christian@cjohansen.no
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
@@ -33,9 +33,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-var sinon = (function () {
-  "use strict";
-
+this.sinon = (function () {
   var buster = (function (setTimeout, B) {
     var isNode = typeof require == "function" && typeof module == "object";
     var div = typeof document != "undefined" && document.createElement("div");
@@ -463,7 +461,7 @@ var sinon = (function () {
    * @author Christian Johansen (christian@cjohansen.no)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
    */
 
   var sinon = (function (buster) {
@@ -505,6 +503,10 @@ var sinon = (function () {
       }
     }
 
+    function isRestorable (obj) {
+      return typeof obj === "function" && typeof obj.restore === "function" && obj.restore.sinon;
+    }
+
     var sinon = {
       wrapMethod: function wrapMethod(object, property, method) {
         if (!object) {
@@ -631,11 +633,7 @@ var sinon = (function () {
           bLength += 1;
         }
 
-        if (aLength != bLength) {
-          return false;
-        }
-
-        return true;
+        return aLength == bLength;
       },
 
       functionName: function functionName(func) {
@@ -706,7 +704,7 @@ var sinon = (function () {
 
       calledInOrder: function (spies) {
         for (var i = 1, l = spies.length; i < l; i++) {
-          if (!spies[i - 1].calledBefore(spies[i])) {
+          if (!spies[i - 1].calledBefore(spies[i]) || !spies[i].called) {
             return false;
           }
         }
@@ -748,6 +746,26 @@ var sinon = (function () {
         }
         var string = Object.prototype.toString.call(value);
         return string.substring(8, string.length - 1).toLowerCase();
+      },
+
+      createStubInstance: function (constructor) {
+        if (typeof constructor !== "function") {
+          throw new TypeError("The constructor should be a function.");
+        }
+        return sinon.stub(sinon.create(constructor.prototype));
+      },
+
+      restore: function (object) {
+        if (object !== null && typeof object === "object") {
+          for (var prop in object) {
+            if (isRestorable(object[prop])) {
+              object[prop].restore();
+            }
+          }
+        }
+        else if (isRestorable(object)) {
+          object.restore();
+        }
       }
     };
 
@@ -759,6 +777,7 @@ var sinon = (function () {
       } catch (e) {}
       module.exports = sinon;
       module.exports.spy = require("./sinon/spy");
+      module.exports.spyCall = require("./sinon/call");
       module.exports.stub = require("./sinon/stub");
       module.exports.mock = require("./sinon/mock");
       module.exports.collection = require("./sinon/collection");
@@ -1037,21 +1056,18 @@ var sinon = (function () {
   /*jslint eqeqeq: false, onevar: false, plusplus: false*/
   /*global module, require, sinon*/
   /**
-   * Spy functions
+   * Spy calls
    *
    * @author Christian Johansen (christian@cjohansen.no)
+   * @author Maximilian Antoni (mail@maxantoni.de)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
+   * Copyright (c) 2013 Maximilian Antoni
    */
 
   (function (sinon) {
     var commonJSModule = typeof module == "object" && typeof require == "function";
-    var spyCall;
-    var callId = 0;
-    var push = [].push;
-    var slice = Array.prototype.slice;
-
     if (!sinon && commonJSModule) {
       sinon = require("../sinon");
     }
@@ -1060,505 +1076,565 @@ var sinon = (function () {
       return;
     }
 
-    function spy(object, property) {
-      if (!property && typeof object == "function") {
-        return spy.create(object);
-      }
-
-      if (!object && !property) {
-        return spy.create(function () {});
+    function throwYieldError(proxy, text, args) {
+      var msg = sinon.functionName(proxy) + text;
+      if (args.length) {
+        msg += " Received [" + slice.call(args).join(", ") + "]";
       }
-
-      var method = object[property];
-      return sinon.wrapMethod(object, property, spy.create(method));
+      throw new Error(msg);
     }
 
-    sinon.extend(spy, (function () {
+    var slice = Array.prototype.slice;
 
-      function delegateToCalls(api, method, matchAny, actual, notCalled) {
-        api[method] = function () {
-          if (!this.called) {
-            if (notCalled) {
-              return notCalled.apply(this, arguments);
-            }
+    var callProto = {
+      calledOn: function calledOn(thisValue) {
+        if (sinon.match && sinon.match.isMatcher(thisValue)) {
+          return thisValue.test(this.thisValue);
+        }
+        return this.thisValue === thisValue;
+      },
+
+      calledWith: function calledWith() {
+        for (var i = 0, l = arguments.length; i < l; i += 1) {
+          if (!sinon.deepEqual(arguments[i], this.args[i])) {
             return false;
           }
+        }
+
+        return true;
+      },
 
-          var currentCall;
-          var matches = 0;
+      calledWithMatch: function calledWithMatch() {
+        for (var i = 0, l = arguments.length; i < l; i += 1) {
+          var actual = this.args[i];
+          var expectation = arguments[i];
+          if (!sinon.match || !sinon.match(expectation).test(actual)) {
+            return false;
+          }
+        }
+        return true;
+      },
 
-          for (var i = 0, l = this.callCount; i < l; i += 1) {
-            currentCall = this.getCall(i);
+      calledWithExactly: function calledWithExactly() {
+        return arguments.length == this.args.length &&
+            this.calledWith.apply(this, arguments);
+      },
 
-            if (currentCall[actual || method].apply(currentCall, arguments)) {
-              matches += 1;
+      notCalledWith: function notCalledWith() {
+        return !this.calledWith.apply(this, arguments);
+      },
 
-              if (matchAny) {
-                return true;
-              }
-            }
-          }
+      notCalledWithMatch: function notCalledWithMatch() {
+        return !this.calledWithMatch.apply(this, arguments);
+      },
 
-          return matches === this.callCount;
-        };
-      }
+      returned: function returned(value) {
+        return sinon.deepEqual(value, this.returnValue);
+      },
 
-      function matchingFake(fakes, args, strict) {
-        if (!fakes) {
-          return;
+      threw: function threw(error) {
+        if (typeof error === "undefined" || !this.exception) {
+          return !!this.exception;
         }
 
-        var alen = args.length;
+        return this.exception === error || this.exception.name === error;
+      },
 
-        for (var i = 0, l = fakes.length; i < l; i++) {
-          if (fakes[i].matches(args, strict)) {
-            return fakes[i];
-          }
-        }
-      }
+      calledWithNew: function calledWithNew(thisValue) {
+        return this.thisValue instanceof this.proxy;
+      },
 
-      function incrementCallCount() {
-        this.called = true;
-        this.callCount += 1;
-        this.notCalled = false;
-        this.calledOnce = this.callCount == 1;
-        this.calledTwice = this.callCount == 2;
-        this.calledThrice = this.callCount == 3;
-      }
+      calledBefore: function (other) {
+        return this.callId < other.callId;
+      },
 
-      function createCallProperties() {
-        this.firstCall = this.getCall(0);
-        this.secondCall = this.getCall(1);
-        this.thirdCall = this.getCall(2);
-        this.lastCall = this.getCall(this.callCount - 1);
-      }
+      calledAfter: function (other) {
+        return this.callId > other.callId;
+      },
 
-      var vars = "a,b,c,d,e,f,g,h,i,j,k,l";
-      function createProxy(func) {
-        // Retain the function length:
-        var p;
-        if (func.length) {
-          eval("p = (function proxy(" + vars.substring(0, func.length * 2 - 1) +
-              ") { return p.invoke(func, this, slice.call(arguments)); });");
-        }
-        else {
-          p = function proxy() {
-            return p.invoke(func, this, slice.call(arguments));
-          };
-        }
-        return p;
-      }
+      callArg: function (pos) {
+        this.args[pos]();
+      },
 
-      var uuid = 0;
-
-      // Public API
-      var spyApi = {
-        reset: function () {
-          this.called = false;
-          this.notCalled = true;
-          this.calledOnce = false;
-          this.calledTwice = false;
-          this.calledThrice = false;
-          this.callCount = 0;
-          this.firstCall = null;
-          this.secondCall = null;
-          this.thirdCall = null;
-          this.lastCall = null;
-          this.args = [];
-          this.returnValues = [];
-          this.thisValues = [];
-          this.exceptions = [];
-          this.callIds = [];
-          if (this.fakes) {
-            for (var i = 0; i < this.fakes.length; i++) {
-              this.fakes[i].reset();
-            }
-          }
-        },
+      callArgOn: function (pos, thisValue) {
+        this.args[pos].apply(thisValue);
+      },
 
-        create: function create(func) {
-          var name;
+      callArgWith: function (pos) {
+        this.callArgOnWith.apply(this, [pos, null].concat(slice.call(arguments, 1)));
+      },
 
-          if (typeof func != "function") {
-            func = function () {};
-          } else {
-            name = sinon.functionName(func);
+      callArgOnWith: function (pos, thisValue) {
+        var args = slice.call(arguments, 2);
+        this.args[pos].apply(thisValue, args);
+      },
+
+      "yield": function () {
+        this.yieldOn.apply(this, [null].concat(slice.call(arguments, 0)));
+      },
+
+      yieldOn: function (thisValue) {
+        var args = this.args;
+        for (var i = 0, l = args.length; i < l; ++i) {
+          if (typeof args[i] === "function") {
+            args[i].apply(thisValue, slice.call(arguments, 1));
+            return;
           }
+        }
+        throwYieldError(this.proxy, " cannot yield since no callback was passed.", args);
+      },
 
-          var proxy = createProxy(func);
+      yieldTo: function (prop) {
+        this.yieldToOn.apply(this, [prop, null].concat(slice.call(arguments, 1)));
+      },
 
-          sinon.extend(proxy, spy);
-          delete proxy.create;
-          sinon.extend(proxy, func);
+      yieldToOn: function (prop, thisValue) {
+        var args = this.args;
+        for (var i = 0, l = args.length; i < l; ++i) {
+          if (args[i] && typeof args[i][prop] === "function") {
+            args[i][prop].apply(thisValue, slice.call(arguments, 2));
+            return;
+          }
+        }
+        throwYieldError(this.proxy, " cannot yield to '" + prop +
+            "' since no callback was passed.", args);
+      },
 
-          proxy.reset();
-          proxy.prototype = func.prototype;
-          proxy.displayName = name || "spy";
-          proxy.toString = sinon.functionToString;
-          proxy._create = sinon.spy.create;
-          proxy.id = "spy#" + uuid++;
+      toString: function () {
+        var callStr = this.proxy.toString() + "(";
+        var args = [];
 
-          return proxy;
-        },
+        for (var i = 0, l = this.args.length; i < l; ++i) {
+          args.push(sinon.format(this.args[i]));
+        }
 
-        invoke: function invoke(func, thisValue, args) {
-          var matching = matchingFake(this.fakes, args);
-          var exception, returnValue;
+        callStr = callStr + args.join(", ") + ")";
 
-          incrementCallCount.call(this);
-          push.call(this.thisValues, thisValue);
-          push.call(this.args, args);
-          push.call(this.callIds, callId++);
+        if (typeof this.returnValue != "undefined") {
+          callStr += " => " + sinon.format(this.returnValue);
+        }
 
-          try {
-            if (matching) {
-              returnValue = matching.invoke(func, thisValue, args);
-            } else {
-              returnValue = (this.func || func).apply(thisValue, args);
-            }
-          } catch (e) {
-            push.call(this.returnValues, undefined);
-            exception = e;
-            throw e;
-          } finally {
-            push.call(this.exceptions, exception);
+        if (this.exception) {
+          callStr += " !" + this.exception.name;
+
+          if (this.exception.message) {
+            callStr += "(" + this.exception.message + ")";
           }
+        }
 
-          push.call(this.returnValues, returnValue);
+        return callStr;
+      }
+    };
 
-          createCallProperties.call(this);
+    callProto.invokeCallback = callProto.yield;
 
-          return returnValue;
-        },
+    function createSpyCall(spy, thisValue, args, returnValue, exception, id) {
+      if (typeof id !== "number") {
+        throw new TypeError("Call id is not a number");
+      }
+      var proxyCall = sinon.create(callProto);
+      proxyCall.proxy = spy;
+      proxyCall.thisValue = thisValue;
+      proxyCall.args = args;
+      proxyCall.returnValue = returnValue;
+      proxyCall.exception = exception;
+      proxyCall.callId = id;
+
+      return proxyCall;
+    };
+    createSpyCall.toString = callProto.toString; // used by mocks
 
-        getCall: function getCall(i) {
-          if (i < 0 || i >= this.callCount) {
-            return null;
-          }
+    if (commonJSModule) {
+      module.exports = createSpyCall;
+    } else {
+      sinon.spyCall = createSpyCall;
+    }
+  }(typeof sinon == "object" && sinon || null));
 
-          return spyCall.create(this, this.thisValues[i], this.args[i],
-              this.returnValues[i], this.exceptions[i],
-              this.callIds[i]);
-        },
 
-        calledBefore: function calledBefore(spyFn) {
-          if (!this.called) {
-            return false;
-          }
+  /**
+   * @depend ../sinon.js
+   * @depend call.js
+   */
+  /*jslint eqeqeq: false, onevar: false, plusplus: false*/
+  /*global module, require, sinon*/
+  /**
+   * Spy functions
+   *
+   * @author Christian Johansen (christian@cjohansen.no)
+   * @license BSD
+   *
+   * Copyright (c) 2010-2013 Christian Johansen
+   */
 
-          if (!spyFn.called) {
-            return true;
-          }
+  (function (sinon) {
+    var commonJSModule = typeof module == "object" && typeof require == "function";
+    var push = Array.prototype.push;
+    var slice = Array.prototype.slice;
+    var callId = 0;
 
-          return this.callIds[0] < spyFn.callIds[spyFn.callIds.length - 1];
-        },
+    if (!sinon && commonJSModule) {
+      sinon = require("../sinon");
+    }
 
-        calledAfter: function calledAfter(spyFn) {
-          if (!this.called || !spyFn.called) {
-            return false;
-          }
+    if (!sinon) {
+      return;
+    }
 
-          return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1];
-        },
+    function spy(object, property) {
+      if (!property && typeof object == "function") {
+        return spy.create(object);
+      }
 
-        withArgs: function () {
-          var args = slice.call(arguments);
+      if (!object && !property) {
+        return spy.create(function () { });
+      }
 
-          if (this.fakes) {
-            var match = matchingFake(this.fakes, args, true);
+      var method = object[property];
+      return sinon.wrapMethod(object, property, spy.create(method));
+    }
 
-            if (match) {
-              return match;
-            }
-          } else {
-            this.fakes = [];
-          }
+    function matchingFake(fakes, args, strict) {
+      if (!fakes) {
+        return;
+      }
 
-          var original = this;
-          var fake = this._create();
-          fake.matchingAguments = args;
-          push.call(this.fakes, fake);
+      var alen = args.length;
 
-          fake.withArgs = function () {
-            return original.withArgs.apply(original, arguments);
-          };
+      for (var i = 0, l = fakes.length; i < l; i++) {
+        if (fakes[i].matches(args, strict)) {
+          return fakes[i];
+        }
+      }
+    }
 
-          for (var i = 0; i < this.args.length; i++) {
-            if (fake.matches(this.args[i])) {
-              incrementCallCount.call(fake);
-              push.call(fake.thisValues, this.thisValues[i]);
-              push.call(fake.args, this.args[i]);
-              push.call(fake.returnValues, this.returnValues[i]);
-              push.call(fake.exceptions, this.exceptions[i]);
-              push.call(fake.callIds, this.callIds[i]);
-            }
-          }
-          createCallProperties.call(fake);
+    function incrementCallCount() {
+      this.called = true;
+      this.callCount += 1;
+      this.notCalled = false;
+      this.calledOnce = this.callCount == 1;
+      this.calledTwice = this.callCount == 2;
+      this.calledThrice = this.callCount == 3;
+    }
 
-          return fake;
-        },
+    function createCallProperties() {
+      this.firstCall = this.getCall(0);
+      this.secondCall = this.getCall(1);
+      this.thirdCall = this.getCall(2);
+      this.lastCall = this.getCall(this.callCount - 1);
+    }
+
+    var vars = "a,b,c,d,e,f,g,h,i,j,k,l";
+    function createProxy(func) {
+      // Retain the function length:
+      var p;
+      if (func.length) {
+        eval("p = (function proxy(" + vars.substring(0, func.length * 2 - 1) +
+            ") { return p.invoke(func, this, slice.call(arguments)); });");
+      }
+      else {
+        p = function proxy() {
+          return p.invoke(func, this, slice.call(arguments));
+        };
+      }
+      return p;
+    }
 
-        matches: function (args, strict) {
-          var margs = this.matchingAguments;
+    var uuid = 0;
 
-          if (margs.length <= args.length &&
-              sinon.deepEqual(margs, args.slice(0, margs.length))) {
-            return !strict || margs.length == args.length;
+    // Public API
+    var spyApi = {
+      reset: function () {
+        this.called = false;
+        this.notCalled = true;
+        this.calledOnce = false;
+        this.calledTwice = false;
+        this.calledThrice = false;
+        this.callCount = 0;
+        this.firstCall = null;
+        this.secondCall = null;
+        this.thirdCall = null;
+        this.lastCall = null;
+        this.args = [];
+        this.returnValues = [];
+        this.thisValues = [];
+        this.exceptions = [];
+        this.callIds = [];
+        if (this.fakes) {
+          for (var i = 0; i < this.fakes.length; i++) {
+            this.fakes[i].reset();
           }
-        },
+        }
+      },
 
-        printf: function (format) {
-          var spy = this;
-          var args = slice.call(arguments, 1);
-          var formatter;
+      create: function create(func) {
+        var name;
 
-          return (format || "").replace(/%(.)/g, function (match, specifyer) {
-            formatter = spyApi.formatters[specifyer];
+        if (typeof func != "function") {
+          func = function () { };
+        } else {
+          name = sinon.functionName(func);
+        }
 
-            if (typeof formatter == "function") {
-              return formatter.call(null, spy, args);
-            } else if (!isNaN(parseInt(specifyer), 10)) {
-              return sinon.format(args[specifyer - 1]);
-            }
+        var proxy = createProxy(func);
 
-            return "%" + specifyer;
-          });
-        }
-      };
+        sinon.extend(proxy, spy);
+        delete proxy.create;
+        sinon.extend(proxy, func);
 
-      delegateToCalls(spyApi, "calledOn", true);
-      delegateToCalls(spyApi, "alwaysCalledOn", false, "calledOn");
-      delegateToCalls(spyApi, "calledWith", true);
-      delegateToCalls(spyApi, "calledWithMatch", true);
-      delegateToCalls(spyApi, "alwaysCalledWith", false, "calledWith");
-      delegateToCalls(spyApi, "alwaysCalledWithMatch", false, "calledWithMatch");
-      delegateToCalls(spyApi, "calledWithExactly", true);
-      delegateToCalls(spyApi, "alwaysCalledWithExactly", false, "calledWithExactly");
-      delegateToCalls(spyApi, "neverCalledWith", false, "notCalledWith",
-          function () { return true; });
-      delegateToCalls(spyApi, "neverCalledWithMatch", false, "notCalledWithMatch",
-          function () { return true; });
-      delegateToCalls(spyApi, "threw", true);
-      delegateToCalls(spyApi, "alwaysThrew", false, "threw");
-      delegateToCalls(spyApi, "returned", true);
-      delegateToCalls(spyApi, "alwaysReturned", false, "returned");
-      delegateToCalls(spyApi, "calledWithNew", true);
-      delegateToCalls(spyApi, "alwaysCalledWithNew", false, "calledWithNew");
-      delegateToCalls(spyApi, "callArg", false, "callArgWith", function () {
-        throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
-      });
-      spyApi.callArgWith = spyApi.callArg;
-      delegateToCalls(spyApi, "yield", false, "yield", function () {
-        throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
-      });
-      // "invokeCallback" is an alias for "yield" since "yield" is invalid in strict mode.
-      spyApi.invokeCallback = spyApi.yield;
-      delegateToCalls(spyApi, "yieldTo", false, "yieldTo", function (property) {
-        throw new Error(this.toString() + " cannot yield to '" + property +
-            "' since it was not yet invoked.");
-      });
+        proxy.reset();
+        proxy.prototype = func.prototype;
+        proxy.displayName = name || "spy";
+        proxy.toString = sinon.functionToString;
+        proxy._create = sinon.spy.create;
+        proxy.id = "spy#" + uuid++;
 
-      spyApi.formatters = {
-        "c": function (spy) {
-          return sinon.timesInWords(spy.callCount);
-        },
+        return proxy;
+      },
 
-        "n": function (spy) {
-          return spy.toString();
-        },
+      invoke: function invoke(func, thisValue, args) {
+        var matching = matchingFake(this.fakes, args);
+        var exception, returnValue;
 
-        "C": function (spy) {
-          var calls = [];
+        incrementCallCount.call(this);
+        push.call(this.thisValues, thisValue);
+        push.call(this.args, args);
+        push.call(this.callIds, callId++);
 
-          for (var i = 0, l = spy.callCount; i < l; ++i) {
-            push.call(calls, "    " + spy.getCall(i).toString());
+        try {
+          if (matching) {
+            returnValue = matching.invoke(func, thisValue, args);
+          } else {
+            returnValue = (this.func || func).apply(thisValue, args);
           }
+        } catch (e) {
+          push.call(this.returnValues, undefined);
+          exception = e;
+          throw e;
+        } finally {
+          push.call(this.exceptions, exception);
+        }
 
-          return calls.length > 0 ? "\n" + calls.join("\n") : "";
-        },
-
-        "t": function (spy) {
-          var objects = [];
+        push.call(this.returnValues, returnValue);
 
-          for (var i = 0, l = spy.callCount; i < l; ++i) {
-            push.call(objects, sinon.format(spy.thisValues[i]));
-          }
+        createCallProperties.call(this);
 
-          return objects.join(", ");
-        },
+        return returnValue;
+      },
 
-        "*": function (spy, args) {
-          var formatted = [];
+      getCall: function getCall(i) {
+        if (i < 0 || i >= this.callCount) {
+          return null;
+        }
 
-          for (var i = 0, l = args.length; i < l; ++i) {
-            push.call(formatted, sinon.format(args[i]));
-          }
+        return sinon.spyCall(this, this.thisValues[i], this.args[i],
+            this.returnValues[i], this.exceptions[i],
+            this.callIds[i]);
+      },
 
-          return formatted.join(", ");
+      calledBefore: function calledBefore(spyFn) {
+        if (!this.called) {
+          return false;
         }
-      };
 
-      return spyApi;
-    }()));
+        if (!spyFn.called) {
+          return true;
+        }
 
-    spyCall = (function () {
+        return this.callIds[0] < spyFn.callIds[spyFn.callIds.length - 1];
+      },
 
-      function throwYieldError(proxy, text, args) {
-        var msg = sinon.functionName(proxy) + text;
-        if (args.length) {
-          msg += " Received [" + slice.call(args).join(", ") + "]";
+      calledAfter: function calledAfter(spyFn) {
+        if (!this.called || !spyFn.called) {
+          return false;
         }
-        throw new Error(msg);
-      }
 
-      var callApi = {
-        create: function create(spy, thisValue, args, returnValue, exception, id) {
-          var proxyCall = sinon.create(spyCall);
-          delete proxyCall.create;
-          proxyCall.proxy = spy;
-          proxyCall.thisValue = thisValue;
-          proxyCall.args = args;
-          proxyCall.returnValue = returnValue;
-          proxyCall.exception = exception;
-          proxyCall.callId = typeof id == "number" && id || callId++;
-
-          return proxyCall;
-        },
+        return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1];
+      },
 
-        calledOn: function calledOn(thisValue) {
-          if (sinon.match && sinon.match.isMatcher(thisValue)) {
-            return thisValue.test(this.thisValue);
-          }
-          return this.thisValue === thisValue;
-        },
+      withArgs: function () {
+        var args = slice.call(arguments);
 
-        calledWith: function calledWith() {
-          for (var i = 0, l = arguments.length; i < l; i += 1) {
-            if (!sinon.deepEqual(arguments[i], this.args[i])) {
-              return false;
-            }
+        if (this.fakes) {
+          var match = matchingFake(this.fakes, args, true);
+
+          if (match) {
+            return match;
           }
+        } else {
+          this.fakes = [];
+        }
 
-          return true;
-        },
+        var original = this;
+        var fake = this._create();
+        fake.matchingAguments = args;
+        push.call(this.fakes, fake);
 
-        calledWithMatch: function calledWithMatch() {
-          for (var i = 0, l = arguments.length; i < l; i += 1) {
-            var actual = this.args[i];
-            var expectation = arguments[i];
-            if (!sinon.match || !sinon.match(expectation).test(actual)) {
-              return false;
-            }
+        fake.withArgs = function () {
+          return original.withArgs.apply(original, arguments);
+        };
+
+        for (var i = 0; i < this.args.length; i++) {
+          if (fake.matches(this.args[i])) {
+            incrementCallCount.call(fake);
+            push.call(fake.thisValues, this.thisValues[i]);
+            push.call(fake.args, this.args[i]);
+            push.call(fake.returnValues, this.returnValues[i]);
+            push.call(fake.exceptions, this.exceptions[i]);
+            push.call(fake.callIds, this.callIds[i]);
           }
-          return true;
-        },
+        }
+        createCallProperties.call(fake);
 
-        calledWithExactly: function calledWithExactly() {
-          return arguments.length == this.args.length &&
-              this.calledWith.apply(this, arguments);
-        },
+        return fake;
+      },
 
-        notCalledWith: function notCalledWith() {
-          return !this.calledWith.apply(this, arguments);
-        },
+      matches: function (args, strict) {
+        var margs = this.matchingAguments;
 
-        notCalledWithMatch: function notCalledWithMatch() {
-          return !this.calledWithMatch.apply(this, arguments);
-        },
+        if (margs.length <= args.length &&
+            sinon.deepEqual(margs, args.slice(0, margs.length))) {
+          return !strict || margs.length == args.length;
+        }
+      },
 
-        returned: function returned(value) {
-          return sinon.deepEqual(value, this.returnValue);
-        },
+      printf: function (format) {
+        var spy = this;
+        var args = slice.call(arguments, 1);
+        var formatter;
 
-        threw: function threw(error) {
-          if (typeof error == "undefined" || !this.exception) {
-            return !!this.exception;
-          }
+        return (format || "").replace(/%(.)/g, function (match, specifyer) {
+          formatter = spyApi.formatters[specifyer];
 
-          if (typeof error == "string") {
-            return this.exception.name == error;
+          if (typeof formatter == "function") {
+            return formatter.call(null, spy, args);
+          } else if (!isNaN(parseInt(specifyer), 10)) {
+            return sinon.format(args[specifyer - 1]);
           }
 
-          return this.exception === error;
-        },
-
-        calledWithNew: function calledWithNew(thisValue) {
-          return this.thisValue instanceof this.proxy;
-        },
+          return "%" + specifyer;
+        });
+      }
+    };
 
-        calledBefore: function (other) {
-          return this.callId < other.callId;
-        },
+    function delegateToCalls(method, matchAny, actual, notCalled) {
+      spyApi[method] = function () {
+        if (!this.called) {
+          if (notCalled) {
+            return notCalled.apply(this, arguments);
+          }
+          return false;
+        }
 
-        calledAfter: function (other) {
-          return this.callId > other.callId;
-        },
+        var currentCall;
+        var matches = 0;
 
-        callArg: function (pos) {
-          this.args[pos]();
-        },
+        for (var i = 0, l = this.callCount; i < l; i += 1) {
+          currentCall = this.getCall(i);
 
-        callArgWith: function (pos) {
-          var args = slice.call(arguments, 1);
-          this.args[pos].apply(null, args);
-        },
+          if (currentCall[actual || method].apply(currentCall, arguments)) {
+            matches += 1;
 
-        "yield": function () {
-          var args = this.args;
-          for (var i = 0, l = args.length; i < l; ++i) {
-            if (typeof args[i] === "function") {
-              args[i].apply(null, slice.call(arguments));
-              return;
+            if (matchAny) {
+              return true;
             }
           }
-          throwYieldError(this.proxy, " cannot yield since no callback was passed.", args);
-        },
+        }
 
-        yieldTo: function (prop) {
-          var args = this.args;
-          for (var i = 0, l = args.length; i < l; ++i) {
-            if (args[i] && typeof args[i][prop] === "function") {
-              args[i][prop].apply(null, slice.call(arguments, 1));
-              return;
-            }
-          }
-          throwYieldError(this.proxy, " cannot yield to '" + prop +
-              "' since no callback was passed.", args);
-        },
+        return matches === this.callCount;
+      };
+    }
 
-        toString: function () {
-          var callStr = this.proxy.toString() + "(";
-          var args = [];
+    delegateToCalls("calledOn", true);
+    delegateToCalls("alwaysCalledOn", false, "calledOn");
+    delegateToCalls("calledWith", true);
+    delegateToCalls("calledWithMatch", true);
+    delegateToCalls("alwaysCalledWith", false, "calledWith");
+    delegateToCalls("alwaysCalledWithMatch", false, "calledWithMatch");
+    delegateToCalls("calledWithExactly", true);
+    delegateToCalls("alwaysCalledWithExactly", false, "calledWithExactly");
+    delegateToCalls("neverCalledWith", false, "notCalledWith",
+        function () { return true; });
+    delegateToCalls("neverCalledWithMatch", false, "notCalledWithMatch",
+        function () { return true; });
+    delegateToCalls("threw", true);
+    delegateToCalls("alwaysThrew", false, "threw");
+    delegateToCalls("returned", true);
+    delegateToCalls("alwaysReturned", false, "returned");
+    delegateToCalls("calledWithNew", true);
+    delegateToCalls("alwaysCalledWithNew", false, "calledWithNew");
+    delegateToCalls("callArg", false, "callArgWith", function () {
+      throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
+    });
+    spyApi.callArgWith = spyApi.callArg;
+    delegateToCalls("callArgOn", false, "callArgOnWith", function () {
+      throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
+    });
+    spyApi.callArgOnWith = spyApi.callArgOn;
+    delegateToCalls("yield", false, "yield", function () {
+      throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
+    });
+    // "invokeCallback" is an alias for "yield" since "yield" is invalid in strict mode.
+    spyApi.invokeCallback = spyApi.yield;
+    delegateToCalls("yieldOn", false, "yieldOn", function () {
+      throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
+    });
+    delegateToCalls("yieldTo", false, "yieldTo", function (property) {
+      throw new Error(this.toString() + " cannot yield to '" + property +
+          "' since it was not yet invoked.");
+    });
+    delegateToCalls("yieldToOn", false, "yieldToOn", function (property) {
+      throw new Error(this.toString() + " cannot yield to '" + property +
+          "' since it was not yet invoked.");
+    });
 
-          for (var i = 0, l = this.args.length; i < l; ++i) {
-            push.call(args, sinon.format(this.args[i]));
-          }
+    spyApi.formatters = {
+      "c": function (spy) {
+        return sinon.timesInWords(spy.callCount);
+      },
 
-          callStr = callStr + args.join(", ") + ")";
+      "n": function (spy) {
+        return spy.toString();
+      },
+
+      "C": function (spy) {
+        var calls = [];
 
-          if (typeof this.returnValue != "undefined") {
-            callStr += " => " + sinon.format(this.returnValue);
+        for (var i = 0, l = spy.callCount; i < l; ++i) {
+          var stringifiedCall = "    " + spy.getCall(i).toString();
+          if (/\n/.test(calls[i - 1])) {
+            stringifiedCall = "\n" + stringifiedCall;
           }
+          push.call(calls, stringifiedCall);
+        }
 
-          if (this.exception) {
-            callStr += " !" + this.exception.name;
+        return calls.length > 0 ? "\n" + calls.join("\n") : "";
+      },
 
-            if (this.exception.message) {
-              callStr += "(" + this.exception.message + ")";
-            }
-          }
+      "t": function (spy) {
+        var objects = [];
 
-          return callStr;
+        for (var i = 0, l = spy.callCount; i < l; ++i) {
+          push.call(objects, sinon.format(spy.thisValues[i]));
         }
-      };
-      callApi.invokeCallback = callApi.yield;
-      return callApi;
-    }());
 
-    spy.spyCall = spyCall;
+        return objects.join(", ");
+      },
 
-    // This steps outside the module sandbox and will be removed
-    sinon.spyCall = spyCall;
+      "*": function (spy, args) {
+        var formatted = [];
+
+        for (var i = 0, l = args.length; i < l; ++i) {
+          push.call(formatted, sinon.format(args[i]));
+        }
+
+        return formatted.join(", ");
+      }
+    };
+
+    sinon.extend(spy, spyApi);
+
+    spy.spyCall = sinon.spyCall;
 
     if (commonJSModule) {
       module.exports = spy;
@@ -1579,7 +1655,7 @@ var sinon = (function () {
    * @author Christian Johansen (christian@cjohansen.no)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
    */
 
   (function (sinon) {
@@ -1625,7 +1701,8 @@ var sinon = (function () {
 
     function getChangingValue(stub, property) {
       var index = stub.callCount - 1;
-      var prop = index in stub[property] ? stub[property][index] : stub[property + "Last"];
+      var values = stub[property];
+      var prop = index in values ? values[index] : values[values.length - 1];
       stub[property + "Last"] = prop;
 
       return prop;
@@ -1682,8 +1759,6 @@ var sinon = (function () {
     var nextTick = (function () {
       if (typeof process === "object" && typeof process.nextTick === "function") {
         return process.nextTick;
-      } else if (typeof msSetImmediate === "function") {
-        return msSetImmediate.bind(window);
       } else if (typeof setImmediate === "function") {
         return setImmediate;
       } else {
@@ -1701,8 +1776,6 @@ var sinon = (function () {
           throw new TypeError(getCallbackError(stub, func, args));
         }
 
-        var index = stub.callCount - 1;
-
         var callbackArguments = getChangingValue(stub, "callbackArguments");
         var callbackContext = getChangingValue(stub, "callbackContexts");
 
@@ -1768,6 +1841,25 @@ var sinon = (function () {
           return functionStub;
         },
 
+        resetBehavior: function () {
+          var i;
+
+          this.callArgAts = [];
+          this.callbackArguments = [];
+          this.callbackContexts = [];
+          this.callArgProps = [];
+
+          delete this.returnValue;
+          delete this.returnArgAt;
+          this.returnThis = false;
+
+          if (this.fakes) {
+            for (i = 0; i < this.fakes.length; i++) {
+              this.fakes[i].resetBehavior();
+            }
+          }
+        },
+
         returns: function returns(value) {
           this.returnValue = value;
 
@@ -1934,7 +2026,7 @@ var sinon = (function () {
    * @author Christian Johansen (christian@cjohansen.no)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
    */
 
   (function (sinon) {
@@ -2302,7 +2394,8 @@ var sinon = (function () {
           }
 
           var callStr = sinon.spyCall.toString.call({
-            proxy: this.method, args: args
+            proxy: this.method || "anonymous mock expectation",
+            args: args
           });
 
           var message = callStr.replace(", [...", "[, ...") + " " +
@@ -2358,7 +2451,7 @@ var sinon = (function () {
    * @author Christian Johansen (christian@cjohansen.no)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
    */
 
   (function (sinon) {
@@ -2515,7 +2608,7 @@ var sinon = (function () {
    * @author Christian Johansen (christian@cjohansen.no)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
    */
 
   if (typeof sinon == "undefined") {
@@ -2656,6 +2749,8 @@ var sinon = (function () {
         if (firstException) {
           throw firstException;
         }
+
+        return this.now;
       },
 
       firstTimerInRange: function (from, to) {
@@ -2869,15 +2964,16 @@ var sinon = (function () {
   (function () {
     var push = [].push;
 
-    sinon.Event = function Event(type, bubbles, cancelable) {
-      this.initEvent(type, bubbles, cancelable);
+    sinon.Event = function Event(type, bubbles, cancelable, target) {
+      this.initEvent(type, bubbles, cancelable, target);
     };
 
     sinon.Event.prototype = {
-      initEvent: function(type, bubbles, cancelable) {
+      initEvent: function(type, bubbles, cancelable, target) {
         this.type = type;
         this.bubbles = bubbles;
         this.cancelable = cancelable;
+        this.target = target;
       },
 
       stopPropagation: function () {},
@@ -2933,7 +3029,7 @@ var sinon = (function () {
    * @author Christian Johansen (christian@cjohansen.no)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
    */
 
   if (typeof sinon == "undefined") {
@@ -2981,6 +3077,18 @@ var sinon = (function () {
       this.status = 0;
       this.statusText = "";
 
+      var xhr = this;
+
+      ["loadstart", "load", "abort", "loadend"].forEach(function (eventName) {
+        xhr.addEventListener(eventName, function (event) {
+          var listener = xhr["on" + eventName];
+
+          if (listener && typeof listener == "function") {
+            listener(event);
+          }
+        });
+      });
+
       if (typeof FakeXMLHttpRequest.onCreate == "function") {
         FakeXMLHttpRequest.onCreate(this);
       }
@@ -3134,6 +3242,13 @@ var sinon = (function () {
         }
 
         this.dispatchEvent(new sinon.Event("readystatechange"));
+
+        switch (this.readyState) {
+          case FakeXMLHttpRequest.DONE:
+            this.dispatchEvent(new sinon.Event("load", false, false, this));
+            this.dispatchEvent(new sinon.Event("loadend", false, false, this));
+            break;
+        }
       },
 
       setRequestHeader: function setRequestHeader(header, value) {
@@ -3162,6 +3277,8 @@ var sinon = (function () {
 
         if (this.async) {
           this.readyStateChange(FakeXMLHttpRequest.HEADERS_RECEIVED);
+        } else {
+          this.readyState = FakeXMLHttpRequest.HEADERS_RECEIVED;
         }
       },
 
@@ -3187,6 +3304,8 @@ var sinon = (function () {
         if (typeof this.onSend == "function") {
           this.onSend(this);
         }
+
+        this.dispatchEvent(new sinon.Event("loadstart", false, false, this));
       },
 
       abort: function abort() {
@@ -3201,6 +3320,11 @@ var sinon = (function () {
         }
 
         this.readyState = sinon.FakeXMLHttpRequest.UNSENT;
+
+        this.dispatchEvent(new sinon.Event("abort", false, false, this));
+        if (typeof this.onerror === "function") {
+          this.onerror();
+        }
       },
 
       getResponseHeader: function getResponseHeader(header) {
@@ -3281,6 +3405,10 @@ var sinon = (function () {
         this.status = typeof status == "number" ? status : 200;
         this.statusText = FakeXMLHttpRequest.statusCodes[this.status];
         this.setResponseBody(body || "");
+        if (typeof this.onload === "function"){
+          this.onload();
+        }
+
       }
     });
 
@@ -3407,7 +3535,7 @@ var sinon = (function () {
    * @author Christian Johansen (christian@cjohansen.no)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
    */
 
   if (typeof sinon == "undefined") {
@@ -3471,6 +3599,15 @@ var sinon = (function () {
       return false;
     }
 
+    function log(response, request) {
+      var str;
+
+      str =  "Request:\n"  + sinon.format(request)  + "\n\n";
+      str += "Response:\n" + sinon.format(response) + "\n\n";
+
+      sinon.log(str);
+    }
+
     return {
       create: function () {
         var server = create(this);
@@ -3577,6 +3714,8 @@ var sinon = (function () {
           }
 
           if (request.readyState != 4) {
+            log(response, request);
+
             request.respond(response[0], response[1], response[2]);
           }
         } catch (e) {
@@ -3612,7 +3751,7 @@ var sinon = (function () {
    * @author Christian Johansen (christian@cjohansen.no)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
    */
 
   (function () {
@@ -3692,7 +3831,7 @@ var sinon = (function () {
    * @author Christian Johansen (christian@cjohansen.no)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
    */
 
   if (typeof module == "object" && typeof require == "function") {
@@ -3816,7 +3955,7 @@ var sinon = (function () {
    * @author Christian Johansen (christian@cjohansen.no)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
    */
 
   (function (sinon) {
@@ -3889,7 +4028,7 @@ var sinon = (function () {
    * @author Christian Johansen (christian@cjohansen.no)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
    */
 
   (function (sinon) {
@@ -3986,7 +4125,7 @@ var sinon = (function () {
    * @author Christian Johansen (christian@cjohansen.no)
    * @license BSD
    *
-   * Copyright (c) 2010-2011 Christian Johansen
+   * Copyright (c) 2010-2013 Christian Johansen
    */
 
   (function (sinon, global) {
@@ -4079,7 +4218,14 @@ var sinon = (function () {
         if (!sinon.calledInOrder(arguments)) {
           try {
             expected = [].join.call(arguments, ", ");
-            actual = sinon.orderByFirstCall(slice.call(arguments)).join(", ");
+            var calls = slice.call(arguments);
+            var i = calls.length;
+            while (i) {
+              if (!calls[--i].called) {
+                calls.splice(i, 1);
+              }
+            }
+            actual = sinon.orderByFirstCall(calls).join(", ");
           } catch (e) {
             // If this fails, we'll just fall back to the blank string
           }
@@ -4148,6 +4294,6 @@ var sinon = (function () {
     } else {
       sinon.assert = assert;
     }
-  }(typeof sinon == "object" && sinon || null, typeof window != "undefined" ? window : global));
+  }(typeof sinon == "object" && sinon || null, typeof window != "undefined" ? window : (typeof self != "undefined") ? self : global));
 
   return sinon;}.call(typeof window != 'undefined' && window || {}));