├── .gitignore
├── .jshintrc
├── CONTRIBUTING.md
├── Gruntfile.js
├── LICENSE-MIT
├── README.md
├── demo.html
├── dist
    ├── textbox-revision-tracker.js
    └── textbox-revision-tracker.min.js
├── libs
    ├── diff.js
    ├── jquery-loader.js
    ├── jquery
    │   └── jquery.js
    └── qunit
    │   ├── qunit.css
    │   └── qunit.js
├── package.json
├── src
    ├── .jshintrc
    └── textbox-revision-tracker.js
├── test
    ├── .jshintrc
    ├── textbox-revision-tracker.html
    └── textbox-revision-tracker_test.js
└── textbox-revision-tracker.jquery.json


/.gitignore:
--------------------------------------------------------------------------------
1 | /node_modules/
2 | 


--------------------------------------------------------------------------------
/.jshintrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "curly": true,
 3 |   "eqeqeq": true,
 4 |   "immed": true,
 5 |   "latedef": true,
 6 |   "newcap": true,
 7 |   "noarg": true,
 8 |   "sub": true,
 9 |   "undef": true,
10 |   "unused": true,
11 |   "boss": true,
12 |   "eqnull": true,
13 |   "node": true
14 | }
15 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contributing
 2 | 
 3 | ## Important notes
 4 | Please don't edit files in the `dist` subdirectory as they are generated via Grunt. You'll find source code in the `src` subdirectory!
 5 | 
 6 | ### Code style
 7 | Regarding code style like indentation and whitespace, **follow the conventions you see used in the source already.**
 8 | 
 9 | ### PhantomJS
10 | While Grunt can run the included unit tests via [PhantomJS](http://phantomjs.org/), this shouldn't be considered a substitute for the real thing. Please be sure to test the `test/*.html` unit test file(s) in _actual_ browsers.
11 | 
12 | ## Modifying the code
13 | First, ensure that you have the latest [Node.js](http://nodejs.org/) and [npm](http://npmjs.org/) installed.
14 | 
15 | Test that Grunt's CLI is installed by running `grunt --version`.  If the command isn't found, run `npm install -g grunt-cli`.  For more information about installing Grunt, see the [getting started guide](http://gruntjs.com/getting-started).
16 | 
17 | 1. Fork and clone the repo.
18 | 1. Run `npm install` to install all dependencies (including Grunt).
19 | 1. Run `grunt` to grunt this project.
20 | 
21 | Assuming that you don't see any red, you're ready to go. Just be sure to run `grunt` after making any changes, to ensure that nothing is broken.
22 | 
23 | ## Submitting pull requests
24 | 
25 | 1. Create a new branch, please don't work in your `master` branch directly.
26 | 1. Add failing tests for the change you want to make. Run `grunt` to see the tests fail.
27 | 1. Fix stuff.
28 | 1. Run `grunt` to see if the tests pass. Repeat steps 2-4 until done.
29 | 1. Open `test/*.html` unit test file(s) in actual browser to ensure tests pass everywhere.
30 | 1. Update the documentation to reflect any changes.
31 | 1. Push to your fork and submit a pull request.
32 | 


--------------------------------------------------------------------------------
/Gruntfile.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | module.exports = function(grunt) {
 4 | 
 5 |   // Project configuration.
 6 |   grunt.initConfig({
 7 |     // Metadata.
 8 |     pkg: grunt.file.readJSON('textbox-revision-tracker.jquery.json'),
 9 |     banner: '/*! <%= pkg.title || pkg.name %> - v<%= pkg.version %> - ' +
10 |       '<%= grunt.template.today("yyyy-mm-dd") %>\n' +
11 |       '<%= pkg.homepage ? "* " + pkg.homepage + "\\n" : "" %>' +
12 |       '* Copyright (c) <%= grunt.template.today("yyyy") %> <%= pkg.author.name %>;' +
13 |       ' Licensed <%= _.pluck(pkg.licenses, "type").join(", ") %> */\n',
14 |     // Task configuration.
15 |     clean: {
16 |       files: ['dist']
17 |     },
18 |     concat: {
19 |       options: {
20 |         banner: '<%= banner %>',
21 |         stripBanners: true
22 |       },
23 |       dist: {
24 |         src: ['src/<%= pkg.name %>.js'],
25 |         dest: 'dist/<%= pkg.name %>.js'
26 |       },
27 |     },
28 |     uglify: {
29 |       options: {
30 |         banner: '<%= banner %>'
31 |       },
32 |       dist: {
33 |         src: '<%= concat.dist.dest %>',
34 |         dest: 'dist/<%= pkg.name %>.min.js'
35 |       },
36 |     },
37 |     qunit: {
38 |       files: ['test/**/*.html']
39 |     },
40 |     jshint: {
41 |       options: {
42 |         jshintrc: true
43 |       },
44 |       gruntfile: {
45 |         src: 'Gruntfile.js'
46 |       },
47 |       src: {
48 |         src: ['src/**/*.js']
49 |       },
50 |       test: {
51 |         src: ['test/**/*.js']
52 |       },
53 |     },
54 |     watch: {
55 |       gruntfile: {
56 |         files: '<%= jshint.gruntfile.src %>',
57 |         tasks: ['jshint:gruntfile']
58 |       },
59 |       src: {
60 |         files: '<%= jshint.src.src %>',
61 |         tasks: ['jshint:src', 'qunit']
62 |       },
63 |       test: {
64 |         files: '<%= jshint.test.src %>',
65 |         tasks: ['jshint:test', 'qunit']
66 |       },
67 |     },
68 |   });
69 | 
70 |   // These plugins provide necessary tasks.
71 |   grunt.loadNpmTasks('grunt-contrib-clean');
72 |   grunt.loadNpmTasks('grunt-contrib-concat');
73 |   grunt.loadNpmTasks('grunt-contrib-uglify');
74 |   grunt.loadNpmTasks('grunt-contrib-qunit');
75 |   grunt.loadNpmTasks('grunt-contrib-jshint');
76 |   grunt.loadNpmTasks('grunt-contrib-watch');
77 | 
78 |   // Default task.
79 |   grunt.registerTask('default', ['jshint', 'qunit', 'clean', 'concat', 'uglify']);
80 | 
81 | };
82 | 


--------------------------------------------------------------------------------
/LICENSE-MIT:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2015 Jon Bake
 2 | 
 3 | Permission is hereby granted, free of charge, to any person
 4 | obtaining a copy of this software and associated documentation
 5 | files (the "Software"), to deal in the Software without
 6 | restriction, including without limitation the rights to use,
 7 | copy, modify, merge, publish, distribute, sublicense, and/or sell
 8 | copies of the Software, and to permit persons to whom the
 9 | Software is furnished to do so, subject to the following
10 | conditions:
11 | 
12 | The above copyright notice and this permission notice shall be
13 | included in all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
17 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19 | HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Textbox Revision Tracker
 2 | 
 3 | A simple jQuery plugin to track text revisions to HTML inputs or text areas.  Revisions can be saved, undone, redone, diffed and fetched.  Revision data of text, time of revision and revision number are stored.
 4 | 
 5 | ## [Demo](http://jonmbake.github.io/textbox-revision-tracker/demo.html)
 6 | 
 7 | ## Getting Started
 8 | Download the [production version][min] or the [development version][max].
 9 | 
10 | [min]: https://raw.github.com/jonmbake/textbox-revision-tracker/master/dist/textbox-revision-tracker.min.js
11 | [max]: https://raw.github.com/jonmbake/textbox-revision-tracker/master/dist/textbox-revision-tracker.js
12 | 
13 | In your web page:
14 | 
15 | ```html
16 | <textarea id="ta"></textarea>
17 | 
18 | <script src="jquery.js"></script>
19 | <script src="dist/textbox-revision-tracker.min.js"></script>
20 | <!-- provide diff function if you want diff support, alternatively you supply your own diff function, which is passed as an option -->
21 | <script src="libs/diff.js"></script>
22 | 
23 | <script>
24 | //window.diffString provided by libs/diff.js
25 | $('textarea#ta').revisionTracker({diffFunction: window.diffString});
26 | </script>
27 | ```
28 | ## Initialization Options
29 | 
30 | Name         | Type        | Description
31 | ------------ | ----------- | -----------
32 | diffFunction | Function |Takes the text of two revisions and performs a diff.  This only needs to be provided if calling the `diff` method in the API.
33 | autoSave      | Number | If provided, will automatically create a revision after specified number seconds of paused typing
34 | 
35 | ## API
36 | 
37 | To call a method on an instantiated *RevisionTracker*, use the syntax `$('textarea').('methodName', arguments...);`.
38 | 
39 | ### Available Methods
40 | 
41 | Method             | Description                                                                                                    | Arguments
42 | ------------------ | ------------------------------- | ---------
43 | revisions          | List of all revisions.  Revisions are objects with *text*, *time* and *revisionNumber* properties. | *None*
44 | save               | Save the current text as a revsion. | *None*
45 | getRevision        | Get a particular revision. | *RevisionNumber*
46 | undo               | Undo last revision.         | *None*
47 | redo               | Redo last undone revision.  | *None*
48 | goToRevision       | Go to a particular revision. | *RevisionNumber*
49 | getDiff            | Get a diff of two revisions. | *RevisionNumber1*, *RevisionNumber2*
50 | 
51 | ## Example Usage
52 | 
53 | ```html
54 | //init
55 | $('textarea').revisionTracker();
56 | //type in some text
57 | $('textarea').val('foo');
58 | //save the text as a revision
59 | $('textarea').revisionTracker('save');
60 | $('textarea').revisionTracker('revisions');  //returns [{"text":"foo","time":1438307922004,"revisionNumber":1}]
61 | $('textarea').revisionTracker('undo');
62 | $('textarea').revisionTracker('revisions');  //returns []
63 | $('textarea').val() //return ""
64 | $('textarea').revisionTracker('redo');
65 | $('textarea').val() //return "foo"
66 | ```
67 | 
68 | ## Release History
69 | 0.1 - Initial Release
70 | 


--------------------------------------------------------------------------------
/demo.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | 
 3 | <html lang="en">
 4 | <head>
 5 | 	<meta charset="utf-8">
 6 | 
 7 | 	<title>Demo of Textbox Revision Tracker</title>
 8 | 	<meta name="description" content="A demo of the Textbox Revision Tracker, a jquery plugin that tracks text revision to an HTML input or textbox">
 9 | 	<meta name="author" content="Jon Bake">
10 | 
11 |   <!--[if lt IE 9]>
12 |   <script src="http://html5shiv.googlecode.com/svn/trunk/html5.js"></script>
13 |   <![endif]-->
14 |   <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css">
15 |   <style>
16 |   	.diff-ins {
17 |       	background-color: #eaffea;
18 |       }
19 |       .diff-del {
20 |       	background-color: #f8cbcb;
21 |       }
22 |   </style>
23 | </head>
24 | 
25 | <body>
26 | 	<div class="container">
27 | 		<h1>Textbox Revision Tracker</h1>
28 | 		<div class="form-group">
29 | 			<label for"ta">Text</label>
30 | 			<textarea class="form-control" id="ta"></textarea>
31 | 		</div>
32 | 		<button class="btn btn-primary" id="saveRevision">Save</button>
33 | 		<button class="btn" id="undo">Undo</button>
34 | 		<button class="btn" id="redo">Redo</button>
35 | 		<h2>Revision History</h2>
36 | 		<table class="table">
37 | 			<thead>
38 | 				<th>Revision Number</th>
39 | 				<th>Time of Revision</th>
40 | 				<th>Diff from Previous Version</th>
41 | 				<th>Revert to revision?</th>
42 | 			</thead>
43 | 			<tbody id="revs">
44 | 			</tbody>
45 | 		</table>
46 | 	</div>
47 | 
48 | 	<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js"></script>
49 | 	<script src="src/textbox-revision-tracker.js"></script>
50 | 	<script src="libs/diff.js"></script>
51 | 	<script>
52 | 		var $ta = $('textarea#ta');
53 | 		//convenience so we don't have to keep typing '$('textarea#ta').revisionTracker(...)'
54 | 		var rt = $ta.revisionTracker.bind($ta);
55 | 		//initialize revision tracker on textarea
56 | 		rt({diffFunction: window.diffString}).focus();
57 | 		/**
58 | 		 * Update the UI with the revision data.. not ideal, but hey it's a demo.
59 | 		 * @return {undefined}
60 | 		 */
61 | 		var updateRevsDisplay = function () {
62 | 			var $r = $('#revs');
63 | 			$r.empty();
64 | 			rt('revisions').reverse().forEach(function (rev) {
65 | 				var $tr = $('<tr/>');
66 | 				$tr.append($('<td/>').text(rev.revisionNumber));
67 | 				$tr.append($('<td/>').text(new Date(rev.time).toLocaleTimeString()));
68 | 				$tr.append($('<td></td').html(rt('getDiff', rev.revisionNumber - 1, rev.revisionNumber)));
69 | 				var $btn = $('<td><button class="btn btn-xs">Revert to Here</button></td>').on('click', function () {
70 | 					rt('goToRevision', rev.revisionNumber);
71 | 					updateRevsDisplay();
72 | 				});
73 | 				$tr.append($btn);
74 | 				$r.append($tr);
75 | 			});
76 | 		};
77 | 		//add on click handlers for buttons
78 | 		$('#saveRevision').on('click', function () {
79 | 			rt('save');
80 | 			$('#ta').focus();
81 | 			updateRevsDisplay();
82 | 		});
83 | 		$('#undo').on('click', function () {
84 | 			rt('undo');
85 | 			updateRevsDisplay();
86 | 		});
87 | 		$('#redo').on('click', function () {
88 | 			rt('redo');
89 | 			updateRevsDisplay();
90 | 		});
91 | 	</script>
92 | </body>
93 | </html>


--------------------------------------------------------------------------------
/dist/textbox-revision-tracker.js:
--------------------------------------------------------------------------------
  1 | /*! Textbox Revision Tracker - v0.1.0 - 2015-11-15
  2 | * https://github.com/jonmbake/textbox-revision-tracker
  3 | * Copyright (c) 2015 Jon Bake; Licensed MIT */
  4 | (function($) {
  5 |   /**
  6 |    * Revision Tracker Base Class.
  7 |    * @constructor
  8 |    * @param {[type]} $el     jqeury element to attach revision tracker to
  9 |    * @param {[type]} options options -
 10 |    * Valid Options are:
 11 |    *   autoSave (integer) - will automatically create a revision after X seconds of paused typing
 12 |    *   diffFunction (function) - function to call when  performing a diff through the API
 13 |    */
 14 |   var RevisionTracker = function ($el, options) {
 15 |     options = options || {};
 16 | 
 17 |     this.$el = $el;
 18 |     this.revisions = [];
 19 |     this.undoneRevisions = [];
 20 | 
 21 |     this.diffFunction = options.diffFunction;
 22 |     if (options.autoSave) {
 23 |       var lastChange, saveAfter = parseInt(options.autoSave, 10);
 24 |       $el.on('change', function () {
 25 |         var now = Date.now();
 26 |         this.saveRevision((now - lastChange)/1000 > saveAfter);
 27 |         lastChange = now;
 28 |       }.bind(this));
 29 |     }
 30 |   };
 31 |   $.extend(RevisionTracker.prototype, {
 32 |     /**
 33 |      * Saves a revision if predicate passes truth test.
 34 |      *
 35 |      * @param  {Boolean} predicate - only save if predicate evaluates to true (or is undefined)
 36 |      * @return {Object} Revison with property of text and time
 37 |      */
 38 |     saveRevision: function (predicate) {
 39 |       if (predicate === void 0 || predicate === true) {
 40 |         this.revisions.push({text: this.$el.val(), time: Date.now()});
 41 |       }
 42 |     },
 43 |     /**
 44 |      * Get last revision made.
 45 |      * @return {Object} Revison with property of text and time
 46 |      */
 47 |     lastRevision: function () {
 48 |       return this.revisions[this.revisions.length - 1];
 49 |     },
 50 |     /**
 51 |      * Pop a revision from revisions to undone revisions (or vice versa if reverse is true).
 52 |      *
 53 |      * @param  {boolean} reverse if true pop from undone revisions to revisions
 54 |      * @param  {number} popTo   pop to a specific revisions
 55 |      * @return {Object} poped revison
 56 |      */
 57 |     popRevision: function (reverse, popTo) {
 58 |       var popped,
 59 |         fromArray = reverse ? this.undoneRevisions : this.revisions;
 60 |       if (fromArray.length === 0) {
 61 |         return;
 62 |       }
 63 |       if (popTo) {
 64 |         popped = fromArray.splice(popTo)[0];
 65 |       } else {
 66 |         popped = fromArray.pop();
 67 |       }
 68 |       (reverse ? this.revisions : this.undoneRevisions).push(popped);
 69 |       if (this.revisions.length > 0) {
 70 |         this.$el.val(this.lastRevision().text);
 71 |       } else {
 72 |         this.$el.val('');
 73 |       }
 74 |       return popped;
 75 |     },
 76 |     /**
 77 |      * Get a particular revision.
 78 |      *
 79 |      * @param  {number} revisionNumber number of revision to get
 80 |      * @return {Object} Revison with property of text and time
 81 |      */
 82 |     getRevision: function (revisionNumber) {
 83 |       return this.revisions[parseInt(revisionNumber, 10) - 1];
 84 |     },
 85 |     /**
 86 |      * Go to a revision number.
 87 |      *
 88 |      * @param  {number} revisionNumber revision number to make active
 89 |      * @return {Object} newly active revision
 90 |      */
 91 |     goToRevision: function (revisionNumber) {
 92 |       revisionNumber = parseInt(revisionNumber, 10);
 93 |       if (revisionNumber < 0 || revisionNumber > this.revisions.length) {
 94 |         throw new Error('Attempting to go to an invalid revision number');
 95 |       }
 96 |       return this.popRevision(false, revisionNumber);
 97 |     },
 98 |     /**
 99 |      * Undo the last revision.
100 |      *
101 |      * @return {object} undone revision
102 |      */
103 |     undo: function () {
104 |       return this.popRevision();
105 |     },
106 |     /**
107 |      * Redo a revision.
108 |      *
109 |      * @return {object} revision that was re-applied
110 |      */
111 |     redo: function () {
112 |       return this.popRevision(true);
113 |     },
114 |     /**
115 |      * Diff two revisions.
116 |      *
117 |      * @param  {number} firstRevNumber  first revision
118 |      * @param  {number} secondRevNumber second revision
119 |      * @return {string}                 diff of first and second revision
120 |      */
121 |     diff: function (firstRevNumber, secondRevNumber) {
122 |       if (!this.diffFunction) {
123 |         throw new Error('In order to use RevisionTracker#diff, a diffFunction must be supplied as an option');
124 |       }
125 |       var first = this.getRevision(firstRevNumber) || {text: ''},
126 |         second = this.getRevision(secondRevNumber);
127 |       if (second) {
128 |         return this.diffFunction(first.text, second.text);
129 |       }
130 |     }
131 |   });
132 |   /**
133 |    * Returns revision track data for element.
134 |    *
135 |    * @return {RevisionTracker} revision tracker obj.
136 |    */
137 |   var getData = function ($el) {
138 |     var rt = $el.data('revisionTracker');
139 |     if (!rt) {
140 |       throw new Error('Element is currently not tracking revisions');
141 |     }
142 |     return rt;
143 |   };
144 |   /**
145 |    * Public API.
146 |    *
147 |    * @type {Object} api
148 |    */
149 |   var api = {
150 |     /**
151 |      * Inititialize this element to track revisions.
152 |      *
153 |      * @param  {Object} options revision
154 |      * @return {[type]}         [description]
155 |      */
156 |     init: function (options) {
157 |       var rt = new RevisionTracker(this, options);
158 |       this.data('revisionTracker', rt);
159 |       return this;
160 |     },
161 |     /**
162 |      * Get revisions for an element.
163 |      *
164 |      * @param  {jQuery element} $el element to get revisions for
165 |      * @return {Array} revision history
166 |      */
167 |     revisions: function () {
168 |       //also include revision number
169 |       return getData(this).revisions.map(function (val, index) {
170 |         val.revisionNumber = index + 1;
171 |         return val;
172 |       });
173 |     },
174 |     /**
175 |      * @see {@link RevisionTracker.prototype.saveRevision}
176 |      */
177 |     save: function () {
178 |       //can bypass saving if last revision is the same
179 |       var d = getData(this);
180 |       var lastRev = d.lastRevision();
181 |       if (lastRev && lastRev.text === this.val()) {
182 |         return lastRev;
183 |       }
184 |       return getData(this).saveRevision();
185 |     },
186 |     /**
187 |      * @see {@link RevisionTracker.prototype.getRevision}
188 |      */
189 |     getRevision: function (revisionNumber) {
190 |       return getData(this).getRevision(revisionNumber);
191 |     },
192 |     /**
193 |      * @see {@link RevisionTracker.prototype.undo}
194 |      */
195 |     undo: function () {
196 |        return getData(this).undo();
197 |     },
198 |     /**
199 |      * @see {@link RevisionTracker.prototype.redo}
200 |      */
201 |     redo: function () {
202 |        return getData(this).redo();
203 |     },
204 |     /**
205 |      * @see {@link RevisionTracker.prototype.goToRevision}
206 |      */
207 |     goToRevision: function (revisionNumber) {
208 |        return getData(this).goToRevision(revisionNumber);
209 |     },
210 |     /**
211 |      * @see {@link RevisionTracker.prototype.diff}
212 |      */
213 |     getDiff: function (firstRevNumber, secondRevNumber) {
214 |       return getData(this).diff(firstRevNumber, secondRevNumber);
215 |     }
216 |   };	
217 |   //Expose the plugin!
218 |   $.fn.revisionTracker = function(firstArg) {
219 |     var pluginArgs = arguments;
220 |     var isApiCall = typeof firstArg === 'string';
221 |     var r = this.filter('textarea,input').map(function () {
222 |       if (firstArg === void 0 || typeof firstArg === 'object') { //calling the constructor
223 |         return api.init.call($(this), firstArg);
224 |       } else if (isApiCall && api[firstArg]) { //calling an API method
225 |         return api[firstArg].apply($(this), Array.prototype.slice.call(pluginArgs, 1));
226 |       } else { //calling a method that is not part of the API -- throw an error
227 |         throw new Error("Calling method that is not part of the API");
228 |       }
229 |     });
230 |     //if API call, "un-jquery" the return value 
231 |     if (isApiCall) {
232 |       //if a "get" call just return a single element
233 |       if (firstArg.indexOf('get') === 0) {
234 |         return r[0];
235 |       }
236 |       return r.toArray();
237 |     }
238 |     return r;
239 |   };
240 | }(jQuery));
241 | 


--------------------------------------------------------------------------------
/dist/textbox-revision-tracker.min.js:
--------------------------------------------------------------------------------
1 | /*! Textbox Revision Tracker - v0.1.0 - 2015-11-15
2 | * https://github.com/jonmbake/textbox-revision-tracker
3 | * Copyright (c) 2015 Jon Bake; Licensed MIT */
4 | !function(a){var b=function(a,b){if(b=b||{},this.$el=a,this.revisions=[],this.undoneRevisions=[],this.diffFunction=b.diffFunction,b.autoSave){var c,d=parseInt(b.autoSave,10);a.on("change",function(){var a=Date.now();this.saveRevision((a-c)/1e3>d),c=a}.bind(this))}};a.extend(b.prototype,{saveRevision:function(a){(void 0===a||a===!0)&&this.revisions.push({text:this.$el.val(),time:Date.now()})},lastRevision:function(){return this.revisions[this.revisions.length-1]},popRevision:function(a,b){var c,d=a?this.undoneRevisions:this.revisions;if(0!==d.length)return c=b?d.splice(b)[0]:d.pop(),(a?this.revisions:this.undoneRevisions).push(c),this.revisions.length>0?this.$el.val(this.lastRevision().text):this.$el.val(""),c},getRevision:function(a){return this.revisions[parseInt(a,10)-1]},goToRevision:function(a){if(a=parseInt(a,10),0>a||a>this.revisions.length)throw new Error("Attempting to go to an invalid revision number");return this.popRevision(!1,a)},undo:function(){return this.popRevision()},redo:function(){return this.popRevision(!0)},diff:function(a,b){if(!this.diffFunction)throw new Error("In order to use RevisionTracker#diff, a diffFunction must be supplied as an option");var c=this.getRevision(a)||{text:""},d=this.getRevision(b);return d?this.diffFunction(c.text,d.text):void 0}});var c=function(a){var b=a.data("revisionTracker");if(!b)throw new Error("Element is currently not tracking revisions");return b},d={init:function(a){var c=new b(this,a);return this.data("revisionTracker",c),this},revisions:function(){return c(this).revisions.map(function(a,b){return a.revisionNumber=b+1,a})},save:function(){var a=c(this),b=a.lastRevision();return b&&b.text===this.val()?b:c(this).saveRevision()},getRevision:function(a){return c(this).getRevision(a)},undo:function(){return c(this).undo()},redo:function(){return c(this).redo()},goToRevision:function(a){return c(this).goToRevision(a)},getDiff:function(a,b){return c(this).diff(a,b)}};a.fn.revisionTracker=function(b){var c=arguments,e="string"==typeof b,f=this.filter("textarea,input").map(function(){if(void 0===b||"object"==typeof b)return d.init.call(a(this),b);if(e&&d[b])return d[b].apply(a(this),Array.prototype.slice.call(c,1));throw new Error("Calling method that is not part of the API")});return e?0===b.indexOf("get")?f[0]:f.toArray():f}}(jQuery);


--------------------------------------------------------------------------------
/libs/diff.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Javascript Diff Algorithm
  3 |  *  By John Resig (http://ejohn.org/)
  4 |  *  Modified by Chu Alan "sprite"
  5 |  *
  6 |  * Released under the MIT license.
  7 |  *
  8 |  * More Info:
  9 |  *  http://ejohn.org/projects/javascript-diff-algorithm/
 10 |  */
 11 | (function (window) {
 12 |   function escape(s) {
 13 |       var n = s;
 14 |       n = n.replace(/&/g, "&amp;");
 15 |       n = n.replace(/</g, "&lt;");
 16 |       n = n.replace(/>/g, "&gt;");
 17 |       n = n.replace(/"/g, "&quot;");
 18 | 
 19 |       return n;
 20 |   }
 21 | 
 22 |   window.diffString = function ( o, n ) {
 23 |     o = o.replace(/\s+$/, '');
 24 |     n = n.replace(/\s+$/, '');
 25 | 
 26 |     var out = diff(o == "" ? [] : o.split(/\s+/), n == "" ? [] : n.split(/\s+/) );
 27 |     var str = "";
 28 | 
 29 |     var oSpace = o.match(/\s+/g);
 30 |     if (oSpace == null) {
 31 |       oSpace = ["\n"];
 32 |     } else {
 33 |       oSpace.push("\n");
 34 |     }
 35 |     var nSpace = n.match(/\s+/g);
 36 |     if (nSpace == null) {
 37 |       nSpace = ["\n"];
 38 |     } else {
 39 |       nSpace.push("\n");
 40 |     }
 41 | 
 42 |     if (out.n.length == 0) {
 43 |         for (var i = 0; i < out.o.length; i++) {
 44 |           str += '<span class="diff-del">' + escape(out.o[i]) + oSpace[i] + "</span>";
 45 |         }
 46 |     } else {
 47 |       if (out.n[0].text == null) {
 48 |         for (n = 0; n < out.o.length && out.o[n].text == null; n++) {
 49 |           str += '<span class="diff-del">' + escape(out.o[n]) + oSpace[n] + "</span>";
 50 |         }
 51 |       }
 52 | 
 53 |       for ( var i = 0; i < out.n.length; i++ ) {
 54 |         if (out.n[i].text == null) {
 55 |           str += '<span class="diff-ins">' + escape(out.n[i]) + nSpace[i] + "</span>";
 56 |         } else {
 57 |           var pre = "";
 58 | 
 59 |           for (n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++ ) {
 60 |             pre += '<span class="diff-del">' + escape(out.o[n]) + oSpace[n] + "</span>";
 61 |           }
 62 |           str += " " + out.n[i].text + nSpace[i] + pre;
 63 |         }
 64 |       }
 65 |     }
 66 |     
 67 |     return str;
 68 |   }
 69 | 
 70 |   function diff( o, n ) {
 71 |     var ns = new Object();
 72 |     var os = new Object();
 73 |     
 74 |     for ( var i = 0; i < n.length; i++ ) {
 75 |       if ( ns[ n[i] ] == null )
 76 |         ns[ n[i] ] = { rows: new Array(), o: null };
 77 |       ns[ n[i] ].rows.push( i );
 78 |     }
 79 |     
 80 |     for ( var i = 0; i < o.length; i++ ) {
 81 |       if ( os[ o[i] ] == null )
 82 |         os[ o[i] ] = { rows: new Array(), n: null };
 83 |       os[ o[i] ].rows.push( i );
 84 |     }
 85 |     
 86 |     for ( var i in ns ) {
 87 |       if ( ns[i].rows.length == 1 && typeof(os[i]) != "undefined" && os[i].rows.length == 1 ) {
 88 |         n[ ns[i].rows[0] ] = { text: n[ ns[i].rows[0] ], row: os[i].rows[0] };
 89 |         o[ os[i].rows[0] ] = { text: o[ os[i].rows[0] ], row: ns[i].rows[0] };
 90 |       }
 91 |     }
 92 |     
 93 |     for ( var i = 0; i < n.length - 1; i++ ) {
 94 |       if ( n[i].text != null && n[i+1].text == null && n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null && 
 95 |            n[i+1] == o[ n[i].row + 1 ] ) {
 96 |         n[i+1] = { text: n[i+1], row: n[i].row + 1 };
 97 |         o[n[i].row+1] = { text: o[n[i].row+1], row: i + 1 };
 98 |       }
 99 |     }
100 |     
101 |     for ( var i = n.length - 1; i > 0; i-- ) {
102 |       if ( n[i].text != null && n[i-1].text == null && n[i].row > 0 && o[ n[i].row - 1 ].text == null && 
103 |            n[i-1] == o[ n[i].row - 1 ] ) {
104 |         n[i-1] = { text: n[i-1], row: n[i].row - 1 };
105 |         o[n[i].row-1] = { text: o[n[i].row-1], row: i - 1 };
106 |       }
107 |     }
108 |     
109 |     return { o: o, n: n };
110 |   }
111 | }(window));
112 | 


--------------------------------------------------------------------------------
/libs/jquery-loader.js:
--------------------------------------------------------------------------------
 1 | (function() {
 2 |   // Default to the local version.
 3 |   var path = '../libs/jquery/jquery.js';
 4 |   // Get any jquery=___ param from the query string.
 5 |   var jqversion = location.search.match(/[?&]jquery=(.*?)(?=&|$)/);
 6 |   // If a version was specified, use that version from code.jquery.com.
 7 |   if (jqversion) {
 8 |     path = 'http://code.jquery.com/jquery-' + jqversion[1] + '.js';
 9 |   }
10 |   // This is the only time I'll ever use document.write, I promise!
11 |   document.write('<script src="' + path + '"></script>');
12 | }());
13 | 


--------------------------------------------------------------------------------
/libs/qunit/qunit.css:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * QUnit v1.11.0 - A JavaScript Unit Testing Framework
  3 |  *
  4 |  * http://qunitjs.com
  5 |  *
  6 |  * Copyright 2012 jQuery Foundation and other contributors
  7 |  * Released under the MIT license.
  8 |  * http://jquery.org/license
  9 |  */
 10 | 
 11 | /** Font Family and Sizes */
 12 | 
 13 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
 14 | 	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
 15 | }
 16 | 
 17 | #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
 18 | #qunit-tests { font-size: smaller; }
 19 | 
 20 | 
 21 | /** Resets */
 22 | 
 23 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
 24 | 	margin: 0;
 25 | 	padding: 0;
 26 | }
 27 | 
 28 | 
 29 | /** Header */
 30 | 
 31 | #qunit-header {
 32 | 	padding: 0.5em 0 0.5em 1em;
 33 | 
 34 | 	color: #8699a4;
 35 | 	background-color: #0d3349;
 36 | 
 37 | 	font-size: 1.5em;
 38 | 	line-height: 1em;
 39 | 	font-weight: normal;
 40 | 
 41 | 	border-radius: 5px 5px 0 0;
 42 | 	-moz-border-radius: 5px 5px 0 0;
 43 | 	-webkit-border-top-right-radius: 5px;
 44 | 	-webkit-border-top-left-radius: 5px;
 45 | }
 46 | 
 47 | #qunit-header a {
 48 | 	text-decoration: none;
 49 | 	color: #c2ccd1;
 50 | }
 51 | 
 52 | #qunit-header a:hover,
 53 | #qunit-header a:focus {
 54 | 	color: #fff;
 55 | }
 56 | 
 57 | #qunit-testrunner-toolbar label {
 58 | 	display: inline-block;
 59 | 	padding: 0 .5em 0 .1em;
 60 | }
 61 | 
 62 | #qunit-banner {
 63 | 	height: 5px;
 64 | }
 65 | 
 66 | #qunit-testrunner-toolbar {
 67 | 	padding: 0.5em 0 0.5em 2em;
 68 | 	color: #5E740B;
 69 | 	background-color: #eee;
 70 | 	overflow: hidden;
 71 | }
 72 | 
 73 | #qunit-userAgent {
 74 | 	padding: 0.5em 0 0.5em 2.5em;
 75 | 	background-color: #2b81af;
 76 | 	color: #fff;
 77 | 	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
 78 | }
 79 | 
 80 | #qunit-modulefilter-container {
 81 | 	float: right;
 82 | }
 83 | 
 84 | /** Tests: Pass/Fail */
 85 | 
 86 | #qunit-tests {
 87 | 	list-style-position: inside;
 88 | }
 89 | 
 90 | #qunit-tests li {
 91 | 	padding: 0.4em 0.5em 0.4em 2.5em;
 92 | 	border-bottom: 1px solid #fff;
 93 | 	list-style-position: inside;
 94 | }
 95 | 
 96 | #qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
 97 | 	display: none;
 98 | }
 99 | 
100 | #qunit-tests li strong {
101 | 	cursor: pointer;
102 | }
103 | 
104 | #qunit-tests li a {
105 | 	padding: 0.5em;
106 | 	color: #c2ccd1;
107 | 	text-decoration: none;
108 | }
109 | #qunit-tests li a:hover,
110 | #qunit-tests li a:focus {
111 | 	color: #000;
112 | }
113 | 
114 | #qunit-tests li .runtime {
115 | 	float: right;
116 | 	font-size: smaller;
117 | }
118 | 
119 | .qunit-assert-list {
120 | 	margin-top: 0.5em;
121 | 	padding: 0.5em;
122 | 
123 | 	background-color: #fff;
124 | 
125 | 	border-radius: 5px;
126 | 	-moz-border-radius: 5px;
127 | 	-webkit-border-radius: 5px;
128 | }
129 | 
130 | .qunit-collapsed {
131 | 	display: none;
132 | }
133 | 
134 | #qunit-tests table {
135 | 	border-collapse: collapse;
136 | 	margin-top: .2em;
137 | }
138 | 
139 | #qunit-tests th {
140 | 	text-align: right;
141 | 	vertical-align: top;
142 | 	padding: 0 .5em 0 0;
143 | }
144 | 
145 | #qunit-tests td {
146 | 	vertical-align: top;
147 | }
148 | 
149 | #qunit-tests pre {
150 | 	margin: 0;
151 | 	white-space: pre-wrap;
152 | 	word-wrap: break-word;
153 | }
154 | 
155 | #qunit-tests del {
156 | 	background-color: #e0f2be;
157 | 	color: #374e0c;
158 | 	text-decoration: none;
159 | }
160 | 
161 | #qunit-tests ins {
162 | 	background-color: #ffcaca;
163 | 	color: #500;
164 | 	text-decoration: none;
165 | }
166 | 
167 | /*** Test Counts */
168 | 
169 | #qunit-tests b.counts                       { color: black; }
170 | #qunit-tests b.passed                       { color: #5E740B; }
171 | #qunit-tests b.failed                       { color: #710909; }
172 | 
173 | #qunit-tests li li {
174 | 	padding: 5px;
175 | 	background-color: #fff;
176 | 	border-bottom: none;
177 | 	list-style-position: inside;
178 | }
179 | 
180 | /*** Passing Styles */
181 | 
182 | #qunit-tests li li.pass {
183 | 	color: #3c510c;
184 | 	background-color: #fff;
185 | 	border-left: 10px solid #C6E746;
186 | }
187 | 
188 | #qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
189 | #qunit-tests .pass .test-name               { color: #366097; }
190 | 
191 | #qunit-tests .pass .test-actual,
192 | #qunit-tests .pass .test-expected           { color: #999999; }
193 | 
194 | #qunit-banner.qunit-pass                    { background-color: #C6E746; }
195 | 
196 | /*** Failing Styles */
197 | 
198 | #qunit-tests li li.fail {
199 | 	color: #710909;
200 | 	background-color: #fff;
201 | 	border-left: 10px solid #EE5757;
202 | 	white-space: pre;
203 | }
204 | 
205 | #qunit-tests > li:last-child {
206 | 	border-radius: 0 0 5px 5px;
207 | 	-moz-border-radius: 0 0 5px 5px;
208 | 	-webkit-border-bottom-right-radius: 5px;
209 | 	-webkit-border-bottom-left-radius: 5px;
210 | }
211 | 
212 | #qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
213 | #qunit-tests .fail .test-name,
214 | #qunit-tests .fail .module-name             { color: #000000; }
215 | 
216 | #qunit-tests .fail .test-actual             { color: #EE5757; }
217 | #qunit-tests .fail .test-expected           { color: green;   }
218 | 
219 | #qunit-banner.qunit-fail                    { background-color: #EE5757; }
220 | 
221 | 
222 | /** Result */
223 | 
224 | #qunit-testresult {
225 | 	padding: 0.5em 0.5em 0.5em 2.5em;
226 | 
227 | 	color: #2b81af;
228 | 	background-color: #D2E0E6;
229 | 
230 | 	border-bottom: 1px solid white;
231 | }
232 | #qunit-testresult .module-name {
233 | 	font-weight: bold;
234 | }
235 | 
236 | /** Fixture */
237 | 
238 | #qunit-fixture {
239 | 	position: absolute;
240 | 	top: -10000px;
241 | 	left: -10000px;
242 | 	width: 1000px;
243 | 	height: 1000px;
244 | }
245 | 


--------------------------------------------------------------------------------
/libs/qunit/qunit.js:
--------------------------------------------------------------------------------
   1 | /**
   2 |  * QUnit v1.11.0 - A JavaScript Unit Testing Framework
   3 |  *
   4 |  * http://qunitjs.com
   5 |  *
   6 |  * Copyright 2012 jQuery Foundation and other contributors
   7 |  * Released under the MIT license.
   8 |  * http://jquery.org/license
   9 |  */
  10 | 
  11 | (function( window ) {
  12 | 
  13 | var QUnit,
  14 | 	assert,
  15 | 	config,
  16 | 	onErrorFnPrev,
  17 | 	testId = 0,
  18 | 	fileName = (sourceFromStacktrace( 0 ) || "" ).replace(/(:\d+)+\)?/, "").replace(/.+\//, ""),
  19 | 	toString = Object.prototype.toString,
  20 | 	hasOwn = Object.prototype.hasOwnProperty,
  21 | 	// Keep a local reference to Date (GH-283)
  22 | 	Date = window.Date,
  23 | 	defined = {
  24 | 		setTimeout: typeof window.setTimeout !== "undefined",
  25 | 		sessionStorage: (function() {
  26 | 			var x = "qunit-test-string";
  27 | 			try {
  28 | 				sessionStorage.setItem( x, x );
  29 | 				sessionStorage.removeItem( x );
  30 | 				return true;
  31 | 			} catch( e ) {
  32 | 				return false;
  33 | 			}
  34 | 		}())
  35 | 	},
  36 | 	/**
  37 | 	 * Provides a normalized error string, correcting an issue
  38 | 	 * with IE 7 (and prior) where Error.prototype.toString is
  39 | 	 * not properly implemented
  40 | 	 *
  41 | 	 * Based on http://es5.github.com/#x15.11.4.4
  42 | 	 *
  43 | 	 * @param {String|Error} error
  44 | 	 * @return {String} error message
  45 | 	 */
  46 | 	errorString = function( error ) {
  47 | 		var name, message,
  48 | 			errorString = error.toString();
  49 | 		if ( errorString.substring( 0, 7 ) === "[object" ) {
  50 | 			name = error.name ? error.name.toString() : "Error";
  51 | 			message = error.message ? error.message.toString() : "";
  52 | 			if ( name && message ) {
  53 | 				return name + ": " + message;
  54 | 			} else if ( name ) {
  55 | 				return name;
  56 | 			} else if ( message ) {
  57 | 				return message;
  58 | 			} else {
  59 | 				return "Error";
  60 | 			}
  61 | 		} else {
  62 | 			return errorString;
  63 | 		}
  64 | 	},
  65 | 	/**
  66 | 	 * Makes a clone of an object using only Array or Object as base,
  67 | 	 * and copies over the own enumerable properties.
  68 | 	 *
  69 | 	 * @param {Object} obj
  70 | 	 * @return {Object} New object with only the own properties (recursively).
  71 | 	 */
  72 | 	objectValues = function( obj ) {
  73 | 		// Grunt 0.3.x uses an older version of jshint that still has jshint/jshint#392.
  74 | 		/*jshint newcap: false */
  75 | 		var key, val,
  76 | 			vals = QUnit.is( "array", obj ) ? [] : {};
  77 | 		for ( key in obj ) {
  78 | 			if ( hasOwn.call( obj, key ) ) {
  79 | 				val = obj[key];
  80 | 				vals[key] = val === Object(val) ? objectValues(val) : val;
  81 | 			}
  82 | 		}
  83 | 		return vals;
  84 | 	};
  85 | 
  86 | function Test( settings ) {
  87 | 	extend( this, settings );
  88 | 	this.assertions = [];
  89 | 	this.testNumber = ++Test.count;
  90 | }
  91 | 
  92 | Test.count = 0;
  93 | 
  94 | Test.prototype = {
  95 | 	init: function() {
  96 | 		var a, b, li,
  97 | 			tests = id( "qunit-tests" );
  98 | 
  99 | 		if ( tests ) {
 100 | 			b = document.createElement( "strong" );
 101 | 			b.innerHTML = this.nameHtml;
 102 | 
 103 | 			// `a` initialized at top of scope
 104 | 			a = document.createElement( "a" );
 105 | 			a.innerHTML = "Rerun";
 106 | 			a.href = QUnit.url({ testNumber: this.testNumber });
 107 | 
 108 | 			li = document.createElement( "li" );
 109 | 			li.appendChild( b );
 110 | 			li.appendChild( a );
 111 | 			li.className = "running";
 112 | 			li.id = this.id = "qunit-test-output" + testId++;
 113 | 
 114 | 			tests.appendChild( li );
 115 | 		}
 116 | 	},
 117 | 	setup: function() {
 118 | 		if ( this.module !== config.previousModule ) {
 119 | 			if ( config.previousModule ) {
 120 | 				runLoggingCallbacks( "moduleDone", QUnit, {
 121 | 					name: config.previousModule,
 122 | 					failed: config.moduleStats.bad,
 123 | 					passed: config.moduleStats.all - config.moduleStats.bad,
 124 | 					total: config.moduleStats.all
 125 | 				});
 126 | 			}
 127 | 			config.previousModule = this.module;
 128 | 			config.moduleStats = { all: 0, bad: 0 };
 129 | 			runLoggingCallbacks( "moduleStart", QUnit, {
 130 | 				name: this.module
 131 | 			});
 132 | 		} else if ( config.autorun ) {
 133 | 			runLoggingCallbacks( "moduleStart", QUnit, {
 134 | 				name: this.module
 135 | 			});
 136 | 		}
 137 | 
 138 | 		config.current = this;
 139 | 
 140 | 		this.testEnvironment = extend({
 141 | 			setup: function() {},
 142 | 			teardown: function() {}
 143 | 		}, this.moduleTestEnvironment );
 144 | 
 145 | 		this.started = +new Date();
 146 | 		runLoggingCallbacks( "testStart", QUnit, {
 147 | 			name: this.testName,
 148 | 			module: this.module
 149 | 		});
 150 | 
 151 | 		// allow utility functions to access the current test environment
 152 | 		// TODO why??
 153 | 		QUnit.current_testEnvironment = this.testEnvironment;
 154 | 
 155 | 		if ( !config.pollution ) {
 156 | 			saveGlobal();
 157 | 		}
 158 | 		if ( config.notrycatch ) {
 159 | 			this.testEnvironment.setup.call( this.testEnvironment );
 160 | 			return;
 161 | 		}
 162 | 		try {
 163 | 			this.testEnvironment.setup.call( this.testEnvironment );
 164 | 		} catch( e ) {
 165 | 			QUnit.pushFailure( "Setup failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
 166 | 		}
 167 | 	},
 168 | 	run: function() {
 169 | 		config.current = this;
 170 | 
 171 | 		var running = id( "qunit-testresult" );
 172 | 
 173 | 		if ( running ) {
 174 | 			running.innerHTML = "Running: <br/>" + this.nameHtml;
 175 | 		}
 176 | 
 177 | 		if ( this.async ) {
 178 | 			QUnit.stop();
 179 | 		}
 180 | 
 181 | 		this.callbackStarted = +new Date();
 182 | 
 183 | 		if ( config.notrycatch ) {
 184 | 			this.callback.call( this.testEnvironment, QUnit.assert );
 185 | 			this.callbackRuntime = +new Date() - this.callbackStarted;
 186 | 			return;
 187 | 		}
 188 | 
 189 | 		try {
 190 | 			this.callback.call( this.testEnvironment, QUnit.assert );
 191 | 			this.callbackRuntime = +new Date() - this.callbackStarted;
 192 | 		} catch( e ) {
 193 | 			this.callbackRuntime = +new Date() - this.callbackStarted;
 194 | 
 195 | 			QUnit.pushFailure( "Died on test #" + (this.assertions.length + 1) + " " + this.stack + ": " + ( e.message || e ), extractStacktrace( e, 0 ) );
 196 | 			// else next test will carry the responsibility
 197 | 			saveGlobal();
 198 | 
 199 | 			// Restart the tests if they're blocking
 200 | 			if ( config.blocking ) {
 201 | 				QUnit.start();
 202 | 			}
 203 | 		}
 204 | 	},
 205 | 	teardown: function() {
 206 | 		config.current = this;
 207 | 		if ( config.notrycatch ) {
 208 | 			if ( typeof this.callbackRuntime === "undefined" ) {
 209 | 				this.callbackRuntime = +new Date() - this.callbackStarted;
 210 | 			}
 211 | 			this.testEnvironment.teardown.call( this.testEnvironment );
 212 | 			return;
 213 | 		} else {
 214 | 			try {
 215 | 				this.testEnvironment.teardown.call( this.testEnvironment );
 216 | 			} catch( e ) {
 217 | 				QUnit.pushFailure( "Teardown failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
 218 | 			}
 219 | 		}
 220 | 		checkPollution();
 221 | 	},
 222 | 	finish: function() {
 223 | 		config.current = this;
 224 | 		if ( config.requireExpects && this.expected === null ) {
 225 | 			QUnit.pushFailure( "Expected number of assertions to be defined, but expect() was not called.", this.stack );
 226 | 		} else if ( this.expected !== null && this.expected !== this.assertions.length ) {
 227 | 			QUnit.pushFailure( "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run", this.stack );
 228 | 		} else if ( this.expected === null && !this.assertions.length ) {
 229 | 			QUnit.pushFailure( "Expected at least one assertion, but none were run - call expect(0) to accept zero assertions.", this.stack );
 230 | 		}
 231 | 
 232 | 		var i, assertion, a, b, time, li, ol,
 233 | 			test = this,
 234 | 			good = 0,
 235 | 			bad = 0,
 236 | 			tests = id( "qunit-tests" );
 237 | 
 238 | 		this.runtime = +new Date() - this.started;
 239 | 		config.stats.all += this.assertions.length;
 240 | 		config.moduleStats.all += this.assertions.length;
 241 | 
 242 | 		if ( tests ) {
 243 | 			ol = document.createElement( "ol" );
 244 | 			ol.className = "qunit-assert-list";
 245 | 
 246 | 			for ( i = 0; i < this.assertions.length; i++ ) {
 247 | 				assertion = this.assertions[i];
 248 | 
 249 | 				li = document.createElement( "li" );
 250 | 				li.className = assertion.result ? "pass" : "fail";
 251 | 				li.innerHTML = assertion.message || ( assertion.result ? "okay" : "failed" );
 252 | 				ol.appendChild( li );
 253 | 
 254 | 				if ( assertion.result ) {
 255 | 					good++;
 256 | 				} else {
 257 | 					bad++;
 258 | 					config.stats.bad++;
 259 | 					config.moduleStats.bad++;
 260 | 				}
 261 | 			}
 262 | 
 263 | 			// store result when possible
 264 | 			if ( QUnit.config.reorder && defined.sessionStorage ) {
 265 | 				if ( bad ) {
 266 | 					sessionStorage.setItem( "qunit-test-" + this.module + "-" + this.testName, bad );
 267 | 				} else {
 268 | 					sessionStorage.removeItem( "qunit-test-" + this.module + "-" + this.testName );
 269 | 				}
 270 | 			}
 271 | 
 272 | 			if ( bad === 0 ) {
 273 | 				addClass( ol, "qunit-collapsed" );
 274 | 			}
 275 | 
 276 | 			// `b` initialized at top of scope
 277 | 			b = document.createElement( "strong" );
 278 | 			b.innerHTML = this.nameHtml + " <b class='counts'>(<b class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + this.assertions.length + ")</b>";
 279 | 
 280 | 			addEvent(b, "click", function() {
 281 | 				var next = b.parentNode.lastChild,
 282 | 					collapsed = hasClass( next, "qunit-collapsed" );
 283 | 				( collapsed ? removeClass : addClass )( next, "qunit-collapsed" );
 284 | 			});
 285 | 
 286 | 			addEvent(b, "dblclick", function( e ) {
 287 | 				var target = e && e.target ? e.target : window.event.srcElement;
 288 | 				if ( target.nodeName.toLowerCase() === "span" || target.nodeName.toLowerCase() === "b" ) {
 289 | 					target = target.parentNode;
 290 | 				}
 291 | 				if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
 292 | 					window.location = QUnit.url({ testNumber: test.testNumber });
 293 | 				}
 294 | 			});
 295 | 
 296 | 			// `time` initialized at top of scope
 297 | 			time = document.createElement( "span" );
 298 | 			time.className = "runtime";
 299 | 			time.innerHTML = this.runtime + " ms";
 300 | 
 301 | 			// `li` initialized at top of scope
 302 | 			li = id( this.id );
 303 | 			li.className = bad ? "fail" : "pass";
 304 | 			li.removeChild( li.firstChild );
 305 | 			a = li.firstChild;
 306 | 			li.appendChild( b );
 307 | 			li.appendChild( a );
 308 | 			li.appendChild( time );
 309 | 			li.appendChild( ol );
 310 | 
 311 | 		} else {
 312 | 			for ( i = 0; i < this.assertions.length; i++ ) {
 313 | 				if ( !this.assertions[i].result ) {
 314 | 					bad++;
 315 | 					config.stats.bad++;
 316 | 					config.moduleStats.bad++;
 317 | 				}
 318 | 			}
 319 | 		}
 320 | 
 321 | 		runLoggingCallbacks( "testDone", QUnit, {
 322 | 			name: this.testName,
 323 | 			module: this.module,
 324 | 			failed: bad,
 325 | 			passed: this.assertions.length - bad,
 326 | 			total: this.assertions.length,
 327 | 			duration: this.runtime
 328 | 		});
 329 | 
 330 | 		QUnit.reset();
 331 | 
 332 | 		config.current = undefined;
 333 | 	},
 334 | 
 335 | 	queue: function() {
 336 | 		var bad,
 337 | 			test = this;
 338 | 
 339 | 		synchronize(function() {
 340 | 			test.init();
 341 | 		});
 342 | 		function run() {
 343 | 			// each of these can by async
 344 | 			synchronize(function() {
 345 | 				test.setup();
 346 | 			});
 347 | 			synchronize(function() {
 348 | 				test.run();
 349 | 			});
 350 | 			synchronize(function() {
 351 | 				test.teardown();
 352 | 			});
 353 | 			synchronize(function() {
 354 | 				test.finish();
 355 | 			});
 356 | 		}
 357 | 
 358 | 		// `bad` initialized at top of scope
 359 | 		// defer when previous test run passed, if storage is available
 360 | 		bad = QUnit.config.reorder && defined.sessionStorage &&
 361 | 						+sessionStorage.getItem( "qunit-test-" + this.module + "-" + this.testName );
 362 | 
 363 | 		if ( bad ) {
 364 | 			run();
 365 | 		} else {
 366 | 			synchronize( run, true );
 367 | 		}
 368 | 	}
 369 | };
 370 | 
 371 | // Root QUnit object.
 372 | // `QUnit` initialized at top of scope
 373 | QUnit = {
 374 | 
 375 | 	// call on start of module test to prepend name to all tests
 376 | 	module: function( name, testEnvironment ) {
 377 | 		config.currentModule = name;
 378 | 		config.currentModuleTestEnvironment = testEnvironment;
 379 | 		config.modules[name] = true;
 380 | 	},
 381 | 
 382 | 	asyncTest: function( testName, expected, callback ) {
 383 | 		if ( arguments.length === 2 ) {
 384 | 			callback = expected;
 385 | 			expected = null;
 386 | 		}
 387 | 
 388 | 		QUnit.test( testName, expected, callback, true );
 389 | 	},
 390 | 
 391 | 	test: function( testName, expected, callback, async ) {
 392 | 		var test,
 393 | 			nameHtml = "<span class='test-name'>" + escapeText( testName ) + "</span>";
 394 | 
 395 | 		if ( arguments.length === 2 ) {
 396 | 			callback = expected;
 397 | 			expected = null;
 398 | 		}
 399 | 
 400 | 		if ( config.currentModule ) {
 401 | 			nameHtml = "<span class='module-name'>" + escapeText( config.currentModule ) + "</span>: " + nameHtml;
 402 | 		}
 403 | 
 404 | 		test = new Test({
 405 | 			nameHtml: nameHtml,
 406 | 			testName: testName,
 407 | 			expected: expected,
 408 | 			async: async,
 409 | 			callback: callback,
 410 | 			module: config.currentModule,
 411 | 			moduleTestEnvironment: config.currentModuleTestEnvironment,
 412 | 			stack: sourceFromStacktrace( 2 )
 413 | 		});
 414 | 
 415 | 		if ( !validTest( test ) ) {
 416 | 			return;
 417 | 		}
 418 | 
 419 | 		test.queue();
 420 | 	},
 421 | 
 422 | 	// Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through.
 423 | 	expect: function( asserts ) {
 424 | 		if (arguments.length === 1) {
 425 | 			config.current.expected = asserts;
 426 | 		} else {
 427 | 			return config.current.expected;
 428 | 		}
 429 | 	},
 430 | 
 431 | 	start: function( count ) {
 432 | 		// QUnit hasn't been initialized yet.
 433 | 		// Note: RequireJS (et al) may delay onLoad
 434 | 		if ( config.semaphore === undefined ) {
 435 | 			QUnit.begin(function() {
 436 | 				// This is triggered at the top of QUnit.load, push start() to the event loop, to allow QUnit.load to finish first
 437 | 				setTimeout(function() {
 438 | 					QUnit.start( count );
 439 | 				});
 440 | 			});
 441 | 			return;
 442 | 		}
 443 | 
 444 | 		config.semaphore -= count || 1;
 445 | 		// don't start until equal number of stop-calls
 446 | 		if ( config.semaphore > 0 ) {
 447 | 			return;
 448 | 		}
 449 | 		// ignore if start is called more often then stop
 450 | 		if ( config.semaphore < 0 ) {
 451 | 			config.semaphore = 0;
 452 | 			QUnit.pushFailure( "Called start() while already started (QUnit.config.semaphore was 0 already)", null, sourceFromStacktrace(2) );
 453 | 			return;
 454 | 		}
 455 | 		// A slight delay, to avoid any current callbacks
 456 | 		if ( defined.setTimeout ) {
 457 | 			window.setTimeout(function() {
 458 | 				if ( config.semaphore > 0 ) {
 459 | 					return;
 460 | 				}
 461 | 				if ( config.timeout ) {
 462 | 					clearTimeout( config.timeout );
 463 | 				}
 464 | 
 465 | 				config.blocking = false;
 466 | 				process( true );
 467 | 			}, 13);
 468 | 		} else {
 469 | 			config.blocking = false;
 470 | 			process( true );
 471 | 		}
 472 | 	},
 473 | 
 474 | 	stop: function( count ) {
 475 | 		config.semaphore += count || 1;
 476 | 		config.blocking = true;
 477 | 
 478 | 		if ( config.testTimeout && defined.setTimeout ) {
 479 | 			clearTimeout( config.timeout );
 480 | 			config.timeout = window.setTimeout(function() {
 481 | 				QUnit.ok( false, "Test timed out" );
 482 | 				config.semaphore = 1;
 483 | 				QUnit.start();
 484 | 			}, config.testTimeout );
 485 | 		}
 486 | 	}
 487 | };
 488 | 
 489 | // `assert` initialized at top of scope
 490 | // Asssert helpers
 491 | // All of these must either call QUnit.push() or manually do:
 492 | // - runLoggingCallbacks( "log", .. );
 493 | // - config.current.assertions.push({ .. });
 494 | // We attach it to the QUnit object *after* we expose the public API,
 495 | // otherwise `assert` will become a global variable in browsers (#341).
 496 | assert = {
 497 | 	/**
 498 | 	 * Asserts rough true-ish result.
 499 | 	 * @name ok
 500 | 	 * @function
 501 | 	 * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
 502 | 	 */
 503 | 	ok: function( result, msg ) {
 504 | 		if ( !config.current ) {
 505 | 			throw new Error( "ok() assertion outside test context, was " + sourceFromStacktrace(2) );
 506 | 		}
 507 | 		result = !!result;
 508 | 
 509 | 		var source,
 510 | 			details = {
 511 | 				module: config.current.module,
 512 | 				name: config.current.testName,
 513 | 				result: result,
 514 | 				message: msg
 515 | 			};
 516 | 
 517 | 		msg = escapeText( msg || (result ? "okay" : "failed" ) );
 518 | 		msg = "<span class='test-message'>" + msg + "</span>";
 519 | 
 520 | 		if ( !result ) {
 521 | 			source = sourceFromStacktrace( 2 );
 522 | 			if ( source ) {
 523 | 				details.source = source;
 524 | 				msg += "<table><tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr></table>";
 525 | 			}
 526 | 		}
 527 | 		runLoggingCallbacks( "log", QUnit, details );
 528 | 		config.current.assertions.push({
 529 | 			result: result,
 530 | 			message: msg
 531 | 		});
 532 | 	},
 533 | 
 534 | 	/**
 535 | 	 * Assert that the first two arguments are equal, with an optional message.
 536 | 	 * Prints out both actual and expected values.
 537 | 	 * @name equal
 538 | 	 * @function
 539 | 	 * @example equal( format( "Received {0} bytes.", 2), "Received 2 bytes.", "format() replaces {0} with next argument" );
 540 | 	 */
 541 | 	equal: function( actual, expected, message ) {
 542 | 		/*jshint eqeqeq:false */
 543 | 		QUnit.push( expected == actual, actual, expected, message );
 544 | 	},
 545 | 
 546 | 	/**
 547 | 	 * @name notEqual
 548 | 	 * @function
 549 | 	 */
 550 | 	notEqual: function( actual, expected, message ) {
 551 | 		/*jshint eqeqeq:false */
 552 | 		QUnit.push( expected != actual, actual, expected, message );
 553 | 	},
 554 | 
 555 | 	/**
 556 | 	 * @name propEqual
 557 | 	 * @function
 558 | 	 */
 559 | 	propEqual: function( actual, expected, message ) {
 560 | 		actual = objectValues(actual);
 561 | 		expected = objectValues(expected);
 562 | 		QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
 563 | 	},
 564 | 
 565 | 	/**
 566 | 	 * @name notPropEqual
 567 | 	 * @function
 568 | 	 */
 569 | 	notPropEqual: function( actual, expected, message ) {
 570 | 		actual = objectValues(actual);
 571 | 		expected = objectValues(expected);
 572 | 		QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
 573 | 	},
 574 | 
 575 | 	/**
 576 | 	 * @name deepEqual
 577 | 	 * @function
 578 | 	 */
 579 | 	deepEqual: function( actual, expected, message ) {
 580 | 		QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
 581 | 	},
 582 | 
 583 | 	/**
 584 | 	 * @name notDeepEqual
 585 | 	 * @function
 586 | 	 */
 587 | 	notDeepEqual: function( actual, expected, message ) {
 588 | 		QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
 589 | 	},
 590 | 
 591 | 	/**
 592 | 	 * @name strictEqual
 593 | 	 * @function
 594 | 	 */
 595 | 	strictEqual: function( actual, expected, message ) {
 596 | 		QUnit.push( expected === actual, actual, expected, message );
 597 | 	},
 598 | 
 599 | 	/**
 600 | 	 * @name notStrictEqual
 601 | 	 * @function
 602 | 	 */
 603 | 	notStrictEqual: function( actual, expected, message ) {
 604 | 		QUnit.push( expected !== actual, actual, expected, message );
 605 | 	},
 606 | 
 607 | 	"throws": function( block, expected, message ) {
 608 | 		var actual,
 609 | 			expectedOutput = expected,
 610 | 			ok = false;
 611 | 
 612 | 		// 'expected' is optional
 613 | 		if ( typeof expected === "string" ) {
 614 | 			message = expected;
 615 | 			expected = null;
 616 | 		}
 617 | 
 618 | 		config.current.ignoreGlobalErrors = true;
 619 | 		try {
 620 | 			block.call( config.current.testEnvironment );
 621 | 		} catch (e) {
 622 | 			actual = e;
 623 | 		}
 624 | 		config.current.ignoreGlobalErrors = false;
 625 | 
 626 | 		if ( actual ) {
 627 | 			// we don't want to validate thrown error
 628 | 			if ( !expected ) {
 629 | 				ok = true;
 630 | 				expectedOutput = null;
 631 | 			// expected is a regexp
 632 | 			} else if ( QUnit.objectType( expected ) === "regexp" ) {
 633 | 				ok = expected.test( errorString( actual ) );
 634 | 			// expected is a constructor
 635 | 			} else if ( actual instanceof expected ) {
 636 | 				ok = true;
 637 | 			// expected is a validation function which returns true is validation passed
 638 | 			} else if ( expected.call( {}, actual ) === true ) {
 639 | 				expectedOutput = null;
 640 | 				ok = true;
 641 | 			}
 642 | 
 643 | 			QUnit.push( ok, actual, expectedOutput, message );
 644 | 		} else {
 645 | 			QUnit.pushFailure( message, null, 'No exception was thrown.' );
 646 | 		}
 647 | 	}
 648 | };
 649 | 
 650 | /**
 651 |  * @deprecate since 1.8.0
 652 |  * Kept assertion helpers in root for backwards compatibility.
 653 |  */
 654 | extend( QUnit, assert );
 655 | 
 656 | /**
 657 |  * @deprecated since 1.9.0
 658 |  * Kept root "raises()" for backwards compatibility.
 659 |  * (Note that we don't introduce assert.raises).
 660 |  */
 661 | QUnit.raises = assert[ "throws" ];
 662 | 
 663 | /**
 664 |  * @deprecated since 1.0.0, replaced with error pushes since 1.3.0
 665 |  * Kept to avoid TypeErrors for undefined methods.
 666 |  */
 667 | QUnit.equals = function() {
 668 | 	QUnit.push( false, false, false, "QUnit.equals has been deprecated since 2009 (e88049a0), use QUnit.equal instead" );
 669 | };
 670 | QUnit.same = function() {
 671 | 	QUnit.push( false, false, false, "QUnit.same has been deprecated since 2009 (e88049a0), use QUnit.deepEqual instead" );
 672 | };
 673 | 
 674 | // We want access to the constructor's prototype
 675 | (function() {
 676 | 	function F() {}
 677 | 	F.prototype = QUnit;
 678 | 	QUnit = new F();
 679 | 	// Make F QUnit's constructor so that we can add to the prototype later
 680 | 	QUnit.constructor = F;
 681 | }());
 682 | 
 683 | /**
 684 |  * Config object: Maintain internal state
 685 |  * Later exposed as QUnit.config
 686 |  * `config` initialized at top of scope
 687 |  */
 688 | config = {
 689 | 	// The queue of tests to run
 690 | 	queue: [],
 691 | 
 692 | 	// block until document ready
 693 | 	blocking: true,
 694 | 
 695 | 	// when enabled, show only failing tests
 696 | 	// gets persisted through sessionStorage and can be changed in UI via checkbox
 697 | 	hidepassed: false,
 698 | 
 699 | 	// by default, run previously failed tests first
 700 | 	// very useful in combination with "Hide passed tests" checked
 701 | 	reorder: true,
 702 | 
 703 | 	// by default, modify document.title when suite is done
 704 | 	altertitle: true,
 705 | 
 706 | 	// when enabled, all tests must call expect()
 707 | 	requireExpects: false,
 708 | 
 709 | 	// add checkboxes that are persisted in the query-string
 710 | 	// when enabled, the id is set to `true` as a `QUnit.config` property
 711 | 	urlConfig: [
 712 | 		{
 713 | 			id: "noglobals",
 714 | 			label: "Check for Globals",
 715 | 			tooltip: "Enabling this will test if any test introduces new properties on the `window` object. Stored as query-strings."
 716 | 		},
 717 | 		{
 718 | 			id: "notrycatch",
 719 | 			label: "No try-catch",
 720 | 			tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging exceptions in IE reasonable. Stored as query-strings."
 721 | 		}
 722 | 	],
 723 | 
 724 | 	// Set of all modules.
 725 | 	modules: {},
 726 | 
 727 | 	// logging callback queues
 728 | 	begin: [],
 729 | 	done: [],
 730 | 	log: [],
 731 | 	testStart: [],
 732 | 	testDone: [],
 733 | 	moduleStart: [],
 734 | 	moduleDone: []
 735 | };
 736 | 
 737 | // Export global variables, unless an 'exports' object exists,
 738 | // in that case we assume we're in CommonJS (dealt with on the bottom of the script)
 739 | if ( typeof exports === "undefined" ) {
 740 | 	extend( window, QUnit );
 741 | 
 742 | 	// Expose QUnit object
 743 | 	window.QUnit = QUnit;
 744 | }
 745 | 
 746 | // Initialize more QUnit.config and QUnit.urlParams
 747 | (function() {
 748 | 	var i,
 749 | 		location = window.location || { search: "", protocol: "file:" },
 750 | 		params = location.search.slice( 1 ).split( "&" ),
 751 | 		length = params.length,
 752 | 		urlParams = {},
 753 | 		current;
 754 | 
 755 | 	if ( params[ 0 ] ) {
 756 | 		for ( i = 0; i < length; i++ ) {
 757 | 			current = params[ i ].split( "=" );
 758 | 			current[ 0 ] = decodeURIComponent( current[ 0 ] );
 759 | 			// allow just a key to turn on a flag, e.g., test.html?noglobals
 760 | 			current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true;
 761 | 			urlParams[ current[ 0 ] ] = current[ 1 ];
 762 | 		}
 763 | 	}
 764 | 
 765 | 	QUnit.urlParams = urlParams;
 766 | 
 767 | 	// String search anywhere in moduleName+testName
 768 | 	config.filter = urlParams.filter;
 769 | 
 770 | 	// Exact match of the module name
 771 | 	config.module = urlParams.module;
 772 | 
 773 | 	config.testNumber = parseInt( urlParams.testNumber, 10 ) || null;
 774 | 
 775 | 	// Figure out if we're running the tests from a server or not
 776 | 	QUnit.isLocal = location.protocol === "file:";
 777 | }());
 778 | 
 779 | // Extend QUnit object,
 780 | // these after set here because they should not be exposed as global functions
 781 | extend( QUnit, {
 782 | 	assert: assert,
 783 | 
 784 | 	config: config,
 785 | 
 786 | 	// Initialize the configuration options
 787 | 	init: function() {
 788 | 		extend( config, {
 789 | 			stats: { all: 0, bad: 0 },
 790 | 			moduleStats: { all: 0, bad: 0 },
 791 | 			started: +new Date(),
 792 | 			updateRate: 1000,
 793 | 			blocking: false,
 794 | 			autostart: true,
 795 | 			autorun: false,
 796 | 			filter: "",
 797 | 			queue: [],
 798 | 			semaphore: 1
 799 | 		});
 800 | 
 801 | 		var tests, banner, result,
 802 | 			qunit = id( "qunit" );
 803 | 
 804 | 		if ( qunit ) {
 805 | 			qunit.innerHTML =
 806 | 				"<h1 id='qunit-header'>" + escapeText( document.title ) + "</h1>" +
 807 | 				"<h2 id='qunit-banner'></h2>" +
 808 | 				"<div id='qunit-testrunner-toolbar'></div>" +
 809 | 				"<h2 id='qunit-userAgent'></h2>" +
 810 | 				"<ol id='qunit-tests'></ol>";
 811 | 		}
 812 | 
 813 | 		tests = id( "qunit-tests" );
 814 | 		banner = id( "qunit-banner" );
 815 | 		result = id( "qunit-testresult" );
 816 | 
 817 | 		if ( tests ) {
 818 | 			tests.innerHTML = "";
 819 | 		}
 820 | 
 821 | 		if ( banner ) {
 822 | 			banner.className = "";
 823 | 		}
 824 | 
 825 | 		if ( result ) {
 826 | 			result.parentNode.removeChild( result );
 827 | 		}
 828 | 
 829 | 		if ( tests ) {
 830 | 			result = document.createElement( "p" );
 831 | 			result.id = "qunit-testresult";
 832 | 			result.className = "result";
 833 | 			tests.parentNode.insertBefore( result, tests );
 834 | 			result.innerHTML = "Running...<br/>&nbsp;";
 835 | 		}
 836 | 	},
 837 | 
 838 | 	// Resets the test setup. Useful for tests that modify the DOM.
 839 | 	reset: function() {
 840 | 		var fixture = id( "qunit-fixture" );
 841 | 		if ( fixture ) {
 842 | 			fixture.innerHTML = config.fixture;
 843 | 		}
 844 | 	},
 845 | 
 846 | 	// Trigger an event on an element.
 847 | 	// @example triggerEvent( document.body, "click" );
 848 | 	triggerEvent: function( elem, type, event ) {
 849 | 		if ( document.createEvent ) {
 850 | 			event = document.createEvent( "MouseEvents" );
 851 | 			event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView,
 852 | 				0, 0, 0, 0, 0, false, false, false, false, 0, null);
 853 | 
 854 | 			elem.dispatchEvent( event );
 855 | 		} else if ( elem.fireEvent ) {
 856 | 			elem.fireEvent( "on" + type );
 857 | 		}
 858 | 	},
 859 | 
 860 | 	// Safe object type checking
 861 | 	is: function( type, obj ) {
 862 | 		return QUnit.objectType( obj ) === type;
 863 | 	},
 864 | 
 865 | 	objectType: function( obj ) {
 866 | 		if ( typeof obj === "undefined" ) {
 867 | 				return "undefined";
 868 | 		// consider: typeof null === object
 869 | 		}
 870 | 		if ( obj === null ) {
 871 | 				return "null";
 872 | 		}
 873 | 
 874 | 		var match = toString.call( obj ).match(/^\[object\s(.*)\]$/),
 875 | 			type = match && match[1] || "";
 876 | 
 877 | 		switch ( type ) {
 878 | 			case "Number":
 879 | 				if ( isNaN(obj) ) {
 880 | 					return "nan";
 881 | 				}
 882 | 				return "number";
 883 | 			case "String":
 884 | 			case "Boolean":
 885 | 			case "Array":
 886 | 			case "Date":
 887 | 			case "RegExp":
 888 | 			case "Function":
 889 | 				return type.toLowerCase();
 890 | 		}
 891 | 		if ( typeof obj === "object" ) {
 892 | 			return "object";
 893 | 		}
 894 | 		return undefined;
 895 | 	},
 896 | 
 897 | 	push: function( result, actual, expected, message ) {
 898 | 		if ( !config.current ) {
 899 | 			throw new Error( "assertion outside test context, was " + sourceFromStacktrace() );
 900 | 		}
 901 | 
 902 | 		var output, source,
 903 | 			details = {
 904 | 				module: config.current.module,
 905 | 				name: config.current.testName,
 906 | 				result: result,
 907 | 				message: message,
 908 | 				actual: actual,
 909 | 				expected: expected
 910 | 			};
 911 | 
 912 | 		message = escapeText( message ) || ( result ? "okay" : "failed" );
 913 | 		message = "<span class='test-message'>" + message + "</span>";
 914 | 		output = message;
 915 | 
 916 | 		if ( !result ) {
 917 | 			expected = escapeText( QUnit.jsDump.parse(expected) );
 918 | 			actual = escapeText( QUnit.jsDump.parse(actual) );
 919 | 			output += "<table><tr class='test-expected'><th>Expected: </th><td><pre>" + expected + "</pre></td></tr>";
 920 | 
 921 | 			if ( actual !== expected ) {
 922 | 				output += "<tr class='test-actual'><th>Result: </th><td><pre>" + actual + "</pre></td></tr>";
 923 | 				output += "<tr class='test-diff'><th>Diff: </th><td><pre>" + QUnit.diff( expected, actual ) + "</pre></td></tr>";
 924 | 			}
 925 | 
 926 | 			source = sourceFromStacktrace();
 927 | 
 928 | 			if ( source ) {
 929 | 				details.source = source;
 930 | 				output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
 931 | 			}
 932 | 
 933 | 			output += "</table>";
 934 | 		}
 935 | 
 936 | 		runLoggingCallbacks( "log", QUnit, details );
 937 | 
 938 | 		config.current.assertions.push({
 939 | 			result: !!result,
 940 | 			message: output
 941 | 		});
 942 | 	},
 943 | 
 944 | 	pushFailure: function( message, source, actual ) {
 945 | 		if ( !config.current ) {
 946 | 			throw new Error( "pushFailure() assertion outside test context, was " + sourceFromStacktrace(2) );
 947 | 		}
 948 | 
 949 | 		var output,
 950 | 			details = {
 951 | 				module: config.current.module,
 952 | 				name: config.current.testName,
 953 | 				result: false,
 954 | 				message: message
 955 | 			};
 956 | 
 957 | 		message = escapeText( message ) || "error";
 958 | 		message = "<span class='test-message'>" + message + "</span>";
 959 | 		output = message;
 960 | 
 961 | 		output += "<table>";
 962 | 
 963 | 		if ( actual ) {
 964 | 			output += "<tr class='test-actual'><th>Result: </th><td><pre>" + escapeText( actual ) + "</pre></td></tr>";
 965 | 		}
 966 | 
 967 | 		if ( source ) {
 968 | 			details.source = source;
 969 | 			output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
 970 | 		}
 971 | 
 972 | 		output += "</table>";
 973 | 
 974 | 		runLoggingCallbacks( "log", QUnit, details );
 975 | 
 976 | 		config.current.assertions.push({
 977 | 			result: false,
 978 | 			message: output
 979 | 		});
 980 | 	},
 981 | 
 982 | 	url: function( params ) {
 983 | 		params = extend( extend( {}, QUnit.urlParams ), params );
 984 | 		var key,
 985 | 			querystring = "?";
 986 | 
 987 | 		for ( key in params ) {
 988 | 			if ( !hasOwn.call( params, key ) ) {
 989 | 				continue;
 990 | 			}
 991 | 			querystring += encodeURIComponent( key ) + "=" +
 992 | 				encodeURIComponent( params[ key ] ) + "&";
 993 | 		}
 994 | 		return window.location.protocol + "//" + window.location.host +
 995 | 			window.location.pathname + querystring.slice( 0, -1 );
 996 | 	},
 997 | 
 998 | 	extend: extend,
 999 | 	id: id,
1000 | 	addEvent: addEvent
1001 | 	// load, equiv, jsDump, diff: Attached later
1002 | });
1003 | 
1004 | /**
1005 |  * @deprecated: Created for backwards compatibility with test runner that set the hook function
1006 |  * into QUnit.{hook}, instead of invoking it and passing the hook function.
1007 |  * QUnit.constructor is set to the empty F() above so that we can add to it's prototype here.
1008 |  * Doing this allows us to tell if the following methods have been overwritten on the actual
1009 |  * QUnit object.
1010 |  */
1011 | extend( QUnit.constructor.prototype, {
1012 | 
1013 | 	// Logging callbacks; all receive a single argument with the listed properties
1014 | 	// run test/logs.html for any related changes
1015 | 	begin: registerLoggingCallback( "begin" ),
1016 | 
1017 | 	// done: { failed, passed, total, runtime }
1018 | 	done: registerLoggingCallback( "done" ),
1019 | 
1020 | 	// log: { result, actual, expected, message }
1021 | 	log: registerLoggingCallback( "log" ),
1022 | 
1023 | 	// testStart: { name }
1024 | 	testStart: registerLoggingCallback( "testStart" ),
1025 | 
1026 | 	// testDone: { name, failed, passed, total, duration }
1027 | 	testDone: registerLoggingCallback( "testDone" ),
1028 | 
1029 | 	// moduleStart: { name }
1030 | 	moduleStart: registerLoggingCallback( "moduleStart" ),
1031 | 
1032 | 	// moduleDone: { name, failed, passed, total }
1033 | 	moduleDone: registerLoggingCallback( "moduleDone" )
1034 | });
1035 | 
1036 | if ( typeof document === "undefined" || document.readyState === "complete" ) {
1037 | 	config.autorun = true;
1038 | }
1039 | 
1040 | QUnit.load = function() {
1041 | 	runLoggingCallbacks( "begin", QUnit, {} );
1042 | 
1043 | 	// Initialize the config, saving the execution queue
1044 | 	var banner, filter, i, label, len, main, ol, toolbar, userAgent, val,
1045 | 		urlConfigCheckboxesContainer, urlConfigCheckboxes, moduleFilter,
1046 | 		numModules = 0,
1047 | 		moduleFilterHtml = "",
1048 | 		urlConfigHtml = "",
1049 | 		oldconfig = extend( {}, config );
1050 | 
1051 | 	QUnit.init();
1052 | 	extend(config, oldconfig);
1053 | 
1054 | 	config.blocking = false;
1055 | 
1056 | 	len = config.urlConfig.length;
1057 | 
1058 | 	for ( i = 0; i < len; i++ ) {
1059 | 		val = config.urlConfig[i];
1060 | 		if ( typeof val === "string" ) {
1061 | 			val = {
1062 | 				id: val,
1063 | 				label: val,
1064 | 				tooltip: "[no tooltip available]"
1065 | 			};
1066 | 		}
1067 | 		config[ val.id ] = QUnit.urlParams[ val.id ];
1068 | 		urlConfigHtml += "<input id='qunit-urlconfig-" + escapeText( val.id ) +
1069 | 			"' name='" + escapeText( val.id ) +
1070 | 			"' type='checkbox'" + ( config[ val.id ] ? " checked='checked'" : "" ) +
1071 | 			" title='" + escapeText( val.tooltip ) +
1072 | 			"'><label for='qunit-urlconfig-" + escapeText( val.id ) +
1073 | 			"' title='" + escapeText( val.tooltip ) + "'>" + val.label + "</label>";
1074 | 	}
1075 | 
1076 | 	moduleFilterHtml += "<label for='qunit-modulefilter'>Module: </label><select id='qunit-modulefilter' name='modulefilter'><option value='' " +
1077 | 		( config.module === undefined  ? "selected='selected'" : "" ) +
1078 | 		">< All Modules ></option>";
1079 | 
1080 | 	for ( i in config.modules ) {
1081 | 		if ( config.modules.hasOwnProperty( i ) ) {
1082 | 			numModules += 1;
1083 | 			moduleFilterHtml += "<option value='" + escapeText( encodeURIComponent(i) ) + "' " +
1084 | 				( config.module === i ? "selected='selected'" : "" ) +
1085 | 				">" + escapeText(i) + "</option>";
1086 | 		}
1087 | 	}
1088 | 	moduleFilterHtml += "</select>";
1089 | 
1090 | 	// `userAgent` initialized at top of scope
1091 | 	userAgent = id( "qunit-userAgent" );
1092 | 	if ( userAgent ) {
1093 | 		userAgent.innerHTML = navigator.userAgent;
1094 | 	}
1095 | 
1096 | 	// `banner` initialized at top of scope
1097 | 	banner = id( "qunit-header" );
1098 | 	if ( banner ) {
1099 | 		banner.innerHTML = "<a href='" + QUnit.url({ filter: undefined, module: undefined, testNumber: undefined }) + "'>" + banner.innerHTML + "</a> ";
1100 | 	}
1101 | 
1102 | 	// `toolbar` initialized at top of scope
1103 | 	toolbar = id( "qunit-testrunner-toolbar" );
1104 | 	if ( toolbar ) {
1105 | 		// `filter` initialized at top of scope
1106 | 		filter = document.createElement( "input" );
1107 | 		filter.type = "checkbox";
1108 | 		filter.id = "qunit-filter-pass";
1109 | 
1110 | 		addEvent( filter, "click", function() {
1111 | 			var tmp,
1112 | 				ol = document.getElementById( "qunit-tests" );
1113 | 
1114 | 			if ( filter.checked ) {
1115 | 				ol.className = ol.className + " hidepass";
1116 | 			} else {
1117 | 				tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " ";
1118 | 				ol.className = tmp.replace( / hidepass /, " " );
1119 | 			}
1120 | 			if ( defined.sessionStorage ) {
1121 | 				if (filter.checked) {
1122 | 					sessionStorage.setItem( "qunit-filter-passed-tests", "true" );
1123 | 				} else {
1124 | 					sessionStorage.removeItem( "qunit-filter-passed-tests" );
1125 | 				}
1126 | 			}
1127 | 		});
1128 | 
1129 | 		if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem( "qunit-filter-passed-tests" ) ) {
1130 | 			filter.checked = true;
1131 | 			// `ol` initialized at top of scope
1132 | 			ol = document.getElementById( "qunit-tests" );
1133 | 			ol.className = ol.className + " hidepass";
1134 | 		}
1135 | 		toolbar.appendChild( filter );
1136 | 
1137 | 		// `label` initialized at top of scope
1138 | 		label = document.createElement( "label" );
1139 | 		label.setAttribute( "for", "qunit-filter-pass" );
1140 | 		label.setAttribute( "title", "Only show tests and assertons that fail. Stored in sessionStorage." );
1141 | 		label.innerHTML = "Hide passed tests";
1142 | 		toolbar.appendChild( label );
1143 | 
1144 | 		urlConfigCheckboxesContainer = document.createElement("span");
1145 | 		urlConfigCheckboxesContainer.innerHTML = urlConfigHtml;
1146 | 		urlConfigCheckboxes = urlConfigCheckboxesContainer.getElementsByTagName("input");
1147 | 		// For oldIE support:
1148 | 		// * Add handlers to the individual elements instead of the container
1149 | 		// * Use "click" instead of "change"
1150 | 		// * Fallback from event.target to event.srcElement
1151 | 		addEvents( urlConfigCheckboxes, "click", function( event ) {
1152 | 			var params = {},
1153 | 				target = event.target || event.srcElement;
1154 | 			params[ target.name ] = target.checked ? true : undefined;
1155 | 			window.location = QUnit.url( params );
1156 | 		});
1157 | 		toolbar.appendChild( urlConfigCheckboxesContainer );
1158 | 
1159 | 		if (numModules > 1) {
1160 | 			moduleFilter = document.createElement( 'span' );
1161 | 			moduleFilter.setAttribute( 'id', 'qunit-modulefilter-container' );
1162 | 			moduleFilter.innerHTML = moduleFilterHtml;
1163 | 			addEvent( moduleFilter.lastChild, "change", function() {
1164 | 				var selectBox = moduleFilter.getElementsByTagName("select")[0],
1165 | 					selectedModule = decodeURIComponent(selectBox.options[selectBox.selectedIndex].value);
1166 | 
1167 | 				window.location = QUnit.url( { module: ( selectedModule === "" ) ? undefined : selectedModule } );
1168 | 			});
1169 | 			toolbar.appendChild(moduleFilter);
1170 | 		}
1171 | 	}
1172 | 
1173 | 	// `main` initialized at top of scope
1174 | 	main = id( "qunit-fixture" );
1175 | 	if ( main ) {
1176 | 		config.fixture = main.innerHTML;
1177 | 	}
1178 | 
1179 | 	if ( config.autostart ) {
1180 | 		QUnit.start();
1181 | 	}
1182 | };
1183 | 
1184 | addEvent( window, "load", QUnit.load );
1185 | 
1186 | // `onErrorFnPrev` initialized at top of scope
1187 | // Preserve other handlers
1188 | onErrorFnPrev = window.onerror;
1189 | 
1190 | // Cover uncaught exceptions
1191 | // Returning true will surpress the default browser handler,
1192 | // returning false will let it run.
1193 | window.onerror = function ( error, filePath, linerNr ) {
1194 | 	var ret = false;
1195 | 	if ( onErrorFnPrev ) {
1196 | 		ret = onErrorFnPrev( error, filePath, linerNr );
1197 | 	}
1198 | 
1199 | 	// Treat return value as window.onerror itself does,
1200 | 	// Only do our handling if not surpressed.
1201 | 	if ( ret !== true ) {
1202 | 		if ( QUnit.config.current ) {
1203 | 			if ( QUnit.config.current.ignoreGlobalErrors ) {
1204 | 				return true;
1205 | 			}
1206 | 			QUnit.pushFailure( error, filePath + ":" + linerNr );
1207 | 		} else {
1208 | 			QUnit.test( "global failure", extend( function() {
1209 | 				QUnit.pushFailure( error, filePath + ":" + linerNr );
1210 | 			}, { validTest: validTest } ) );
1211 | 		}
1212 | 		return false;
1213 | 	}
1214 | 
1215 | 	return ret;
1216 | };
1217 | 
1218 | function done() {
1219 | 	config.autorun = true;
1220 | 
1221 | 	// Log the last module results
1222 | 	if ( config.currentModule ) {
1223 | 		runLoggingCallbacks( "moduleDone", QUnit, {
1224 | 			name: config.currentModule,
1225 | 			failed: config.moduleStats.bad,
1226 | 			passed: config.moduleStats.all - config.moduleStats.bad,
1227 | 			total: config.moduleStats.all
1228 | 		});
1229 | 	}
1230 | 
1231 | 	var i, key,
1232 | 		banner = id( "qunit-banner" ),
1233 | 		tests = id( "qunit-tests" ),
1234 | 		runtime = +new Date() - config.started,
1235 | 		passed = config.stats.all - config.stats.bad,
1236 | 		html = [
1237 | 			"Tests completed in ",
1238 | 			runtime,
1239 | 			" milliseconds.<br/>",
1240 | 			"<span class='passed'>",
1241 | 			passed,
1242 | 			"</span> assertions of <span class='total'>",
1243 | 			config.stats.all,
1244 | 			"</span> passed, <span class='failed'>",
1245 | 			config.stats.bad,
1246 | 			"</span> failed."
1247 | 		].join( "" );
1248 | 
1249 | 	if ( banner ) {
1250 | 		banner.className = ( config.stats.bad ? "qunit-fail" : "qunit-pass" );
1251 | 	}
1252 | 
1253 | 	if ( tests ) {
1254 | 		id( "qunit-testresult" ).innerHTML = html;
1255 | 	}
1256 | 
1257 | 	if ( config.altertitle && typeof document !== "undefined" && document.title ) {
1258 | 		// show ✖ for good, ✔ for bad suite result in title
1259 | 		// use escape sequences in case file gets loaded with non-utf-8-charset
1260 | 		document.title = [
1261 | 			( config.stats.bad ? "\u2716" : "\u2714" ),
1262 | 			document.title.replace( /^[\u2714\u2716] /i, "" )
1263 | 		].join( " " );
1264 | 	}
1265 | 
1266 | 	// clear own sessionStorage items if all tests passed
1267 | 	if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) {
1268 | 		// `key` & `i` initialized at top of scope
1269 | 		for ( i = 0; i < sessionStorage.length; i++ ) {
1270 | 			key = sessionStorage.key( i++ );
1271 | 			if ( key.indexOf( "qunit-test-" ) === 0 ) {
1272 | 				sessionStorage.removeItem( key );
1273 | 			}
1274 | 		}
1275 | 	}
1276 | 
1277 | 	// scroll back to top to show results
1278 | 	if ( window.scrollTo ) {
1279 | 		window.scrollTo(0, 0);
1280 | 	}
1281 | 
1282 | 	runLoggingCallbacks( "done", QUnit, {
1283 | 		failed: config.stats.bad,
1284 | 		passed: passed,
1285 | 		total: config.stats.all,
1286 | 		runtime: runtime
1287 | 	});
1288 | }
1289 | 
1290 | /** @return Boolean: true if this test should be ran */
1291 | function validTest( test ) {
1292 | 	var include,
1293 | 		filter = config.filter && config.filter.toLowerCase(),
1294 | 		module = config.module && config.module.toLowerCase(),
1295 | 		fullName = (test.module + ": " + test.testName).toLowerCase();
1296 | 
1297 | 	// Internally-generated tests are always valid
1298 | 	if ( test.callback && test.callback.validTest === validTest ) {
1299 | 		delete test.callback.validTest;
1300 | 		return true;
1301 | 	}
1302 | 
1303 | 	if ( config.testNumber ) {
1304 | 		return test.testNumber === config.testNumber;
1305 | 	}
1306 | 
1307 | 	if ( module && ( !test.module || test.module.toLowerCase() !== module ) ) {
1308 | 		return false;
1309 | 	}
1310 | 
1311 | 	if ( !filter ) {
1312 | 		return true;
1313 | 	}
1314 | 
1315 | 	include = filter.charAt( 0 ) !== "!";
1316 | 	if ( !include ) {
1317 | 		filter = filter.slice( 1 );
1318 | 	}
1319 | 
1320 | 	// If the filter matches, we need to honour include
1321 | 	if ( fullName.indexOf( filter ) !== -1 ) {
1322 | 		return include;
1323 | 	}
1324 | 
1325 | 	// Otherwise, do the opposite
1326 | 	return !include;
1327 | }
1328 | 
1329 | // so far supports only Firefox, Chrome and Opera (buggy), Safari (for real exceptions)
1330 | // Later Safari and IE10 are supposed to support error.stack as well
1331 | // See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack
1332 | function extractStacktrace( e, offset ) {
1333 | 	offset = offset === undefined ? 3 : offset;
1334 | 
1335 | 	var stack, include, i;
1336 | 
1337 | 	if ( e.stacktrace ) {
1338 | 		// Opera
1339 | 		return e.stacktrace.split( "\n" )[ offset + 3 ];
1340 | 	} else if ( e.stack ) {
1341 | 		// Firefox, Chrome
1342 | 		stack = e.stack.split( "\n" );
1343 | 		if (/^error$/i.test( stack[0] ) ) {
1344 | 			stack.shift();
1345 | 		}
1346 | 		if ( fileName ) {
1347 | 			include = [];
1348 | 			for ( i = offset; i < stack.length; i++ ) {
1349 | 				if ( stack[ i ].indexOf( fileName ) !== -1 ) {
1350 | 					break;
1351 | 				}
1352 | 				include.push( stack[ i ] );
1353 | 			}
1354 | 			if ( include.length ) {
1355 | 				return include.join( "\n" );
1356 | 			}
1357 | 		}
1358 | 		return stack[ offset ];
1359 | 	} else if ( e.sourceURL ) {
1360 | 		// Safari, PhantomJS
1361 | 		// hopefully one day Safari provides actual stacktraces
1362 | 		// exclude useless self-reference for generated Error objects
1363 | 		if ( /qunit.js$/.test( e.sourceURL ) ) {
1364 | 			return;
1365 | 		}
1366 | 		// for actual exceptions, this is useful
1367 | 		return e.sourceURL + ":" + e.line;
1368 | 	}
1369 | }
1370 | function sourceFromStacktrace( offset ) {
1371 | 	try {
1372 | 		throw new Error();
1373 | 	} catch ( e ) {
1374 | 		return extractStacktrace( e, offset );
1375 | 	}
1376 | }
1377 | 
1378 | /**
1379 |  * Escape text for attribute or text content.
1380 |  */
1381 | function escapeText( s ) {
1382 | 	if ( !s ) {
1383 | 		return "";
1384 | 	}
1385 | 	s = s + "";
1386 | 	// Both single quotes and double quotes (for attributes)
1387 | 	return s.replace( /['"<>&]/g, function( s ) {
1388 | 		switch( s ) {
1389 | 			case '\'':
1390 | 				return '&#039;';
1391 | 			case '"':
1392 | 				return '&quot;';
1393 | 			case '<':
1394 | 				return '&lt;';
1395 | 			case '>':
1396 | 				return '&gt;';
1397 | 			case '&':
1398 | 				return '&amp;';
1399 | 		}
1400 | 	});
1401 | }
1402 | 
1403 | function synchronize( callback, last ) {
1404 | 	config.queue.push( callback );
1405 | 
1406 | 	if ( config.autorun && !config.blocking ) {
1407 | 		process( last );
1408 | 	}
1409 | }
1410 | 
1411 | function process( last ) {
1412 | 	function next() {
1413 | 		process( last );
1414 | 	}
1415 | 	var start = new Date().getTime();
1416 | 	config.depth = config.depth ? config.depth + 1 : 1;
1417 | 
1418 | 	while ( config.queue.length && !config.blocking ) {
1419 | 		if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new Date().getTime() - start ) < config.updateRate ) ) {
1420 | 			config.queue.shift()();
1421 | 		} else {
1422 | 			window.setTimeout( next, 13 );
1423 | 			break;
1424 | 		}
1425 | 	}
1426 | 	config.depth--;
1427 | 	if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) {
1428 | 		done();
1429 | 	}
1430 | }
1431 | 
1432 | function saveGlobal() {
1433 | 	config.pollution = [];
1434 | 
1435 | 	if ( config.noglobals ) {
1436 | 		for ( var key in window ) {
1437 | 			// in Opera sometimes DOM element ids show up here, ignore them
1438 | 			if ( !hasOwn.call( window, key ) || /^qunit-test-output/.test( key ) ) {
1439 | 				continue;
1440 | 			}
1441 | 			config.pollution.push( key );
1442 | 		}
1443 | 	}
1444 | }
1445 | 
1446 | function checkPollution() {
1447 | 	var newGlobals,
1448 | 		deletedGlobals,
1449 | 		old = config.pollution;
1450 | 
1451 | 	saveGlobal();
1452 | 
1453 | 	newGlobals = diff( config.pollution, old );
1454 | 	if ( newGlobals.length > 0 ) {
1455 | 		QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join(", ") );
1456 | 	}
1457 | 
1458 | 	deletedGlobals = diff( old, config.pollution );
1459 | 	if ( deletedGlobals.length > 0 ) {
1460 | 		QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join(", ") );
1461 | 	}
1462 | }
1463 | 
1464 | // returns a new Array with the elements that are in a but not in b
1465 | function diff( a, b ) {
1466 | 	var i, j,
1467 | 		result = a.slice();
1468 | 
1469 | 	for ( i = 0; i < result.length; i++ ) {
1470 | 		for ( j = 0; j < b.length; j++ ) {
1471 | 			if ( result[i] === b[j] ) {
1472 | 				result.splice( i, 1 );
1473 | 				i--;
1474 | 				break;
1475 | 			}
1476 | 		}
1477 | 	}
1478 | 	return result;
1479 | }
1480 | 
1481 | function extend( a, b ) {
1482 | 	for ( var prop in b ) {
1483 | 		if ( b[ prop ] === undefined ) {
1484 | 			delete a[ prop ];
1485 | 
1486 | 		// Avoid "Member not found" error in IE8 caused by setting window.constructor
1487 | 		} else if ( prop !== "constructor" || a !== window ) {
1488 | 			a[ prop ] = b[ prop ];
1489 | 		}
1490 | 	}
1491 | 
1492 | 	return a;
1493 | }
1494 | 
1495 | /**
1496 |  * @param {HTMLElement} elem
1497 |  * @param {string} type
1498 |  * @param {Function} fn
1499 |  */
1500 | function addEvent( elem, type, fn ) {
1501 | 	// Standards-based browsers
1502 | 	if ( elem.addEventListener ) {
1503 | 		elem.addEventListener( type, fn, false );
1504 | 	// IE
1505 | 	} else {
1506 | 		elem.attachEvent( "on" + type, fn );
1507 | 	}
1508 | }
1509 | 
1510 | /**
1511 |  * @param {Array|NodeList} elems
1512 |  * @param {string} type
1513 |  * @param {Function} fn
1514 |  */
1515 | function addEvents( elems, type, fn ) {
1516 | 	var i = elems.length;
1517 | 	while ( i-- ) {
1518 | 		addEvent( elems[i], type, fn );
1519 | 	}
1520 | }
1521 | 
1522 | function hasClass( elem, name ) {
1523 | 	return (" " + elem.className + " ").indexOf(" " + name + " ") > -1;
1524 | }
1525 | 
1526 | function addClass( elem, name ) {
1527 | 	if ( !hasClass( elem, name ) ) {
1528 | 		elem.className += (elem.className ? " " : "") + name;
1529 | 	}
1530 | }
1531 | 
1532 | function removeClass( elem, name ) {
1533 | 	var set = " " + elem.className + " ";
1534 | 	// Class name may appear multiple times
1535 | 	while ( set.indexOf(" " + name + " ") > -1 ) {
1536 | 		set = set.replace(" " + name + " " , " ");
1537 | 	}
1538 | 	// If possible, trim it for prettiness, but not neccecarily
1539 | 	elem.className = window.jQuery ? jQuery.trim( set ) : ( set.trim ? set.trim() : set );
1540 | }
1541 | 
1542 | function id( name ) {
1543 | 	return !!( typeof document !== "undefined" && document && document.getElementById ) &&
1544 | 		document.getElementById( name );
1545 | }
1546 | 
1547 | function registerLoggingCallback( key ) {
1548 | 	return function( callback ) {
1549 | 		config[key].push( callback );
1550 | 	};
1551 | }
1552 | 
1553 | // Supports deprecated method of completely overwriting logging callbacks
1554 | function runLoggingCallbacks( key, scope, args ) {
1555 | 	var i, callbacks;
1556 | 	if ( QUnit.hasOwnProperty( key ) ) {
1557 | 		QUnit[ key ].call(scope, args );
1558 | 	} else {
1559 | 		callbacks = config[ key ];
1560 | 		for ( i = 0; i < callbacks.length; i++ ) {
1561 | 			callbacks[ i ].call( scope, args );
1562 | 		}
1563 | 	}
1564 | }
1565 | 
1566 | // Test for equality any JavaScript type.
1567 | // Author: Philippe Rathé <prathe@gmail.com>
1568 | QUnit.equiv = (function() {
1569 | 
1570 | 	// Call the o related callback with the given arguments.
1571 | 	function bindCallbacks( o, callbacks, args ) {
1572 | 		var prop = QUnit.objectType( o );
1573 | 		if ( prop ) {
1574 | 			if ( QUnit.objectType( callbacks[ prop ] ) === "function" ) {
1575 | 				return callbacks[ prop ].apply( callbacks, args );
1576 | 			} else {
1577 | 				return callbacks[ prop ]; // or undefined
1578 | 			}
1579 | 		}
1580 | 	}
1581 | 
1582 | 	// the real equiv function
1583 | 	var innerEquiv,
1584 | 		// stack to decide between skip/abort functions
1585 | 		callers = [],
1586 | 		// stack to avoiding loops from circular referencing
1587 | 		parents = [],
1588 | 
1589 | 		getProto = Object.getPrototypeOf || function ( obj ) {
1590 | 			return obj.__proto__;
1591 | 		},
1592 | 		callbacks = (function () {
1593 | 
1594 | 			// for string, boolean, number and null
1595 | 			function useStrictEquality( b, a ) {
1596 | 				/*jshint eqeqeq:false */
1597 | 				if ( b instanceof a.constructor || a instanceof b.constructor ) {
1598 | 					// to catch short annotaion VS 'new' annotation of a
1599 | 					// declaration
1600 | 					// e.g. var i = 1;
1601 | 					// var j = new Number(1);
1602 | 					return a == b;
1603 | 				} else {
1604 | 					return a === b;
1605 | 				}
1606 | 			}
1607 | 
1608 | 			return {
1609 | 				"string": useStrictEquality,
1610 | 				"boolean": useStrictEquality,
1611 | 				"number": useStrictEquality,
1612 | 				"null": useStrictEquality,
1613 | 				"undefined": useStrictEquality,
1614 | 
1615 | 				"nan": function( b ) {
1616 | 					return isNaN( b );
1617 | 				},
1618 | 
1619 | 				"date": function( b, a ) {
1620 | 					return QUnit.objectType( b ) === "date" && a.valueOf() === b.valueOf();
1621 | 				},
1622 | 
1623 | 				"regexp": function( b, a ) {
1624 | 					return QUnit.objectType( b ) === "regexp" &&
1625 | 						// the regex itself
1626 | 						a.source === b.source &&
1627 | 						// and its modifers
1628 | 						a.global === b.global &&
1629 | 						// (gmi) ...
1630 | 						a.ignoreCase === b.ignoreCase &&
1631 | 						a.multiline === b.multiline &&
1632 | 						a.sticky === b.sticky;
1633 | 				},
1634 | 
1635 | 				// - skip when the property is a method of an instance (OOP)
1636 | 				// - abort otherwise,
1637 | 				// initial === would have catch identical references anyway
1638 | 				"function": function() {
1639 | 					var caller = callers[callers.length - 1];
1640 | 					return caller !== Object && typeof caller !== "undefined";
1641 | 				},
1642 | 
1643 | 				"array": function( b, a ) {
1644 | 					var i, j, len, loop;
1645 | 
1646 | 					// b could be an object literal here
1647 | 					if ( QUnit.objectType( b ) !== "array" ) {
1648 | 						return false;
1649 | 					}
1650 | 
1651 | 					len = a.length;
1652 | 					if ( len !== b.length ) {
1653 | 						// safe and faster
1654 | 						return false;
1655 | 					}
1656 | 
1657 | 					// track reference to avoid circular references
1658 | 					parents.push( a );
1659 | 					for ( i = 0; i < len; i++ ) {
1660 | 						loop = false;
1661 | 						for ( j = 0; j < parents.length; j++ ) {
1662 | 							if ( parents[j] === a[i] ) {
1663 | 								loop = true;// dont rewalk array
1664 | 							}
1665 | 						}
1666 | 						if ( !loop && !innerEquiv(a[i], b[i]) ) {
1667 | 							parents.pop();
1668 | 							return false;
1669 | 						}
1670 | 					}
1671 | 					parents.pop();
1672 | 					return true;
1673 | 				},
1674 | 
1675 | 				"object": function( b, a ) {
1676 | 					var i, j, loop,
1677 | 						// Default to true
1678 | 						eq = true,
1679 | 						aProperties = [],
1680 | 						bProperties = [];
1681 | 
1682 | 					// comparing constructors is more strict than using
1683 | 					// instanceof
1684 | 					if ( a.constructor !== b.constructor ) {
1685 | 						// Allow objects with no prototype to be equivalent to
1686 | 						// objects with Object as their constructor.
1687 | 						if ( !(( getProto(a) === null && getProto(b) === Object.prototype ) ||
1688 | 							( getProto(b) === null && getProto(a) === Object.prototype ) ) ) {
1689 | 								return false;
1690 | 						}
1691 | 					}
1692 | 
1693 | 					// stack constructor before traversing properties
1694 | 					callers.push( a.constructor );
1695 | 					// track reference to avoid circular references
1696 | 					parents.push( a );
1697 | 
1698 | 					for ( i in a ) { // be strict: don't ensures hasOwnProperty
1699 | 									// and go deep
1700 | 						loop = false;
1701 | 						for ( j = 0; j < parents.length; j++ ) {
1702 | 							if ( parents[j] === a[i] ) {
1703 | 								// don't go down the same path twice
1704 | 								loop = true;
1705 | 							}
1706 | 						}
1707 | 						aProperties.push(i); // collect a's properties
1708 | 
1709 | 						if (!loop && !innerEquiv( a[i], b[i] ) ) {
1710 | 							eq = false;
1711 | 							break;
1712 | 						}
1713 | 					}
1714 | 
1715 | 					callers.pop(); // unstack, we are done
1716 | 					parents.pop();
1717 | 
1718 | 					for ( i in b ) {
1719 | 						bProperties.push( i ); // collect b's properties
1720 | 					}
1721 | 
1722 | 					// Ensures identical properties name
1723 | 					return eq && innerEquiv( aProperties.sort(), bProperties.sort() );
1724 | 				}
1725 | 			};
1726 | 		}());
1727 | 
1728 | 	innerEquiv = function() { // can take multiple arguments
1729 | 		var args = [].slice.apply( arguments );
1730 | 		if ( args.length < 2 ) {
1731 | 			return true; // end transition
1732 | 		}
1733 | 
1734 | 		return (function( a, b ) {
1735 | 			if ( a === b ) {
1736 | 				return true; // catch the most you can
1737 | 			} else if ( a === null || b === null || typeof a === "undefined" ||
1738 | 					typeof b === "undefined" ||
1739 | 					QUnit.objectType(a) !== QUnit.objectType(b) ) {
1740 | 				return false; // don't lose time with error prone cases
1741 | 			} else {
1742 | 				return bindCallbacks(a, callbacks, [ b, a ]);
1743 | 			}
1744 | 
1745 | 			// apply transition with (1..n) arguments
1746 | 		}( args[0], args[1] ) && arguments.callee.apply( this, args.splice(1, args.length - 1 )) );
1747 | 	};
1748 | 
1749 | 	return innerEquiv;
1750 | }());
1751 | 
1752 | /**
1753 |  * jsDump Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com |
1754 |  * http://flesler.blogspot.com Licensed under BSD
1755 |  * (http://www.opensource.org/licenses/bsd-license.php) Date: 5/15/2008
1756 |  *
1757 |  * @projectDescription Advanced and extensible data dumping for Javascript.
1758 |  * @version 1.0.0
1759 |  * @author Ariel Flesler
1760 |  * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
1761 |  */
1762 | QUnit.jsDump = (function() {
1763 | 	function quote( str ) {
1764 | 		return '"' + str.toString().replace( /"/g, '\\"' ) + '"';
1765 | 	}
1766 | 	function literal( o ) {
1767 | 		return o + "";
1768 | 	}
1769 | 	function join( pre, arr, post ) {
1770 | 		var s = jsDump.separator(),
1771 | 			base = jsDump.indent(),
1772 | 			inner = jsDump.indent(1);
1773 | 		if ( arr.join ) {
1774 | 			arr = arr.join( "," + s + inner );
1775 | 		}
1776 | 		if ( !arr ) {
1777 | 			return pre + post;
1778 | 		}
1779 | 		return [ pre, inner + arr, base + post ].join(s);
1780 | 	}
1781 | 	function array( arr, stack ) {
1782 | 		var i = arr.length, ret = new Array(i);
1783 | 		this.up();
1784 | 		while ( i-- ) {
1785 | 			ret[i] = this.parse( arr[i] , undefined , stack);
1786 | 		}
1787 | 		this.down();
1788 | 		return join( "[", ret, "]" );
1789 | 	}
1790 | 
1791 | 	var reName = /^function (\w+)/,
1792 | 		jsDump = {
1793 | 			// type is used mostly internally, you can fix a (custom)type in advance
1794 | 			parse: function( obj, type, stack ) {
1795 | 				stack = stack || [ ];
1796 | 				var inStack, res,
1797 | 					parser = this.parsers[ type || this.typeOf(obj) ];
1798 | 
1799 | 				type = typeof parser;
1800 | 				inStack = inArray( obj, stack );
1801 | 
1802 | 				if ( inStack !== -1 ) {
1803 | 					return "recursion(" + (inStack - stack.length) + ")";
1804 | 				}
1805 | 				if ( type === "function" )  {
1806 | 					stack.push( obj );
1807 | 					res = parser.call( this, obj, stack );
1808 | 					stack.pop();
1809 | 					return res;
1810 | 				}
1811 | 				return ( type === "string" ) ? parser : this.parsers.error;
1812 | 			},
1813 | 			typeOf: function( obj ) {
1814 | 				var type;
1815 | 				if ( obj === null ) {
1816 | 					type = "null";
1817 | 				} else if ( typeof obj === "undefined" ) {
1818 | 					type = "undefined";
1819 | 				} else if ( QUnit.is( "regexp", obj) ) {
1820 | 					type = "regexp";
1821 | 				} else if ( QUnit.is( "date", obj) ) {
1822 | 					type = "date";
1823 | 				} else if ( QUnit.is( "function", obj) ) {
1824 | 					type = "function";
1825 | 				} else if ( typeof obj.setInterval !== undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === "undefined" ) {
1826 | 					type = "window";
1827 | 				} else if ( obj.nodeType === 9 ) {
1828 | 					type = "document";
1829 | 				} else if ( obj.nodeType ) {
1830 | 					type = "node";
1831 | 				} else if (
1832 | 					// native arrays
1833 | 					toString.call( obj ) === "[object Array]" ||
1834 | 					// NodeList objects
1835 | 					( typeof obj.length === "number" && typeof obj.item !== "undefined" && ( obj.length ? obj.item(0) === obj[0] : ( obj.item( 0 ) === null && typeof obj[0] === "undefined" ) ) )
1836 | 				) {
1837 | 					type = "array";
1838 | 				} else if ( obj.constructor === Error.prototype.constructor ) {
1839 | 					type = "error";
1840 | 				} else {
1841 | 					type = typeof obj;
1842 | 				}
1843 | 				return type;
1844 | 			},
1845 | 			separator: function() {
1846 | 				return this.multiline ?	this.HTML ? "<br />" : "\n" : this.HTML ? "&nbsp;" : " ";
1847 | 			},
1848 | 			// extra can be a number, shortcut for increasing-calling-decreasing
1849 | 			indent: function( extra ) {
1850 | 				if ( !this.multiline ) {
1851 | 					return "";
1852 | 				}
1853 | 				var chr = this.indentChar;
1854 | 				if ( this.HTML ) {
1855 | 					chr = chr.replace( /\t/g, "   " ).replace( / /g, "&nbsp;" );
1856 | 				}
1857 | 				return new Array( this._depth_ + (extra||0) ).join(chr);
1858 | 			},
1859 | 			up: function( a ) {
1860 | 				this._depth_ += a || 1;
1861 | 			},
1862 | 			down: function( a ) {
1863 | 				this._depth_ -= a || 1;
1864 | 			},
1865 | 			setParser: function( name, parser ) {
1866 | 				this.parsers[name] = parser;
1867 | 			},
1868 | 			// The next 3 are exposed so you can use them
1869 | 			quote: quote,
1870 | 			literal: literal,
1871 | 			join: join,
1872 | 			//
1873 | 			_depth_: 1,
1874 | 			// This is the list of parsers, to modify them, use jsDump.setParser
1875 | 			parsers: {
1876 | 				window: "[Window]",
1877 | 				document: "[Document]",
1878 | 				error: function(error) {
1879 | 					return "Error(\"" + error.message + "\")";
1880 | 				},
1881 | 				unknown: "[Unknown]",
1882 | 				"null": "null",
1883 | 				"undefined": "undefined",
1884 | 				"function": function( fn ) {
1885 | 					var ret = "function",
1886 | 						// functions never have name in IE
1887 | 						name = "name" in fn ? fn.name : (reName.exec(fn) || [])[1];
1888 | 
1889 | 					if ( name ) {
1890 | 						ret += " " + name;
1891 | 					}
1892 | 					ret += "( ";
1893 | 
1894 | 					ret = [ ret, QUnit.jsDump.parse( fn, "functionArgs" ), "){" ].join( "" );
1895 | 					return join( ret, QUnit.jsDump.parse(fn,"functionCode" ), "}" );
1896 | 				},
1897 | 				array: array,
1898 | 				nodelist: array,
1899 | 				"arguments": array,
1900 | 				object: function( map, stack ) {
1901 | 					var ret = [ ], keys, key, val, i;
1902 | 					QUnit.jsDump.up();
1903 | 					keys = [];
1904 | 					for ( key in map ) {
1905 | 						keys.push( key );
1906 | 					}
1907 | 					keys.sort();
1908 | 					for ( i = 0; i < keys.length; i++ ) {
1909 | 						key = keys[ i ];
1910 | 						val = map[ key ];
1911 | 						ret.push( QUnit.jsDump.parse( key, "key" ) + ": " + QUnit.jsDump.parse( val, undefined, stack ) );
1912 | 					}
1913 | 					QUnit.jsDump.down();
1914 | 					return join( "{", ret, "}" );
1915 | 				},
1916 | 				node: function( node ) {
1917 | 					var len, i, val,
1918 | 						open = QUnit.jsDump.HTML ? "&lt;" : "<",
1919 | 						close = QUnit.jsDump.HTML ? "&gt;" : ">",
1920 | 						tag = node.nodeName.toLowerCase(),
1921 | 						ret = open + tag,
1922 | 						attrs = node.attributes;
1923 | 
1924 | 					if ( attrs ) {
1925 | 						for ( i = 0, len = attrs.length; i < len; i++ ) {
1926 | 							val = attrs[i].nodeValue;
1927 | 							// IE6 includes all attributes in .attributes, even ones not explicitly set.
1928 | 							// Those have values like undefined, null, 0, false, "" or "inherit".
1929 | 							if ( val && val !== "inherit" ) {
1930 | 								ret += " " + attrs[i].nodeName + "=" + QUnit.jsDump.parse( val, "attribute" );
1931 | 							}
1932 | 						}
1933 | 					}
1934 | 					ret += close;
1935 | 
1936 | 					// Show content of TextNode or CDATASection
1937 | 					if ( node.nodeType === 3 || node.nodeType === 4 ) {
1938 | 						ret += node.nodeValue;
1939 | 					}
1940 | 
1941 | 					return ret + open + "/" + tag + close;
1942 | 				},
1943 | 				// function calls it internally, it's the arguments part of the function
1944 | 				functionArgs: function( fn ) {
1945 | 					var args,
1946 | 						l = fn.length;
1947 | 
1948 | 					if ( !l ) {
1949 | 						return "";
1950 | 					}
1951 | 
1952 | 					args = new Array(l);
1953 | 					while ( l-- ) {
1954 | 						// 97 is 'a'
1955 | 						args[l] = String.fromCharCode(97+l);
1956 | 					}
1957 | 					return " " + args.join( ", " ) + " ";
1958 | 				},
1959 | 				// object calls it internally, the key part of an item in a map
1960 | 				key: quote,
1961 | 				// function calls it internally, it's the content of the function
1962 | 				functionCode: "[code]",
1963 | 				// node calls it internally, it's an html attribute value
1964 | 				attribute: quote,
1965 | 				string: quote,
1966 | 				date: quote,
1967 | 				regexp: literal,
1968 | 				number: literal,
1969 | 				"boolean": literal
1970 | 			},
1971 | 			// if true, entities are escaped ( <, >, \t, space and \n )
1972 | 			HTML: false,
1973 | 			// indentation unit
1974 | 			indentChar: "  ",
1975 | 			// if true, items in a collection, are separated by a \n, else just a space.
1976 | 			multiline: true
1977 | 		};
1978 | 
1979 | 	return jsDump;
1980 | }());
1981 | 
1982 | // from jquery.js
1983 | function inArray( elem, array ) {
1984 | 	if ( array.indexOf ) {
1985 | 		return array.indexOf( elem );
1986 | 	}
1987 | 
1988 | 	for ( var i = 0, length = array.length; i < length; i++ ) {
1989 | 		if ( array[ i ] === elem ) {
1990 | 			return i;
1991 | 		}
1992 | 	}
1993 | 
1994 | 	return -1;
1995 | }
1996 | 
1997 | /*
1998 |  * Javascript Diff Algorithm
1999 |  *  By John Resig (http://ejohn.org/)
2000 |  *  Modified by Chu Alan "sprite"
2001 |  *
2002 |  * Released under the MIT license.
2003 |  *
2004 |  * More Info:
2005 |  *  http://ejohn.org/projects/javascript-diff-algorithm/
2006 |  *
2007 |  * Usage: QUnit.diff(expected, actual)
2008 |  *
2009 |  * 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"
2010 |  */
2011 | QUnit.diff = (function() {
2012 | 	/*jshint eqeqeq:false, eqnull:true */
2013 | 	function diff( o, n ) {
2014 | 		var i,
2015 | 			ns = {},
2016 | 			os = {};
2017 | 
2018 | 		for ( i = 0; i < n.length; i++ ) {
2019 | 			if ( !hasOwn.call( ns, n[i] ) ) {
2020 | 				ns[ n[i] ] = {
2021 | 					rows: [],
2022 | 					o: null
2023 | 				};
2024 | 			}
2025 | 			ns[ n[i] ].rows.push( i );
2026 | 		}
2027 | 
2028 | 		for ( i = 0; i < o.length; i++ ) {
2029 | 			if ( !hasOwn.call( os, o[i] ) ) {
2030 | 				os[ o[i] ] = {
2031 | 					rows: [],
2032 | 					n: null
2033 | 				};
2034 | 			}
2035 | 			os[ o[i] ].rows.push( i );
2036 | 		}
2037 | 
2038 | 		for ( i in ns ) {
2039 | 			if ( !hasOwn.call( ns, i ) ) {
2040 | 				continue;
2041 | 			}
2042 | 			if ( ns[i].rows.length === 1 && hasOwn.call( os, i ) && os[i].rows.length === 1 ) {
2043 | 				n[ ns[i].rows[0] ] = {
2044 | 					text: n[ ns[i].rows[0] ],
2045 | 					row: os[i].rows[0]
2046 | 				};
2047 | 				o[ os[i].rows[0] ] = {
2048 | 					text: o[ os[i].rows[0] ],
2049 | 					row: ns[i].rows[0]
2050 | 				};
2051 | 			}
2052 | 		}
2053 | 
2054 | 		for ( i = 0; i < n.length - 1; i++ ) {
2055 | 			if ( n[i].text != null && n[ i + 1 ].text == null && n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null &&
2056 | 						n[ i + 1 ] == o[ n[i].row + 1 ] ) {
2057 | 
2058 | 				n[ i + 1 ] = {
2059 | 					text: n[ i + 1 ],
2060 | 					row: n[i].row + 1
2061 | 				};
2062 | 				o[ n[i].row + 1 ] = {
2063 | 					text: o[ n[i].row + 1 ],
2064 | 					row: i + 1
2065 | 				};
2066 | 			}
2067 | 		}
2068 | 
2069 | 		for ( i = n.length - 1; i > 0; i-- ) {
2070 | 			if ( n[i].text != null && n[ i - 1 ].text == null && n[i].row > 0 && o[ n[i].row - 1 ].text == null &&
2071 | 						n[ i - 1 ] == o[ n[i].row - 1 ]) {
2072 | 
2073 | 				n[ i - 1 ] = {
2074 | 					text: n[ i - 1 ],
2075 | 					row: n[i].row - 1
2076 | 				};
2077 | 				o[ n[i].row - 1 ] = {
2078 | 					text: o[ n[i].row - 1 ],
2079 | 					row: i - 1
2080 | 				};
2081 | 			}
2082 | 		}
2083 | 
2084 | 		return {
2085 | 			o: o,
2086 | 			n: n
2087 | 		};
2088 | 	}
2089 | 
2090 | 	return function( o, n ) {
2091 | 		o = o.replace( /\s+$/, "" );
2092 | 		n = n.replace( /\s+$/, "" );
2093 | 
2094 | 		var i, pre,
2095 | 			str = "",
2096 | 			out = diff( o === "" ? [] : o.split(/\s+/), n === "" ? [] : n.split(/\s+/) ),
2097 | 			oSpace = o.match(/\s+/g),
2098 | 			nSpace = n.match(/\s+/g);
2099 | 
2100 | 		if ( oSpace == null ) {
2101 | 			oSpace = [ " " ];
2102 | 		}
2103 | 		else {
2104 | 			oSpace.push( " " );
2105 | 		}
2106 | 
2107 | 		if ( nSpace == null ) {
2108 | 			nSpace = [ " " ];
2109 | 		}
2110 | 		else {
2111 | 			nSpace.push( " " );
2112 | 		}
2113 | 
2114 | 		if ( out.n.length === 0 ) {
2115 | 			for ( i = 0; i < out.o.length; i++ ) {
2116 | 				str += "<del>" + out.o[i] + oSpace[i] + "</del>";
2117 | 			}
2118 | 		}
2119 | 		else {
2120 | 			if ( out.n[0].text == null ) {
2121 | 				for ( n = 0; n < out.o.length && out.o[n].text == null; n++ ) {
2122 | 					str += "<del>" + out.o[n] + oSpace[n] + "</del>";
2123 | 				}
2124 | 			}
2125 | 
2126 | 			for ( i = 0; i < out.n.length; i++ ) {
2127 | 				if (out.n[i].text == null) {
2128 | 					str += "<ins>" + out.n[i] + nSpace[i] + "</ins>";
2129 | 				}
2130 | 				else {
2131 | 					// `pre` initialized at top of scope
2132 | 					pre = "";
2133 | 
2134 | 					for ( n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++ ) {
2135 | 						pre += "<del>" + out.o[n] + oSpace[n] + "</del>";
2136 | 					}
2137 | 					str += " " + out.n[i].text + nSpace[i] + pre;
2138 | 				}
2139 | 			}
2140 | 		}
2141 | 
2142 | 		return str;
2143 | 	};
2144 | }());
2145 | 
2146 | // for CommonJS enviroments, export everything
2147 | if ( typeof exports !== "undefined" ) {
2148 | 	extend( exports, QUnit );
2149 | }
2150 | 
2151 | // get at whatever the global object is, like window in browsers
2152 | }( (function() {return this;}.call()) ));
2153 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "jquery-plugin",
 3 |   "version": "0.0.0-ignored",
 4 |   "engines": {
 5 |     "node": ">= 0.8.0"
 6 |   },
 7 |   "scripts": {
 8 |     "test": "grunt qunit"
 9 |   },
10 |   "devDependencies": {
11 |     "grunt-contrib-jshint": "~0.10.0",
12 |     "grunt-contrib-qunit": "~0.2.0",
13 |     "grunt-contrib-concat": "~0.3.0",
14 |     "grunt-contrib-uglify": "~0.2.0",
15 |     "grunt-contrib-watch": "~0.4.0",
16 |     "grunt-contrib-clean": "~0.4.0",
17 |     "grunt": "~0.4.5"
18 |   }
19 | }


--------------------------------------------------------------------------------
/src/.jshintrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "curly": true,
 3 |   "eqeqeq": true,
 4 |   "immed": true,
 5 |   "latedef": true,
 6 |   "newcap": true,
 7 |   "noarg": true,
 8 |   "sub": true,
 9 |   "undef": true,
10 |   "unused": true,
11 |   "boss": true,
12 |   "eqnull": true,
13 |   "browser": true,
14 |   "predef": ["jQuery"]
15 | }
16 | 


--------------------------------------------------------------------------------
/src/textbox-revision-tracker.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * ~textbox-revision-tracker~
  3 |  *
  4 |  * A jQuery plugin to track text revisions to HTML inputs or text areas. Revisions can be saved, undone, redone,
  5 |  * diffed and fetched. Revision data of text, time of revision and revision number are stored.
  6 |  *
  7 |  * Source: https://github.com/jonmbake/jquery-textbox-revision-tracker
  8 |  * Demo: http://jonmbake.github.io/textbox-revision-tracker/demo.html
  9 |  *
 10 |  *
 11 |  * Copyright (c) 2015 Jon Bake
 12 |  * Licensed under the MIT license.
 13 |  */
 14 | (function($) {
 15 |   /**
 16 |    * Revision Tracker Base Class.
 17 |    * @constructor
 18 |    * @param {[type]} $el     jqeury element to attach revision tracker to
 19 |    * @param {[type]} options options -
 20 |    * Valid Options are:
 21 |    *   autoSave (integer) - will automatically create a revision after X seconds of paused typing
 22 |    *   diffFunction (function) - function to call when  performing a diff through the API
 23 |    */
 24 |   var RevisionTracker = function ($el, options) {
 25 |     options = options || {};
 26 | 
 27 |     this.$el = $el;
 28 |     this.revisions = [];
 29 |     this.undoneRevisions = [];
 30 | 
 31 |     this.diffFunction = options.diffFunction;
 32 |     if (options.autoSave) {
 33 |       var lastChange, saveAfter = parseInt(options.autoSave, 10);
 34 |       $el.on('change', function () {
 35 |         var now = Date.now();
 36 |         this.saveRevision((now - lastChange)/1000 > saveAfter);
 37 |         lastChange = now;
 38 |       }.bind(this));
 39 |     }
 40 |   };
 41 |   $.extend(RevisionTracker.prototype, {
 42 |     /**
 43 |      * Saves a revision if predicate passes truth test.
 44 |      *
 45 |      * @param  {Boolean} predicate - only save if predicate evaluates to true (or is undefined)
 46 |      * @return {Object} Revison with property of text and time
 47 |      */
 48 |     saveRevision: function (predicate) {
 49 |       if (predicate === void 0 || predicate === true) {
 50 |         this.revisions.push({text: this.$el.val(), time: Date.now()});
 51 |       }
 52 |     },
 53 |     /**
 54 |      * Get last revision made.
 55 |      * @return {Object} Revison with property of text and time
 56 |      */
 57 |     lastRevision: function () {
 58 |       return this.revisions[this.revisions.length - 1];
 59 |     },
 60 |     /**
 61 |      * Pop a revision from revisions to undone revisions (or vice versa if reverse is true).
 62 |      *
 63 |      * @param  {boolean} reverse if true pop from undone revisions to revisions
 64 |      * @param  {number} popTo   pop to a specific revisions
 65 |      * @return {Object} poped revison
 66 |      */
 67 |     popRevision: function (reverse, popTo) {
 68 |       var popped,
 69 |         fromArray = reverse ? this.undoneRevisions : this.revisions;
 70 |       if (fromArray.length === 0) {
 71 |         return;
 72 |       }
 73 |       if (popTo) {
 74 |         popped = fromArray.splice(popTo)[0];
 75 |       } else {
 76 |         popped = fromArray.pop();
 77 |       }
 78 |       (reverse ? this.revisions : this.undoneRevisions).push(popped);
 79 |       if (this.revisions.length > 0) {
 80 |         this.$el.val(this.lastRevision().text);
 81 |       } else {
 82 |         this.$el.val('');
 83 |       }
 84 |       return popped;
 85 |     },
 86 |     /**
 87 |      * Get a particular revision.
 88 |      *
 89 |      * @param  {number} revisionNumber number of revision to get
 90 |      * @return {Object} Revison with property of text and time
 91 |      */
 92 |     getRevision: function (revisionNumber) {
 93 |       return this.revisions[parseInt(revisionNumber, 10) - 1];
 94 |     },
 95 |     /**
 96 |      * Go to a revision number.
 97 |      *
 98 |      * @param  {number} revisionNumber revision number to make active
 99 |      * @return {Object} newly active revision
100 |      */
101 |     goToRevision: function (revisionNumber) {
102 |       revisionNumber = parseInt(revisionNumber, 10);
103 |       if (revisionNumber < 0 || revisionNumber > this.revisions.length) {
104 |         throw new Error('Attempting to go to an invalid revision number');
105 |       }
106 |       return this.popRevision(false, revisionNumber);
107 |     },
108 |     /**
109 |      * Undo the last revision.
110 |      *
111 |      * @return {object} undone revision
112 |      */
113 |     undo: function () {
114 |       return this.popRevision();
115 |     },
116 |     /**
117 |      * Redo a revision.
118 |      *
119 |      * @return {object} revision that was re-applied
120 |      */
121 |     redo: function () {
122 |       return this.popRevision(true);
123 |     },
124 |     /**
125 |      * Diff two revisions.
126 |      *
127 |      * @param  {number} firstRevNumber  first revision
128 |      * @param  {number} secondRevNumber second revision
129 |      * @return {string}                 diff of first and second revision
130 |      */
131 |     diff: function (firstRevNumber, secondRevNumber) {
132 |       if (!this.diffFunction) {
133 |         throw new Error('In order to use RevisionTracker#diff, a diffFunction must be supplied as an option');
134 |       }
135 |       var first = this.getRevision(firstRevNumber) || {text: ''},
136 |         second = this.getRevision(secondRevNumber);
137 |       if (second) {
138 |         return this.diffFunction(first.text, second.text);
139 |       }
140 |     }
141 |   });
142 |   /**
143 |    * Returns revision track data for element.
144 |    *
145 |    * @return {RevisionTracker} revision tracker obj.
146 |    */
147 |   var getData = function ($el) {
148 |     var rt = $el.data('revisionTracker');
149 |     if (!rt) {
150 |       throw new Error('Element is currently not tracking revisions');
151 |     }
152 |     return rt;
153 |   };
154 |   /**
155 |    * Public API.
156 |    *
157 |    * @type {Object} api
158 |    */
159 |   var api = {
160 |     /**
161 |      * Inititialize this element to track revisions.
162 |      *
163 |      * @param  {Object} options revision
164 |      * @return {[type]}         [description]
165 |      */
166 |     init: function (options) {
167 |       var rt = new RevisionTracker(this, options);
168 |       this.data('revisionTracker', rt);
169 |       return this;
170 |     },
171 |     /**
172 |      * Get revisions for an element.
173 |      *
174 |      * @param  {jQuery element} $el element to get revisions for
175 |      * @return {Array} revision history
176 |      */
177 |     revisions: function () {
178 |       //also include revision number
179 |       return getData(this).revisions.map(function (val, index) {
180 |         val.revisionNumber = index + 1;
181 |         return val;
182 |       });
183 |     },
184 |     /**
185 |      * @see {@link RevisionTracker.prototype.saveRevision}
186 |      */
187 |     save: function () {
188 |       //can bypass saving if last revision is the same
189 |       var d = getData(this);
190 |       var lastRev = d.lastRevision();
191 |       if (lastRev && lastRev.text === this.val()) {
192 |         return lastRev;
193 |       }
194 |       return getData(this).saveRevision();
195 |     },
196 |     /**
197 |      * @see {@link RevisionTracker.prototype.getRevision}
198 |      */
199 |     getRevision: function (revisionNumber) {
200 |       return getData(this).getRevision(revisionNumber);
201 |     },
202 |     /**
203 |      * @see {@link RevisionTracker.prototype.undo}
204 |      */
205 |     undo: function () {
206 |        return getData(this).undo();
207 |     },
208 |     /**
209 |      * @see {@link RevisionTracker.prototype.redo}
210 |      */
211 |     redo: function () {
212 |        return getData(this).redo();
213 |     },
214 |     /**
215 |      * @see {@link RevisionTracker.prototype.goToRevision}
216 |      */
217 |     goToRevision: function (revisionNumber) {
218 |        return getData(this).goToRevision(revisionNumber);
219 |     },
220 |     /**
221 |      * @see {@link RevisionTracker.prototype.diff}
222 |      */
223 |     getDiff: function (firstRevNumber, secondRevNumber) {
224 |       return getData(this).diff(firstRevNumber, secondRevNumber);
225 |     }
226 |   };	
227 |   //Expose the plugin!
228 |   $.fn.revisionTracker = function(firstArg) {
229 |     var pluginArgs = arguments;
230 |     var isApiCall = typeof firstArg === 'string';
231 |     var r = this.filter('textarea,input').map(function () {
232 |       if (firstArg === void 0 || typeof firstArg === 'object') { //calling the constructor
233 |         return api.init.call($(this), firstArg);
234 |       } else if (isApiCall && api[firstArg]) { //calling an API method
235 |         return api[firstArg].apply($(this), Array.prototype.slice.call(pluginArgs, 1));
236 |       } else { //calling a method that is not part of the API -- throw an error
237 |         throw new Error("Calling method that is not part of the API");
238 |       }
239 |     });
240 |     //if API call, "un-jquery" the return value 
241 |     if (isApiCall) {
242 |       //if a "get" call just return a single element
243 |       if (firstArg.indexOf('get') === 0) {
244 |         return r[0];
245 |       }
246 |       return r.toArray();
247 |     }
248 |     return r;
249 |   };
250 | }(jQuery));
251 | 


--------------------------------------------------------------------------------
/test/.jshintrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "curly": true,
 3 |   "eqeqeq": true,
 4 |   "immed": true,
 5 |   "latedef": true,
 6 |   "newcap": true,
 7 |   "noarg": true,
 8 |   "sub": true,
 9 |   "undef": true,
10 |   "unused": true,
11 |   "boss": true,
12 |   "eqnull": true,
13 |   "browser": true,
14 |   "predef": [
15 |     "jQuery",
16 |     "QUnit",
17 |     "module",
18 |     "test",
19 |     "asyncTest",
20 |     "expect",
21 |     "start",
22 |     "stop",
23 |     "ok",
24 |     "equal",
25 |     "notEqual",
26 |     "deepEqual",
27 |     "notDeepEqual",
28 |     "strictEqual",
29 |     "notStrictEqual",
30 |     "throws"
31 |   ]
32 | }


--------------------------------------------------------------------------------
/test/textbox-revision-tracker.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <title>Textbox Revision Tracker Test Suite</title>
 6 |   <!-- Load local jQuery. This can be overridden with a ?jquery=___ param. -->
 7 |   <script src="../libs/jquery-loader.js"></script>
 8 |   <!-- Load local QUnit. -->
 9 |   <link rel="stylesheet" href="../libs/qunit/qunit.css" media="screen">
10 |   <script src="../libs/qunit/qunit.js"></script>
11 |   <script src="../libs/diff.js"></script>
12 |   <!-- Load local lib and tests. -->
13 |   <script src="../src/textbox-revision-tracker.js"></script>
14 |   <script src="textbox-revision-tracker_test.js"></script>
15 |   <!-- Removing access to jQuery and $. But it'll still be available as _$, if
16 |        you REALLY want to mess around with jQuery in the console. REMEMBER WE
17 |        ARE TESTING A PLUGIN HERE, THIS HELPS ENSURE BEST PRACTICES. REALLY. -->
18 |   <script>window._$ = jQuery.noConflict(true);</script>
19 | </head>
20 | <body>
21 |   <textarea id="qunit-fixture"></textarea>
22 | </body>
23 | </html>
24 | 


--------------------------------------------------------------------------------
/test/textbox-revision-tracker_test.js:
--------------------------------------------------------------------------------
 1 | (function($) {
 2 |   /*
 3 |     ======== A Handy Little QUnit Reference ========
 4 |     http://api.qunitjs.com/
 5 | 
 6 |     Test methods:
 7 |       module(name, {[setup][ ,teardown]})
 8 |       test(name, callback)
 9 |       expect(numberOfAssertions)
10 |       stop(increment)
11 |       start(decrement)
12 |     Test assertions:
13 |       ok(value, [message])
14 |       equal(actual, expected, [message])
15 |       notEqual(actual, expected, [message])
16 |       deepEqual(actual, expected, [message])
17 |       notDeepEqual(actual, expected, [message])
18 |       strictEqual(actual, expected, [message])
19 |       notStrictEqual(actual, expected, [message])
20 |       throws(block, [expected], [message])
21 |   */
22 | 
23 |   module('jQuery#textbox_revision_tracker', {
24 |     // This will run before each test in this module.
25 |     setup: function() {
26 |       this.$elem = $('#qunit-fixture');
27 |       this.rt = this.$elem.revisionTracker({diffFunction: window.diffString});
28 |     },
29 |     saveAFewRevs: function () {
30 |       this.$elem.val('foo');
31 |       this.$elem.revisionTracker('save');
32 |       this.$elem.val('foo bar');
33 |       this.$elem.revisionTracker('save');
34 |     }
35 |   });
36 | 
37 |   test('can save revisions', function() {
38 |     expect(1);
39 |     this.saveAFewRevs();
40 |     equal(this.$elem.revisionTracker('revisions').length, 2, 'There is one revision added');
41 |   });
42 | 
43 |   test('should not save revison if text has not changed', function() {
44 |     expect(1);
45 |     this.$elem.val('foo');
46 |     this.$elem.revisionTracker('save');
47 |     this.$elem.revisionTracker('save');
48 |     equal(this.$elem.revisionTracker('revisions').length, 1);
49 |   });
50 | 
51 |   test('can get a revision', function() {
52 |     expect(1);
53 |     this.saveAFewRevs();
54 |     equal(this.$elem.revisionTracker('getRevision', 1).text, 'foo');
55 |   });
56 | 
57 |   test('can got to a revision', function() {
58 |     expect(1);
59 |     this.saveAFewRevs();
60 |     this.$elem.revisionTracker('goToRevision', 1);
61 |     equal(this.$elem.val(), 'foo');
62 |   });
63 | 
64 |   test('can undo revisions', function() {
65 |     expect(1);
66 |     this.saveAFewRevs();
67 |     this.$elem.revisionTracker('undo');
68 |     equal(this.$elem.val(), 'foo', 'The revision has been undone');
69 |   });
70 | 
71 |   test('can redo revisions', function() {
72 |     expect(1);
73 |     this.saveAFewRevs();
74 |     this.$elem.revisionTracker('undo');
75 |     this.$elem.revisionTracker('redo');
76 |     equal(this.$elem.val(), 'foo bar', 'The revison has been redone');
77 |   });
78 | 
79 |   test('can diff revisions', function() {
80 |     this.saveAFewRevs();
81 |     equal(this.$elem.revisionTracker('getDiff', 1, 2), ' foo <span class="diff-ins">bar\n</span>');
82 |   });
83 | }(jQuery));
84 | 


--------------------------------------------------------------------------------
/textbox-revision-tracker.jquery.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "textbox-revision-tracker",
 3 |   "title": "Textbox Revision Tracker",
 4 |   "description": "Track text revisisions to an HTML input or textarea.",
 5 |   "version": "0.1.0",
 6 |   "homepage": "https://github.com/jonmbake/textbox-revision-tracker",
 7 |   "author": {
 8 |     "name": "Jon Bake",
 9 |     "email": "jonmbake@gmail.com"
10 |   },
11 |   "repository": {
12 |     "type": "git",
13 |     "url": "https://github.com/jonmbake/textbox-revision-tracker.git"
14 |   },
15 |   "bugs": "https://github.com/jonmbake/textbox-revision-tracker/issues",
16 |   "licenses": [
17 |     {
18 |       "type": "MIT",
19 |       "url": "https://github.com/jonmbake/textbox-revision-tracker/blob/master/LICENSE-MIT"
20 |     }
21 |   ],
22 |   "dependencies": {
23 |     "jquery": "*"
24 |   },
25 |   "keywords": []
26 | }


--------------------------------------------------------------------------------