Refactored into class files. Meta-tests and runner for jasmine. Stack traces available for Firefox and supported browsers. Experimental pretty print matcher support. Many other new features

src/base.js

@@ -0,0 +1,213 @@
+/*
+ * Jasmine internal classes & objects
+ */
+
+/** @namespace */
+var jasmine = {};
+
+/** @deprecated use jasmine (lowercase because it's a package name) instead */
+var Jasmine = jasmine;
+
+jasmine.unimplementedMethod_ = function() {
+  throw new Error("unimplemented method");
+};
+
+jasmine.bindOriginal_ = function(base, name) {
+  var original = base[name];
+  return function() {
+    return original.apply(base, arguments);
+  };
+};
+
+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.MessageResult = function(text) {
+  this.type = 'MessageResult';
+  this.text = text;
+  this.trace = new Error(); // todo: test better
+};
+
+jasmine.ExpectationResult = function(passed, message, details) {
+  this.type = 'ExpectationResult';
+  this.passed = passed;
+  this.message = message;
+  this.details = details;
+  this.trace = new Error(message); // todo: test better
+};
+
+jasmine.getEnv = function() {
+  return jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env();
+};
+
+jasmine.isArray_ = function(value) {
+  return value &&
+         typeof value === 'object' &&
+         typeof value.length === 'number' &&
+         typeof value.splice === 'function' &&
+         !(value.propertyIsEnumerable('length'));
+};
+
+jasmine.pp = function(value) {
+  var stringPrettyPrinter = new jasmine.StringPrettyPrinter();
+  stringPrettyPrinter.format(value);
+  return stringPrettyPrinter.string;
+};
+
+jasmine.isDomNode = function(obj) {
+  return obj['nodeType'] > 0;
+};
+
+jasmine.any = function(clazz) {
+  return new jasmine.Matchers.Any(clazz);
+};
+
+
+jasmine.createSpy = function(name) {
+  var spyObj = function() {
+    spyObj.wasCalled = true;
+    spyObj.callCount++;
+    var args = jasmine.util.argsToArray(arguments);
+    spyObj.mostRecentCall = {
+      object: this,
+      args: args
+    };
+    spyObj.argsForCall.push(args);
+    return spyObj.plan.apply(this, arguments);
+  };
+
+  spyObj.identity = name || 'unknown';
+  spyObj.isSpy = true;
+
+  spyObj.plan = function() {
+  };
+
+  spyObj.andCallThrough = function() {
+    spyObj.plan = spyObj.originalValue;
+    return spyObj;
+  };
+  spyObj.andReturn = function(value) {
+    spyObj.plan = function() {
+      return value;
+    };
+    return spyObj;
+  };
+  spyObj.andThrow = function(exceptionMsg) {
+    spyObj.plan = function() {
+      throw exceptionMsg;
+    };
+    return spyObj;
+  };
+  spyObj.andCallFake = function(fakeFunc) {
+    spyObj.plan = fakeFunc;
+    return spyObj;
+  };
+  spyObj.reset = function() {
+    spyObj.wasCalled = false;
+    spyObj.callCount = 0;
+    spyObj.argsForCall = [];
+    spyObj.mostRecentCall = {};
+  };
+  spyObj.reset();
+
+  return spyObj;
+};
+
+jasmine.createSpyObj = function(baseName, methodNames) {
+  var obj = {};
+  for (var i = 0; i < methodNames.length; i++) {
+    obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]);
+  }
+  return obj;
+};
+
+jasmine.log = function(message) {
+  jasmine.getEnv().currentSpec.getResults().log(message);
+};
+
+var spyOn = function(obj, methodName) {
+  return jasmine.getEnv().currentSpec.spyOn(obj, methodName);
+};
+
+var it = function(desc, func) {
+  return jasmine.getEnv().it(desc, func);
+};
+
+//this mirrors the spec syntax so you can define a spec description that will not run.
+var xit = function(desc, func) {
+  return jasmine.getEnv().xit(desc, func);
+};
+
+var expect = function(actual) {
+  return jasmine.getEnv().currentSpec.expect(actual);
+};
+
+var runs = function(func) {
+  jasmine.getEnv().currentSpec.runs(func);
+};
+
+var waits = function(timeout) {
+  jasmine.getEnv().currentSpec.waits(timeout);
+};
+
+var waitsFor = function(timeout, latchFunction, message) {
+  jasmine.getEnv().currentSpec.waitsFor(timeout, latchFunction, message);
+};
+
+var beforeEach = function(beforeEachFunction) {
+  jasmine.getEnv().beforeEach(beforeEachFunction);
+};
+
+var afterEach = function(afterEachFunction) {
+  jasmine.getEnv().afterEach(afterEachFunction);
+};
+
+var describe = function(description, specDefinitions) {
+  return jasmine.getEnv().describe(description, specDefinitions);
+};
+
+var xdescribe = function(description, specDefinitions) {
+  return jasmine.getEnv().xdescribe(description, specDefinitions);
+};
+
+jasmine.XmlHttpRequest = XMLHttpRequest;
+
+// Provide the XMLHttpRequest class for IE 5.x-6.x:
+if (typeof XMLHttpRequest == "undefined") jasmine.XmlHttpRequest = function() {
+  try {
+    return new ActiveXObject("Msxml2.XMLHTTP.6.0");
+  } catch(e) {
+  }
+  try {
+    return new ActiveXObject("Msxml2.XMLHTTP.3.0");
+  } catch(e) {
+  }
+  try {
+    return new ActiveXObject("Msxml2.XMLHTTP");
+  } catch(e) {
+  }
+  try {
+    return new ActiveXObject("Microsoft.XMLHTTP");
+  } catch(e) {
+  }
+  throw new Error("This browser does not support XMLHttpRequest.");
+};
+
+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);
+  }
+};