sproutit-narwhal 0.1.106

data/lib/test/assert.js

@@ -0,0 +1,95 @@
+var equiv = require("./equiv").equiv,
+    jsDump = require("./jsdump").jsDump,
+    util = require("../util");
+
+var assert = exports;
+
+function fail(message) {
+    throw new AssertionError(message);
+}
+
+assert.isTrue = function(assertion, message) {
+    if (assertion !== true)
+        fail((message || "") + "\nExpected true." +
+            "\nActual = " + assertion);
+}
+
+assert.isFalse = function(assertion, message) {
+    if (assertion !== false)
+        fail((message || "") + "\nExpected false." +
+            "\nActual = " + assertion);
+}
+
+assert.isNull = function(assertion, message) {
+    if (assertion !== null)
+        fail((message || "") + "\nExpected null." +
+            "\nActual = " + assertion);
+}
+
+assert.isNaN = function(assertion, message) {
+    if (!isNaN(assertion))
+        fail((message || "") + "\nExpected NaN." +
+            "\nActual = " + assertion);
+}
+
+assert.isEqual = function(expected, actual, message) {
+    if (expected !== actual)
+        fail((message || "") + "\nExpected equal to = " + jsDump.parse(expected) +
+            "\nActual = " + jsDump.parse(actual));
+}
+
+assert.is = function (expected, actual, message) {
+    if (!util.is(expected, actual))
+        fail((message || "") + "\nExpected identical = " + jsDump.parse(expected) +
+            "\nActual = " + jsDump.parse(actual));
+};
+
+assert.isSame = function(expected, actual, message) {
+    if (!equiv(expected, actual))
+        fail((message || "") + "\nExpected same as = " + jsDump.parse(expected) +
+            "\nActual = " + jsDump.parse(actual));
+}
+
+assert.eq = function (expected, actual, message) {
+    if (!util.eq(expected, actual))
+        fail((message || "") + "\nExpected equal = " + jsDump.parse(expected) +
+            "\nActual = " + jsDump.parse(actual));
+};
+
+
+assert.isDiff = function(expected, actual, message) {
+    if (equiv(expected, actual))
+        fail((message || "") + "\nExpected different than = " + jsDump.parse(expected) +
+            "\nActual = " + jsDump.parse(actual));
+}
+
+assert.throwsError = function(block, type, message) {
+    var threw = false,
+        exception = null;
+        
+    try {
+        block();
+    } catch (e) {
+        threw = true;
+        exception = e;
+    }
+    
+    if (!threw)
+        fail("Expected exception" + (message ? ": " + message : ""));
+    
+    if (type !== undefined && !(exception instanceof type))
+        fail("Expected exception type '"+type+
+            "', actually '"+exception+"'" + (message ? ": " + message : ""));
+}
+
+
+var AssertionError = exports.AssertionError = function(message) {
+    this.name = "AssertionError";
+    this.message = message;
+
+    // this lets us get a stack trace in Rhino
+    if (typeof Packages !== "undefined")
+        this.rhinoException = Packages.org.mozilla.javascript.JavaScriptException(this, null, 0);
+}
+
+AssertionError.prototype = new Error();

data/lib/test/equiv.js

@@ -0,0 +1,188 @@
+// Hoozit
+// Determine what is o.
+function hoozit(o) {
+    if (typeof o === "string") {
+        return "string";
+
+    } else if (typeof o === "boolean") {
+        return "boolean";
+
+    } else if (typeof o === "number") {
+
+        if (isNaN(o)) {
+            return "nan";
+        } else {
+            return "number";
+        }
+
+    } else if (typeof o === "undefined") {
+        return "undefined";
+
+    // consider: typeof null === object
+    } else if (o === null) {
+        return "null";
+
+    // consider: typeof [] === object
+    } else if (o instanceof Array) {
+        return "array";
+    
+    // consider: typeof new Date() === object
+    } else if (o instanceof Date) {
+        return "date";
+
+    // consider: /./ instanceof Object;
+    //           /./ instanceof RegExp;
+    //          typeof /./ === "function"; // => false in IE and Opera,
+    //                                          true in FF and Safari
+    } else if (o instanceof RegExp) {
+        return "regexp";
+
+    } else if (typeof o === "object") {
+        return "object";
+
+    } else if (o instanceof Function) {
+        return "function";
+    }
+}
+
+// Call the o related callback with the given arguments.
+function bindCallbacks(o, callbacks, args) {
+    var prop = hoozit(o);
+    if (prop) {
+        if (hoozit(callbacks[prop]) === "function") {
+            return callbacks[prop].apply(callbacks, args);
+        } else {
+            return callbacks[prop]; // or undefined
+        }
+    }
+}
+
+// Equiv
+// Test for equality any JavaScript type.
+// Discussions and reference: http://philrathe.com/articles/equiv
+// Test suites: http://philrathe.com/tests/equiv
+// Author: Philippe Rathé <prathe@gmail.com>
+var equiv = exports.equiv = function () {
+
+    var innerEquiv; // the real equiv function
+    var callers = []; // stack to decide between skip/abort functions
+
+    
+    var callbacks = function () {
+
+        // for string, boolean, number and null
+        function useStrictEquality(b, a) {
+            return a === b;
+        }
+
+        return {
+            "string": useStrictEquality,
+            "boolean": useStrictEquality,
+            "number": useStrictEquality,
+            "null": useStrictEquality,
+            "undefined": useStrictEquality,
+
+            "nan": function (b) {
+                return isNaN(b);
+            },
+
+            "date": function (b, a) {
+                return hoozit(b) === "date" && a.valueOf() === b.valueOf();
+            },
+
+            "regexp": function (b, a) {
+                return hoozit(b) === "regexp" &&
+                    a.source === b.source && // the regex itself
+                    a.global === b.global && // and its modifers (gmi) ...
+                    a.ignoreCase === b.ignoreCase &&
+                    a.multiline === b.multiline;
+            },
+
+            // - skip when the property is a method of an instance (OOP)
+            // - abort otherwise,
+            //   initial === would have catch identical references anyway
+            "function": function () {
+                var caller = callers[callers.length - 1];
+                return caller !== Object &&
+                        typeof caller !== "undefined";
+            },
+
+            "array": function (b, a) {
+                var i;
+                var len;
+
+                // b could be an object literal here
+                if ( ! (hoozit(b) === "array")) {
+                    return false;
+                }
+
+                len = a.length;
+                if (len !== b.length) { // safe and faster
+                    return false;
+                }
+                for (i = 0; i < len; i++) {
+                    if( ! innerEquiv(a[i], b[i])) {
+                        return false;
+                    }
+                }
+                return true;
+            },
+
+            "object": function (b, a) {
+                var i;
+                var eq = true; // unless we can proove it
+                var aProperties = [], bProperties = []; // collection of strings
+
+                // comparing constructors is more strict than using instanceof
+                if ( a.constructor !== b.constructor) {
+                    return false;
+                }
+
+                // stack constructor before traversing properties
+                callers.push(a.constructor);
+
+                for (i in a) { // be strict: don't ensures hasOwnProperty and go deep
+
+                    aProperties.push(i); // collect a's properties
+
+                    if ( ! innerEquiv(a[i], b[i])) {
+                        eq = false;
+                    }
+                }
+
+                callers.pop(); // unstack, we are done
+
+                for (i in b) {
+                    bProperties.push(i); // collect b's properties
+                }
+
+                // Ensures identical properties name
+                return eq && innerEquiv(aProperties.sort(), bProperties.sort());
+            }
+        };
+    }();
+
+    innerEquiv = function () { // can take multiple arguments
+        var args = Array.prototype.slice.apply(arguments);
+        if (args.length < 2) {
+            return true; // end transition
+        }
+
+        return (function (a, b) {
+            if (a === b) {
+                return true; // catch the most you can
+
+            } else if (typeof a !== typeof b || a === null || b === null || typeof a === "undefined" || typeof b === "undefined") {
+                return false; // don't lose time with error prone cases
+
+            } else {
+                return bindCallbacks(a, callbacks, [b, a]);
+            }
+
+        // apply transition with (1..n) arguments
+        })(args[0], args[1]) && arguments.callee.apply(this, args.splice(1, args.length -1));
+    };
+
+    return innerEquiv;
+
+}();

data/lib/test/jsdump.js

@@ -0,0 +1,165 @@
+/**
+ * jsDump
+ * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
+ * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
+ * Date: 5/15/2008
+ * @projectDescription Advanced and extensible data dumping for Javascript.
+ * @version 1.0.0
+ * @author Ariel Flesler
+ */
+var jsDump;
+
+(function(){
+    function quote( str ){
+        return '"' + str.toString().replace(/"/g, '\\"') + '"';
+    };
+    function literal( o ){
+        return o + '';  
+    };
+    function join( pre, arr, post ){
+        var s = jsDump.separator(),
+            base = jsDump.indent(),
+            inner = jsDump.indent(1);
+        if( arr.join )
+            arr = arr.join( ',' + s + inner );
+        if( !arr )
+            return pre + post;
+        return [ pre, inner + arr, base + post ].join(s);
+    };
+    function array( arr ){
+        var i = arr.length, ret = Array(i);                 
+        this.up();
+        while( i-- )
+            ret[i] = this.parse( arr[i] );              
+        this.down();
+        return join( '[', ret, ']' );
+    };
+    
+    var reName = /^function (\w+)/;
+    
+    jsDump = {
+        parse:function( obj, type ){//type is used mostly internally, you can fix a (custom)type in advance
+            var parser = this.parsers[ type || this.typeOf(obj) ];
+            type = typeof parser;           
+            
+            return type == 'function' ? parser.call( this, obj ) :
+                   type == 'string' ? parser :
+                   this.parsers.error;
+        },
+        typeOf:function( obj ){
+            var type = typeof obj,
+                f = 'function';//we'll use it 3 times, save it
+            return type != 'object' && type != f ? type :
+                !obj ? 'null' :
+                obj.exec ? 'regexp' :// some browsers (FF) consider regexps functions
+                obj.getHours ? 'date' :
+                obj.scrollBy ?  'window' :
+                obj.nodeName == '#document' ? 'document' :
+                obj.nodeName ? 'node' :
+                obj.item ? 'nodelist' : // Safari reports nodelists as functions
+                obj.callee ? 'arguments' :
+                obj.call || obj.constructor != Array && //an array would also fall on this hack
+                    (obj+'').indexOf(f) != -1 ? f : //IE reports functions like alert, as objects
+                'length' in obj ? 'array' :
+                type;
+        },
+        separator:function(){
+            return this.multiline ? this.HTML ? '<br />' : '\n' : this.HTML ? '&nbsp;' : ' ';
+        },
+        indent:function( extra ){// extra can be a number, shortcut for increasing-calling-decreasing
+            if( !this.multiline )
+                return '';
+            var chr = this.indentChar;
+            if( this.HTML )
+                chr = chr.replace(/\t/g,'   ').replace(/ /g,'&nbsp;');
+            return Array( this._depth_ + (extra||0) ).join(chr);
+        },
+        up:function( a ){
+            this._depth_ += a || 1;
+        },
+        down:function( a ){
+            this._depth_ -= a || 1;
+        },
+        setParser:function( name, parser ){
+            this.parsers[name] = parser;
+        },
+        // The next 3 are exposed so you can use them
+        quote:quote, 
+        literal:literal,
+        join:join,
+        //
+        _depth_: 1,
+        // This is the list of parsers, to modify them, use jsDump.setParser
+        parsers:{
+            window: '[Window]',
+            document: '[Document]',
+            error:'[ERROR]', //when no parser is found, shouldn't happen
+            unknown: '[Unknown]',
+            'null':'null',
+            undefined:'undefined',
+            'function':function( fn ){
+                var ret = 'function',
+                    name = 'name' in fn ? fn.name : (reName.exec(fn)||[])[1];//functions never have name in IE
+                if( name )
+                    ret += ' ' + name;
+                ret += '(';
+                
+                ret = [ ret, this.parse( fn, 'functionArgs' ), '){'].join('');
+                return join( ret, this.parse(fn,'functionCode'), '}' );
+            },
+            array: array,
+            nodelist: array,
+            arguments: array,
+            object:function( map ){
+                var ret = [ ];
+                this.up();
+                for( var key in map )
+                    ret.push( this.parse(key,'key') + ': ' + this.parse(map[key]) );
+                this.down();
+                return join( '{', ret, '}' );
+            },
+            node:function( node ){
+                var open = this.HTML ? '&lt;' : '<',
+                    close = this.HTML ? '&gt;' : '>';
+                    
+                var tag = node.nodeName.toLowerCase(),
+                    ret = open + tag;
+                    
+                for( var a in this.DOMAttrs ){
+                    var val = node[this.DOMAttrs[a]];
+                    if( val )
+                        ret += ' ' + a + '=' + this.parse( val, 'attribute' );
+                }
+                return ret + close + open + '/' + tag + close;
+            },
+            functionArgs:function( fn ){//function calls it internally, it's the arguments part of the function
+                var l = fn.length;
+                if( !l ) return '';             
+                
+                var args = Array(l);
+                while( l-- )
+                    args[l] = String.fromCharCode(97+l);//97 is 'a'
+                return ' ' + args.join(', ') + ' ';
+            },
+            key:quote, //object calls it internally, the key part of an item in a map
+            functionCode:'[code]', //function calls it internally, it's the content of the function
+            attribute:quote, //onode calls it internally, it's an html attribute value
+            string:quote,
+            date:quote,
+            regexp:literal, //regex
+            number:literal,
+            'boolean':literal
+        },
+        DOMAttrs:{//attributes to dump from nodes, name=>realName
+            id:'id',
+            name:'name',
+            'class':'className'
+        },
+        HTML:false,//if true, entities are escaped ( <, >, \t, space and \n )
+        indentChar:'   ',//indentation unit
+        multiline:true //if true, items in a collection, are separated by a \n, else just a space.
+    };
+
+})();
+
+exports.jsDump = jsDump;