smparkes-jazrb 0.0.10 → 0.0.11

data/lib/jazrb/jasmine/TrivialReporter.js

@@ -89,9 +89,7 @@ jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {
   for (var i = 0; i < resultItems.length; i++) {
     var result = resultItems[i];
     if (result.passed && !result.passed()) {
-      var resultMessageDiv = this.createDom('div', {className: 'resultMessage fail'});
-      resultMessageDiv.innerHTML = result.message; // todo: lame; mend
-      specDiv.appendChild(resultMessageDiv);
+      specDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
       specDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
     }
   }

data/lib/jazrb/jasmine/XMLReporter.js

@@ -137,7 +137,11 @@ jasmine.XMLReporter.prototype.reportSpecResults = function(spec) {
     name.unshift( suite.description );
     suite = suite.parentSuite;
   }
-  puts("  <testsuite"+formatAttributes({name:name.join(" : ")}) +">");
+  var attrs = {name:name.join(" : ")};
+  if(spec.pending) {
+    attrs.skipped = "true";
+  }
+  puts("  <testsuite"+formatAttributes(attrs) +">");
   jasmine.XMLReporter.current_spec = spec;
   this.results_[spec.id] = {
     spec: spec,
@@ -147,8 +151,9 @@ jasmine.XMLReporter.prototype.reportSpecResults = function(spec) {
   var results = spec.results().getItems();
   for(var i in results) {
     var result = results[i];
-    puts("    <testcase"+formatAttributes({name:(1+parseInt(i))+ ": " + result.matcherName})+">");
-    if(!result.passed()){
+    var attrs = {name:(1+parseInt(i))+ ": " + result.matcherName};
+    puts("    <testcase"+formatAttributes(attrs)+">");
+    if(!result.passed() && !attrs.skipped){
       puts("     <failure"+formatAttributes({type:result.matcherName,
                                               message:result.message})+">");
       puts("<![CDATA[");

data/lib/jazrb/jasmine/jasmine-0.10.0.js

@@ -19,7 +19,7 @@ jasmine.unimplementedMethod_ = function() {
 jasmine.DEFAULT_UPDATE_INTERVAL = 250;
 
 /**
- * Allows for bound functions to be comapred.  Internal use only.
+ * Allows for bound functions to be compared.  Internal use only.
  *
  * @ignore
  * @private
@@ -325,6 +325,16 @@ jasmine.createSpy = function(name) {
   return spyObj;
 };
 
+/**
+ * Determines whether an object is a spy.
+ *
+ * @param {jasmine.Spy|Object} putativeSpy
+ * @returns {Boolean}
+ */
+jasmine.isSpy = function(putativeSpy) {
+  return putativeSpy && putativeSpy.isSpy;
+};
+
 /**
  * Creates a more complicated spy: an Object that has every property a function that is a spy.  Used for stubbing something
  * large in one call.
@@ -392,6 +402,15 @@ var xit = function(desc, func) {
   return jasmine.getEnv().xit(desc, func);
 };
 
+jasmine.pending_ = function(){
+  Error.call(this,"Pending");
+};
+jasmine.pending_.prototype = new Error;
+
+var pending = function() {
+  throw new jasmine.pending_;
+};
+
 /**
  * Starts a chain for a Jasmine expectation.
  *
@@ -552,7 +571,7 @@ jasmine.version_= {
   "major": 0,
   "minor": 10,
   "build": 0,
-  "revision": 1258603168
+  "revision": 1259177226
   };
 /**
  * @namespace
@@ -633,7 +652,7 @@ jasmine.Env = function() {
 
   this.reporter = new jasmine.MultiReporter();
 
-  this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL
+  this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL;
   this.lastUpdate = 0;
   this.specFilter = function() {
     return true;
@@ -642,6 +661,17 @@ jasmine.Env = function() {
   this.nextSpecId_ = 0;
   this.nextSuiteId_ = 0;
   this.equalityTesters_ = [];
+
+  // wrap matchers
+  this.matchersClass = function() {
+    jasmine.Matchers.apply(this, arguments);
+  };
+  jasmine.util.inherit(this.matchersClass, jasmine.Matchers);
+
+  for (var methodName in jasmine.Matchers.prototype) {
+    var orig = jasmine.Matchers.prototype[methodName];
+    this.matchersClass.prototype[methodName] = jasmine.Matchers.matcherFn_(methodName, orig);
+  }
 };
 
 
@@ -738,20 +768,21 @@ jasmine.Env.prototype.it = function(description, func) {
   var spec = new jasmine.Spec(this, this.currentSuite, description);
   this.currentSuite.add(spec);
   this.currentSpec = spec;
+  spec.pending = false;
 
   if (func) {
     spec.runs(func);
+  } else {
+    spec.pending = true;
   }
 
   return spec;
 };
 
-jasmine.Env.prototype.xit = function(desc, func) {
-  return {
-    id: this.nextSpecId(),
-    runs: function() {
-    }
-  };
+jasmine.Env.prototype.xit = function(description, func) {
+  var spec = this.it(description, func);
+  spec.pending = -1;
+  return spec;
 };
 
 jasmine.Env.prototype.compareObjects_ = function(a, b, mismatchKeys, mismatchValues) {
@@ -888,9 +919,15 @@ jasmine.Block = function(env, func, spec) {
 
 jasmine.Block.prototype.execute = function(onComplete) {  
   try {
-    this.func.apply(this.spec);
+    if(!this.spec.pending){
+      this.func.apply(this.spec);
+    }
   } catch (e) {
-    this.spec.fail(e);
+    if(e instanceof jasmine.pending_){
+      this.spec.pending = true;
+    } else {
+      this.spec && this.spec.fail(e);
+    }
   }
   onComplete();
 };
@@ -975,7 +1012,8 @@ jasmine.JsApiReporter.prototype.resultsForSpecs = function(specIds){
 
 jasmine.JsApiReporter.prototype.summarizeResult_ = function(result){
   var summaryMessages = [];
-  for (var messageIndex in result.messages) {
+  var messagesLength = result.messages.length
+  for (var messageIndex = 0; messageIndex < messagesLength; messageIndex++) {
     var resultMessage = result.messages[messageIndex];
     summaryMessages.push({
       text: resultMessage.text,
@@ -1022,15 +1060,25 @@ jasmine.Matchers.prototype.report = function(result, failing_message, details) {
   return result;
 };
 
-jasmine.Matchers.matcherFn_ = function(matcherName, options) {
-  return function () {
-    jasmine.util.extend(this, options);
+jasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) {
+  return function() {
     var matcherArgs = jasmine.util.argsToArray(arguments);
-    var args = [this.actual].concat(matcherArgs);
-    var result = options.test.apply(this, args);
+    var result = matcherFunction.apply(this, arguments);
     var message;
     if (!result) {
-      message = options.message.apply(this, args);
+      if (this.message) {
+        message = this.message.apply(this, arguments);
+      } else {
+        var englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); });
+        message = "Expected " + jasmine.pp(this.actual) + " " + englishyPredicate;
+        if (matcherArgs.length > 0) {
+          for (var i = 0; i < matcherArgs.length; i++) {
+            if (i > 0) message += ",";
+            message += " " + jasmine.pp(matcherArgs[i]);
+          }
+        }
+        message += ".";
+      }
     }
     var expectationResult = new jasmine.ExpectationResult({
       matcherName: matcherName,
@@ -1052,27 +1100,17 @@ jasmine.Matchers.matcherFn_ = function(matcherName, options) {
  * @param expected
  */
 
-jasmine.Matchers.prototype.toBe = jasmine.Matchers.matcherFn_('toBe', {
-  test: function (actual, expected) {
-    return actual === expected;
-  },
-  message: function(actual, expected) {
-    return "Expected " + jasmine.pp(actual) + " to be " + jasmine.pp(expected);
-  }
-});
+jasmine.Matchers.prototype.toBe = function(expected) {
+  return this.actual === expected;
+};
 
 /**
  * toNotBe: compares the actual to the expected using !==
  * @param expected
  */
-jasmine.Matchers.prototype.toNotBe = jasmine.Matchers.matcherFn_('toNotBe', {
-  test: function (actual, expected) {
-    return actual !== expected;
-  },
-  message: function(actual, expected) {
-    return "Expected " + jasmine.pp(actual) + " to not be " + jasmine.pp(expected);
-  }
-});
+jasmine.Matchers.prototype.toNotBe = function(expected) {
+  return this.actual !== expected;
+};
 
 /**
  * toEqual: compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc.
@@ -1080,27 +1118,17 @@ jasmine.Matchers.prototype.toNotBe = jasmine.Matchers.matcherFn_('toNotBe', {
  * @param expected
  */
 
-jasmine.Matchers.prototype.toEqual = jasmine.Matchers.matcherFn_('toEqual', {
-  test: function (actual, expected) {
-    return this.env.equals_(actual, expected);
-  },
-  message: function(actual, expected) {
-    return "Expected " + jasmine.pp(actual) + " to equal " + jasmine.pp(expected);
-  }
-});
+jasmine.Matchers.prototype.toEqual = function(expected) {
+  return this.env.equals_(this.actual, expected);
+};
 
 /**
  * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual
  * @param expected
  */
-jasmine.Matchers.prototype.toNotEqual = jasmine.Matchers.matcherFn_('toNotEqual', {
-  test: function (actual, expected) {
-    return !this.env.equals_(actual, expected);
-  },
-  message: function(actual, expected) {
-    return "Expected " + jasmine.pp(actual) + " to not equal " + jasmine.pp(expected);
-  }
-});
+jasmine.Matchers.prototype.toNotEqual = function(expected) {
+  return !this.env.equals_(this.actual, expected);
+};
 
 /**
  * Matcher that compares the actual to the expected using a regular expression.  Constructs a RegExp, so takes
@@ -1108,228 +1136,143 @@ jasmine.Matchers.prototype.toNotEqual = jasmine.Matchers.matcherFn_('toNotEqual'
  *
  * @param reg_exp
  */
-jasmine.Matchers.prototype.toMatch = jasmine.Matchers.matcherFn_('toMatch', {
-  test: function(actual, expected) {
-    return new RegExp(expected).test(actual);
-  },
-  message: function(actual, expected) {
-    return jasmine.pp(actual) + " does not match the regular expression " + new RegExp(expected).toString();
-  }
-});
+jasmine.Matchers.prototype.toMatch = function(expected) {
+  return new RegExp(expected).test(this.actual);
+};
 
 /**
  * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch
  * @param reg_exp
  */
-
-jasmine.Matchers.prototype.toNotMatch = jasmine.Matchers.matcherFn_('toNotMatch', {
-  test: function(actual, expected) {
-    return !(new RegExp(expected).test(actual));
-  },
-  message: function(actual, expected) {
-    return jasmine.pp(actual) + " should not match " + new RegExp(expected).toString();
-  }
-});
+jasmine.Matchers.prototype.toNotMatch = function(expected) {
+  return !(new RegExp(expected).test(this.actual));
+};
 
 /**
- * Matcher that compares the acutal to undefined.
+ * Matcher that compares the actual to undefined.
  */
-
-jasmine.Matchers.prototype.toBeDefined = jasmine.Matchers.matcherFn_('toBeDefined', {
-  test: function(actual) {
-    return (actual !== undefined);
-  },
-  message: function() {
-    return 'Expected actual to not be undefined.';
-  }
-});
+jasmine.Matchers.prototype.toBeDefined = function() {
+  return (this.actual !== undefined);
+};
 
 /**
- * Matcher that compares the acutal to undefined.
+ * Matcher that compares the actual to undefined.
  */
-
-jasmine.Matchers.prototype.toBeUndefined = jasmine.Matchers.matcherFn_('toBeUndefined', {
-  test: function(actual) {
-    return (actual === undefined);
-  },
-  message: function(actual) {
-    return 'Expected ' + jasmine.pp(actual) + ' to be undefined.';
-  }
-});
+jasmine.Matchers.prototype.toBeUndefined = function() {
+  return (this.actual === undefined);
+};
 
 /**
  * Matcher that compares the actual to null.
- *
  */
-jasmine.Matchers.prototype.toBeNull = jasmine.Matchers.matcherFn_('toBeNull', {
-  test: function(actual) {
-    return (actual === null);
-  },
-  message: function(actual) {
-    return 'Expected ' + jasmine.pp(actual) + ' to be null.';
-  }
-});
+jasmine.Matchers.prototype.toBeNull = function() {
+  return (this.actual === null);
+};
 
 /**
  * Matcher that boolean not-nots the actual.
  */
-jasmine.Matchers.prototype.toBeTruthy = jasmine.Matchers.matcherFn_('toBeTruthy', {
-  test: function(actual) {
-    return !!actual;
-  },
-  message: function() {
-    return 'Expected actual to be truthy';
-  }
-});
+jasmine.Matchers.prototype.toBeTruthy = function() {
+  return !!this.actual;
+};
 
 
 /**
  * Matcher that boolean nots the actual.
  */
-jasmine.Matchers.prototype.toBeFalsy = jasmine.Matchers.matcherFn_('toBeFalsy', {
-  test: function(actual) {
-    return !actual;
-  },
-  message: function(actual) {
-    return 'Expected ' + jasmine.pp(actual) + ' to be falsy';
-  }
-});
+jasmine.Matchers.prototype.toBeFalsy = function() {
+  return !this.actual;
+};
 
 /**
- * Matcher that checks to see if the acutal, a Jasmine spy, was called.
+ * Matcher that checks to see if the actual, a Jasmine spy, was called.
  */
+jasmine.Matchers.prototype.wasCalled = function() {
+  if (arguments.length > 0) {
+    throw new Error('wasCalled does not take arguments, use wasCalledWith');
+  }
 
-jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.matcherFn_('wasCalled', {
-  getActual_: function() {
-    var args = jasmine.util.argsToArray(arguments);
-    if (args.length > 1) {
-      throw(new Error('wasCalled does not take arguments, use wasCalledWith'));
-    }
-    return args.splice(0, 1)[0];
-  },
-  test: function() {
-    var actual = this.getActual_.apply(this, arguments);
-    if (!actual || !actual.isSpy) {
-      return false;
-    }
-    return actual.wasCalled;
-  },
-  message: function() {
-    var actual = this.getActual_.apply(this, arguments);
-    if (!actual || !actual.isSpy) {
-      return 'Actual is not a spy.';
-    }
-    return "Expected spy " + actual.identity + " to have been called.";
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.Matchers.pp(this.actual) + '.');
   }
-});
+
+  this.message = function() {
+    return "Expected spy " + this.actual.identity + " to have been called.";
+  };
+
+  return this.actual.wasCalled;
+};
 
 /**
- * Matcher that checks to see if the acutal, a Jasmine spy, was not called.
+ * Matcher that checks to see if the actual, a Jasmine spy, was not called.
  */
-jasmine.Matchers.prototype.wasNotCalled = jasmine.Matchers.matcherFn_('wasNotCalled', {
-  getActual_: function() {
-    var args = jasmine.util.argsToArray(arguments);
-    return args.splice(0, 1)[0];
-  },
-  test: function() {
-    var actual = this.getActual_.apply(this, arguments);
-    if (!actual || !actual.isSpy) {
-      return false;
-    }
-    return !actual.wasCalled;
-  },
-  message: function() {
-    var actual = this.getActual_.apply(this, arguments);
-    if (!actual || !actual.isSpy) {
-      return 'Actual is not a spy.';
-    }
-    return "Expected spy " + actual.identity + " to not have been called.";
+jasmine.Matchers.prototype.wasNotCalled = function() {
+  if (arguments.length > 0) {
+    throw new Error('wasNotCalled does not take arguments');
   }
-});
 
-jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.matcherFn_('wasCalledWith', {
-  test: function() {
-    var args = jasmine.util.argsToArray(arguments);
-    var actual = args.splice(0, 1)[0];
-    if (!actual || !actual.isSpy) {
-      return false;
-    }
-    return this.env.contains_(actual.argsForCall, args);
-  },
-  message: function() {
-    var args = jasmine.util.argsToArray(arguments);
-    var actual = args.splice(0, 1)[0];
-    var message;
-    if (!actual || !actual.isSpy) {
-      message = 'Actual is not a spy';
-    } else {
-      message = "Expected spy to have been called with " + jasmine.pp(args) + " but was called with " + actual.argsForCall;
-    }
-    return message;
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.Matchers.pp(this.actual) + '.');
   }
-});
+
+  this.message = function() {
+    return "Expected spy " + this.actual.identity + " to not have been called.";
+  };
+
+  return !this.actual.wasCalled;
+};
 
 /**
- * Matcher that checks to see if the acutal, a Jasmine spy, was called with a set of parameters.
+ * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters.
  *
  * @example
  *
  */
+jasmine.Matchers.prototype.wasCalledWith = function() {
+  if (!jasmine.isSpy(this.actual)) {
+    throw new Error('Expected a spy, but got ' + jasmine.Matchers.pp(this.actual) + '.');
+  }
+
+  this.message = function() {
+    return "Expected spy to have been called with " + jasmine.pp(arguments) + " but was called with " + jasmine.pp(this.actual.argsForCall);
+  };
+
+  return this.env.contains_(this.actual.argsForCall, jasmine.util.argsToArray(arguments));
+};
 
 /**
  * Matcher that checks that the expected item is an element in the actual Array.
  *
  * @param {Object} item
  */
-
-jasmine.Matchers.prototype.toContain = jasmine.Matchers.matcherFn_('toContain', {
-  test: function(actual, expected) {
-    return this.env.contains_(actual, expected);
-  },
-  message: function(actual, expected) {
-    return 'Expected ' + jasmine.pp(actual) + ' to contain ' + jasmine.pp(expected);
-  }
-});
+jasmine.Matchers.prototype.toContain = function(expected) {
+  return this.env.contains_(this.actual, expected);
+};
 
 /**
  * Matcher that checks that the expected item is NOT an element in the actual Array.
  *
  * @param {Object} item
  */
-jasmine.Matchers.prototype.toNotContain = jasmine.Matchers.matcherFn_('toNotContain', {
-  test: function(actual, expected) {
-    return !this.env.contains_(actual, expected);
-  },
-  message: function(actual, expected) {
-    return 'Expected ' + jasmine.pp(actual) + ' to not contain ' + jasmine.pp(expected);
-  }
-});
+jasmine.Matchers.prototype.toNotContain = function(expected) {
+  return !this.env.contains_(this.actual, expected);
+};
 
-jasmine.Matchers.prototype.toBeLessThan = jasmine.Matchers.matcherFn_('toBeLessThan', {
-  test: function(actual, expected) {
-    return actual < expected;
-  },
-  message: function(actual, expected) {
-    return 'Expected ' + jasmine.pp(actual) + ' to be less than ' + jasmine.pp(expected);
-  }
-});
+jasmine.Matchers.prototype.toBeLessThan = function(expected) {
+  return this.actual < expected;
+};
 
-jasmine.Matchers.prototype.toBeGreaterThan = jasmine.Matchers.matcherFn_('toBeGreaterThan', {
-  test: function(actual, expected) {
-    return actual > expected;
-  },
-  message: function(actual, expected) {
-    return 'Expected ' + jasmine.pp(actual) + ' to be greater than ' + jasmine.pp(expected);
-  }
-});
+jasmine.Matchers.prototype.toBeGreaterThan = function(expected) {
+  return this.actual > expected;
+};
 
 /**
  * Matcher that checks that the expected exception was thrown by the actual.
  *
  * @param {String} expectedException
  */
-jasmine.Matchers.prototype.toThrow = jasmine.Matchers.matcherFn_('toThrow', {
-  getException_: function(actual, expected) {
+jasmine.Matchers.prototype.toThrow = function(expected) {
+  function getException_(actual, expected) {
     var exception;
     if (typeof actual != 'function') {
       throw new Error('Actual is not a function');
@@ -1340,24 +1283,25 @@ jasmine.Matchers.prototype.toThrow = jasmine.Matchers.matcherFn_('toThrow', {
       exception = e;
     }
     return exception;
-  },
-  test: function(actual, expected) {
-    var result = false;
-    var exception = this.getException_(actual, expected);
-    if (exception) {
-      result = (expected === undefined || this.env.equals_(exception.message || exception, expected.message || expected));
-    }
-    return result;
-  },
-  message: function(actual, expected) {
-    var exception = this.getException_(actual, expected);
+  }
+
+  var result = false;
+  var exception = getException_(this.actual, expected);
+  if (exception) {
+    result = (expected === undefined || this.env.equals_(exception.message || exception, expected.message || expected));
+  }
+
+  this.message = function(expected) {
+    var exception = getException_(this.actual, expected);
     if (exception && (expected === undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) {
       return ["Expected function to throw", expected.message || expected, ", but it threw", exception.message || exception  ].join(' ');
     } else {
       return "Expected function to throw an exception.";
     }
-  }
-});
+  };
+
+  return result;
+};
 
 jasmine.Matchers.Any = function(expectedClass) {
   this.expectedClass = expectedClass;
@@ -1506,11 +1450,9 @@ jasmine.PrettyPrinter = function() {
  * Formats a value in a nice, human-readable string.
  *
  * @param value
- * @returns {String}
  */
 jasmine.PrettyPrinter.prototype.format = function(value) {
   if (this.ppNestLevel_ > 40) {
-    //    return '(jasmine.pp nested too deeply!)';
     throw new Error('jasmine.PrettyPrinter: format() nested too deeply!');
   }
 
@@ -1526,12 +1468,16 @@ jasmine.PrettyPrinter.prototype.format = function(value) {
       this.emitScalar(value.toString());
     } else if (typeof value === 'string') {
       this.emitString(value);
+    } else if (jasmine.isSpy(value)) {
+      this.emitScalar("spy on " + value.identity);
     } else if (typeof value === 'function') {
       this.emitScalar('Function');
     } else if (typeof value.nodeType === 'number') {
       this.emitScalar('HTMLNode');
     } else if (value instanceof Date) {
       this.emitScalar('Date(' + value + ')');
+    } else if (value instanceof RegExp) {
+      this.emitScalar(value.toString());
     } else if (value.__Jasmine_been_here_before__) {
       this.emitScalar('<circular reference: ' + (jasmine.isArray_(value) ? 'Array' : 'Object') + '>');
     } else if (jasmine.isArray_(value) || typeof value == 'object') {
@@ -1849,11 +1795,9 @@ jasmine.Spec = function(env, suite, description) {
   if (!env) {
     throw new Error('jasmine.Env() required');
   }
-  ;
   if (!suite) {
     throw new Error('jasmine.Suite() required');
   }
-  ;
   var spec = this;
   spec.id = env.nextSpecId ? env.nextSpecId() : null;
   spec.env = env;
@@ -1890,6 +1834,7 @@ jasmine.Spec.prototype.getResults = function() {
 jasmine.Spec.prototype.runs = function (func) {
   var block = new jasmine.Block(this.env, func, this);
   this.addToQueue(block);
+  ( this.pending != -1 ) && ( this.pending = false );
   return this;
 };
 
@@ -1943,7 +1888,7 @@ jasmine.Spec.prototype.fail = function (e) {
 };
 
 jasmine.Spec.prototype.getMatchersClass_ = function() {
-  return this.matchersClass || jasmine.Matchers;
+  return this.matchersClass || this.env.matchersClass;
 };
 
 jasmine.Spec.prototype.addMatchers = function(matchersPrototype) {