evergreen 0.1 → 0.2.0

data/lib/jasmine/lib/{jasmine-0.10.4.js → jasmine.js}

@@ -26,6 +26,14 @@ jasmine.undefined = jasmine.___undefined___;
  */
 jasmine.DEFAULT_UPDATE_INTERVAL = 250;
 
+jasmine.getGlobal = function() {
+  function getGlobal() {
+    return this;
+  }
+
+  return getGlobal();
+};
+
 /**
  * Allows for bound functions to be compared.  Internal use only.
  *
@@ -42,35 +50,41 @@ jasmine.bindOriginal_ = function(base, name) {
     };
   } else {
     // IE support
-    return window[name];
+    return jasmine.getGlobal()[name];
   }
 };
 
-jasmine.setTimeout = jasmine.bindOriginal_(window, 'setTimeout');
-jasmine.clearTimeout = jasmine.bindOriginal_(window, 'clearTimeout');
-jasmine.setInterval = jasmine.bindOriginal_(window, 'setInterval');
-jasmine.clearInterval = jasmine.bindOriginal_(window, 'clearInterval');
+jasmine.setTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'setTimeout');
+jasmine.clearTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearTimeout');
+jasmine.setInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'setInterval');
+jasmine.clearInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearInterval');
 
-jasmine.MessageResult = function(text) {
-  this.type = 'MessageResult';
-  this.text = text;
+jasmine.MessageResult = function(values) {
+  this.type = 'log';
+  this.values = values;
   this.trace = new Error(); // todo: test better
 };
 
 jasmine.MessageResult.prototype.toString = function() {
-  return this.text;
+  var text = "";
+  for(var i = 0; i < this.values.length; i++) {
+    if (i > 0) text += " ";
+    if (jasmine.isString_(this.values[i])) {
+      text += this.values[i];
+    } else {
+      text += jasmine.pp(this.values[i]);
+    }
+  }
+  return text;
 };
 
 jasmine.ExpectationResult = function(params) {
-  this.type = 'ExpectationResult';
+  this.type = 'expect';
   this.matcherName = params.matcherName;
   this.passed_ = params.passed;
   this.expected = params.expected;
   this.actual = params.actual;
 
-  /** @deprecated */
-  this.details = params.details;
-
   this.message = this.passed_ ? 'Passed.' : params.message;
   this.trace = this.passed_ ? '' : new Error(this.message);
 };
@@ -158,7 +172,7 @@ jasmine.isDomNode = function(obj) {
  *
  * @example
  * // don't care about which function is passed in, as long as it's a function
- * expect(mySpy).wasCalledWith(jasmine.any(Function));
+ * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function));
  *
  * @param {Class} clazz
  * @returns matchable object of the type clazz
@@ -173,7 +187,8 @@ jasmine.any = function(clazz) {
  * Spies should be created in test setup, before expectations.  They can then be checked, using the standard Jasmine
  * expectation syntax. Spies can be checked if they were called or not and what the calling params were.
  *
- * A Spy has the following mehtod: wasCalled, callCount, mostRecentCall, and argsForCall (see docs)
+ * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs).
+ *
  * Spies are torn down at the end of every spec.
  *
  * Note: Do <b>not</b> call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.
@@ -203,8 +218,8 @@ jasmine.any = function(clazz) {
  *
  * // mock example
  * foo.not(7 == 7);
- * expect(foo.not).wasCalled();
- * expect(foo.not).wasCalledWith(true);
+ * expect(foo.not).toHaveBeenCalled();
+ * expect(foo.not).toHaveBeenCalledWith(true);
  *
  * @constructor
  * @see spyOn, jasmine.createSpy, jasmine.createSpyObj
@@ -395,8 +410,14 @@ jasmine.createSpyObj = function(baseName, methodNames) {
   return obj;
 };
 
-jasmine.log = function(message) {
-  jasmine.getEnv().currentSpec.log(message);
+/**
+ * All parameters are pretty-printed and concatenated together, then written to the current spec's output.
+ *
+ * Be careful not to leave calls to <code>jasmine.log</code> in production code.
+ */
+jasmine.log = function() {
+  var spec = jasmine.getEnv().currentSpec;
+  spec.log.apply(spec, arguments);
 };
 
 /**
@@ -559,31 +580,6 @@ jasmine.XmlHttpRequest = (typeof XMLHttpRequest == "undefined") ? function() {
   }
   throw new Error("This browser does not support XMLHttpRequest.");
 } : XMLHttpRequest;
-
-/**
- * Adds suite files to an HTML document so that they are executed, thus adding them to the current
- * Jasmine environment.
- *
- * @param {String} url path to the file to include
- * @param {Boolean} opt_global
- * @deprecated We suggest you use a different method of including JS source files. <code>jasmine.include</code> will be removed soon.
- */
-jasmine.include = function(url, opt_global) {
-  if (opt_global) {
-    document.write('<script type="text/javascript" src="' + url + '"></' + 'script>');
-  } else {
-    var xhr;
-    try {
-      xhr = new jasmine.XmlHttpRequest();
-      xhr.open("GET", url, false);
-      xhr.send(null);
-    } catch(e) {
-      throw new Error("couldn't fetch " + url + ": " + e);
-    }
-
-    return eval(xhr.responseText);
-  }
-};
 /**
  * @namespace
  */
@@ -933,6 +929,10 @@ jasmine.Reporter.prototype.reportRunnerResults = function(runner) {
 jasmine.Reporter.prototype.reportSuiteResults = function(suite) {
 };
 
+//noinspection JSUnusedLocalSymbols
+jasmine.Reporter.prototype.reportSpecStarting = function(spec) {
+};
+
 //noinspection JSUnusedLocalSymbols
 jasmine.Reporter.prototype.reportSpecResults = function(spec) {
 };
@@ -1045,11 +1045,11 @@ jasmine.JsApiReporter.prototype.resultsForSpecs = function(specIds){
 
 jasmine.JsApiReporter.prototype.summarizeResult_ = function(result){
   var summaryMessages = [];
-  var messagesLength = result.messages.length
+  var messagesLength = result.messages.length;
   for (var messageIndex = 0; messageIndex < messagesLength; messageIndex++) {
     var resultMessage = result.messages[messageIndex];
     summaryMessages.push({
-      text: resultMessage.text,
+      text: resultMessage.type == 'log' ? resultMessage.toString() : jasmine.undefined,
       passed: resultMessage.passed ? resultMessage.passed() : true,
       type: resultMessage.type,
       message: resultMessage.message,
@@ -1057,14 +1057,12 @@ jasmine.JsApiReporter.prototype.summarizeResult_ = function(result){
         stack: resultMessage.passed && !resultMessage.passed() ? resultMessage.trace.stack : jasmine.undefined
       }
     });
-  };
+  }
 
-  var summaryResult = {
+  return {
     result : result.result,
     messages : summaryMessages
   };
-
-  return summaryResult;
 };
 
 /**
@@ -1084,25 +1082,11 @@ jasmine.Matchers = function(env, actual, spec, opt_isNot) {
 // todo: @deprecated as of Jasmine 0.11, remove soon [xw]
 jasmine.Matchers.pp = function(str) {
   throw new Error("jasmine.Matchers.pp() is no longer supported, please use jasmine.pp() instead!");
-  this.report();
 };
 
-/** @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. */
+// todo: @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. [xw]
 jasmine.Matchers.prototype.report = function(result, failing_message, details) {
-  // todo: report a deprecation warning [xw]
-
-  if (this.isNot) {
-    throw new Error("As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs");
-  }
-  
-  this.reportWasCalled_ = true;
-  var expectationResult = new jasmine.ExpectationResult({
-    passed: result,
-    message: failing_message,
-    details: details
-  });
-  this.spec.addMatcherResult(expectationResult);
-  return result;
+  throw new Error("As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs");
 };
 
 jasmine.Matchers.wrapInto_ = function(prototype, matchersClass) {
@@ -1245,12 +1229,18 @@ jasmine.Matchers.prototype.toBeFalsy = function() {
   return !this.actual;
 };
 
+
+/** @deprecated Use expect(xxx).toHaveBeenCalled() instead */
+jasmine.Matchers.prototype.wasCalled = function() {
+  return this.toHaveBeenCalled();
+};
+
 /**
  * Matcher that checks to see if the actual, a Jasmine spy, was called.
  */
-jasmine.Matchers.prototype.wasCalled = function() {
+jasmine.Matchers.prototype.toHaveBeenCalled = function() {
   if (arguments.length > 0) {
-    throw new Error('wasCalled does not take arguments, use wasCalledWith');
+    throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
   }
 
   if (!jasmine.isSpy(this.actual)) {
@@ -1266,6 +1256,8 @@ jasmine.Matchers.prototype.wasCalled = function() {
 
 /**
  * Matcher that checks to see if the actual, a Jasmine spy, was not called.
+ *
+ * @deprecated Use expect(xxx).not.toHaveBeenCalled() instead
  */
 jasmine.Matchers.prototype.wasNotCalled = function() {
   if (arguments.length > 0) {
@@ -1283,13 +1275,18 @@ jasmine.Matchers.prototype.wasNotCalled = function() {
   return !this.actual.wasCalled;
 };
 
+/** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */
+jasmine.Matchers.prototype.wasCalledWith = function() {
+  return this.toHaveBeenCalledWith.apply(this, arguments);
+};
+
 /**
  * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters.
  *
  * @example
  *
  */
-jasmine.Matchers.prototype.wasCalledWith = function() {
+jasmine.Matchers.prototype.toHaveBeenCalledWith = function() {
   var expectedArgs = jasmine.util.argsToArray(arguments);
   if (!jasmine.isSpy(this.actual)) {
     throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
@@ -1305,6 +1302,7 @@ jasmine.Matchers.prototype.wasCalledWith = function() {
   return this.env.contains_(this.actual.argsForCall, expectedArgs);
 };
 
+/** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead */
 jasmine.Matchers.prototype.wasNotCalledWith = function() {
   var expectedArgs = jasmine.util.argsToArray(arguments);
   if (!jasmine.isSpy(this.actual)) {
@@ -1416,7 +1414,14 @@ jasmine.MultiReporter.prototype.addReporter = function(reporter) {
 };
 
 (function() {
-  var functionNames = ["reportRunnerStarting", "reportRunnerResults", "reportSuiteResults", "reportSpecResults", "log"];
+  var functionNames = [
+    "reportRunnerStarting",
+    "reportRunnerResults",
+    "reportSuiteResults",
+    "reportSpecStarting",
+    "reportSpecResults",
+    "log"
+  ];
   for (var i = 0; i < functionNames.length; i++) {
     var functionName = functionNames[i];
     jasmine.MultiReporter.prototype[functionName] = (function(functionName) {
@@ -1471,11 +1476,11 @@ jasmine.NestedResults.prototype.rollupCounts = function(result) {
 };
 
 /**
- * Tracks a result's message.
- * @param message
+ * Adds a log message.
+ * @param values Array of message parts which will be concatenated later.
  */
-jasmine.NestedResults.prototype.log = function(message) {
-  this.items_.push(new jasmine.MessageResult(message));
+jasmine.NestedResults.prototype.log = function(values) {
+  this.items_.push(new jasmine.MessageResult(values));
 };
 
 /**
@@ -1490,7 +1495,7 @@ jasmine.NestedResults.prototype.getItems = function() {
  * @param {jasmine.ExpectationResult|jasmine.NestedResults} result
  */
 jasmine.NestedResults.prototype.addResult = function(result) {
-  if (result.type != 'MessageResult') {
+  if (result.type != 'log') {
     if (result.items_) {
       this.rollupCounts(result);
     } else {
@@ -1534,8 +1539,8 @@ jasmine.PrettyPrinter.prototype.format = function(value) {
       this.emitScalar('undefined');
     } else if (value === null) {
       this.emitScalar('null');
-    } else if (value.navigator && value.frames && value.setTimeout) {
-      this.emitScalar('<window>');
+    } else if (value === jasmine.getGlobal()) {
+      this.emitScalar('<global>');
     } else if (value instanceof jasmine.Matchers.Any) {
       this.emitScalar(value.toString());
     } else if (typeof value === 'string') {
@@ -1727,49 +1732,6 @@ jasmine.Queue.prototype.results = function() {
 };
 
 
-/** JasmineReporters.reporter
- *    Base object that will get called whenever a Spec, Suite, or Runner is done.  It is up to
- *    descendants of this object to do something with the results (see json_reporter.js)
- *
- * @deprecated
- */
-jasmine.Reporters = {};
-
-/**
- * @deprecated
- * @param callbacks
- */
-jasmine.Reporters.reporter = function(callbacks) {
-  /**
-   * @deprecated
-   * @param callbacks
-   */
-  var that = {
-    callbacks: callbacks || {},
-
-    doCallback: function(callback, results) {
-      if (callback) {
-        callback(results);
-      }
-    },
-
-    reportRunnerResults: function(runner) {
-      that.doCallback(that.callbacks.runnerCallback, runner);
-    },
-    reportSuiteResults:  function(suite) {
-      that.doCallback(that.callbacks.suiteCallback, suite);
-    },
-    reportSpecResults:   function(spec) {
-      that.doCallback(that.callbacks.specCallback, spec);
-    },
-    log: function (str) {
-      if (console && console.log) console.log(str);
-    }
-  };
-
-  return that;
-};
-
 /**
  * Runner
  *
@@ -1886,13 +1848,13 @@ jasmine.Spec.prototype.results = function() {
   return this.results_;
 };
 
-jasmine.Spec.prototype.log = function(message) {
-  return this.results_.log(message);
-};
-
-/** @deprecated */
-jasmine.Spec.prototype.getResults = function() {
-  return this.results_;
+/**
+ * All parameters are pretty-printed and concatenated together, then written to the spec's output.
+ *
+ * Be careful not to leave calls to <code>jasmine.log</code> in production code.
+ */
+jasmine.Spec.prototype.log = function() {
+  return this.results_.log(arguments);
 };
 
 jasmine.Spec.prototype.runs = function (func) {
@@ -1909,6 +1871,9 @@ jasmine.Spec.prototype.addToQueue = function (block) {
   }
 };
 
+/**
+ * @param {jasmine.ExpectationResult} result
+ */
 jasmine.Spec.prototype.addMatcherResult = function(result) {
   this.results_.addResult(result);
 };
@@ -1980,7 +1945,8 @@ jasmine.Spec.prototype.execute = function(onComplete) {
     spec.finish(onComplete);
     return;
   }
-  this.env.reporter.log('>> Jasmine Running ' + this.suite.description + ' ' + this.description + '...');
+
+  this.env.reporter.reportSpecStarting(this);
 
   spec.env.currentSpec = spec;
 
@@ -2106,15 +2072,15 @@ jasmine.Suite.prototype.results = function() {
   return this.queue.results();
 };
 
-jasmine.Suite.prototype.add = function(block) {
-  this.children_.push(block);
-  if (block instanceof jasmine.Suite) {
-    this.suites_.push(block);
-    this.env.currentRunner().addSuite(block);
+jasmine.Suite.prototype.add = function(suiteOrSpec) {
+  this.children_.push(suiteOrSpec);
+  if (suiteOrSpec instanceof jasmine.Suite) {
+    this.suites_.push(suiteOrSpec);
+    this.env.currentRunner().addSuite(suiteOrSpec);
   } else {
-    this.specs_.push(block);
+    this.specs_.push(suiteOrSpec);
   }
-  this.queue.add(block);
+  this.queue.add(suiteOrSpec);
 };
 
 jasmine.Suite.prototype.specs = function() {
@@ -2251,9 +2217,9 @@ jasmine.FakeTimer.prototype.runFunctionsWithinRange = function(oldMillis, nowMil
         funcToRun.funcToCall();
         if (funcToRun.recurring) {
           this.scheduleFunction(funcToRun.timeoutKey,
-            funcToRun.funcToCall,
-            funcToRun.millis,
-            true);
+              funcToRun.funcToCall,
+              funcToRun.millis,
+              true);
         }
       } catch(e) {
       }
@@ -2297,10 +2263,12 @@ jasmine.Clock = {
   },
 
   useMock: function() {
-    var spec = jasmine.getEnv().currentSpec;
-    spec.after(jasmine.Clock.uninstallMock);
+    if (!jasmine.Clock.isInstalled()) {
+      var spec = jasmine.getEnv().currentSpec;
+      spec.after(jasmine.Clock.uninstallMock);
 
-    jasmine.Clock.installMock();
+      jasmine.Clock.installMock();
+    }
   },
 
   installMock: function() {
@@ -2313,24 +2281,28 @@ jasmine.Clock = {
   },
 
   real: {
-    setTimeout: window.setTimeout,
-    clearTimeout: window.clearTimeout,
-    setInterval: window.setInterval,
-    clearInterval: window.clearInterval
+    setTimeout: jasmine.getGlobal().setTimeout,
+    clearTimeout: jasmine.getGlobal().clearTimeout,
+    setInterval: jasmine.getGlobal().setInterval,
+    clearInterval: jasmine.getGlobal().clearInterval
   },
 
   assertInstalled: function() {
-    if (jasmine.Clock.installed != jasmine.Clock.defaultFakeTimer) {
+    if (!jasmine.Clock.isInstalled()) {
       throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()");
     }
   },
 
+  isInstalled: function() {
+    return jasmine.Clock.installed == jasmine.Clock.defaultFakeTimer;
+  },
+
   installed: null
 };
 jasmine.Clock.installed = jasmine.Clock.real;
 
 //else for IE support
-window.setTimeout = function(funcToCall, millis) {
+jasmine.getGlobal().setTimeout = function(funcToCall, millis) {
   if (jasmine.Clock.installed.setTimeout.apply) {
     return jasmine.Clock.installed.setTimeout.apply(this, arguments);
   } else {
@@ -2338,7 +2310,7 @@ window.setTimeout = function(funcToCall, millis) {
   }
 };
 
-window.setInterval = function(funcToCall, millis) {
+jasmine.getGlobal().setInterval = function(funcToCall, millis) {
   if (jasmine.Clock.installed.setInterval.apply) {
     return jasmine.Clock.installed.setInterval.apply(this, arguments);
   } else {
@@ -2346,7 +2318,7 @@ window.setInterval = function(funcToCall, millis) {
   }
 };
 
-window.clearTimeout = function(timeoutKey) {
+jasmine.getGlobal().clearTimeout = function(timeoutKey) {
   if (jasmine.Clock.installed.clearTimeout.apply) {
     return jasmine.Clock.installed.clearTimeout.apply(this, arguments);
   } else {
@@ -2354,18 +2326,18 @@ window.clearTimeout = function(timeoutKey) {
   }
 };
 
-window.clearInterval = function(timeoutKey) {
+jasmine.getGlobal().clearInterval = function(timeoutKey) {
   if (jasmine.Clock.installed.clearTimeout.apply) {
     return jasmine.Clock.installed.clearInterval.apply(this, arguments);
   } else {
-  return jasmine.Clock.installed.clearInterval(timeoutKey);
+    return jasmine.Clock.installed.clearInterval(timeoutKey);
   }
 };
 
 
 jasmine.version_= {
   "major": 0,
-  "minor": 10,
-  "build": 4,
-  "revision": 1277227072
-  };
+  "minor": 11,
+  "build": 1,
+  "revision": 1277514571
+};