newjs 1.7.2 → 1.7.4

data/vendor/jsunittest/src/ajax.js

@@ -111,8 +111,9 @@ JsUnitTest.ajax = function( options ) {
 
         // If the specified type is "script", execute the returned text
         // response as if it was JavaScript
-        if ( type == "script" )
+        if ( type == "script" ) {
             eval.call( window, data );
+        }
 
         // Return the response data (either an XML Document or a text string)
         return data;

data/vendor/jsunittest/src/assertions.js

@@ -4,172 +4,142 @@ JsUnitTest.Unit.Assertions = {
     return (message ? message + '\n' : '') + 
       new JsUnitTest.Unit.MessageTemplate(template).evaluate(args);
   },
-  
+    
   flunk: function(message) {
-    this.assertBlock(message || 'Flunked', function() { return false });
+    this.assertBlock(message || 'Flunked', function() { return false; });
   },
   
   assertBlock: function(message, block) {
     try {
       block.call(this) ? this.pass() : this.fail(message);
-    } catch(e) { this.error(e) }
+    } catch(e) { this.error(e); }
   },
   
   assert: function(expression, message) {
     message = this.buildMessage(message || 'assert', 'got <?>', expression);
-    this.assertBlock(message, function() { return expression });
+    this.assertBlock(message, function() { return expression; });
   },
   
   assertEqual: function(expected, actual, message) {
     message = this.buildMessage(message || 'assertEqual', 'expected <?>, actual: <?>', expected, actual);
-    this.assertBlock(message, function() { return expected == actual });
+    this.assertBlock(message, function() { return expected == actual; });
   },
   
   assertNotEqual: function(expected, actual, message) {
     message = this.buildMessage(message || 'assertNotEqual', 'expected <?>, actual: <?>', expected, actual);
-    this.assertBlock(message, function() { return expected != actual });
+    this.assertBlock(message, function() { return expected != actual; });
   },
   
   assertEnumEqual: function(expected, actual, message) {
     message = this.buildMessage(message || 'assertEnumEqual', 'expected <?>, actual: <?>', expected, actual);
-    var expected_array = JsUnitTest.flattenArray(expected);
-    var actual_array   = JsUnitTest.flattenArray(actual);
-    this.assertBlock(message, function() {
-      if (expected_array.length == actual_array.length) {
-        for (var i=0; i < expected_array.length; i++) {
-          if (expected_array[i] != actual_array[i]) return false;
-        };
-        return true;
-      }
-      return false;
-    });
+    this.assertBlock(message, function() { return JsUnitTest.areArraysEqual(expected, actual); });
   },
   
   assertEnumNotEqual: function(expected, actual, message) {
     message = this.buildMessage(message || 'assertEnumNotEqual', '<?> was the same as <?>', expected, actual);
-    var expected_array = JsUnitTest.flattenArray(expected);
-    var actual_array   = JsUnitTest.flattenArray(actual);
-    this.assertBlock(message, function() {
-      if (expected_array.length == actual_array.length) {
-        for (var i=0; i < expected_array.length; i++) {
-          if (expected_array[i] != actual_array[i]) return true;
-        };
-        return false;
-      }
-      return true;
-    });
+    this.assertBlock(message, function() { return JsUnitTest.areArraysNotEqual(expected, actual); });
   },
   
   assertHashEqual: function(expected, actual, message) {
-    message = this.buildMessage(message || 'assertHashEqual', 'expected <?>, actual: <?>', expected, actual);
-    var expected_array = JsUnitTest.flattenArray(JsUnitTest.hashToSortedArray(expected));
-    var actual_array   = JsUnitTest.flattenArray(JsUnitTest.hashToSortedArray(actual));
-    var block = function() {
-      if (expected_array.length == actual_array.length) {
-        for (var i=0; i < expected_array.length; i++) {
-          if (expected_array[i] != actual_array[i]) return false;
-        };
-        return true;
-      }
-      return false;
-    };
-    this.assertBlock(message, block);
+    message = this.buildMessage(message || 'assertHashEqual', 'expected <?>, actual: <?>', JsUnitTest.inspect(expected), JsUnitTest.inspect(actual));
+    this.assertBlock(message, function() { return JsUnitTest.areHashesEqual(expected, actual); });
   },
   
   assertHashNotEqual: function(expected, actual, message) {
-    message = this.buildMessage(message || 'assertHashNotEqual', '<?> was the same as <?>', expected, actual);
-    var expected_array = JsUnitTest.flattenArray(JsUnitTest.hashToSortedArray(expected));
-    var actual_array   = JsUnitTest.flattenArray(JsUnitTest.hashToSortedArray(actual));
-    // from now we recursively zip & compare nested arrays
-    var block = function() {
-      if (expected_array.length == actual_array.length) {
-        for (var i=0; i < expected_array.length; i++) {
-          if (expected_array[i] != actual_array[i]) return true;
-        };
-        return false;
-      }
-      return true;
-    };
-    this.assertBlock(message, block);
+    message = this.buildMessage(message || 'assertHashNotEqual', '<?> was the same as <?>', JsUnitTest.inspect(expected), JsUnitTest.inspect(actual));
+    this.assertBlock(message, function() { return JsUnitTest.areHashesNotEqual(expected, actual); });
   },
   
   assertIdentical: function(expected, actual, message) {
     message = this.buildMessage(message || 'assertIdentical', 'expected <?>, actual: <?>', expected, actual);
-    this.assertBlock(message, function() { return expected === actual });
+    this.assertBlock(message, function() { return expected === actual; });
   },
   
   assertNotIdentical: function(expected, actual, message) { 
     message = this.buildMessage(message || 'assertNotIdentical', 'expected <?>, actual: <?>', expected, actual);
-    this.assertBlock(message, function() { return expected !== actual });
+    this.assertBlock(message, function() { return expected !== actual; });
   },
   
   assertNull: function(obj, message) {
     message = this.buildMessage(message || 'assertNull', 'got <?>', obj);
-    this.assertBlock(message, function() { return obj === null });
+    this.assertBlock(message, function() { return obj === null; });
   },
   
   assertNotNull: function(obj, message) {
     message = this.buildMessage(message || 'assertNotNull', 'got <?>', obj);
-    this.assertBlock(message, function() { return obj !== null });
+    this.assertBlock(message, function() { return obj !== null; });
   },
   
   assertUndefined: function(obj, message) {
     message = this.buildMessage(message || 'assertUndefined', 'got <?>', obj);
-    this.assertBlock(message, function() { return typeof obj == "undefined" });
+    this.assertBlock(message, function() { return typeof obj == "undefined"; });
   },
   
   assertNotUndefined: function(obj, message) {
     message = this.buildMessage(message || 'assertNotUndefined', 'got <?>', obj);
-    this.assertBlock(message, function() { return typeof obj != "undefined" });
+    this.assertBlock(message, function() { return typeof obj != "undefined"; });
   },
   
   assertNullOrUndefined: function(obj, message) {
     message = this.buildMessage(message || 'assertNullOrUndefined', 'got <?>', obj);
-    this.assertBlock(message, function() { return obj == null });
+    this.assertBlock(message, function() { return obj == null; });
   },
   
   assertNotNullOrUndefined: function(obj, message) {
     message = this.buildMessage(message || 'assertNotNullOrUndefined', 'got <?>', obj);
-    this.assertBlock(message, function() { return obj != null });
+    this.assertBlock(message, function() { return obj != null; });
   },
   
   assertMatch: function(expected, actual, message) {
     message = this.buildMessage(message || 'assertMatch', 'regex <?> did not match <?>', expected, actual);
-    this.assertBlock(message, function() { return new RegExp(expected).exec(actual) });
+    this.assertBlock(message, function() { return new RegExp(expected).exec(actual); });
   },
   
   assertNoMatch: function(expected, actual, message) {
     message = this.buildMessage(message || 'assertNoMatch', 'regex <?> matched <?>', expected, actual);
-    this.assertBlock(message, function() { return !(new RegExp(expected).exec(actual)) });
+    this.assertBlock(message, function() { return !(new RegExp(expected).exec(actual)); });
   },
   
   assertHasClass: function(element, klass, message) {
     element = JsUnitTest.$(element);
     message = this.buildMessage(message || 'assertHasClass', '? doesn\'t have class <?>.', element, klass);
-    this.assertBlock(message, function() { 
-      return !!element.className.match(new RegExp(klass))
+    this.assertBlock(message, function() {
+      var elementClassName = element.className;
+      return (elementClassName.length > 0 && (elementClassName == klass ||
+        new RegExp("(^|\\s)" + klass + "(\\s|$)").test(elementClassName)));
+      // return !!element.className.match(new RegExp(klass))
+    });
+  },
+  
+  assertNotHasClass: function(element, klass, message) {
+    element = JsUnitTest.$(element);
+    message = this.buildMessage(message || 'assertNotHasClass', '? does have class <?>.', element, klass);
+    this.assertBlock(message, function() {
+      var elementClassName = element.className;
+      return !(elementClassName.length > 0 && (elementClassName == klass ||
+        new RegExp("(^|\\s)" + klass + "(\\s|$)").test(elementClassName)));
     });
   },
   
   assertHidden: function(element, message) {
     element = JsUnitTest.$(element);
     message = this.buildMessage(message || 'assertHidden', '? isn\'t hidden.', element);
-    this.assertBlock(message, function() { return !element.style.display || element.style.display == 'none' });
+    this.assertBlock(message, function() { return !element.style.display || element.style.display == 'none'; });
   },
   
   assertInstanceOf: function(expected, actual, message) {
     message = this.buildMessage(message || 'assertInstanceOf', '<?> was not an instance of the expected type', actual);
-    this.assertBlock(message, function() { return actual instanceof expected });
+    this.assertBlock(message, function() { return actual instanceof expected; });
   },
   
   assertNotInstanceOf: function(expected, actual, message) {
     message = this.buildMessage(message || 'assertNotInstanceOf', '<?> was an instance of the expected type', actual);
-    this.assertBlock(message, function() { return !(actual instanceof expected) });
+    this.assertBlock(message, function() { return !(actual instanceof expected); });
   },
   
   assertRespondsTo: function(method, obj, message) {
     message = this.buildMessage(message || 'assertRespondsTo', 'object doesn\'t respond to <?>', method);
-    this.assertBlock(message, function() { return (method in obj && typeof obj[method] == 'function') });
+    this.assertBlock(message, function() { return (method in obj && typeof obj[method] == 'function'); });
   },
 
   assertRaise: function(exceptionName, method, message) {
@@ -179,8 +149,8 @@ JsUnitTest.Unit.Assertions = {
         method();
         return false;
       } catch(e) {
-        if (e.name == exceptionName) return true;
-        else throw e;
+        if (e.name == exceptionName) {return true;}
+        else {throw e;}
       }
     };
     this.assertBlock(message, block);
@@ -198,22 +168,23 @@ JsUnitTest.Unit.Assertions = {
   
   _isVisible: function(element) {
     element = JsUnitTest.$(element);
-    if(!element.parentNode) return true;
+    if(!element.parentNode) {return true;}
     this.assertNotNull(element);
-    if(element.style && (element.style.display == 'none'))
+    if(element.style && (element.style.display == 'none')) {
       return false;
+    }
     
     return arguments.callee.call(this, element.parentNode);
   },
   
   assertVisible: function(element, message) {
     message = this.buildMessage(message, '? was not visible.', element);
-    this.assertBlock(message, function() { return this._isVisible(element) });
+    this.assertBlock(message, function() { return this._isVisible(element); });
   },
   
   assertNotVisible: function(element, message) {
     message = this.buildMessage(message, '? was not hidden and didn\'t have a hidden parent either.', element);
-    this.assertBlock(message, function() { return !this._isVisible(element) });
+    this.assertBlock(message, function() { return !this._isVisible(element); });
   },
   
   assertElementsMatch: function() {
@@ -234,7 +205,7 @@ JsUnitTest.Unit.Assertions = {
       message = this.buildMessage('assertElementsMatch', 'In index <?>: expected <?> but got ?', index, expression, element);
       this.flunk(message);
       pass = false;
-    };
+    }
     this.assert(pass, "Expected all elements to match.");
   },
   

data/vendor/jsunittest/src/common.js

@@ -2,34 +2,57 @@ var JsUnitTest = {
   Unit: {},
   inspect: function(object) {
     try {
-      if (typeof object == "undefined") return 'undefined';
-      if (object === null) return 'null';
+      if (typeof object == "undefined") {return 'undefined';}
+      if (object === null) {return 'null';}
       if (typeof object == "string") {
         var useDoubleQuotes = arguments[1];
         var escapedString = this.gsub(object, /[\x00-\x1f\\]/, function(match) {
-          var character = String.specialChar[match[0]];
-          return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
+          var character = {
+            '\b': '\\b',
+            '\t': '\\t',
+            '\n': '\\n',
+            '\f': '\\f',
+            '\r': '\\r',
+            '\\': '\\\\'
+          }[match[0]];
+          return character ? character : '\\u00' + JsUnitTest.toHexString(match[0].charCodeAt());
         });
-        if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
+        if (useDoubleQuotes) {return '"' + escapedString.replace(/"/g, '\\"') + '"';}
         return "'" + escapedString.replace(/'/g, '\\\'') + "'";
-      };
+      }
+			if (JsUnitTest.getClass(object) === 'Object') {
+        var keys_values = new Array(), prefix = 'Object: { ';
+        for (property in object) {
+          keys_values.push(property + ': ' + object[property]);
+        }
+        return (prefix + keys_values.join(', ') + ' }');
+      }
       return String(object);
     } catch (e) {
-      if (e instanceof RangeError) return '...';
+      if (e instanceof RangeError) {return '...';}
       throw e;
     }
   },
-  $: function(element) {
+
+  getClass: function(object) {
+    return Object.prototype.toString.call(object)
+     .match(/^\[object\s(.*)\]$/)[1]; 
+  },
+
+	$: function(element) {
     if (arguments.length > 1) {
-      for (var i = 0, elements = [], length = arguments.length; i < length; i++)
+      for (var i = 0, elements = [], length = arguments.length; i < length; i++) {
         elements.push(this.$(arguments[i]));
+      }
       return elements;
     }
-    if (typeof element == "string")
+    if (typeof element == "string") {
       element = document.getElementById(element);
+    }
     return element;
   },
-  gsub: function(source, pattern, replacement) {
+
+	gsub: function(source, pattern, replacement) {
     var result = '', match;
     replacement = arguments.callee.prepareReplacement(replacement);
 
@@ -51,15 +74,48 @@ var JsUnitTest = {
   escapeHTML: function(data) {
     return data.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
   },
+  toHexString : function(n) {
+    var string = n.toString(16);
+    return '00'.substring(string.length) + string;
+  },
   arrayfromargs: function(args) {
   	var myarray = new Array();
   	var i;
 
-  	for (i=0;i<args.length;i++)
-  		myarray[i] = args[i];
+  	for (i=0;i<args.length;i++) {
+  	  myarray[i] = args[i];
+  	}
 
   	return myarray;
   },
+  
+  // from now we recursively zip & compare nested arrays
+  areArraysEqual: function(expected, actual) {
+    var expected_array = JsUnitTest.flattenArray(expected);
+    var actual_array   = JsUnitTest.flattenArray(actual);
+    if (expected_array.length == actual_array.length) {
+      for (var i=0; i < expected_array.length; i++) {
+        if (expected_array[i] != actual_array[i]) {return false;}
+      }
+      return true;
+    }
+    return false;
+  },
+  
+  areArraysNotEqual: function(expected, actual) {
+    return !this.areArraysEqual(expected, actual);
+  },
+
+  areHashesEqual: function(expected, actual) {
+    var expected_array = JsUnitTest.hashToSortedArray(expected);
+    var actual_array   = JsUnitTest.hashToSortedArray(actual);
+    return this.areArraysEqual(expected_array, actual_array);
+  },
+  
+  areHashesNotEqual: function(expected, actual) {
+    return !this.areHashesEqual(expected, actual);
+  },
+  
   hashToSortedArray: function(hash) {
     var results = [];
     for (key in hash) {
@@ -77,7 +133,7 @@ var JsUnitTest = {
       } else {
         results.push(object);
       }
-    };
+    }
     return results;
   },
   selectorMatch: function(expression, element) {
@@ -142,7 +198,7 @@ var JsUnitTest = {
 
     var match = true, name, matches;
     for (var i = 0, token; token = tokens[i]; i++) {
-      name = token[0], matches = token[1];
+      name = token[0]; matches = token[1];
       if (!assertions[name](element, matches)) {
         match = false; break;
       }
@@ -150,10 +206,11 @@ var JsUnitTest = {
 
     return match;
   },
+  
   toQueryParams: function(query, separator) {
     var query = query || window.location.search;
     var match = query.replace(/^\s+/, '').replace(/\s+$/, '').match(/([^?#]*)(#.*)?$/);
-    if (!match) return { };
+    if (!match) {return { };}
 
     var hash = {};
     var parts = match[1].split(separator || '&');
@@ -162,18 +219,20 @@ var JsUnitTest = {
       if (pair[0]) {
         var key = decodeURIComponent(pair.shift());
         var value = pair.length > 1 ? pair.join('=') : pair[0];
-        if (value != undefined) value = decodeURIComponent(value);
+        if (value != undefined) {value = decodeURIComponent(value);}
 
         if (key in hash) {
           var object = hash[key];
           var isArray = object != null && typeof object == "object" &&
-            'splice' in object && 'join' in object
-          if (!isArray) hash[key] = [hash[key]];
+            'splice' in object && 'join' in object;
+          if (!isArray) {hash[key] = [hash[key]];}
           hash[key].push(value);
         }
-        else hash[key] = value;
+        else {
+          hash[key] = value;
+        }
       }
-    };
+    }
     return hash;
   },
   
@@ -185,7 +244,7 @@ var JsUnitTest = {
 };
 
 JsUnitTest.gsub.prepareReplacement = function(replacement) {
-  if (typeof replacement == "function") return replacement;
+  if (typeof replacement == "function") {return replacement;}
   var template = new Template(replacement);
-  return function(match) { return template.evaluate(match) };
-};
+  return function(match) { return template.evaluate(match); };
+};