http://git-wip-us.apache.org/repos/asf/james-site/blob/38b1b837/content/development-bundle/external/qunit.css
----------------------------------------------------------------------
diff --git a/content/development-bundle/external/qunit.css 
b/content/development-bundle/external/qunit.css
new file mode 100644
index 0000000..55970e0
--- /dev/null
+++ b/content/development-bundle/external/qunit.css
@@ -0,0 +1,235 @@
+/**
+ * QUnit v1.10.0 - A JavaScript Unit Testing Framework
+ *
+ * http://qunitjs.com
+ *
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/** Font Family and Sizes */
+
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, 
#qunit-userAgent, #qunit-testresult {
+       font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica 
Neue", Calibri, Helvetica, Arial, sans-serif;
+}
+
+#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests 
li { font-size: small; }
+#qunit-tests { font-size: smaller; }
+
+
+/** Resets */
+
+#qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, 
#qunit-testresult, #qunit-modulefilter {
+       margin: 0;
+       padding: 0;
+}
+
+
+/** Header */
+
+#qunit-header {
+       padding: 0.5em 0 0.5em 1em;
+
+       color: #8699a4;
+       background-color: #0d3349;
+
+       font-size: 1.5em;
+       line-height: 1em;
+       font-weight: normal;
+
+       border-radius: 5px 5px 0 0;
+       -moz-border-radius: 5px 5px 0 0;
+       -webkit-border-top-right-radius: 5px;
+       -webkit-border-top-left-radius: 5px;
+}
+
+#qunit-header a {
+       text-decoration: none;
+       color: #c2ccd1;
+}
+
+#qunit-header a:hover,
+#qunit-header a:focus {
+       color: #fff;
+}
+
+#qunit-testrunner-toolbar label {
+       display: inline-block;
+       padding: 0 .5em 0 .1em;
+}
+
+#qunit-banner {
+       height: 5px;
+}
+
+#qunit-testrunner-toolbar {
+       padding: 0.5em 0 0.5em 2em;
+       color: #5E740B;
+       background-color: #eee;
+       overflow: hidden;
+}
+
+#qunit-userAgent {
+       padding: 0.5em 0 0.5em 2.5em;
+       background-color: #2b81af;
+       color: #fff;
+       text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
+}
+
+#qunit-modulefilter-container {
+       float: right;
+}
+
+/** Tests: Pass/Fail */
+
+#qunit-tests {
+       list-style-position: inside;
+}
+
+#qunit-tests li {
+       padding: 0.4em 0.5em 0.4em 2.5em;
+       border-bottom: 1px solid #fff;
+       list-style-position: inside;
+}
+
+#qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
+       display: none;
+}
+
+#qunit-tests li strong {
+       cursor: pointer;
+}
+
+#qunit-tests li a {
+       padding: 0.5em;
+       color: #c2ccd1;
+       text-decoration: none;
+}
+#qunit-tests li a:hover,
+#qunit-tests li a:focus {
+       color: #000;
+}
+
+#qunit-tests ol {
+       margin-top: 0.5em;
+       padding: 0.5em;
+
+       background-color: #fff;
+
+       border-radius: 5px;
+       -moz-border-radius: 5px;
+       -webkit-border-radius: 5px;
+}
+
+#qunit-tests table {
+       border-collapse: collapse;
+       margin-top: .2em;
+}
+
+#qunit-tests th {
+       text-align: right;
+       vertical-align: top;
+       padding: 0 .5em 0 0;
+}
+
+#qunit-tests td {
+       vertical-align: top;
+}
+
+#qunit-tests pre {
+       margin: 0;
+       white-space: pre-wrap;
+       word-wrap: break-word;
+}
+
+#qunit-tests del {
+       background-color: #e0f2be;
+       color: #374e0c;
+       text-decoration: none;
+}
+
+#qunit-tests ins {
+       background-color: #ffcaca;
+       color: #500;
+       text-decoration: none;
+}
+
+/*** Test Counts */
+
+#qunit-tests b.counts                       { color: black; }
+#qunit-tests b.passed                       { color: #5E740B; }
+#qunit-tests b.failed                       { color: #710909; }
+
+#qunit-tests li li {
+       padding: 5px;
+       background-color: #fff;
+       border-bottom: none;
+       list-style-position: inside;
+}
+
+/*** Passing Styles */
+
+#qunit-tests li li.pass {
+       color: #3c510c;
+       background-color: #fff;
+       border-left: 10px solid #C6E746;
+}
+
+#qunit-tests .pass                          { color: #528CE0; 
background-color: #D2E0E6; }
+#qunit-tests .pass .test-name               { color: #366097; }
+
+#qunit-tests .pass .test-actual,
+#qunit-tests .pass .test-expected           { color: #999999; }
+
+#qunit-banner.qunit-pass                    { background-color: #C6E746; }
+
+/*** Failing Styles */
+
+#qunit-tests li li.fail {
+       color: #710909;
+       background-color: #fff;
+       border-left: 10px solid #EE5757;
+       white-space: pre;
+}
+
+#qunit-tests > li:last-child {
+       border-radius: 0 0 5px 5px;
+       -moz-border-radius: 0 0 5px 5px;
+       -webkit-border-bottom-right-radius: 5px;
+       -webkit-border-bottom-left-radius: 5px;
+}
+
+#qunit-tests .fail                          { color: #000000; 
background-color: #EE5757; }
+#qunit-tests .fail .test-name,
+#qunit-tests .fail .module-name             { color: #000000; }
+
+#qunit-tests .fail .test-actual             { color: #EE5757; }
+#qunit-tests .fail .test-expected           { color: green;   }
+
+#qunit-banner.qunit-fail                    { background-color: #EE5757; }
+
+
+/** Result */
+
+#qunit-testresult {
+       padding: 0.5em 0.5em 0.5em 2.5em;
+
+       color: #2b81af;
+       background-color: #D2E0E6;
+
+       border-bottom: 1px solid white;
+}
+#qunit-testresult .module-name {
+       font-weight: bold;
+}
+
+/** Fixture */
+
+#qunit-fixture {
+       position: absolute;
+       top: -10000px;
+       left: -10000px;
+       width: 1000px;
+       height: 1000px;
+}

http://git-wip-us.apache.org/repos/asf/james-site/blob/38b1b837/content/development-bundle/external/qunit.js
----------------------------------------------------------------------
diff --git a/content/development-bundle/external/qunit.js 
b/content/development-bundle/external/qunit.js
new file mode 100644
index 0000000..d4f17b5
--- /dev/null
+++ b/content/development-bundle/external/qunit.js
@@ -0,0 +1,1977 @@
+/**
+ * QUnit v1.10.0 - A JavaScript Unit Testing Framework
+ *
+ * http://qunitjs.com
+ *
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+(function( window ) {
+
+var QUnit,
+       config,
+       onErrorFnPrev,
+       testId = 0,
+       fileName = (sourceFromStacktrace( 0 ) || "" ).replace(/(:\d+)+\)?/, 
"").replace(/.+\//, ""),
+       toString = Object.prototype.toString,
+       hasOwn = Object.prototype.hasOwnProperty,
+       // Keep a local reference to Date (GH-283)
+       Date = window.Date,
+       defined = {
+       setTimeout: typeof window.setTimeout !== "undefined",
+       sessionStorage: (function() {
+               var x = "qunit-test-string";
+               try {
+                       sessionStorage.setItem( x, x );
+                       sessionStorage.removeItem( x );
+                       return true;
+               } catch( e ) {
+                       return false;
+               }
+       }())
+};
+
+function Test( settings ) {
+       extend( this, settings );
+       this.assertions = [];
+       this.testNumber = ++Test.count;
+}
+
+Test.count = 0;
+
+Test.prototype = {
+       init: function() {
+               var a, b, li,
+        tests = id( "qunit-tests" );
+
+               if ( tests ) {
+                       b = document.createElement( "strong" );
+                       b.innerHTML = this.name;
+
+                       // `a` initialized at top of scope
+                       a = document.createElement( "a" );
+                       a.innerHTML = "Rerun";
+                       a.href = QUnit.url({ testNumber: this.testNumber });
+
+                       li = document.createElement( "li" );
+                       li.appendChild( b );
+                       li.appendChild( a );
+                       li.className = "running";
+                       li.id = this.id = "qunit-test-output" + testId++;
+
+                       tests.appendChild( li );
+               }
+       },
+       setup: function() {
+               if ( this.module !== config.previousModule ) {
+                       if ( config.previousModule ) {
+                               runLoggingCallbacks( "moduleDone", QUnit, {
+                                       name: config.previousModule,
+                                       failed: config.moduleStats.bad,
+                                       passed: config.moduleStats.all - 
config.moduleStats.bad,
+                                       total: config.moduleStats.all
+                               });
+                       }
+                       config.previousModule = this.module;
+                       config.moduleStats = { all: 0, bad: 0 };
+                       runLoggingCallbacks( "moduleStart", QUnit, {
+                               name: this.module
+                       });
+               } else if ( config.autorun ) {
+                       runLoggingCallbacks( "moduleStart", QUnit, {
+                               name: this.module
+                       });
+               }
+
+               config.current = this;
+
+               this.testEnvironment = extend({
+                       setup: function() {},
+                       teardown: function() {}
+               }, this.moduleTestEnvironment );
+
+               runLoggingCallbacks( "testStart", QUnit, {
+                       name: this.testName,
+                       module: this.module
+               });
+
+               // allow utility functions to access the current test 
environment
+               // TODO why??
+               QUnit.current_testEnvironment = this.testEnvironment;
+
+               if ( !config.pollution ) {
+                       saveGlobal();
+               }
+               if ( config.notrycatch ) {
+                       this.testEnvironment.setup.call( this.testEnvironment );
+                       return;
+               }
+               try {
+                       this.testEnvironment.setup.call( this.testEnvironment );
+               } catch( e ) {
+                       QUnit.pushFailure( "Setup failed on " + this.testName + 
": " + e.message, extractStacktrace( e, 1 ) );
+               }
+       },
+       run: function() {
+               config.current = this;
+
+               var running = id( "qunit-testresult" );
+
+               if ( running ) {
+                       running.innerHTML = "Running: <br/>" + this.name;
+               }
+
+               if ( this.async ) {
+                       QUnit.stop();
+               }
+
+               if ( config.notrycatch ) {
+                       this.callback.call( this.testEnvironment, QUnit.assert 
);
+                       return;
+               }
+
+               try {
+                       this.callback.call( this.testEnvironment, QUnit.assert 
);
+               } catch( e ) {
+                       QUnit.pushFailure( "Died on test #" + 
(this.assertions.length + 1) + " " + this.stack + ": " + e.message, 
extractStacktrace( e, 0 ) );
+                       // else next test will carry the responsibility
+                       saveGlobal();
+
+                       // Restart the tests if they're blocking
+                       if ( config.blocking ) {
+                               QUnit.start();
+                       }
+               }
+       },
+       teardown: function() {
+               config.current = this;
+               if ( config.notrycatch ) {
+                       this.testEnvironment.teardown.call( 
this.testEnvironment );
+                       return;
+               } else {
+                       try {
+                               this.testEnvironment.teardown.call( 
this.testEnvironment );
+                       } catch( e ) {
+                               QUnit.pushFailure( "Teardown failed on " + 
this.testName + ": " + e.message, extractStacktrace( e, 1 ) );
+                       }
+               }
+               checkPollution();
+       },
+       finish: function() {
+               config.current = this;
+               if ( config.requireExpects && this.expected == null ) {
+                       QUnit.pushFailure( "Expected number of assertions to be 
defined, but expect() was not called.", this.stack );
+               } else if ( this.expected != null && this.expected != 
this.assertions.length ) {
+                       QUnit.pushFailure( "Expected " + this.expected + " 
assertions, but " + this.assertions.length + " were run", this.stack );
+               } else if ( this.expected == null && !this.assertions.length ) {
+                       QUnit.pushFailure( "Expected at least one assertion, 
but none were run - call expect(0) to accept zero assertions.", this.stack );
+               }
+
+               var assertion, a, b, i, li, ol,
+                       test = this,
+                       good = 0,
+                       bad = 0,
+                       tests = id( "qunit-tests" );
+
+               config.stats.all += this.assertions.length;
+               config.moduleStats.all += this.assertions.length;
+
+               if ( tests ) {
+                       ol = document.createElement( "ol" );
+
+                       for ( i = 0; i < this.assertions.length; i++ ) {
+                               assertion = this.assertions[i];
+
+                               li = document.createElement( "li" );
+                               li.className = assertion.result ? "pass" : 
"fail";
+                               li.innerHTML = assertion.message || ( 
assertion.result ? "okay" : "failed" );
+                               ol.appendChild( li );
+
+                               if ( assertion.result ) {
+                                       good++;
+                               } else {
+                                       bad++;
+                                       config.stats.bad++;
+                                       config.moduleStats.bad++;
+                               }
+                       }
+
+                       // store result when possible
+                       if ( QUnit.config.reorder && defined.sessionStorage ) {
+                               if ( bad ) {
+                                       sessionStorage.setItem( "qunit-test-" + 
this.module + "-" + this.testName, bad );
+                               } else {
+                                       sessionStorage.removeItem( 
"qunit-test-" + this.module + "-" + this.testName );
+                               }
+                       }
+
+                       if ( bad === 0 ) {
+                               ol.style.display = "none";
+                       }
+
+                       // `b` initialized at top of scope
+                       b = document.createElement( "strong" );
+                       b.innerHTML = this.name + " <b class='counts'>(<b 
class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + 
this.assertions.length + ")</b>";
+
+                       addEvent(b, "click", function() {
+                               var next = b.nextSibling.nextSibling,
+                                       display = next.style.display;
+                               next.style.display = display === "none" ? 
"block" : "none";
+                       });
+
+                       addEvent(b, "dblclick", function( e ) {
+                               var target = e && e.target ? e.target : 
window.event.srcElement;
+                               if ( target.nodeName.toLowerCase() == "span" || 
target.nodeName.toLowerCase() == "b" ) {
+                                       target = target.parentNode;
+                               }
+                               if ( window.location && 
target.nodeName.toLowerCase() === "strong" ) {
+                                       window.location = QUnit.url({ 
testNumber: test.testNumber });
+                               }
+                       });
+
+                       // `li` initialized at top of scope
+                       li = id( this.id );
+                       li.className = bad ? "fail" : "pass";
+                       li.removeChild( li.firstChild );
+                       a = li.firstChild;
+                       li.appendChild( b );
+                       li.appendChild ( a );
+                       li.appendChild( ol );
+
+               } else {
+                       for ( i = 0; i < this.assertions.length; i++ ) {
+                               if ( !this.assertions[i].result ) {
+                                       bad++;
+                                       config.stats.bad++;
+                                       config.moduleStats.bad++;
+                               }
+                       }
+               }
+
+               runLoggingCallbacks( "testDone", QUnit, {
+                       name: this.testName,
+                       module: this.module,
+                       failed: bad,
+                       passed: this.assertions.length - bad,
+                       total: this.assertions.length
+               });
+
+               QUnit.reset();
+
+               config.current = undefined;
+       },
+
+       queue: function() {
+               var bad,
+                       test = this;
+
+               synchronize(function() {
+                       test.init();
+               });
+               function run() {
+                       // each of these can by async
+                       synchronize(function() {
+                               test.setup();
+                       });
+                       synchronize(function() {
+                               test.run();
+                       });
+                       synchronize(function() {
+                               test.teardown();
+                       });
+                       synchronize(function() {
+                               test.finish();
+                       });
+               }
+
+               // `bad` initialized at top of scope
+               // defer when previous test run passed, if storage is available
+               bad = QUnit.config.reorder && defined.sessionStorage &&
+                                               +sessionStorage.getItem( 
"qunit-test-" + this.module + "-" + this.testName );
+
+               if ( bad ) {
+                       run();
+               } else {
+                       synchronize( run, true );
+               }
+       }
+};
+
+// Root QUnit object.
+// `QUnit` initialized at top of scope
+QUnit = {
+
+       // call on start of module test to prepend name to all tests
+       module: function( name, testEnvironment ) {
+               config.currentModule = name;
+               config.currentModuleTestEnvironment = testEnvironment;
+               config.modules[name] = true;
+       },
+
+       asyncTest: function( testName, expected, callback ) {
+               if ( arguments.length === 2 ) {
+                       callback = expected;
+                       expected = null;
+               }
+
+               QUnit.test( testName, expected, callback, true );
+       },
+
+       test: function( testName, expected, callback, async ) {
+               var test,
+                       name = "<span class='test-name'>" + escapeInnerText( 
testName ) + "</span>";
+
+               if ( arguments.length === 2 ) {
+                       callback = expected;
+                       expected = null;
+               }
+
+               if ( config.currentModule ) {
+                       name = "<span class='module-name'>" + 
config.currentModule + "</span>: " + name;
+               }
+
+               test = new Test({
+                       name: name,
+                       testName: testName,
+                       expected: expected,
+                       async: async,
+                       callback: callback,
+                       module: config.currentModule,
+                       moduleTestEnvironment: 
config.currentModuleTestEnvironment,
+                       stack: sourceFromStacktrace( 2 )
+               });
+
+               if ( !validTest( test ) ) {
+                       return;
+               }
+
+               test.queue();
+       },
+
+       // Specify the number of expected assertions to gurantee that failed 
test (no assertions are run at all) don't slip through.
+       expect: function( asserts ) {
+               if (arguments.length === 1) {
+                       config.current.expected = asserts;
+               } else {
+                       return config.current.expected;
+               }
+       },
+
+       start: function( count ) {
+               config.semaphore -= count || 1;
+               // don't start until equal number of stop-calls
+               if ( config.semaphore > 0 ) {
+                       return;
+               }
+               // ignore if start is called more often then stop
+               if ( config.semaphore < 0 ) {
+                       config.semaphore = 0;
+               }
+               // A slight delay, to avoid any current callbacks
+               if ( defined.setTimeout ) {
+                       window.setTimeout(function() {
+                               if ( config.semaphore > 0 ) {
+                                       return;
+                               }
+                               if ( config.timeout ) {
+                                       clearTimeout( config.timeout );
+                               }
+
+                               config.blocking = false;
+                               process( true );
+                       }, 13);
+               } else {
+                       config.blocking = false;
+                       process( true );
+               }
+       },
+
+       stop: function( count ) {
+               config.semaphore += count || 1;
+               config.blocking = true;
+
+               if ( config.testTimeout && defined.setTimeout ) {
+                       clearTimeout( config.timeout );
+                       config.timeout = window.setTimeout(function() {
+                               QUnit.ok( false, "Test timed out" );
+                               config.semaphore = 1;
+                               QUnit.start();
+                       }, config.testTimeout );
+               }
+       }
+};
+
+// Asssert helpers
+// All of these must call either QUnit.push() or manually do:
+// - runLoggingCallbacks( "log", .. );
+// - config.current.assertions.push({ .. });
+QUnit.assert = {
+       /**
+        * Asserts rough true-ish result.
+        * @name ok
+        * @function
+        * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" 
);
+        */
+       ok: function( result, msg ) {
+               if ( !config.current ) {
+                       throw new Error( "ok() assertion outside test context, 
was " + sourceFromStacktrace(2) );
+               }
+               result = !!result;
+
+               var source,
+                       details = {
+                               module: config.current.module,
+                               name: config.current.testName,
+                               result: result,
+                               message: msg
+                       };
+
+               msg = escapeInnerText( msg || (result ? "okay" : "failed" ) );
+               msg = "<span class='test-message'>" + msg + "</span>";
+
+               if ( !result ) {
+                       source = sourceFromStacktrace( 2 );
+                       if ( source ) {
+                               details.source = source;
+                               msg += "<table><tr 
class='test-source'><th>Source: </th><td><pre>" + escapeInnerText( source ) + 
"</pre></td></tr></table>";
+                       }
+               }
+               runLoggingCallbacks( "log", QUnit, details );
+               config.current.assertions.push({
+                       result: result,
+                       message: msg
+               });
+       },
+
+       /**
+        * Assert that the first two arguments are equal, with an optional 
message.
+        * Prints out both actual and expected values.
+        * @name equal
+        * @function
+        * @example equal( format( "Received {0} bytes.", 2), "Received 2 
bytes.", "format() replaces {0} with next argument" );
+        */
+       equal: function( actual, expected, message ) {
+               QUnit.push( expected == actual, actual, expected, message );
+       },
+
+       /**
+        * @name notEqual
+        * @function
+        */
+       notEqual: function( actual, expected, message ) {
+               QUnit.push( expected != actual, actual, expected, message );
+       },
+
+       /**
+        * @name deepEqual
+        * @function
+        */
+       deepEqual: function( actual, expected, message ) {
+               QUnit.push( QUnit.equiv(actual, expected), actual, expected, 
message );
+       },
+
+       /**
+        * @name notDeepEqual
+        * @function
+        */
+       notDeepEqual: function( actual, expected, message ) {
+               QUnit.push( !QUnit.equiv(actual, expected), actual, expected, 
message );
+       },
+
+       /**
+        * @name strictEqual
+        * @function
+        */
+       strictEqual: function( actual, expected, message ) {
+               QUnit.push( expected === actual, actual, expected, message );
+       },
+
+       /**
+        * @name notStrictEqual
+        * @function
+        */
+       notStrictEqual: function( actual, expected, message ) {
+               QUnit.push( expected !== actual, actual, expected, message );
+       },
+
+       throws: function( block, expected, message ) {
+               var actual,
+                       ok = false;
+
+               // 'expected' is optional
+               if ( typeof expected === "string" ) {
+                       message = expected;
+                       expected = null;
+               }
+
+               config.current.ignoreGlobalErrors = true;
+               try {
+                       block.call( config.current.testEnvironment );
+               } catch (e) {
+                       actual = e;
+               }
+               config.current.ignoreGlobalErrors = false;
+
+               if ( actual ) {
+                       // we don't want to validate thrown error
+                       if ( !expected ) {
+                               ok = true;
+                       // expected is a regexp
+                       } else if ( QUnit.objectType( expected ) === "regexp" ) 
{
+                               ok = expected.test( actual );
+                       // expected is a constructor
+                       } else if ( actual instanceof expected ) {
+                               ok = true;
+                       // expected is a validation function which returns true 
is validation passed
+                       } else if ( expected.call( {}, actual ) === true ) {
+                               ok = true;
+                       }
+
+                       QUnit.push( ok, actual, null, message );
+               } else {
+                       QUnit.pushFailure( message, null, 'No exception was 
thrown.' );
+               }
+       }
+};
+
+/**
+ * @deprecate since 1.8.0
+ * Kept assertion helpers in root for backwards compatibility
+ */
+extend( QUnit, QUnit.assert );
+
+/**
+ * @deprecated since 1.9.0
+ * Kept global "raises()" for backwards compatibility
+ */
+QUnit.raises = QUnit.assert.throws;
+
+/**
+ * @deprecated since 1.0.0, replaced with error pushes since 1.3.0
+ * Kept to avoid TypeErrors for undefined methods.
+ */
+QUnit.equals = function() {
+       QUnit.push( false, false, false, "QUnit.equals has been deprecated 
since 2009 (e88049a0), use QUnit.equal instead" );
+};
+QUnit.same = function() {
+       QUnit.push( false, false, false, "QUnit.same has been deprecated since 
2009 (e88049a0), use QUnit.deepEqual instead" );
+};
+
+// We want access to the constructor's prototype
+(function() {
+       function F() {}
+       F.prototype = QUnit;
+       QUnit = new F();
+       // Make F QUnit's constructor so that we can add to the prototype later
+       QUnit.constructor = F;
+}());
+
+/**
+ * Config object: Maintain internal state
+ * Later exposed as QUnit.config
+ * `config` initialized at top of scope
+ */
+config = {
+       // The queue of tests to run
+       queue: [],
+
+       // block until document ready
+       blocking: true,
+
+       // when enabled, show only failing tests
+       // gets persisted through sessionStorage and can be changed in UI via 
checkbox
+       hidepassed: false,
+
+       // by default, run previously failed tests first
+       // very useful in combination with "Hide passed tests" checked
+       reorder: true,
+
+       // by default, modify document.title when suite is done
+       altertitle: true,
+
+       // when enabled, all tests must call expect()
+       requireExpects: false,
+
+       // add checkboxes that are persisted in the query-string
+       // when enabled, the id is set to `true` as a `QUnit.config` property
+       urlConfig: [
+               {
+                       id: "noglobals",
+                       label: "Check for Globals",
+                       tooltip: "Enabling this will test if any test 
introduces new properties on the `window` object. Stored as query-strings."
+               },
+               {
+                       id: "notrycatch",
+                       label: "No try-catch",
+                       tooltip: "Enabling this will run tests outside of a 
try-catch block. Makes debugging exceptions in IE reasonable. Stored as 
query-strings."
+               }
+       ],
+
+       // Set of all modules.
+       modules: {},
+
+       // logging callback queues
+       begin: [],
+       done: [],
+       log: [],
+       testStart: [],
+       testDone: [],
+       moduleStart: [],
+       moduleDone: []
+};
+
+// Initialize more QUnit.config and QUnit.urlParams
+(function() {
+       var i,
+               location = window.location || { search: "", protocol: "file:" },
+               params = location.search.slice( 1 ).split( "&" ),
+               length = params.length,
+               urlParams = {},
+               current;
+
+       if ( params[ 0 ] ) {
+               for ( i = 0; i < length; i++ ) {
+                       current = params[ i ].split( "=" );
+                       current[ 0 ] = decodeURIComponent( current[ 0 ] );
+                       // allow just a key to turn on a flag, e.g., 
test.html?noglobals
+                       current[ 1 ] = current[ 1 ] ? decodeURIComponent( 
current[ 1 ] ) : true;
+                       urlParams[ current[ 0 ] ] = current[ 1 ];
+               }
+       }
+
+       QUnit.urlParams = urlParams;
+
+       // String search anywhere in moduleName+testName
+       config.filter = urlParams.filter;
+
+       // Exact match of the module name
+       config.module = urlParams.module;
+
+       config.testNumber = parseInt( urlParams.testNumber, 10 ) || null;
+
+       // Figure out if we're running the tests from a server or not
+       QUnit.isLocal = location.protocol === "file:";
+}());
+
+// Export global variables, unless an 'exports' object exists,
+// in that case we assume we're in CommonJS (dealt with on the bottom of the 
script)
+if ( typeof exports === "undefined" ) {
+       extend( window, QUnit );
+
+       // Expose QUnit object
+       window.QUnit = QUnit;
+}
+
+// Extend QUnit object,
+// these after set here because they should not be exposed as global functions
+extend( QUnit, {
+       config: config,
+
+       // Initialize the configuration options
+       init: function() {
+               extend( config, {
+                       stats: { all: 0, bad: 0 },
+                       moduleStats: { all: 0, bad: 0 },
+                       started: +new Date(),
+                       updateRate: 1000,
+                       blocking: false,
+                       autostart: true,
+                       autorun: false,
+                       filter: "",
+                       queue: [],
+                       semaphore: 0
+               });
+
+               var tests, banner, result,
+                       qunit = id( "qunit" );
+
+               if ( qunit ) {
+                       qunit.innerHTML =
+                               "<h1 id='qunit-header'>" + escapeInnerText( 
document.title ) + "</h1>" +
+                               "<h2 id='qunit-banner'></h2>" +
+                               "<div id='qunit-testrunner-toolbar'></div>" +
+                               "<h2 id='qunit-userAgent'></h2>" +
+                               "<ol id='qunit-tests'></ol>";
+               }
+
+               tests = id( "qunit-tests" );
+               banner = id( "qunit-banner" );
+               result = id( "qunit-testresult" );
+
+               if ( tests ) {
+                       tests.innerHTML = "";
+               }
+
+               if ( banner ) {
+                       banner.className = "";
+               }
+
+               if ( result ) {
+                       result.parentNode.removeChild( result );
+               }
+
+               if ( tests ) {
+                       result = document.createElement( "p" );
+                       result.id = "qunit-testresult";
+                       result.className = "result";
+                       tests.parentNode.insertBefore( result, tests );
+                       result.innerHTML = "Running...<br/>&nbsp;";
+               }
+       },
+
+       // Resets the test setup. Useful for tests that modify the DOM.
+       reset: function() {
+               var fixture = id( "qunit-fixture" );
+               if ( fixture ) {
+                       fixture.innerHTML = config.fixture;
+               }
+       },
+
+       // Trigger an event on an element.
+       // @example triggerEvent( document.body, "click" );
+       triggerEvent: function( elem, type, event ) {
+               if ( document.createEvent ) {
+                       event = document.createEvent( "MouseEvents" );
+                       event.initMouseEvent(type, true, true, 
elem.ownerDocument.defaultView,
+                               0, 0, 0, 0, 0, false, false, false, false, 0, 
null);
+
+                       elem.dispatchEvent( event );
+               } else if ( elem.fireEvent ) {
+                       elem.fireEvent( "on" + type );
+               }
+       },
+
+       // Safe object type checking
+       is: function( type, obj ) {
+               return QUnit.objectType( obj ) == type;
+       },
+
+       objectType: function( obj ) {
+               if ( typeof obj === "undefined" ) {
+                               return "undefined";
+               // consider: typeof null === object
+               }
+               if ( obj === null ) {
+                               return "null";
+               }
+
+               var type = toString.call( obj ).match(/^\[object\s(.*)\]$/)[1] 
|| "";
+
+               switch ( type ) {
+                       case "Number":
+                               if ( isNaN(obj) ) {
+                                       return "nan";
+                               }
+                               return "number";
+                       case "String":
+                       case "Boolean":
+                       case "Array":
+                       case "Date":
+                       case "RegExp":
+                       case "Function":
+                               return type.toLowerCase();
+               }
+               if ( typeof obj === "object" ) {
+                       return "object";
+               }
+               return undefined;
+       },
+
+       push: function( result, actual, expected, message ) {
+               if ( !config.current ) {
+                       throw new Error( "assertion outside test context, was " 
+ sourceFromStacktrace() );
+               }
+
+               var output, source,
+                       details = {
+                               module: config.current.module,
+                               name: config.current.testName,
+                               result: result,
+                               message: message,
+                               actual: actual,
+                               expected: expected
+                       };
+
+               message = escapeInnerText( message ) || ( result ? "okay" : 
"failed" );
+               message = "<span class='test-message'>" + message + "</span>";
+               output = message;
+
+               if ( !result ) {
+                       expected = escapeInnerText( 
QUnit.jsDump.parse(expected) );
+                       actual = escapeInnerText( QUnit.jsDump.parse(actual) );
+                       output += "<table><tr 
class='test-expected'><th>Expected: </th><td><pre>" + expected + 
"</pre></td></tr>";
+
+                       if ( actual != expected ) {
+                               output += "<tr class='test-actual'><th>Result: 
</th><td><pre>" + actual + "</pre></td></tr>";
+                               output += "<tr class='test-diff'><th>Diff: 
</th><td><pre>" + QUnit.diff( expected, actual ) + "</pre></td></tr>";
+                       }
+
+                       source = sourceFromStacktrace();
+
+                       if ( source ) {
+                               details.source = source;
+                               output += "<tr class='test-source'><th>Source: 
</th><td><pre>" + escapeInnerText( source ) + "</pre></td></tr>";
+                       }
+
+                       output += "</table>";
+               }
+
+               runLoggingCallbacks( "log", QUnit, details );
+
+               config.current.assertions.push({
+                       result: !!result,
+                       message: output
+               });
+       },
+
+       pushFailure: function( message, source, actual ) {
+               if ( !config.current ) {
+                       throw new Error( "pushFailure() assertion outside test 
context, was " + sourceFromStacktrace(2) );
+               }
+
+               var output,
+                       details = {
+                               module: config.current.module,
+                               name: config.current.testName,
+                               result: false,
+                               message: message
+                       };
+
+               message = escapeInnerText( message ) || "error";
+               message = "<span class='test-message'>" + message + "</span>";
+               output = message;
+
+               output += "<table>";
+
+               if ( actual ) {
+                       output += "<tr class='test-actual'><th>Result: 
</th><td><pre>" + escapeInnerText( actual ) + "</pre></td></tr>";
+               }
+
+               if ( source ) {
+                       details.source = source;
+                       output += "<tr class='test-source'><th>Source: 
</th><td><pre>" + escapeInnerText( source ) + "</pre></td></tr>";
+               }
+
+               output += "</table>";
+
+               runLoggingCallbacks( "log", QUnit, details );
+
+               config.current.assertions.push({
+                       result: false,
+                       message: output
+               });
+       },
+
+       url: function( params ) {
+               params = extend( extend( {}, QUnit.urlParams ), params );
+               var key,
+                       querystring = "?";
+
+               for ( key in params ) {
+                       if ( !hasOwn.call( params, key ) ) {
+                               continue;
+                       }
+                       querystring += encodeURIComponent( key ) + "=" +
+                               encodeURIComponent( params[ key ] ) + "&";
+               }
+               return window.location.pathname + querystring.slice( 0, -1 );
+       },
+
+       extend: extend,
+       id: id,
+       addEvent: addEvent
+       // load, equiv, jsDump, diff: Attached later
+});
+
+/**
+ * @deprecated: Created for backwards compatibility with test runner that set 
the hook function
+ * into QUnit.{hook}, instead of invoking it and passing the hook function.
+ * QUnit.constructor is set to the empty F() above so that we can add to it's 
prototype here.
+ * Doing this allows us to tell if the following methods have been overwritten 
on the actual
+ * QUnit object.
+ */
+extend( QUnit.constructor.prototype, {
+
+       // Logging callbacks; all receive a single argument with the listed 
properties
+       // run test/logs.html for any related changes
+       begin: registerLoggingCallback( "begin" ),
+
+       // done: { failed, passed, total, runtime }
+       done: registerLoggingCallback( "done" ),
+
+       // log: { result, actual, expected, message }
+       log: registerLoggingCallback( "log" ),
+
+       // testStart: { name }
+       testStart: registerLoggingCallback( "testStart" ),
+
+       // testDone: { name, failed, passed, total }
+       testDone: registerLoggingCallback( "testDone" ),
+
+       // moduleStart: { name }
+       moduleStart: registerLoggingCallback( "moduleStart" ),
+
+       // moduleDone: { name, failed, passed, total }
+       moduleDone: registerLoggingCallback( "moduleDone" )
+});
+
+if ( typeof document === "undefined" || document.readyState === "complete" ) {
+       config.autorun = true;
+}
+
+QUnit.load = function() {
+       runLoggingCallbacks( "begin", QUnit, {} );
+
+       // Initialize the config, saving the execution queue
+       var banner, filter, i, label, len, main, ol, toolbar, userAgent, val, 
urlConfigCheckboxes, moduleFilter,
+           numModules = 0,
+           moduleFilterHtml = "",
+               urlConfigHtml = "",
+               oldconfig = extend( {}, config );
+
+       QUnit.init();
+       extend(config, oldconfig);
+
+       config.blocking = false;
+
+       len = config.urlConfig.length;
+
+       for ( i = 0; i < len; i++ ) {
+               val = config.urlConfig[i];
+               if ( typeof val === "string" ) {
+                       val = {
+                               id: val,
+                               label: val,
+                               tooltip: "[no tooltip available]"
+                       };
+               }
+               config[ val.id ] = QUnit.urlParams[ val.id ];
+               urlConfigHtml += "<input id='qunit-urlconfig-" + val.id + "' 
name='" + val.id + "' type='checkbox'" + ( config[ val.id ] ? " 
checked='checked'" : "" ) + " title='" + val.tooltip + "'><label 
for='qunit-urlconfig-" + val.id + "' title='" + val.tooltip + "'>" + val.label 
+ "</label>";
+       }
+
+       moduleFilterHtml += "<label for='qunit-modulefilter'>Module: 
</label><select id='qunit-modulefilter' name='modulefilter'><option value='' " 
+ ( config.module === undefined  ? "selected" : "" ) + ">< All Modules 
></option>";
+       for ( i in config.modules ) {
+               if ( config.modules.hasOwnProperty( i ) ) {
+                       numModules += 1;
+                       moduleFilterHtml += "<option value='" + 
encodeURIComponent(i) + "' " + ( config.module === i ? "selected" : "" ) + ">" 
+ i + "</option>";
+               }
+       }
+       moduleFilterHtml += "</select>";
+
+       // `userAgent` initialized at top of scope
+       userAgent = id( "qunit-userAgent" );
+       if ( userAgent ) {
+               userAgent.innerHTML = navigator.userAgent;
+       }
+
+       // `banner` initialized at top of scope
+       banner = id( "qunit-header" );
+       if ( banner ) {
+               banner.innerHTML = "<a href='" + QUnit.url({ filter: undefined, 
module: undefined, testNumber: undefined }) + "'>" + banner.innerHTML + "</a> ";
+       }
+
+       // `toolbar` initialized at top of scope
+       toolbar = id( "qunit-testrunner-toolbar" );
+       if ( toolbar ) {
+               // `filter` initialized at top of scope
+               filter = document.createElement( "input" );
+               filter.type = "checkbox";
+               filter.id = "qunit-filter-pass";
+
+               addEvent( filter, "click", function() {
+                       var tmp,
+                               ol = document.getElementById( "qunit-tests" );
+
+                       if ( filter.checked ) {
+                               ol.className = ol.className + " hidepass";
+                       } else {
+                               tmp = " " + ol.className.replace( /[\n\t\r]/g, 
" " ) + " ";
+                               ol.className = tmp.replace( / hidepass /, " " );
+                       }
+                       if ( defined.sessionStorage ) {
+                               if (filter.checked) {
+                                       sessionStorage.setItem( 
"qunit-filter-passed-tests", "true" );
+                               } else {
+                                       sessionStorage.removeItem( 
"qunit-filter-passed-tests" );
+                               }
+                       }
+               });
+
+               if ( config.hidepassed || defined.sessionStorage && 
sessionStorage.getItem( "qunit-filter-passed-tests" ) ) {
+                       filter.checked = true;
+                       // `ol` initialized at top of scope
+                       ol = document.getElementById( "qunit-tests" );
+                       ol.className = ol.className + " hidepass";
+               }
+               toolbar.appendChild( filter );
+
+               // `label` initialized at top of scope
+               label = document.createElement( "label" );
+               label.setAttribute( "for", "qunit-filter-pass" );
+               label.setAttribute( "title", "Only show tests and assertons 
that fail. Stored in sessionStorage." );
+               label.innerHTML = "Hide passed tests";
+               toolbar.appendChild( label );
+
+               urlConfigCheckboxes = document.createElement( 'span' );
+               urlConfigCheckboxes.innerHTML = urlConfigHtml;
+               addEvent( urlConfigCheckboxes, "change", function( event ) {
+                       var params = {};
+                       params[ event.target.name ] = event.target.checked ? 
true : undefined;
+                       window.location = QUnit.url( params );
+               });
+               toolbar.appendChild( urlConfigCheckboxes );
+
+               if (numModules > 1) {
+                       moduleFilter = document.createElement( 'span' );
+                       moduleFilter.setAttribute( 'id', 
'qunit-modulefilter-container' );
+                       moduleFilter.innerHTML = moduleFilterHtml;
+                       addEvent( moduleFilter, "change", function() {
+                               var selectBox = 
moduleFilter.getElementsByTagName("select")[0],
+                                   selectedModule = 
decodeURIComponent(selectBox.options[selectBox.selectedIndex].value);
+
+                               window.location = QUnit.url( { module: ( 
selectedModule === "" ) ? undefined : selectedModule } );
+                       });
+                       toolbar.appendChild(moduleFilter);
+               }
+       }
+
+       // `main` initialized at top of scope
+       main = id( "qunit-fixture" );
+       if ( main ) {
+               config.fixture = main.innerHTML;
+       }
+
+       if ( config.autostart ) {
+               QUnit.start();
+       }
+};
+
+addEvent( window, "load", QUnit.load );
+
+// `onErrorFnPrev` initialized at top of scope
+// Preserve other handlers
+onErrorFnPrev = window.onerror;
+
+// Cover uncaught exceptions
+// Returning true will surpress the default browser handler,
+// returning false will let it run.
+window.onerror = function ( error, filePath, linerNr ) {
+       var ret = false;
+       if ( onErrorFnPrev ) {
+               ret = onErrorFnPrev( error, filePath, linerNr );
+       }
+
+       // Treat return value as window.onerror itself does,
+       // Only do our handling if not surpressed.
+       if ( ret !== true ) {
+               if ( QUnit.config.current ) {
+                       if ( QUnit.config.current.ignoreGlobalErrors ) {
+                               return true;
+                       }
+                       QUnit.pushFailure( error, filePath + ":" + linerNr );
+               } else {
+                       QUnit.test( "global failure", extend( function() {
+                               QUnit.pushFailure( error, filePath + ":" + 
linerNr );
+                       }, { validTest: validTest } ) );
+               }
+               return false;
+       }
+
+       return ret;
+};
+
+function done() {
+       config.autorun = true;
+
+       // Log the last module results
+       if ( config.currentModule ) {
+               runLoggingCallbacks( "moduleDone", QUnit, {
+                       name: config.currentModule,
+                       failed: config.moduleStats.bad,
+                       passed: config.moduleStats.all - config.moduleStats.bad,
+                       total: config.moduleStats.all
+               });
+       }
+
+       var i, key,
+               banner = id( "qunit-banner" ),
+               tests = id( "qunit-tests" ),
+               runtime = +new Date() - config.started,
+               passed = config.stats.all - config.stats.bad,
+               html = [
+                       "Tests completed in ",
+                       runtime,
+                       " milliseconds.<br/>",
+                       "<span class='passed'>",
+                       passed,
+                       "</span> tests of <span class='total'>",
+                       config.stats.all,
+                       "</span> passed, <span class='failed'>",
+                       config.stats.bad,
+                       "</span> failed."
+               ].join( "" );
+
+       if ( banner ) {
+               banner.className = ( config.stats.bad ? "qunit-fail" : 
"qunit-pass" );
+       }
+
+       if ( tests ) {
+               id( "qunit-testresult" ).innerHTML = html;
+       }
+
+       if ( config.altertitle && typeof document !== "undefined" && 
document.title ) {
+               // show ✖ for good, ✔ for bad suite result in title
+               // use escape sequences in case file gets loaded with 
non-utf-8-charset
+               document.title = [
+                       ( config.stats.bad ? "\u2716" : "\u2714" ),
+                       document.title.replace( /^[\u2714\u2716] /i, "" )
+               ].join( " " );
+       }
+
+       // clear own sessionStorage items if all tests passed
+       if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 
) {
+               // `key` & `i` initialized at top of scope
+               for ( i = 0; i < sessionStorage.length; i++ ) {
+                       key = sessionStorage.key( i++ );
+                       if ( key.indexOf( "qunit-test-" ) === 0 ) {
+                               sessionStorage.removeItem( key );
+                       }
+               }
+       }
+
+       // scroll back to top to show results
+       if ( window.scrollTo ) {
+               window.scrollTo(0, 0);
+       }
+
+       runLoggingCallbacks( "done", QUnit, {
+               failed: config.stats.bad,
+               passed: passed,
+               total: config.stats.all,
+               runtime: runtime
+       });
+}
+
+/** @return Boolean: true if this test should be ran */
+function validTest( test ) {
+       var include,
+               filter = config.filter && config.filter.toLowerCase(),
+               module = config.module && config.module.toLowerCase(),
+               fullName = (test.module + ": " + test.testName).toLowerCase();
+
+       // Internally-generated tests are always valid
+       if ( test.callback && test.callback.validTest === validTest ) {
+               delete test.callback.validTest;
+               return true;
+       }
+
+       if ( config.testNumber ) {
+               return test.testNumber === config.testNumber;
+       }
+
+       if ( module && ( !test.module || test.module.toLowerCase() !== module ) 
) {
+               return false;
+       }
+
+       if ( !filter ) {
+               return true;
+       }
+
+       include = filter.charAt( 0 ) !== "!";
+       if ( !include ) {
+               filter = filter.slice( 1 );
+       }
+
+       // If the filter matches, we need to honour include
+       if ( fullName.indexOf( filter ) !== -1 ) {
+               return include;
+       }
+
+       // Otherwise, do the opposite
+       return !include;
+}
+
+// so far supports only Firefox, Chrome and Opera (buggy), Safari (for real 
exceptions)
+// Later Safari and IE10 are supposed to support error.stack as well
+// See also 
https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack
+function extractStacktrace( e, offset ) {
+       offset = offset === undefined ? 3 : offset;
+
+       var stack, include, i, regex;
+
+       if ( e.stacktrace ) {
+               // Opera
+               return e.stacktrace.split( "\n" )[ offset + 3 ];
+       } else if ( e.stack ) {
+               // Firefox, Chrome
+               stack = e.stack.split( "\n" );
+               if (/^error$/i.test( stack[0] ) ) {
+                       stack.shift();
+               }
+               if ( fileName ) {
+                       include = [];
+                       for ( i = offset; i < stack.length; i++ ) {
+                               if ( stack[ i ].indexOf( fileName ) != -1 ) {
+                                       break;
+                               }
+                               include.push( stack[ i ] );
+                       }
+                       if ( include.length ) {
+                               return include.join( "\n" );
+                       }
+               }
+               return stack[ offset ];
+       } else if ( e.sourceURL ) {
+               // Safari, PhantomJS
+               // hopefully one day Safari provides actual stacktraces
+               // exclude useless self-reference for generated Error objects
+               if ( /qunit.js$/.test( e.sourceURL ) ) {
+                       return;
+               }
+               // for actual exceptions, this is useful
+               return e.sourceURL + ":" + e.line;
+       }
+}
+function sourceFromStacktrace( offset ) {
+       try {
+               throw new Error();
+       } catch ( e ) {
+               return extractStacktrace( e, offset );
+       }
+}
+
+function escapeInnerText( s ) {
+       if ( !s ) {
+               return "";
+       }
+       s = s + "";
+       return s.replace( /[\&<>]/g, function( s ) {
+               switch( s ) {
+                       case "&": return "&amp;";
+                       case "<": return "&lt;";
+                       case ">": return "&gt;";
+                       default: return s;
+               }
+       });
+}
+
+function synchronize( callback, last ) {
+       config.queue.push( callback );
+
+       if ( config.autorun && !config.blocking ) {
+               process( last );
+       }
+}
+
+function process( last ) {
+       function next() {
+               process( last );
+       }
+       var start = new Date().getTime();
+       config.depth = config.depth ? config.depth + 1 : 1;
+
+       while ( config.queue.length && !config.blocking ) {
+               if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new 
Date().getTime() - start ) < config.updateRate ) ) {
+                       config.queue.shift()();
+               } else {
+                       window.setTimeout( next, 13 );
+                       break;
+               }
+       }
+       config.depth--;
+       if ( last && !config.blocking && !config.queue.length && config.depth 
=== 0 ) {
+               done();
+       }
+}
+
+function saveGlobal() {
+       config.pollution = [];
+
+       if ( config.noglobals ) {
+               for ( var key in window ) {
+                       // in Opera sometimes DOM element ids show up here, 
ignore them
+                       if ( !hasOwn.call( window, key ) || 
/^qunit-test-output/.test( key ) ) {
+                               continue;
+                       }
+                       config.pollution.push( key );
+               }
+       }
+}
+
+function checkPollution( name ) {
+       var newGlobals,
+               deletedGlobals,
+               old = config.pollution;
+
+       saveGlobal();
+
+       newGlobals = diff( config.pollution, old );
+       if ( newGlobals.length > 0 ) {
+               QUnit.pushFailure( "Introduced global variable(s): " + 
newGlobals.join(", ") );
+       }
+
+       deletedGlobals = diff( old, config.pollution );
+       if ( deletedGlobals.length > 0 ) {
+               QUnit.pushFailure( "Deleted global variable(s): " + 
deletedGlobals.join(", ") );
+       }
+}
+
+// returns a new Array with the elements that are in a but not in b
+function diff( a, b ) {
+       var i, j,
+               result = a.slice();
+
+       for ( i = 0; i < result.length; i++ ) {
+               for ( j = 0; j < b.length; j++ ) {
+                       if ( result[i] === b[j] ) {
+                               result.splice( i, 1 );
+                               i--;
+                               break;
+                       }
+               }
+       }
+       return result;
+}
+
+function extend( a, b ) {
+       for ( var prop in b ) {
+               if ( b[ prop ] === undefined ) {
+                       delete a[ prop ];
+
+               // Avoid "Member not found" error in IE8 caused by setting 
window.constructor
+               } else if ( prop !== "constructor" || a !== window ) {
+                       a[ prop ] = b[ prop ];
+               }
+       }
+
+       return a;
+}
+
+function addEvent( elem, type, fn ) {
+       if ( elem.addEventListener ) {
+               elem.addEventListener( type, fn, false );
+       } else if ( elem.attachEvent ) {
+               elem.attachEvent( "on" + type, fn );
+       } else {
+               fn();
+       }
+}
+
+function id( name ) {
+       return !!( typeof document !== "undefined" && document && 
document.getElementById ) &&
+               document.getElementById( name );
+}
+
+function registerLoggingCallback( key ) {
+       return function( callback ) {
+               config[key].push( callback );
+       };
+}
+
+// Supports deprecated method of completely overwriting logging callbacks
+function runLoggingCallbacks( key, scope, args ) {
+       //debugger;
+       var i, callbacks;
+       if ( QUnit.hasOwnProperty( key ) ) {
+               QUnit[ key ].call(scope, args );
+       } else {
+               callbacks = config[ key ];
+               for ( i = 0; i < callbacks.length; i++ ) {
+                       callbacks[ i ].call( scope, args );
+               }
+       }
+}
+
+// Test for equality any JavaScript type.
+// Author: Philippe Rathé <pra...@gmail.com>
+QUnit.equiv = (function() {
+
+       // Call the o related callback with the given arguments.
+       function bindCallbacks( o, callbacks, args ) {
+               var prop = QUnit.objectType( o );
+               if ( prop ) {
+                       if ( QUnit.objectType( callbacks[ prop ] ) === 
"function" ) {
+                               return callbacks[ prop ].apply( callbacks, args 
);
+                       } else {
+                               return callbacks[ prop ]; // or undefined
+                       }
+               }
+       }
+
+       // the real equiv function
+       var innerEquiv,
+               // stack to decide between skip/abort functions
+               callers = [],
+               // stack to avoiding loops from circular referencing
+               parents = [],
+
+               getProto = Object.getPrototypeOf || function ( obj ) {
+                       return obj.__proto__;
+               },
+               callbacks = (function () {
+
+                       // for string, boolean, number and null
+                       function useStrictEquality( b, a ) {
+                               if ( b instanceof a.constructor || a instanceof 
b.constructor ) {
+                                       // to catch short annotaion VS 'new' 
annotation of a
+                                       // declaration
+                                       // e.g. var i = 1;
+                                       // var j = new Number(1);
+                                       return a == b;
+                               } else {
+                                       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 QUnit.objectType( b ) === "date" 
&& a.valueOf() === b.valueOf();
+                               },
+
+                               "regexp": function( b, a ) {
+                                       return QUnit.objectType( b ) === 
"regexp" &&
+                                               // the regex itself
+                                               a.source === b.source &&
+                                               // and its modifers
+                                               a.global === b.global &&
+                                               // (gmi) ...
+                                               a.ignoreCase === b.ignoreCase &&
+                                               a.multiline === b.multiline &&
+                                               a.sticky === b.sticky;
+                               },
+
+                               // - 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, j, len, loop;
+
+                                       // b could be an object literal here
+                                       if ( QUnit.objectType( b ) !== "array" 
) {
+                                               return false;
+                                       }
+
+                                       len = a.length;
+                                       if ( len !== b.length ) {
+                                               // safe and faster
+                                               return false;
+                                       }
+
+                                       // track reference to avoid circular 
references
+                                       parents.push( a );
+                                       for ( i = 0; i < len; i++ ) {
+                                               loop = false;
+                                               for ( j = 0; j < 
parents.length; j++ ) {
+                                                       if ( parents[j] === 
a[i] ) {
+                                                               loop = true;// 
dont rewalk array
+                                                       }
+                                               }
+                                               if ( !loop && !innerEquiv(a[i], 
b[i]) ) {
+                                                       parents.pop();
+                                                       return false;
+                                               }
+                                       }
+                                       parents.pop();
+                                       return true;
+                               },
+
+                               "object": function( b, a ) {
+                                       var i, j, loop,
+                                               // Default to true
+                                               eq = true,
+                                               aProperties = [],
+                                               bProperties = [];
+
+                                       // comparing constructors is more 
strict than using
+                                       // instanceof
+                                       if ( a.constructor !== b.constructor ) {
+                                               // Allow objects with no 
prototype to be equivalent to
+                                               // objects with Object as their 
constructor.
+                                               if ( !(( getProto(a) === null 
&& getProto(b) === Object.prototype ) ||
+                                                       ( getProto(b) === null 
&& getProto(a) === Object.prototype ) ) ) {
+                                                               return false;
+                                               }
+                                       }
+
+                                       // stack constructor before traversing 
properties
+                                       callers.push( a.constructor );
+                                       // track reference to avoid circular 
references
+                                       parents.push( a );
+
+                                       for ( i in a ) { // be strict: don't 
ensures hasOwnProperty
+                                                                       // and 
go deep
+                                               loop = false;
+                                               for ( j = 0; j < 
parents.length; j++ ) {
+                                                       if ( parents[j] === 
a[i] ) {
+                                                               // don't go 
down the same path twice
+                                                               loop = true;
+                                                       }
+                                               }
+                                               aProperties.push(i); // collect 
a's properties
+
+                                               if (!loop && !innerEquiv( a[i], 
b[i] ) ) {
+                                                       eq = false;
+                                                       break;
+                                               }
+                                       }
+
+                                       callers.pop(); // unstack, we are done
+                                       parents.pop();
+
+                                       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 = [].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 ( a === null || b === null || typeof a === 
"undefined" ||
+                                       typeof b === "undefined" ||
+                                       QUnit.objectType(a) !== 
QUnit.objectType(b) ) {
+                               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;
+}());
+
+/**
+ * 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
+ * @link 
{http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
+ */
+QUnit.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, stack ) {
+               var i = arr.length, ret = new Array(i);
+               this.up();
+               while ( i-- ) {
+                       ret[i] = this.parse( arr[i] , undefined , stack);
+               }
+               this.down();
+               return join( "[", ret, "]" );
+       }
+
+       var reName = /^function (\w+)/,
+               jsDump = {
+                       parse: function( obj, type, stack ) { //type is used 
mostly internally, you can fix a (custom)type in advance
+                               stack = stack || [ ];
+                               var inStack, res,
+                                       parser = this.parsers[ type || 
this.typeOf(obj) ];
+
+                               type = typeof parser;
+                               inStack = inArray( obj, stack );
+
+                               if ( inStack != -1 ) {
+                                       return "recursion(" + (inStack - 
stack.length) + ")";
+                               }
+                               //else
+                               if ( type == "function" )  {
+                                       stack.push( obj );
+                                       res = parser.call( this, obj, stack );
+                                       stack.pop();
+                                       return res;
+                               }
+                               // else
+                               return ( type == "string" ) ? parser : 
this.parsers.error;
+                       },
+                       typeOf: function( obj ) {
+                               var type;
+                               if ( obj === null ) {
+                                       type = "null";
+                               } else if ( typeof obj === "undefined" ) {
+                                       type = "undefined";
+                               } else if ( QUnit.is( "regexp", obj) ) {
+                                       type = "regexp";
+                               } else if ( QUnit.is( "date", obj) ) {
+                                       type = "date";
+                               } else if ( QUnit.is( "function", obj) ) {
+                                       type = "function";
+                               } else if ( typeof obj.setInterval !== 
undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === 
"undefined" ) {
+                                       type = "window";
+                               } else if ( obj.nodeType === 9 ) {
+                                       type = "document";
+                               } else if ( obj.nodeType ) {
+                                       type = "node";
+                               } else if (
+                                       // native arrays
+                                       toString.call( obj ) === "[object 
Array]" ||
+                                       // NodeList objects
+                                       ( typeof obj.length === "number" && 
typeof obj.item !== "undefined" && ( obj.length ? obj.item(0) === obj[0] : ( 
obj.item( 0 ) === null && typeof obj[0] === "undefined" ) ) )
+                               ) {
+                                       type = "array";
+                               } else {
+                                       type = typeof obj;
+                               }
+                               return 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 new 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, QUnit.jsDump.parse( fn, 
"functionArgs" ), "){" ].join( "" );
+                                       return join( ret, 
QUnit.jsDump.parse(fn,"functionCode" ), "}" );
+                               },
+                               array: array,
+                               nodelist: array,
+                               "arguments": array,
+                               object: function( map, stack ) {
+                                       var ret = [ ], keys, key, val, i;
+                                       QUnit.jsDump.up();
+                                       if ( Object.keys ) {
+                                               keys = Object.keys( map );
+                                       } else {
+                                               keys = [];
+                                               for ( key in map ) {
+                                                       keys.push( key );
+                                               }
+                                       }
+                                       keys.sort();
+                                       for ( i = 0; i < keys.length; i++ ) {
+                                               key = keys[ i ];
+                                               val = map[ key ];
+                                               ret.push( QUnit.jsDump.parse( 
key, "key" ) + ": " + QUnit.jsDump.parse( val, undefined, stack ) );
+                                       }
+                                       QUnit.jsDump.down();
+                                       return join( "{", ret, "}" );
+                               },
+                               node: function( node ) {
+                                       var a, val,
+                                               open = QUnit.jsDump.HTML ? 
"&lt;" : "<",
+                                               close = QUnit.jsDump.HTML ? 
"&gt;" : ">",
+                                               tag = 
node.nodeName.toLowerCase(),
+                                               ret = open + tag;
+
+                                       for ( a in QUnit.jsDump.DOMAttrs ) {
+                                               val = node[ 
QUnit.jsDump.DOMAttrs[a] ];
+                                               if ( val ) {
+                                                       ret += " " + a + "=" + 
QUnit.jsDump.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 args,
+                                               l = fn.length;
+
+                                       if ( !l ) {
+                                               return "";
+                                       }
+
+                                       args = new 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, //node 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.
+               };
+
+       return jsDump;
+}());
+
+// from Sizzle.js
+function getText( elems ) {
+       var i, elem,
+               ret = "";
+
+       for ( i = 0; elems[i]; i++ ) {
+               elem = elems[i];
+
+               // Get the text from text nodes and CDATA nodes
+               if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
+                       ret += elem.nodeValue;
+
+               // Traverse everything else, except comment nodes
+               } else if ( elem.nodeType !== 8 ) {
+                       ret += getText( elem.childNodes );
+               }
+       }
+
+       return ret;
+}
+
+// from jquery.js
+function inArray( elem, array ) {
+       if ( array.indexOf ) {
+               return array.indexOf( elem );
+       }
+
+       for ( var i = 0, length = array.length; i < length; i++ ) {
+               if ( array[ i ] === elem ) {
+                       return i;
+               }
+       }
+
+       return -1;
+}
+
+/*
+ * Javascript Diff Algorithm
+ *  By John Resig (http://ejohn.org/)
+ *  Modified by Chu Alan "sprite"
+ *
+ * Released under the MIT license.
+ *
+ * More Info:
+ *  http://ejohn.org/projects/javascript-diff-algorithm/
+ *
+ * Usage: QUnit.diff(expected, actual)
+ *
+ * QUnit.diff( "the quick brown fox jumped over", "the quick fox jumps over" ) 
== "the  quick <del>brown </del> fox <del>jumped </del><ins>jumps </ins> over"
+ */
+QUnit.diff = (function() {
+       function diff( o, n ) {
+               var i,
+                       ns = {},
+                       os = {};
+
+               for ( i = 0; i < n.length; i++ ) {
+                       if ( ns[ n[i] ] == null ) {
+                               ns[ n[i] ] = {
+                                       rows: [],
+                                       o: null
+                               };
+                       }
+                       ns[ n[i] ].rows.push( i );
+               }
+
+               for ( i = 0; i < o.length; i++ ) {
+                       if ( os[ o[i] ] == null ) {
+                               os[ o[i] ] = {
+                                       rows: [],
+                                       n: null
+                               };
+                       }
+                       os[ o[i] ].rows.push( i );
+               }
+
+               for ( i in ns ) {
+                       if ( !hasOwn.call( ns, i ) ) {
+                               continue;
+                       }
+                       if ( ns[i].rows.length == 1 && typeof os[i] != 
"undefined" && os[i].rows.length == 1 ) {
+                               n[ ns[i].rows[0] ] = {
+                                       text: n[ ns[i].rows[0] ],
+                                       row: os[i].rows[0]
+                               };
+                               o[ os[i].rows[0] ] = {
+                                       text: o[ os[i].rows[0] ],
+                                       row: ns[i].rows[0]
+                               };
+                       }
+               }
+
+               for ( i = 0; i < n.length - 1; i++ ) {
+                       if ( n[i].text != null && n[ i + 1 ].text == null && 
n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null &&
+                                               n[ i + 1 ] == o[ n[i].row + 1 ] 
) {
+
+                               n[ i + 1 ] = {
+                                       text: n[ i + 1 ],
+                                       row: n[i].row + 1
+                               };
+                               o[ n[i].row + 1 ] = {
+                                       text: o[ n[i].row + 1 ],
+                                       row: i + 1
+                               };
+                       }
+               }
+
+               for ( i = n.length - 1; i > 0; i-- ) {
+                       if ( n[i].text != null && n[ i - 1 ].text == null && 
n[i].row > 0 && o[ n[i].row - 1 ].text == null &&
+                                               n[ i - 1 ] == o[ n[i].row - 1 
]) {
+
+                               n[ i - 1 ] = {
+                                       text: n[ i - 1 ],
+                                       row: n[i].row - 1
+                               };
+                               o[ n[i].row - 1 ] = {
+                                       text: o[ n[i].row - 1 ],
+                                       row: i - 1
+                               };
+                       }
+               }
+
+               return {
+                       o: o,
+                       n: n
+               };
+       }
+
+       return function( o, n ) {
+               o = o.replace( /\s+$/, "" );
+               n = n.replace( /\s+$/, "" );
+
+               var i, pre,
+                       str = "",
+                       out = diff( o === "" ? [] : o.split(/\s+/), n === "" ? 
[] : n.split(/\s+/) ),
+                       oSpace = o.match(/\s+/g),
+                       nSpace = n.match(/\s+/g);
+
+               if ( oSpace == null ) {
+                       oSpace = [ " " ];
+               }
+               else {
+                       oSpace.push( " " );
+               }
+
+               if ( nSpace == null ) {
+                       nSpace = [ " " ];
+               }
+               else {
+                       nSpace.push( " " );
+               }
+
+               if ( out.n.length === 0 ) {
+                       for ( i = 0; i < out.o.length; i++ ) {
+                               str += "<del>" + out.o[i] + oSpace[i] + 
"</del>";
+                       }
+               }
+               else {
+                       if ( out.n[0].text == null ) {
+                               for ( n = 0; n < out.o.length && out.o[n].text 
== null; n++ ) {
+                                       str += "<del>" + out.o[n] + oSpace[n] + 
"</del>";
+                               }
+                       }
+
+                       for ( i = 0; i < out.n.length; i++ ) {
+                               if (out.n[i].text == null) {
+                                       str += "<ins>" + out.n[i] + nSpace[i] + 
"</ins>";
+                               }
+                               else {
+                                       // `pre` initialized at top of scope
+                                       pre = "";
+
+                                       for ( n = out.n[i].row + 1; n < 
out.o.length && out.o[n].text == null; n++ ) {
+                                               pre += "<del>" + out.o[n] + 
oSpace[n] + "</del>";
+                                       }
+                                       str += " " + out.n[i].text + nSpace[i] 
+ pre;
+                               }
+                       }
+               }
+
+               return str;
+       };
+}());
+
+// for CommonJS enviroments, export everything
+if ( typeof exports !== "undefined" ) {
+       extend(exports, QUnit);
+}
+
+// get at whatever the global object is, like window in browsers
+}( (function() {return this;}.call()) ));

http://git-wip-us.apache.org/repos/asf/james-site/blob/38b1b837/content/development-bundle/grunt.js
----------------------------------------------------------------------
diff --git a/content/development-bundle/grunt.js 
b/content/development-bundle/grunt.js
new file mode 100644
index 0000000..96b53fe
--- /dev/null
+++ b/content/development-bundle/grunt.js
@@ -0,0 +1,348 @@
+module.exports = function( grunt ) {
+
+"use strict";
+
+var
+       // files
+       coreFiles = [
+               "jquery.ui.core.js",
+               "jquery.ui.widget.js",
+               "jquery.ui.mouse.js",
+               "jquery.ui.draggable.js",
+               "jquery.ui.droppable.js",
+               "jquery.ui.resizable.js",
+               "jquery.ui.selectable.js",
+               "jquery.ui.sortable.js",
+               "jquery.ui.effect.js"
+       ],
+
+       uiFiles = coreFiles.map(function( file ) {
+               return "ui/" + file;
+       }).concat( grunt.file.expandFiles( "ui/*.js" ).filter(function( file ) {
+               return coreFiles.indexOf( file.substring(3) ) === -1;
+       })),
+
+       allI18nFiles = grunt.file.expandFiles( "ui/i18n/*.js" ),
+
+       cssFiles = [
+               "core",
+               "accordion",
+               "autocomplete",
+               "button",
+               "datepicker",
+               "dialog",
+               "menu",
+               "progressbar",
+               "resizable",
+               "selectable",
+               "slider",
+               "spinner",
+               "tabs",
+               "tooltip",
+               "theme"
+       ].map(function( component ) {
+               return "themes/base/jquery.ui." + component + ".css";
+       }),
+
+       // minified files
+       minify = {
+               "dist/jquery-ui.min.js": [ "<banner:meta.bannerAll>", 
"dist/jquery-ui.js" ],
+               "dist/i18n/jquery-ui-i18n.min.js": [ 
"<banner:meta.bannerI18n>", "dist/i18n/jquery-ui-i18n.js" ]
+       },
+
+       minifyCSS = {
+               "dist/jquery-ui.min.css": "dist/jquery-ui.css"
+       },
+
+       compareFiles = {
+               all: [
+                       "dist/jquery-ui.js",
+                       "dist/jquery-ui.min.js"
+               ]
+       };
+
+function mapMinFile( file ) {
+       return "dist/" + file.replace( /\.js$/, ".min.js" ).replace( /ui\//, 
"minified/" );
+}
+
+uiFiles.concat( allI18nFiles ).forEach(function( file ) {
+       minify[ mapMinFile( file ) ] = [ "<banner>", file ];
+});
+
+cssFiles.forEach(function( file ) {
+       minifyCSS[ "dist/" + file.replace( /\.css$/, ".min.css" ).replace( 
/themes\/base\//, "themes/base/minified/" ) ] = [ "<banner>", 
"<strip_all_banners:" + file + ">" ];
+});
+
+uiFiles.forEach(function( file ) {
+       compareFiles[ file ] = [ file,  mapMinFile( file ) ];
+});
+
+// grunt plugins
+grunt.loadNpmTasks( "grunt-css" );
+grunt.loadNpmTasks( "grunt-html" );
+grunt.loadNpmTasks( "grunt-compare-size" );
+grunt.loadNpmTasks( "grunt-junit" );
+grunt.loadNpmTasks( "grunt-git-authors" );
+// local testswarm and build tasks
+grunt.loadTasks( "build/tasks" );
+
+grunt.registerHelper( "strip_all_banners", function( filepath ) {
+       return grunt.file.read( filepath ).replace( /^\s*\/\*[\s\S]*?\*\/\s*/g, 
"" );
+});
+
+function stripBanner( files ) {
+       return files.map(function( file ) {
+               return "<strip_all_banners:" + file + ">";
+       });
+}
+
+function stripDirectory( file ) {
+       // TODO: we're receiving the directive, so we need to strip the 
trailing >
+       // we should be receving a clean path without the directive
+       return file.replace( /.+\/(.+?)>?$/, "$1" );
+}
+// allow access from banner template
+global.stripDirectory = stripDirectory;
+
+function createBanner( files ) {
+       // strip folders
+       var fileNames = files && files.map( stripDirectory );
+       return "/*! <%= pkg.title || pkg.name %> - v<%= pkg.version %> - " +
+               "<%= grunt.template.today('isoDate') %>\n" +
+               "<%= pkg.homepage ? '* ' + pkg.homepage + '\n' : '' %>" +
+               "* Includes: " + (files ? fileNames.join(", ") : "<%= 
stripDirectory(grunt.task.current.file.src[1]) %>") + "\n" +
+               "* Copyright <%= grunt.template.today('yyyy') %> <%= 
pkg.author.name %>;" +
+               " Licensed <%= _.pluck(pkg.licenses, 'type').join(', ') %> */";
+}
+
+grunt.initConfig({
+       pkg: "<json:package.json>",
+       files: {
+               dist: "<%= pkg.name %>-<%= pkg.version %>",
+               cdn: "<%= pkg.name %>-<%= pkg.version %>-cdn",
+               themes: "<%= pkg.name %>-themes-<%= pkg.version %>"
+       },
+       meta: {
+               banner: createBanner(),
+               bannerAll: createBanner( uiFiles ),
+               bannerI18n: createBanner( allI18nFiles ),
+               bannerCSS: createBanner( cssFiles )
+       },
+       compare_size: compareFiles,
+       concat: {
+               ui: {
+                       src: [ "<banner:meta.bannerAll>", stripBanner( uiFiles 
) ],
+                       dest: "dist/jquery-ui.js"
+               },
+               i18n: {
+                       src: [ "<banner:meta.bannerI18n>", allI18nFiles ],
+                       dest: "dist/i18n/jquery-ui-i18n.js"
+               },
+               css: {
+                       src: [ "<banner:meta.bannerCSS>", stripBanner( cssFiles 
) ],
+                       dest: "dist/jquery-ui.css"
+               }
+       },
+       min: minify,
+       cssmin: minifyCSS,
+       htmllint: {
+               // ignore files that contain invalid html, used only for ajax 
content testing
+               all: grunt.file.expand( [ "demos/**/*.html", "tests/**/*.html" 
] ).filter(function( file ) {
+                       return 
!/(?:ajax\/content\d\.html|tabs\/data\/test\.html|tests\/unit\/core\/core\.html)/.test(
 file );
+               })
+       },
+       copy: {
+               dist: {
+                       src: [
+                               "AUTHORS.txt",
+                               "jquery-*.js",
+                               "MIT-LICENSE.txt",
+                               "README.md",
+                               "grunt.js",
+                               "package.json",
+                               "*.jquery.json",
+                               "ui/**/*",
+                               "ui/.jshintrc",
+                               "demos/**/*",
+                               "themes/**/*",
+                               "external/**/*",
+                               "tests/**/*"
+                       ],
+                       renames: {
+                               "dist/jquery-ui.js": "ui/jquery-ui.js",
+                               "dist/jquery-ui.min.js": 
"ui/minified/jquery-ui.min.js",
+                               "dist/i18n/jquery-ui-i18n.js": 
"ui/i18n/jquery-ui-i18n.js",
+                               "dist/i18n/jquery-ui-i18n.min.js": 
"ui/minified/i18n/jquery-ui-i18n.min.js",
+                               "dist/jquery-ui.css": 
"themes/base/jquery-ui.css",
+                               "dist/jquery-ui.min.css": 
"themes/base/minified/jquery-ui.min.css"
+                       },
+                       dest: "dist/<%= files.dist %>"
+               },
+               dist_min: {
+                       src: "dist/minified/**/*",
+                       strip: /^dist/,
+                       dest: "dist/<%= files.dist %>/ui"
+               },
+               dist_css_min: {
+                       src: "dist/themes/base/minified/*.css",
+                       strip: /^dist/,
+                       dest: "dist/<%= files.dist %>"
+               },
+               dist_units_images: {
+                       src: "themes/base/images/*",
+                       strip: /^themes\/base\//,
+                       dest: "dist/"
+               },
+               dist_min_images: {
+                       src: "themes/base/images/*",
+                       strip: /^themes\/base\//,
+                       dest: "dist/<%= files.dist %>/themes/base/minified"
+               },
+               cdn: {
+                       src: [
+                               "AUTHORS.txt",
+                               "MIT-LICENSE.txt",
+                               "ui/*.js",
+                               "package.json"
+                       ],
+                       renames: {
+                               "dist/jquery-ui.js": "jquery-ui.js",
+                               "dist/jquery-ui.min.js": "jquery-ui.min.js",
+                               "dist/i18n/jquery-ui-i18n.js": 
"i18n/jquery-ui-i18n.js",
+                               "dist/i18n/jquery-ui-i18n.min.js": 
"i18n/jquery-ui-i18n.min.js",
+                               "dist/jquery-ui.css": 
"themes/base/jquery-ui.css",
+                               "dist/jquery-ui.min.css": 
"themes/base/minified/jquery-ui.min.css"
+                       },
+                       dest: "dist/<%= files.cdn %>"
+               },
+               cdn_i18n: {
+                       src: "ui/i18n/jquery.ui.datepicker-*.js",
+                       strip: "ui/",
+                       dest: "dist/<%= files.cdn %>"
+               },
+               cdn_i18n_min: {
+                       src: "dist/minified/i18n/jquery.ui.datepicker-*.js",
+                       strip: "dist/minified",
+                       dest: "dist/<%= files.cdn %>"
+               },
+               cdn_min: {
+                       src: "dist/minified/*.js",
+                       strip: /^dist\/minified/,
+                       dest: "dist/<%= files.cdn %>/ui"
+               },
+               cdn_min_images: {
+                       src: "themes/base/images/*",
+                       strip: /^themes\/base\//,
+                       dest: "dist/<%= files.cdn %>/themes/base/minified"
+               },
+               cdn_themes: {
+                       src: "dist/<%= files.themes %>/themes/**/*",
+                       strip: "dist/<%= files.themes %>",
+                       dest: "dist/<%= files.cdn %>"
+               },
+               themes: {
+                       src: [
+                               "AUTHORS.txt",
+                               "MIT-LICENSE.txt",
+                               "package.json"
+                       ],
+                       dest: "dist/<%= files.themes %>"
+               }
+       },
+       zip: {
+               dist: {
+                       src: "<%= files.dist %>",
+                       dest: "<%= files.dist %>.zip"
+               },
+               cdn: {
+                       src: "<%= files.cdn %>",
+                       dest: "<%= files.cdn %>.zip"
+               },
+               themes: {
+                       src: "<%= files.themes %>",
+                       dest: "<%= files.themes %>.zip"
+               }
+       },
+       md5: {
+               dist: {
+                       src: "dist/<%= files.dist %>",
+                       dest: "dist/<%= files.dist %>/MANIFEST"
+               },
+               cdn: {
+                       src: "dist/<%= files.cdn %>",
+                       dest: "dist/<%= files.cdn %>/MANIFEST"
+               },
+               themes: {
+                       src: "dist/<%= files.themes %>",
+                       dest: "dist/<%= files.themes %>/MANIFEST"
+               }
+       },
+       qunit: {
+               files: grunt.file.expandFiles( "tests/unit/**/*.html" 
).filter(function( file ) {
+                       // disabling everything that doesn't (quite) work with 
PhantomJS for now
+                       // TODO except for all|index|test, try to include more 
as we go
+                       return !( 
/(all|all-active|index|test|draggable|droppable|selectable|resizable|sortable|dialog|slider|datepicker|tabs|tabs_deprecated|tooltip)\.html$/
 ).test( file );
+               })
+       },
+       lint: {
+               ui: grunt.file.expandFiles( "ui/*.js" ).filter(function( file ) 
{
+                       // TODO remove items from this list once rewritten
+                       return !( 
/(mouse|datepicker|draggable|droppable|resizable|selectable|sortable)\.js$/ 
).test( file );
+               }),
+               grunt: [ "grunt.js", "build/**/*.js" ],
+               tests: "tests/unit/**/*.js"
+       },
+       csslint: {
+               // nothing: []
+               // TODO figure out what to check for, then fix and enable
+               base_theme: {
+                       src: grunt.file.expandFiles( "themes/base/*.css" 
).filter(function( file ) {
+                               // TODO remove items from this list once 
rewritten
+                               return !( 
/(button|datepicker|core|dialog|theme)\.css$/ ).test( file );
+                       }),
+                       // TODO consider reenabling some of these rules
+                       rules: {
+                               "import": false,
+                               "important": false,
+                               "outline-none": false,
+                               // especially this one
+                               "overqualified-elements": false,
+                               "compatible-vendor-prefixes": false
+                       }
+               }
+       },
+       jshint: (function() {
+               function parserc( path ) {
+                       var rc = grunt.file.readJSON( (path || "") + 
".jshintrc" ),
+                               settings = {
+                                       options: rc,
+                                       globals: {}
+                               };
+
+                       (rc.predef || []).forEach(function( prop ) {
+                               settings.globals[ prop ] = true;
+                       });
+                       delete rc.predef;
+
+                       return settings;
+               }
+
+               return {
+                       grunt: parserc(),
+                       ui: parserc( "ui/" ),
+                       // TODO: `evil: true` is only for document.write() 
https://github.com/jshint/jshint/issues/519
+                       // TODO: don't create so many globals in tests
+                       tests: parserc( "tests/" )
+               };
+       })()
+});
+
+grunt.registerTask( "default", "lint csslint htmllint qunit" );
+grunt.registerTask( "sizer", "concat:ui min:dist/jquery-ui.min.js 
compare_size:all" );
+grunt.registerTask( "sizer_all", "concat:ui min compare_size" );
+grunt.registerTask( "build", "concat min cssmin copy:dist_units_images" );
+grunt.registerTask( "release", "clean build copy:dist copy:dist_min 
copy:dist_min_images copy:dist_css_min md5:dist zip:dist" );
+grunt.registerTask( "release_themes", "release generate_themes copy:themes 
md5:themes zip:themes" );
+grunt.registerTask( "release_cdn", "release_themes copy:cdn copy:cdn_min 
copy:cdn_i18n copy:cdn_i18n_min copy:cdn_min_images copy:cdn_themes md5:cdn 
zip:cdn" );
+
+};


---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscr...@james.apache.org
For additional commands, e-mail: server-dev-h...@james.apache.org

Reply via email to