smparkes-envjs 0.0.9 → 0.0.10

data/test/{qunit/qunit/qunit.js.smp → specs/dist/env.spec.js}

@@ -8,13 +8,8 @@
  * and GPL (GPL-LICENSE.txt) licenses.
  */
 
-print(this);
-
 (function(window) {
 
-print(this);
-print(window);
-
 var QUnit = {
 
 	// Initialize the configuration options
@@ -166,7 +161,7 @@ var QUnit = {
 
 					var li = document.createElement("li");
 					li.className = assertion.result ? "pass" : "fail";
-					li.innerHTML = assertion.message || "(no message)";
+					li.innerHTML = config.currentModule+' : '+assertion.message || "(no message)";
 					ol.appendChild( li );
 
 					if ( assertion.result ) {
@@ -260,7 +255,7 @@ var QUnit = {
 	 */
 	ok: function ok(a, msg) {
 		QUnit.log(a, msg);
-
+        
 		config.assertions.push({
 			result: !!a,
 			message: msg
@@ -1000,3 +995,540 @@ QUnit.jsDump = (function() {
 })();
 
 })(this);
+
+(function(Q){
+
+    Q.Spec = function(name){
+        this.before = false;
+        this.after = false;
+        this.assigns = {};
+        this.name = name;
+        Q.module(name);
+    };
+    Q.Spec.reminders = {};
+    
+    
+    // RSpec style describe
+    // takes an arbitrary number of arguments that are contactenated as strings
+    // the last argument is the configuration object
+    // which can have before: after: callbacks
+    function describe(){
+        var args = [].splice.call(arguments, 0);
+        // configuration function
+        var bddconfig = (args[args.length - 1].constructor == Object) ? args.pop() : {};
+        var spec = new Q.Spec(args.join(' '));
+        spec.before = bddconfig['before'] || bddconfig['setup'];
+        spec.after = bddconfig['after'] || bddconfig['teardown'];
+        return spec;
+    };
+    
+    
+    
+    
+    // RSpec style test definition
+    Q.Spec.prototype.it = function(name, callback ){
+        var spec = this;
+        if (spec.before) 
+            spec.before.apply(spec.assigns);
+        Q.test(spec.name+" : "+name, function(){
+            callback.apply(spec);
+        });
+        if (spec.after) 
+            spec.after.apply(spec.assigns);
+        return spec;
+    };
+    
+    // Shoulda style test definition
+    Q.Spec.prototype.should = function(name, callback){
+        name = 'should ' + name;
+        return this.it.apply(this, [name, callback]);
+    };
+    
+    Q.Spec.prototype.pending = function(name, callback, nowait){
+        name = '<span style="color: #EB8531;" class="pending">deferred: ' + name + '</span>';
+        Q.test(name, function(){
+            Q.ok(true,'behavior pending');
+        });
+        return this;
+    };
+    
+    Q.Spec.prototype.should_eventually = function(name, callback, nowait){
+        return this.pending(name, callback);
+    };
+    
+    Q.Spec.prototype.a = function(key){
+        if (typeof key == 'undefined') {
+            return this.assigns;
+        }
+        else {
+            return this.assigns[key];
+        }
+    };
+    
+    // aliases for describe
+    Q.describe = describe;
+    Q.context = describe;
+    
+    // asserts that the method is defined (like respond_to?)
+    Q.defined = function(object, method){
+        return Q.ok(typeof object[method] == 'function', method + 'is not defined on' + object);
+    };
+    
+    // asserts that the object is of a certain type
+    Q.isType = function(object, type){
+        return Q.ok(object.constructor === type, object.toString() + ' is not of type ' + type + ', is ' + object.constructor);
+    };
+    
+    // assert a string matches a regex
+    Q.match = function(matcher, string, message){
+        return Q.ok(string.match(matcher), message);
+    };
+    
+    // assert that a matching error is raised
+    // expected can be a regex, a string, or an object
+    Q.raised = function(expected_error, callback){
+        var error = '';
+        try {
+            callback.apply(this);
+        } 
+        catch (e) {
+            error = e;
+        }
+        message = "Expected error to match " + expected_error + " but was " + error.toString();
+        if (expected_error.constructor == RegExp) {
+            return Q.match(expected_error, error.toString(), message);
+        }
+        else 
+            if (expected_error.constructor == String) {
+                return Q.equals(expected_error, error.toString(), message);
+            }
+            else {
+                return Q.equals(expected_error, error, message);
+            }
+    };
+    
+    
+    var log;
+    try{
+        if(Envjs)
+            log = Envjs.log;
+    }catch(e){
+        try{
+            log = console.log;
+        }catch(e){
+            log=function(){};
+        }
+        
+    }
+    var assertion_index = 0;
+    
+    var module_index = 0;
+    var module;
+    
+    var test_index = 0;
+    var test;
+    
+    Q._moduleStart  = Q.moduleStart;
+    Q.moduleStart = function(m, te){
+        Q._moduleStart.apply(this, arguments);
+        module = m;
+        module_index++;
+    };
+    
+    Q._moduleDone  = Q.moduleDone;
+    Q.moduleDone = function(t, f, tx){
+        Q._moduleDone.apply(this, arguments);
+        var s = module_index + ". module " + t + ": ";
+        if (f) {
+            s += f + " failure(s) in " + tx + " tests";
+        }
+        else {
+            s += "all " + tx + " tests successful";
+        }
+        // print(s);
+        module = undefined;
+    };
+    
+    Q._testStart  = Q.testStart;
+    Q.testStart = function(t){
+        Q._testStart.apply(this, arguments);
+        test = t;
+        test_index++;
+    };
+    
+    Q._testDone  = Q.testDone;
+    Q.testDone = function(t){
+        Q._testDone.apply(this, arguments);
+        test = undefined;
+    }
+    
+    Q._log  = Q.log;
+    Q.log = function(r, m){
+        Q._log.apply(this, arguments);
+        assertion_index++;
+        var test_string = "";
+        if (module || test) {
+            var test_string = "[";
+            if (module) {
+                test_string += module;
+                if (test) {
+                    test_string += ": ";
+                }
+            }
+            if (test) {
+                test_string += test;
+            }
+            test_string += "] ";
+        }
+        var s = (r ? "PASS (" : "FAIL (") + assertion_index + ") " + test_string + m;
+        log(s);
+    };
+    
+    Q._done  = Q.done;
+    Q.done = function(f, t){
+        Q._done.apply(this, arguments);
+        log((t - f) + " Passed, " + f + " Failed, " + t + " Total Tests");
+        try{
+            if(Envjs){
+                var scripts = document.getElementsByTagName('script');
+                for(var i = 0;i<scripts.length;i++){
+                    //prevents scripts from being re-run when
+                    //we look at the results in the browser
+                    scripts[i].type='text/envjs';
+                }
+                Envjs.writeToFile(document.xml, Envjs.location('results.html'));
+            }
+        }catch(e){
+            log('failed to print results to file.\n'+e);
+        }
+    };
+    
+})(QUnit);
+
+/**
+ * @author thatcher
+ */
+var global_scope=this;
+
+(function(Q){
+
+    Q.describe('Window Basic Properties',{
+
+        before:function(){
+            //setup
+        },
+        after:function(){
+            //tear down
+        }    
+        
+    }).should('provide the required w3c interfaces', function(){
+
+        expect(19);
+        ok(window,              'window');
+        ok(self,                'self');
+        ok(top,                 'top');
+        ok(parent,              'parent');
+        ok(window.toString(),   '[object Window]');
+        
+        //these values are usually the empty string ''
+        //so we just verify the property is available
+        ok('name' in window,            'name');
+        ok('status' in window,          'status');
+        ok('closed' in window,          'closed');
+        ok('defaultStatus' in window,   'defaultStatus');
+        ok('length' in window,          'length');
+        ok('opener' in window,          'opener');
+        
+        ok(frames,              'frames');
+        ok(open,                'open');
+        ok(close,               'close');
+        ok(innerHeight,         'innerHeight');
+        ok(outerHeight,         'outerHeight');
+        ok(outerWidth,          'outerWidth');
+        ok(screenX,             'screenX');
+        ok(screenY,             'screenY');
+
+        
+    }).should('have the expected values', function(){
+        
+        equals( window, global_scope,   'window is the global scope "this"');
+        equals( window, self,           'self is an alias for window');
+        equals( window, top,            'top is an alias for window when the window is not in a frame');
+
+    });
+    
+})(QUnit);/**
+ * @author thatcher
+ */
+
+(function(Q){
+
+    Q.describe('Window Location',{
+
+        before:function(){
+            //setup
+        },
+        after:function(){
+            //tear down
+        }    
+        
+    }).should('provide required w3c interfaces', function(){
+
+        expect(12);
+        ok(location === window.location, "location is window.location");
+        ok('href' in location,      'location.href');
+        ok('hash' in location,      'location.hash');
+        ok('host' in location,      'location.host');
+        ok('hostname' in location,  'location.hostname');
+        ok('pathname' in location,  'location.pathname');
+        ok('port' in location,      'location.port');
+        ok('search' in location,    'location.search');
+        ok(location.protocol,       'location.protocol');
+        ok(location.reload,         'location.reload');
+        ok(location.replace,        'location.replace');
+        ok(location.assign,         'location.assign');
+        
+    });
+    
+})(QUnit);/**
+ * @author thatcher
+ */
+
+(function(Q){
+
+    Q.describe('Window History',{
+
+        before:function(){
+            //setup
+        },
+        after:function(){
+            //tear down
+        }    
+        
+    }).should('provide the required w3c interfaces', function(){
+
+        expect(8);
+        ok(history === window.history, "history is window.history");
+        ok(history.length,   'history.length');
+        ok(history.back,     'history.back');
+        ok(history.forward,  'history.forward');
+        ok(history.go,       'history.go');
+        ok(history.item,     'history.item');
+        
+        //these are generally secured properties of the history
+        //object so we only check that the are defined since
+        //trying to access them will throw an exception
+        ok('current'  in history,  'history.current');
+        ok('previous' in history,  'history.previous');
+        
+    });
+    
+})(QUnit);/**
+ * @author thatcher
+ */
+
+(function(Q){
+
+    Q.describe('Window Navigator',{
+
+        before:function(){
+            //setup
+        },
+        after:function(){
+            //tear down
+        }    
+        
+    }).should('provide the required w3c interfaces', function(){
+
+        expect(24);
+        ok(navigator === window.navigator, 'navigator is window.navigator');
+        ok(navigator.userAgent,         'userAgent');
+        ok(navigator.appCodeName,       'appCodeName');
+        ok(navigator.appName,           'appName');
+        ok(navigator.appVersion,        'appVersion');
+        ok(navigator.language,          'language');
+        ok(navigator.mimeTypes,         'mimeTypes');
+        ok(navigator.platform,          'platform');
+        ok(navigator.oscpu,             'oscpu');
+        ok(navigator.product,           'product');
+        ok(navigator.productSub,        'productSub');
+        ok(navigator.plugins,           'plugins');
+        ok(navigator.cookieEnabled,     'cookieEnabled');
+        ok(navigator.buildID,           'buildID');
+        ok(navigator.javaEnabled,       'javaEnabled');
+        ok(navigator.taintEnabled,      'taintEnabled');
+        ok(navigator.preference,        'preference');
+        ok(navigator.geolocation,       'geolocation');
+        ok(navigator.registerContentHandler, 'registerContentHandler');
+        ok(navigator.registerProtocolHandler, 'registerProtocolHandler');
+        
+        //several properties will throw a security exception if they 
+        //are accessed, so we only check that they exist
+        ok("vendor" in navigator,            'vendor');
+        ok("vendorSub" in navigator,         'vendorSub');
+        ok("securityPolicy" in navigator,    'securityPolicy');
+        ok("onLine" in navigator,            'onLine');
+        
+    }).should('have the expected values', function(){
+
+        ok(navigator.userAgent,         'userAgent');
+        ok(navigator.appCodeName,       'appCodeName');
+        ok(navigator.appName,           'appName');
+        ok(navigator.appVersion,        'appVersion');
+        ok(navigator.language,          'language');
+        ok(navigator.mimeTypes,         'mimeTypes');
+        ok(navigator.platform,          'platform');
+        ok(navigator.oscpu,             'oscpu');
+        ok(navigator.product,           'product');
+        ok(navigator.productSub,        'productSub');
+        ok(navigator.plugins,           'plugins');
+        ok(navigator.cookieEnabled,     'cookieEnabled');
+        ok(navigator.buildID,           'buildID');
+        ok(navigator.javaEnabled,       'javaEnabled');
+        ok(navigator.taintEnabled,      'taintEnabled');
+        ok(navigator.preference,        'preference');
+        ok(navigator.geolocation,       'geolocation');
+        ok(navigator.registerContentHandler, 'registerContentHandler');
+        ok(navigator.registerProtocolHandler, 'registerProtocolHandler');
+    
+    });
+    
+})(QUnit);/**
+ * @author thatcher
+ */
+
+(function(Q){
+
+    Q.describe('Window Timer',{
+
+        before:function(){
+            //setup
+        },
+        after:function(){
+            //tear down
+        }    
+        
+    }).should('provide the required w3c interfaces', function(){
+
+        expect(4);
+        ok(setTimeout,      'setTimeout');
+        ok(setInterval,     'setInterval');
+        ok(clearTimeout,    'clearTimeout');
+        ok(clearInterval,   'clearInterval');
+        
+    });
+    
+})(QUnit);/**
+ * @author thatcher
+ */
+
+(function(Q){
+
+    Q.describe('Window Event',{
+
+        before:function(){
+            //setup
+        },
+        after:function(){
+            //tear down
+        }    
+        
+    }).should('provide the required w3c interfaces', function(){
+
+        expect(3);
+        ok(addEventListener,    'addEventListener');
+        ok(removeEventListener, 'removeEventListener');
+        ok(dispatchEvent,       'dispatchEvent');
+        
+    })
+    
+})(QUnit);/**
+ * @author thatcher
+ */
+(function(Q){
+
+    Q.describe('Window CSS',{
+
+        before:function(){
+            //setup
+        },
+        after:function(){
+            //tear down
+        }    
+        
+    }).should('provide the required w3c interfaces', function(){
+
+        expect(1);
+        ok(window.getComputedStyle, 'window.getComputedStyle');
+        
+    });
+    
+})(QUnit);
+
+/**
+ * @author thatcher
+ */
+(function(Q){
+
+    Q.describe('Window Screen',{
+
+        before:function(){
+            //setup
+        },
+        after:function(){
+            //tear down
+        }    
+        
+    }).should('provide the required w3c interfaces', function(){
+
+        expect(18);
+        ok(screen === window.screen , 'screen is window screen');
+        ok("top" in screen,          'top');
+        ok(screen.height,       'height');
+        ok(screen.width,        'width');
+        ok("left" in screen,         'left');
+        ok(screen.pixelDepth,   'pixelDepth');
+        ok(screen.colorDepth,   'colorDepth');
+        ok(screen.availWidth,   'availWidth');
+        ok(screen.availHeight,  'availHeight');
+        ok("availLeft" in screen,    'availLeft');
+        ok(screen.availTop,     'availTop');
+        
+        //closely related function available at window
+        ok(moveBy,              'moveBy');
+        ok(moveTo,              'moveTo');
+        ok(resizeBy,            'resizeBy');
+        ok(resizeTo,            'resizeTo');
+        ok(scroll,              'scroll');
+        ok(scrollBy,            'scrollBy');
+        ok(scrollTo,            'scrollTo');
+        
+    });
+    
+})(QUnit);
+
+/**
+ * @author thatcher
+ */
+
+(function(Q){
+
+    Q.describe('Window Dialog',{
+
+        before:function(){
+            //setup
+        },
+        after:function(){
+            //tear down
+        }    
+        
+    }).should('provide the required w3c interfaces', function(){
+
+        expect(3);
+        ok(alert,   'alert');
+        ok(confirm, 'confirm');
+        ok(prompt,  'prompt');
+        
+    });
+    
+})(QUnit);

data/test/specs/envjs.spec.css

@@ -0,0 +1,46 @@
+html{
+    background-color:#333;
+}
+body.container{
+    margin-top:20px;
+    border:none;
+    background-color:#333;
+}
+body.container strong {
+    text-transform:none;
+}
+h2#qunit-banner {
+    -moz-border-radius:30px;
+    padding:10px 10px 50px 10px;
+    text-align:center;
+}
+h2#qunit-banner.pass {
+    background-color:#66BB66;
+    text-align:center;
+}
+h2#qunit-banner #envjs-icon{
+    margin:5px 5px 0 20px;
+}
+h2#qunit-userAgent {
+    -moz-border-radius:0px;
+    background-color:#111;
+    color:white;
+    text-align:center;
+    margin:-40px 0 0 0;
+    padding:10px;
+}
+#qunit-test-summary{
+    -moz-border-radius-bottomleft:30px;
+    -moz-border-radius-bottomright:30px;
+    background-color:#338;
+    color:#99FFFF;
+}
+#qunit-tests{
+    background-color:#fff;
+    margin:0 0 40px;
+    padding:15px 60px;
+}
+p#qunit-testresult {
+    text-align:center;
+    padding:0 0 20px;
+}

data/test/specs/parser/html.js

@@ -0,0 +1,31 @@
+/**
+ * @author thatcher
+ */
+(function(Q){
+
+    Q.describe('TEMPLATE Spec',{
+        before:function(){
+            //setup
+        },
+        after:function(){
+            //tear down
+        }    
+        
+    }).should('do something', function(){
+
+        expect(1);
+        ok(true, 'good job');
+        
+    }).should('do something else', function(){
+
+        expect(1);
+        ok(true, 'good job');
+        
+    }).pending('should do something new soon', function(){
+
+        expect(1);
+        ok(false, 'todo');
+    });
+    
+})(QUnit);
+

data/test/specs/parser/spec.html

@@ -0,0 +1,40 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+		<title>Envjs HTML5 Parser Spec</title>
+        <link rel="stylesheet" media="screen" href="../qunit.css"/>
+        <link rel="stylesheet" media="screen" href="../envjs.spec.css"/>
+        <link rel="stylesheet" media="screen" href="http://www.envjs.com/css/blueprint/screen.css"/>
+        <link rel="stylesheet" media="screen" href="http://www.envjs.com/css/site.css"/>
+        <script type='text/javascript' src='../qunit.js'></script>
+        <script type='text/javascript' src='../qunit.bdd.js'></script>
+        
+        <!-- specs for this general api 'module' -->
+        <script type='text/javascript' src='spec-0.js'></script>
+        <script type='text/javascript' src='spec-1.js'></script>
+	</head>
+	<body class='container'>
+        <h2  id="qunit-banner">
+            <img id="envjs-icon" 
+                 src="../../fixtures/images/icon-blue.png"
+                 height='40'/>
+             <span id="spec-title">Envjs HTML5 Parser Spec</span>
+        </h2>
+        <h2  id="qunit-userAgent"></h2>
+        <div id='qunit-testrunner-toolbar'></div>
+        <div id='qunit-test-summary'>
+            <ol id='qunit-tests'></ol>
+        </div>
+        <div id="qunit-main" style="display:none;">
+            <!-- 
+                Test HTML here:
+                 
+                not required to be in here but it makes it convenient
+                by convention to avoid having to look at the html
+                artifacts the test may require or have generated as 
+                a side effect.
+            -->
+        </div>
+	</body>
+</html>