├── client
├── easierStorage.js
├── index.html
├── mocha
│ ├── mocha.css
│ └── mocha.js
└── easierStorage_test.js
├── LICENSE
├── README.md
└── src
└── easierStorage.js
/client/easierStorage.js:
--------------------------------------------------------------------------------
1 | ../src/easierStorage.js
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | This software is available under version 2.0 of the MPL:
2 |
3 | https://www.mozilla.org/MPL/
4 |
--------------------------------------------------------------------------------
/client/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Test!
6 |
26 |
27 |
28 |
29 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # easierStorage
2 | easierStorage makes it dead simple to work with tree structures that are stored in localStorage.
3 |
4 | ## Examples
5 | ```
6 | // Write an item 3 levels deep without ever checking whether top or middle
7 | // exist. calling setItem like this will automatically create any nodes that
8 | // are needed.
9 | easierStorage.setItem("top", "middle", "leaf", "oooh!");
10 |
11 | // Write into a new branch off of the top, this will not destroy the middle
12 | // branch.
13 | easierStorage.setItem("top", "right", "end", "wee!");
14 |
15 | // Go directly to the item you want to get, without checking whether top or
16 | // middle exist. Returns undefined if any nodes do not exist.
17 | var leafValue = easierStorage.getItem("top", "middle", "leaf");
18 | // leafValue === "oooh!"
19 |
20 |
21 | ```
22 | ## License:
23 | Mozilla MPL 2.0
24 |
25 | ## Author
26 | * Shane Tomlinson
27 | * @shane_tomlinson
28 | * shane@shanetomlinson.com
29 | * set117@yahoo.com
30 | * stomlinson@mozilla.com
31 | * http://shanetomlinson.com
32 |
33 |
--------------------------------------------------------------------------------
/client/mocha/mocha.css:
--------------------------------------------------------------------------------
1 |
2 | body {
3 | font: 20px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif;
4 | padding: 60px 50px;
5 | }
6 |
7 | #mocha h1, h2 {
8 | margin: 0;
9 | }
10 |
11 | #mocha h1 {
12 | margin-top: 15px;
13 | font-size: 1em;
14 | font-weight: 200;
15 | }
16 |
17 | #mocha .suite .suite h1 {
18 | margin-top: 0;
19 | font-size: .8em;
20 | }
21 |
22 | #mocha h2 {
23 | font-size: 12px;
24 | font-weight: normal;
25 | cursor: pointer;
26 | }
27 |
28 | #mocha .suite {
29 | margin-left: 15px;
30 | }
31 |
32 | #mocha .test {
33 | margin-left: 15px;
34 | }
35 |
36 | #mocha .test:hover h2::after {
37 | position: relative;
38 | top: 0;
39 | right: -10px;
40 | content: '(view source)';
41 | font-size: 12px;
42 | font-family: arial;
43 | color: #888;
44 | }
45 |
46 | #mocha .test.pending:hover h2::after {
47 | content: '(pending)';
48 | font-family: arial;
49 | }
50 |
51 | #mocha .test.pass::before {
52 | content: '✓';
53 | font-size: 12px;
54 | display: block;
55 | float: left;
56 | margin-right: 5px;
57 | color: #00c41c;
58 | }
59 |
60 | #mocha .test.pending {
61 | color: #0b97c4;
62 | }
63 |
64 | #mocha .test.pending::before {
65 | content: '◦';
66 | color: #0b97c4;
67 | }
68 |
69 | #mocha .test.fail {
70 | color: #c00;
71 | }
72 |
73 | #mocha .test.fail pre {
74 | color: black;
75 | }
76 |
77 | #mocha .test.fail::before {
78 | content: '✖';
79 | font-size: 12px;
80 | display: block;
81 | float: left;
82 | margin-right: 5px;
83 | color: #c00;
84 | }
85 |
86 | #mocha .test pre.error {
87 | color: #c00;
88 | }
89 |
90 | #mocha .test pre {
91 | display: inline-block;
92 | font: 12px/1.5 monaco, monospace;
93 | margin: 5px;
94 | padding: 15px;
95 | border: 1px solid #eee;
96 | border-bottom-color: #ddd;
97 | -webkit-border-radius: 3px;
98 | -webkit-box-shadow: 0 1px 3px #eee;
99 | }
100 |
101 | #error {
102 | color: #c00;
103 | font-size: 1.5 em;
104 | font-weight: 100;
105 | letter-spacing: 1px;
106 | }
107 |
108 | #stats {
109 | position: fixed;
110 | top: 15px;
111 | right: 10px;
112 | font-size: 12px;
113 | margin: 0;
114 | color: #888;
115 | }
116 |
117 | #stats .progress {
118 | float: right;
119 | padding-top: 0;
120 | }
121 |
122 | #stats em {
123 | color: black;
124 | }
125 |
126 | #stats li {
127 | display: inline-block;
128 | margin: 0 5px;
129 | list-style: none;
130 | padding-top: 11px;
131 | }
132 |
133 | code .comment { color: #ddd }
134 | code .init { color: #2F6FAD }
135 | code .string { color: #5890AD }
136 | code .keyword { color: #8A6343 }
137 | code .number { color: #2F6FAD }
138 |
--------------------------------------------------------------------------------
/src/easierStorage.js:
--------------------------------------------------------------------------------
1 | (function(exports) {
2 | "use strict";
3 |
4 | function setItem() {
5 | var args = [].slice.call(arguments, 0),
6 | rootname = args[0],
7 | value = args.pop(),
8 | obj,
9 | root,
10 | len = args.length;
11 |
12 | if(!len) {
13 | throw "setItem must be called with at least one key and a value";
14 | }
15 | else {
16 | root = obj = JSON.parse(localStorage[rootname] || "{}");
17 |
18 | if(len === 1) {
19 | root = value;
20 | }
21 | else {
22 | for(var index = 1, key, max = len - 1; key = args[index]; ++index) {
23 | if(index === max) {
24 | obj[key] = value;
25 | }
26 | else {
27 | obj = obj[key] = obj[key] || {};
28 | }
29 | }
30 | }
31 |
32 | localStorage[rootname] = JSON.stringify(root);
33 | }
34 | }
35 |
36 | function getItem(key) {
37 | var args = [].slice.call(arguments, 0),
38 | rootname = args[0],
39 | len = args.length,
40 | max = len - 1;
41 |
42 | if(len === 0) {
43 | throw "getItem must be called with at least one key";
44 | }
45 | else if(len === 1) {
46 | var value = localStorage[rootname],
47 | undef;
48 | return (typeof value !== "undefined" && value !== null) ? JSON.parse(value) : undef;
49 | }
50 | else {
51 | var obj = JSON.parse(localStorage[rootname] || "{}");
52 |
53 | for(var index = 1, key; obj && (key = args[index]); ++index) {
54 | if(index === max) {
55 | return obj[key];
56 | }
57 | else {
58 | obj = obj[key];
59 | }
60 | }
61 | }
62 | }
63 |
64 | function removeItem() {
65 | var args = [].slice.call(arguments, 0),
66 | rootname = args[0],
67 | len = args.length;
68 |
69 | if(len === 0) {
70 | throw "removeItem must be called with at least one key";
71 | }
72 | else if(len === 1) {
73 | localStorage.removeItem(rootname);
74 | }
75 | else {
76 | var root = JSON.parse(localStorage[rootname] || "{}"),
77 | obj = root;
78 |
79 | for(var index = 1, key, max = len - 1; obj && (key = args[index]); ++index) {
80 | if(index === max) {
81 | obj[key] = null;
82 | delete obj[key];
83 | }
84 | else {
85 | obj = obj[key];
86 | }
87 | }
88 |
89 | localStorage[rootname] = JSON.stringify(root);
90 | }
91 |
92 | }
93 |
94 | exports.easierStorage = {
95 | setItem: setItem,
96 | getItem: getItem,
97 | removeItem: removeItem
98 | };
99 | }(window || exports));
100 |
--------------------------------------------------------------------------------
/client/easierStorage_test.js:
--------------------------------------------------------------------------------
1 |
2 | (function() {
3 |
4 | describe("easierStorage", function() {
5 | it("should exist", function() {
6 | assert(typeof easierStorage !== "undefined", "easierStorage exists");
7 | });
8 |
9 | beforeEach(function() {
10 | for(var key in localStorage) {
11 | localStorage.removeItem(key);
12 | }
13 | });
14 |
15 |
16 | describe("setItem/getItem", function() {
17 | it("setItem must have at least one key and one value", function() {
18 | var err;
19 | try {
20 | easierStorage.setItem("first");
21 | } catch(e) {
22 | err = e;
23 | }
24 |
25 | assert(err.toString() === "setItem must be called with at least one key and a value");
26 | });
27 |
28 | it("setItem setItems value, getItem getItems value", function() {
29 | easierStorage.setItem("first", "value");
30 | assert(easierStorage.getItem("first") === "value", "correct getItem after setItem");
31 | });
32 |
33 | it("getItem with no keys throws an exception", function() {
34 | var err;
35 | try {
36 | easierStorage.getItem()
37 | } catch(e) {
38 | err = e;
39 | }
40 | assert(err);
41 | });
42 |
43 | it("setItem/getItem with 2 keys", function() {
44 | easierStorage.setItem("first", "second", "some value");
45 | assert(easierStorage.getItem("first", "second") === "some value", "setItem/getItem with 2 keys");
46 | });
47 |
48 | it("getItem of undefined leaf returns undefined", function() {
49 | assert(typeof easierStorage.getItem("unknown") === "undefined");
50 | assert(typeof easierStorage.getItem("unknown", "unknown") === "undefined");
51 | });
52 | });
53 |
54 | describe("removeItem", function() {
55 | it("removeItem without a key - throw exception", function() {
56 | var err;
57 | try {
58 | easierStorage.removeItem();
59 | } catch(e) {
60 | err = e;
61 | }
62 |
63 | assert(err.toString() === "removeItem must be called with at least one key");
64 |
65 | });
66 |
67 | it("removeItems an unknown item - does not cause problem", function() {
68 | var err;
69 | try {
70 | easierStorage.removeItem("first");
71 | } catch(e) {
72 | err = e;
73 | }
74 |
75 | assert(typeof err === "undefined");
76 | });
77 |
78 | it("removeItems a leaf", function() {
79 | easierStorage.setItem("first", "second", "third", "value");
80 | easierStorage.removeItem("first", "second", "third");
81 | assert(typeof easierStorage.getItem("first", "second", "third") === "undefined");
82 | });
83 |
84 | it("removeItems a branch", function() {
85 | easierStorage.setItem("first", "second", "third", "value");
86 | easierStorage.removeItem("first", "second");
87 | assert(typeof easierStorage.getItem("first", "second") === "undefined");
88 | assert(typeof easierStorage.getItem("first").second === "undefined");
89 | });
90 | });
91 | });
92 | }());
93 |
94 |
95 |
--------------------------------------------------------------------------------
/client/mocha/mocha.js:
--------------------------------------------------------------------------------
1 | ;(function(){
2 |
3 |
4 | // CommonJS require()
5 |
6 | function require(p){
7 | var path = require.resolve(p)
8 | , mod = require.modules[path];
9 | if (!mod) throw new Error('failed to require "' + p + '"');
10 | if (!mod.exports) {
11 | mod.exports = {};
12 | mod.call(mod.exports, mod, mod.exports, require.relative(path));
13 | }
14 | return mod.exports;
15 | }
16 |
17 | require.modules = {};
18 |
19 | require.resolve = function (path){
20 | var orig = path
21 | , reg = path + '.js'
22 | , index = path + '/index.js';
23 | return require.modules[reg] && reg
24 | || require.modules[index] && index
25 | || orig;
26 | };
27 |
28 | require.register = function (path, fn){
29 | require.modules[path] = fn;
30 | };
31 |
32 | require.relative = function (parent) {
33 | return function(p){
34 | if ('.' != p.charAt(0)) return require(p);
35 |
36 | var path = parent.split('/')
37 | , segs = p.split('/');
38 | path.pop();
39 |
40 | for (var i = 0; i < segs.length; i++) {
41 | var seg = segs[i];
42 | if ('..' == seg) path.pop();
43 | else if ('.' != seg) path.push(seg);
44 | }
45 |
46 | return require(path.join('/'));
47 | };
48 | };
49 |
50 |
51 | require.register("browser/debug.js", function(module, exports, require){
52 |
53 | module.exports = function(type){
54 | return function(){
55 |
56 | }
57 | };
58 | }); // module: browser/debug.js
59 |
60 | require.register("browser/diff.js", function(module, exports, require){
61 |
62 | }); // module: browser/diff.js
63 |
64 | require.register("browser/events.js", function(module, exports, require){
65 |
66 | /**
67 | * Module exports.
68 | */
69 |
70 | exports.EventEmitter = EventEmitter;
71 |
72 | /**
73 | * Check if `obj` is an array.
74 | */
75 |
76 | function isArray(obj) {
77 | return '[object Array]' == {}.toString.call(obj);
78 | }
79 |
80 | /**
81 | * Event emitter constructor.
82 | *
83 | * @api public.
84 | */
85 |
86 | function EventEmitter(){};
87 |
88 | /**
89 | * Adds a listener.
90 | *
91 | * @api public
92 | */
93 |
94 | EventEmitter.prototype.on = function (name, fn) {
95 | if (!this.$events) {
96 | this.$events = {};
97 | }
98 |
99 | if (!this.$events[name]) {
100 | this.$events[name] = fn;
101 | } else if (isArray(this.$events[name])) {
102 | this.$events[name].push(fn);
103 | } else {
104 | this.$events[name] = [this.$events[name], fn];
105 | }
106 |
107 | return this;
108 | };
109 |
110 | EventEmitter.prototype.addListener = EventEmitter.prototype.on;
111 |
112 | /**
113 | * Adds a volatile listener.
114 | *
115 | * @api public
116 | */
117 |
118 | EventEmitter.prototype.once = function (name, fn) {
119 | var self = this;
120 |
121 | function on () {
122 | self.removeListener(name, on);
123 | fn.apply(this, arguments);
124 | };
125 |
126 | on.listener = fn;
127 | this.on(name, on);
128 |
129 | return this;
130 | };
131 |
132 | /**
133 | * Removes a listener.
134 | *
135 | * @api public
136 | */
137 |
138 | EventEmitter.prototype.removeListener = function (name, fn) {
139 | if (this.$events && this.$events[name]) {
140 | var list = this.$events[name];
141 |
142 | if (isArray(list)) {
143 | var pos = -1;
144 |
145 | for (var i = 0, l = list.length; i < l; i++) {
146 | if (list[i] === fn || (list[i].listener && list[i].listener === fn)) {
147 | pos = i;
148 | break;
149 | }
150 | }
151 |
152 | if (pos < 0) {
153 | return this;
154 | }
155 |
156 | list.splice(pos, 1);
157 |
158 | if (!list.length) {
159 | delete this.$events[name];
160 | }
161 | } else if (list === fn || (list.listener && list.listener === fn)) {
162 | delete this.$events[name];
163 | }
164 | }
165 |
166 | return this;
167 | };
168 |
169 | /**
170 | * Removes all listeners for an event.
171 | *
172 | * @api public
173 | */
174 |
175 | EventEmitter.prototype.removeAllListeners = function (name) {
176 | if (name === undefined) {
177 | this.$events = {};
178 | return this;
179 | }
180 |
181 | if (this.$events && this.$events[name]) {
182 | this.$events[name] = null;
183 | }
184 |
185 | return this;
186 | };
187 |
188 | /**
189 | * Gets all listeners for a certain event.
190 | *
191 | * @api publci
192 | */
193 |
194 | EventEmitter.prototype.listeners = function (name) {
195 | if (!this.$events) {
196 | this.$events = {};
197 | }
198 |
199 | if (!this.$events[name]) {
200 | this.$events[name] = [];
201 | }
202 |
203 | if (!isArray(this.$events[name])) {
204 | this.$events[name] = [this.$events[name]];
205 | }
206 |
207 | return this.$events[name];
208 | };
209 |
210 | /**
211 | * Emits an event.
212 | *
213 | * @api public
214 | */
215 |
216 | EventEmitter.prototype.emit = function (name) {
217 | if (!this.$events) {
218 | return false;
219 | }
220 |
221 | var handler = this.$events[name];
222 |
223 | if (!handler) {
224 | return false;
225 | }
226 |
227 | var args = [].slice.call(arguments, 1);
228 |
229 | if ('function' == typeof handler) {
230 | handler.apply(this, args);
231 | } else if (isArray(handler)) {
232 | var listeners = handler.slice();
233 |
234 | for (var i = 0, l = listeners.length; i < l; i++) {
235 | listeners[i].apply(this, args);
236 | }
237 | } else {
238 | return false;
239 | }
240 |
241 | return true;
242 | };
243 | }); // module: browser/events.js
244 |
245 | require.register("browser/fs.js", function(module, exports, require){
246 |
247 | }); // module: browser/fs.js
248 |
249 | require.register("browser/path.js", function(module, exports, require){
250 |
251 | }); // module: browser/path.js
252 |
253 | require.register("browser/progress.js", function(module, exports, require){
254 |
255 | /**
256 | * Expose `Progress`.
257 | */
258 |
259 | module.exports = Progress;
260 |
261 | /**
262 | * Initialize a new `Progress` indicator.
263 | */
264 |
265 | function Progress() {
266 | this.percent = 0;
267 | this.size(0);
268 | this.fontSize(11);
269 | this.font('helvetica, arial, sans-serif');
270 | }
271 |
272 | /**
273 | * Set progress size to `n`.
274 | *
275 | * @param {Number} n
276 | * @return {Progress} for chaining
277 | * @api public
278 | */
279 |
280 | Progress.prototype.size = function(n){
281 | this._size = n;
282 | return this;
283 | };
284 |
285 | /**
286 | * Set text to `str`.
287 | *
288 | * @param {String} str
289 | * @return {Progress} for chaining
290 | * @api public
291 | */
292 |
293 | Progress.prototype.text = function(str){
294 | this._text = str;
295 | return this;
296 | };
297 |
298 | /**
299 | * Set font size to `n`.
300 | *
301 | * @param {Number} n
302 | * @return {Progress} for chaining
303 | * @api public
304 | */
305 |
306 | Progress.prototype.fontSize = function(n){
307 | this._fontSize = n;
308 | return this;
309 | };
310 |
311 | /**
312 | * Set font `family`.
313 | *
314 | * @param {String} family
315 | * @return {Progress} for chaining
316 | */
317 |
318 | Progress.prototype.font = function(family){
319 | this._font = family;
320 | return this;
321 | };
322 |
323 | /**
324 | * Update percentage to `n`.
325 | *
326 | * @param {Number} n
327 | * @return {Progress} for chaining
328 | */
329 |
330 | Progress.prototype.update = function(n){
331 | this.percent = n;
332 | return this;
333 | };
334 |
335 | /**
336 | * Draw on `ctx`.
337 | *
338 | * @param {CanvasRenderingContext2d} ctx
339 | * @return {Progress} for chaining
340 | */
341 |
342 | Progress.prototype.draw = function(ctx){
343 | var percent = Math.min(this.percent, 100)
344 | , size = this._size
345 | , half = size / 2
346 | , x = half
347 | , y = half
348 | , rad = half - 1
349 | , fontSize = this._fontSize;
350 |
351 | ctx.font = fontSize + 'px ' + this._font;
352 |
353 | var angle = Math.PI * 2 * (percent / 100);
354 | ctx.clearRect(0, 0, size, size);
355 |
356 | // outer circle
357 | ctx.strokeStyle = '#9f9f9f';
358 | ctx.beginPath();
359 | ctx.arc(x, y, rad, 0, angle, false);
360 | ctx.stroke();
361 |
362 | // inner circle
363 | ctx.strokeStyle = '#eee';
364 | ctx.beginPath();
365 | ctx.arc(x, y, rad - 1, 0, angle, true);
366 | ctx.stroke();
367 |
368 | // text
369 | var text = this._text || (percent | 0) + '%'
370 | , w = ctx.measureText(text).width;
371 |
372 | ctx.fillText(
373 | text
374 | , x - w / 2 + 1
375 | , y + fontSize / 2 - 1);
376 |
377 | return this;
378 | };
379 |
380 | }); // module: browser/progress.js
381 |
382 | require.register("browser/tty.js", function(module, exports, require){
383 |
384 | exports.isatty = function(){
385 | return true;
386 | };
387 |
388 | exports.getWindowSize = function(){
389 | return [window.innerHeight, window.innerWidth];
390 | };
391 | }); // module: browser/tty.js
392 |
393 | require.register("context.js", function(module, exports, require){
394 |
395 | /**
396 | * Expose `Context`.
397 | */
398 |
399 | module.exports = Context;
400 |
401 | /**
402 | * Initialize a new `Context`.
403 | *
404 | * @api private
405 | */
406 |
407 | function Context(){}
408 |
409 | /**
410 | * Set the context `Runnable` to `runnable`.
411 | *
412 | * @param {Runnable} runnable
413 | * @return {Context}
414 | * @api private
415 | */
416 |
417 | Context.prototype.runnable = function(runnable){
418 | this._runnable = runnable;
419 | return this;
420 | };
421 |
422 | /**
423 | * Set test timeout `ms`.
424 | *
425 | * @param {Number} ms
426 | * @return {Context} self
427 | * @api private
428 | */
429 |
430 | Context.prototype.timeout = function(ms){
431 | this._runnable.timeout(ms);
432 | return this;
433 | };
434 |
435 | /**
436 | * Inspect the context void of `._runnable`.
437 | *
438 | * @return {String}
439 | * @api private
440 | */
441 |
442 | Context.prototype.inspect = function(){
443 | return JSON.stringify(this, function(key, val){
444 | return '_runnable' == key
445 | ? undefined
446 | : val;
447 | }, 2);
448 | };
449 |
450 | }); // module: context.js
451 |
452 | require.register("hook.js", function(module, exports, require){
453 |
454 | /**
455 | * Module dependencies.
456 | */
457 |
458 | var Runnable = require('./runnable');
459 |
460 | /**
461 | * Expose `Hook`.
462 | */
463 |
464 | module.exports = Hook;
465 |
466 | /**
467 | * Initialize a new `Hook` with the given `title` and callback `fn`.
468 | *
469 | * @param {String} title
470 | * @param {Function} fn
471 | * @api private
472 | */
473 |
474 | function Hook(title, fn) {
475 | Runnable.call(this, title, fn);
476 | this.type = 'hook';
477 | }
478 |
479 | /**
480 | * Inherit from `Runnable.prototype`.
481 | */
482 |
483 | Hook.prototype = new Runnable;
484 | Hook.prototype.constructor = Hook;
485 |
486 |
487 | }); // module: hook.js
488 |
489 | require.register("interfaces/bdd.js", function(module, exports, require){
490 |
491 | /**
492 | * Module dependencies.
493 | */
494 |
495 | var Suite = require('../suite')
496 | , Test = require('../test');
497 |
498 | /**
499 | * BDD-style interface:
500 | *
501 | * describe('Array', function(){
502 | * describe('#indexOf()', function(){
503 | * it('should return -1 when not present', function(){
504 | *
505 | * });
506 | *
507 | * it('should return the index when present', function(){
508 | *
509 | * });
510 | * });
511 | * });
512 | *
513 | */
514 |
515 | module.exports = function(suite){
516 | var suites = [suite];
517 |
518 | suite.on('pre-require', function(context){
519 |
520 | // noop variants
521 |
522 | context.xdescribe = function(){};
523 | context.xit = function(){};
524 |
525 | /**
526 | * Execute before running tests.
527 | */
528 |
529 | context.before = function(fn){
530 | suites[0].beforeAll(fn);
531 | };
532 |
533 | /**
534 | * Execute after running tests.
535 | */
536 |
537 | context.after = function(fn){
538 | suites[0].afterAll(fn);
539 | };
540 |
541 | /**
542 | * Execute before each test case.
543 | */
544 |
545 | context.beforeEach = function(fn){
546 | suites[0].beforeEach(fn);
547 | };
548 |
549 | /**
550 | * Execute after each test case.
551 | */
552 |
553 | context.afterEach = function(fn){
554 | suites[0].afterEach(fn);
555 | };
556 |
557 | /**
558 | * Describe a "suite" with the given `title`
559 | * and callback `fn` containing nested suites
560 | * and/or tests.
561 | */
562 |
563 | context.describe = function(title, fn){
564 | var suite = Suite.create(suites[0], title);
565 | suites.unshift(suite);
566 | fn();
567 | suites.shift();
568 | };
569 |
570 | /**
571 | * Describe a specification or test-case
572 | * with the given `title` and callback `fn`
573 | * acting as a thunk.
574 | */
575 |
576 | context.it = function(title, fn){
577 | suites[0].addTest(new Test(title, fn));
578 | };
579 | });
580 | };
581 |
582 | }); // module: interfaces/bdd.js
583 |
584 | require.register("interfaces/exports.js", function(module, exports, require){
585 |
586 | /**
587 | * Module dependencies.
588 | */
589 |
590 | var Suite = require('../suite')
591 | , Test = require('../test');
592 |
593 | /**
594 | * TDD-style interface:
595 | *
596 | * exports.Array = {
597 | * '#indexOf()': {
598 | * 'should return -1 when the value is not present': function(){
599 | *
600 | * },
601 | *
602 | * 'should return the correct index when the value is present': function(){
603 | *
604 | * }
605 | * }
606 | * };
607 | *
608 | */
609 |
610 | module.exports = function(suite){
611 | var suites = [suite];
612 |
613 | suite.on('require', visit);
614 |
615 | function visit(obj) {
616 | var suite;
617 | for (var key in obj) {
618 | if ('function' == typeof obj[key]) {
619 | var fn = obj[key];
620 | switch (key) {
621 | case 'before':
622 | suites[0].beforeAll(fn);
623 | break;
624 | case 'after':
625 | suites[0].afterAll(fn);
626 | break;
627 | case 'beforeEach':
628 | suites[0].beforeEach(fn);
629 | break;
630 | case 'afterEach':
631 | suites[0].afterEach(fn);
632 | break;
633 | default:
634 | suites[0].addTest(new Test(key, fn));
635 | }
636 | } else {
637 | var suite = Suite.create(suites[0], key);
638 | suites.unshift(suite);
639 | visit(obj[key]);
640 | suites.shift();
641 | }
642 | }
643 | }
644 | };
645 | }); // module: interfaces/exports.js
646 |
647 | require.register("interfaces/index.js", function(module, exports, require){
648 |
649 | exports.bdd = require('./bdd');
650 | exports.tdd = require('./tdd');
651 | exports.qunit = require('./qunit');
652 | exports.exports = require('./exports');
653 |
654 | }); // module: interfaces/index.js
655 |
656 | require.register("interfaces/qunit.js", function(module, exports, require){
657 |
658 | /**
659 | * Module dependencies.
660 | */
661 |
662 | var Suite = require('../suite')
663 | , Test = require('../test');
664 |
665 | /**
666 | * QUnit-style interface:
667 | *
668 | * suite('Array');
669 | *
670 | * test('#length', function(){
671 | * var arr = [1,2,3];
672 | * ok(arr.length == 3);
673 | * });
674 | *
675 | * test('#indexOf()', function(){
676 | * var arr = [1,2,3];
677 | * ok(arr.indexOf(1) == 0);
678 | * ok(arr.indexOf(2) == 1);
679 | * ok(arr.indexOf(3) == 2);
680 | * });
681 | *
682 | * suite('String');
683 | *
684 | * test('#length', function(){
685 | * ok('foo'.length == 3);
686 | * });
687 | *
688 | */
689 |
690 | module.exports = function(suite){
691 | var suites = [suite];
692 |
693 | suite.on('pre-require', function(context){
694 |
695 | /**
696 | * Execute before running tests.
697 | */
698 |
699 | context.before = function(fn){
700 | suites[0].beforeAll(fn);
701 | };
702 |
703 | /**
704 | * Execute after running tests.
705 | */
706 |
707 | context.after = function(fn){
708 | suites[0].afterAll(fn);
709 | };
710 |
711 | /**
712 | * Execute before each test case.
713 | */
714 |
715 | context.beforeEach = function(fn){
716 | suites[0].beforeEach(fn);
717 | };
718 |
719 | /**
720 | * Execute after each test case.
721 | */
722 |
723 | context.afterEach = function(fn){
724 | suites[0].afterEach(fn);
725 | };
726 |
727 | /**
728 | * Describe a "suite" with the given `title`.
729 | */
730 |
731 | context.suite = function(title){
732 | if (suites.length > 1) suites.shift();
733 | var suite = Suite.create(suites[0], title);
734 | suites.unshift(suite);
735 | };
736 |
737 | /**
738 | * Describe a specification or test-case
739 | * with the given `title` and callback `fn`
740 | * acting as a thunk.
741 | */
742 |
743 | context.test = function(title, fn){
744 | suites[0].addTest(new Test(title, fn));
745 | };
746 | });
747 | };
748 |
749 | }); // module: interfaces/qunit.js
750 |
751 | require.register("interfaces/tdd.js", function(module, exports, require){
752 |
753 | /**
754 | * Module dependencies.
755 | */
756 |
757 | var Suite = require('../suite')
758 | , Test = require('../test');
759 |
760 | /**
761 | * TDD-style interface:
762 | *
763 | * suite('Array', function(){
764 | * suite('#indexOf()', function(){
765 | * suiteSetup(function(){
766 | *
767 | * });
768 | *
769 | * test('should return -1 when not present', function(){
770 | *
771 | * });
772 | *
773 | * test('should return the index when present', function(){
774 | *
775 | * });
776 | *
777 | * suiteTeardown(function(){
778 | *
779 | * });
780 | * });
781 | * });
782 | *
783 | */
784 |
785 | module.exports = function(suite){
786 | var suites = [suite];
787 |
788 | suite.on('pre-require', function(context){
789 |
790 | /**
791 | * Execute before each test case.
792 | */
793 |
794 | context.setup = function(fn){
795 | suites[0].beforeEach(fn);
796 | };
797 |
798 | /**
799 | * Execute after each test case.
800 | */
801 |
802 | context.teardown = function(fn){
803 | suites[0].afterEach(fn);
804 | };
805 |
806 | /**
807 | * Execute before the suite.
808 | */
809 |
810 | context.suiteSetup = function(fn){
811 | suites[0].beforeAll(fn);
812 | };
813 |
814 | /**
815 | * Execute after the suite.
816 | */
817 |
818 | context.suiteTeardown = function(fn){
819 | suites[0].afterAll(fn);
820 | };
821 |
822 | /**
823 | * Describe a "suite" with the given `title`
824 | * and callback `fn` containing nested suites
825 | * and/or tests.
826 | */
827 |
828 | context.suite = function(title, fn){
829 | var suite = Suite.create(suites[0], title);
830 | suites.unshift(suite);
831 | fn();
832 | suites.shift();
833 | };
834 |
835 | /**
836 | * Describe a specification or test-case
837 | * with the given `title` and callback `fn`
838 | * acting as a thunk.
839 | */
840 |
841 | context.test = function(title, fn){
842 | suites[0].addTest(new Test(title, fn));
843 | };
844 | });
845 | };
846 |
847 | }); // module: interfaces/tdd.js
848 |
849 | require.register("mocha.js", function(module, exports, require){
850 |
851 | /*!
852 | * mocha
853 | * Copyright(c) 2011 TJ Holowaychuk
854 | * MIT Licensed
855 | */
856 |
857 | /**
858 | * Module dependencies.
859 | */
860 |
861 | var path = require('browser/path');
862 |
863 | /**
864 | * Expose `Mocha`.
865 | */
866 |
867 | exports = module.exports = Mocha;
868 |
869 | /**
870 | * Library version.
871 | */
872 |
873 | exports.version = '1.0.1';
874 |
875 | /**
876 | * Expose internals.
877 | */
878 |
879 | exports.utils = require('./utils');
880 | exports.interfaces = require('./interfaces');
881 | exports.reporters = require('./reporters');
882 | exports.Runnable = require('./runnable');
883 | exports.Context = require('./context');
884 | exports.Runner = require('./runner');
885 | exports.Suite = require('./suite');
886 | exports.Hook = require('./hook');
887 | exports.Test = require('./test');
888 |
889 | /**
890 | * Return image `name` path.
891 | *
892 | * @param {String} name
893 | * @return {String}
894 | * @api private
895 | */
896 |
897 | function image(name) {
898 | return __dirname + '/../images/' + name + '.png';
899 | }
900 |
901 | /**
902 | * Setup mocha with `options`.
903 | *
904 | * Options:
905 | *
906 | * - `ui` name "bdd", "tdd", "exports" etc
907 | * - `reporter` reporter instance, defaults to `mocha.reporters.Dot`
908 | * - `globals` array of accepted globals
909 | * - `timeout` timeout in milliseconds
910 | * - `ignoreLeaks` ignore global leaks
911 | *
912 | * @param {Object} options
913 | * @api public
914 | */
915 |
916 | function Mocha(options) {
917 | options = options || {};
918 | this.files = [];
919 | this.options = options;
920 | this.suite = new exports.Suite('', new exports.Context);
921 | this.ui(options.ui);
922 | this.reporter(options.reporter);
923 | if (options.timeout) this.suite.timeout(options.timeout);
924 | }
925 |
926 | /**
927 | * Add test `file`.
928 | *
929 | * @param {String} file
930 | * @api public
931 | */
932 |
933 | Mocha.prototype.addFile = function(file){
934 | this.files.push(file);
935 | return this;
936 | };
937 |
938 | /**
939 | * Set reporter to `name`, defaults to "dot".
940 | *
941 | * @param {String} name
942 | * @api public
943 | */
944 |
945 | Mocha.prototype.reporter = function(name){
946 | name = name || 'dot';
947 | this._reporter = require('./reporters/' + name);
948 | if (!this._reporter) throw new Error('invalid reporter "' + name + '"');
949 | return this;
950 | };
951 |
952 | /**
953 | * Set test UI `name`, defaults to "bdd".
954 | *
955 | * @param {String} bdd
956 | * @api public
957 | */
958 |
959 | Mocha.prototype.ui = function(name){
960 | name = name || 'bdd';
961 | this._ui = exports.interfaces[name];
962 | if (!this._ui) throw new Error('invalid interface "' + name + '"');
963 | this._ui = this._ui(this.suite);
964 | return this;
965 | };
966 |
967 | /**
968 | * Load registered files.
969 | *
970 | * @api private
971 | */
972 |
973 | Mocha.prototype.loadFiles = function(){
974 | var suite = this.suite;
975 | this.files.forEach(function(file){
976 | file = path.resolve(file);
977 | suite.emit('pre-require', global, file);
978 | suite.emit('require', require(file), file);
979 | suite.emit('post-require', global, file);
980 | });
981 | };
982 |
983 | /**
984 | * Enable growl support.
985 | *
986 | * @api private
987 | */
988 |
989 | Mocha.prototype.growl = function(runner, reporter) {
990 | var notify = require('growl');
991 |
992 | runner.on('end', function(){
993 | var stats = reporter.stats;
994 | if (stats.failures) {
995 | var msg = stats.failures + ' of ' + runner.total + ' tests failed';
996 | notify(msg, { title: 'Failed', image: image('fail') });
997 | } else {
998 | notify(stats.passes + ' tests passed in ' + stats.duration + 'ms', {
999 | title: 'Passed'
1000 | , image: image('pass')
1001 | });
1002 | }
1003 | });
1004 | };
1005 |
1006 | /**
1007 | * Run tests and invoke `fn()` when complete.
1008 | *
1009 | * @param {Function} fn
1010 | * @return {Runner}
1011 | * @api public
1012 | */
1013 |
1014 | Mocha.prototype.run = function(fn){
1015 | this.loadFiles();
1016 | var suite = this.suite;
1017 | var options = this.options;
1018 | var runner = new exports.Runner(suite);
1019 | var reporter = new this._reporter(runner);
1020 | runner.ignoreLeaks = options.ignoreLeaks;
1021 | if (options.grep) runner.grep(options.grep);
1022 | if (options.globals) runner.globals(options.globals);
1023 | if (options.growl) this.growl(runner, reporter);
1024 | return runner.run(fn);
1025 | };
1026 |
1027 | }); // module: mocha.js
1028 |
1029 | require.register("reporters/base.js", function(module, exports, require){
1030 |
1031 | /**
1032 | * Module dependencies.
1033 | */
1034 |
1035 | var tty = require('browser/tty')
1036 | , diff = require('browser/diff');
1037 |
1038 | /**
1039 | * Check if both stdio streams are associated with a tty.
1040 | */
1041 |
1042 | var isatty = tty.isatty(1) && tty.isatty(2);
1043 |
1044 | /**
1045 | * Expose `Base`.
1046 | */
1047 |
1048 | exports = module.exports = Base;
1049 |
1050 | /**
1051 | * Enable coloring by default.
1052 | */
1053 |
1054 | exports.useColors = isatty;
1055 |
1056 | /**
1057 | * Default color map.
1058 | */
1059 |
1060 | exports.colors = {
1061 | 'pass': 90
1062 | , 'fail': 31
1063 | , 'bright pass': 92
1064 | , 'bright fail': 91
1065 | , 'bright yellow': 93
1066 | , 'pending': 36
1067 | , 'suite': 0
1068 | , 'error title': 0
1069 | , 'error message': 31
1070 | , 'error stack': 90
1071 | , 'checkmark': 32
1072 | , 'fast': 90
1073 | , 'medium': 33
1074 | , 'slow': 31
1075 | , 'green': 32
1076 | , 'light': 90
1077 | , 'diff gutter': 90
1078 | , 'diff added': 42
1079 | , 'diff removed': 41
1080 | };
1081 |
1082 | /**
1083 | * Color `str` with the given `type`,
1084 | * allowing colors to be disabled,
1085 | * as well as user-defined color
1086 | * schemes.
1087 | *
1088 | * @param {String} type
1089 | * @param {String} str
1090 | * @return {String}
1091 | * @api private
1092 | */
1093 |
1094 | var color = exports.color = function(type, str) {
1095 | if (!exports.useColors) return str;
1096 | return '\033[' + exports.colors[type] + 'm' + str + '\033[0m';
1097 | };
1098 |
1099 | /**
1100 | * Expose term window size, with some
1101 | * defaults for when stderr is not a tty.
1102 | */
1103 |
1104 | exports.window = {
1105 | width: isatty
1106 | ? process.stdout.getWindowSize
1107 | ? process.stdout.getWindowSize(1)[0]
1108 | : tty.getWindowSize()[1]
1109 | : 75
1110 | };
1111 |
1112 | /**
1113 | * Expose some basic cursor interactions
1114 | * that are common among reporters.
1115 | */
1116 |
1117 | exports.cursor = {
1118 | hide: function(){
1119 | process.stdout.write('\033[?25l');
1120 | },
1121 |
1122 | show: function(){
1123 | process.stdout.write('\033[?25h');
1124 | },
1125 |
1126 | deleteLine: function(){
1127 | process.stdout.write('\033[2K');
1128 | },
1129 |
1130 | beginningOfLine: function(){
1131 | process.stdout.write('\033[0G');
1132 | },
1133 |
1134 | CR: function(){
1135 | exports.cursor.deleteLine();
1136 | exports.cursor.beginningOfLine();
1137 | }
1138 | };
1139 |
1140 | /**
1141 | * A test is considered slow if it
1142 | * exceeds the following value in milliseconds.
1143 | */
1144 |
1145 | exports.slow = 75;
1146 |
1147 | /**
1148 | * Outut the given `failures` as a list.
1149 | *
1150 | * @param {Array} failures
1151 | * @api public
1152 | */
1153 |
1154 | exports.list = function(failures){
1155 | console.error();
1156 | failures.forEach(function(test, i){
1157 | // format
1158 | var fmt = color('error title', ' %s) %s:\n')
1159 | + color('error message', ' %s')
1160 | + color('error stack', '\n%s\n');
1161 |
1162 | // msg
1163 | var err = test.err
1164 | , message = err.message || ''
1165 | , stack = err.stack || message
1166 | , index = stack.indexOf(message) + message.length
1167 | , msg = stack.slice(0, index)
1168 | , actual = err.actual
1169 | , expected = err.expected;
1170 |
1171 | // actual / expected diff
1172 | if ('string' == typeof actual && 'string' == typeof expected) {
1173 | var len = Math.max(actual.length, expected.length);
1174 |
1175 | if (len < 20) msg = errorDiff(err, 'Chars');
1176 | else msg = errorDiff(err, 'Words');
1177 |
1178 | // linenos
1179 | var lines = msg.split('\n');
1180 | if (lines.length > 4) {
1181 | var width = String(lines.length).length;
1182 | msg = lines.map(function(str, i){
1183 | return pad(++i, width) + ' |' + ' ' + str;
1184 | }).join('\n');
1185 | }
1186 |
1187 | // legend
1188 | msg = '\n'
1189 | + color('diff removed', 'actual')
1190 | + ' '
1191 | + color('diff added', 'expected')
1192 | + '\n\n'
1193 | + msg
1194 | + '\n';
1195 |
1196 | // indent
1197 | msg = msg.replace(/^/gm, ' ');
1198 |
1199 | fmt = color('error title', ' %s) %s:\n%s')
1200 | + color('error stack', '\n%s\n');
1201 | }
1202 |
1203 | // indent stack trace without msg
1204 | stack = stack.slice(index ? index + 1 : index)
1205 | .replace(/^/gm, ' ');
1206 |
1207 | console.error(fmt, (i + 1), test.fullTitle(), msg, stack);
1208 | });
1209 | };
1210 |
1211 | /**
1212 | * Initialize a new `Base` reporter.
1213 | *
1214 | * All other reporters generally
1215 | * inherit from this reporter, providing
1216 | * stats such as test duration, number
1217 | * of tests passed / failed etc.
1218 | *
1219 | * @param {Runner} runner
1220 | * @api public
1221 | */
1222 |
1223 | function Base(runner) {
1224 | var self = this
1225 | , stats = this.stats = { suites: 0, tests: 0, passes: 0, failures: 0 }
1226 | , failures = this.failures = [];
1227 |
1228 | if (!runner) return;
1229 | this.runner = runner;
1230 |
1231 | runner.on('start', function(){
1232 | stats.start = new Date;
1233 | });
1234 |
1235 | runner.on('suite', function(suite){
1236 | stats.suites = stats.suites || 0;
1237 | suite.root || stats.suites++;
1238 | });
1239 |
1240 | runner.on('test end', function(test){
1241 | stats.tests = stats.tests || 0;
1242 | stats.tests++;
1243 | });
1244 |
1245 | runner.on('pass', function(test){
1246 | stats.passes = stats.passes || 0;
1247 |
1248 | var medium = exports.slow / 2;
1249 | test.speed = test.duration > exports.slow
1250 | ? 'slow'
1251 | : test.duration > medium
1252 | ? 'medium'
1253 | : 'fast';
1254 |
1255 | stats.passes++;
1256 | });
1257 |
1258 | runner.on('fail', function(test, err){
1259 | stats.failures = stats.failures || 0;
1260 | stats.failures++;
1261 | test.err = err;
1262 | failures.push(test);
1263 | });
1264 |
1265 | runner.on('end', function(){
1266 | stats.end = new Date;
1267 | stats.duration = new Date - stats.start;
1268 | });
1269 | }
1270 |
1271 | /**
1272 | * Output common epilogue used by many of
1273 | * the bundled reporters.
1274 | *
1275 | * @api public
1276 | */
1277 |
1278 | Base.prototype.epilogue = function(){
1279 | var stats = this.stats
1280 | , fmt;
1281 |
1282 | console.log();
1283 |
1284 | // failure
1285 | if (stats.failures) {
1286 | fmt = color('bright fail', ' ✖')
1287 | + color('fail', ' %d of %d tests failed')
1288 | + color('light', ':')
1289 |
1290 | console.error(fmt, stats.failures, this.runner.total);
1291 | Base.list(this.failures);
1292 | console.error();
1293 | return;
1294 | }
1295 |
1296 | // pass
1297 | fmt = color('bright pass', ' ✔')
1298 | + color('green', ' %d tests complete')
1299 | + color('light', ' (%dms)');
1300 |
1301 | console.log(fmt, stats.tests || 0, stats.duration);
1302 | console.log();
1303 | };
1304 |
1305 | /**
1306 | * Pad the given `str` to `len`.
1307 | *
1308 | * @param {String} str
1309 | * @param {String} len
1310 | * @return {String}
1311 | * @api private
1312 | */
1313 |
1314 | function pad(str, len) {
1315 | str = String(str);
1316 | return Array(len - str.length + 1).join(' ') + str;
1317 | }
1318 |
1319 | /**
1320 | * Return a character diff for `err`.
1321 | *
1322 | * @param {Error} err
1323 | * @return {String}
1324 | * @api private
1325 | */
1326 |
1327 | function errorDiff(err, type) {
1328 | return diff['diff' + type](err.actual, err.expected).map(function(str){
1329 | if (str.added) return colorLines('diff added', str.value);
1330 | if (str.removed) return colorLines('diff removed', str.value);
1331 | return str.value;
1332 | }).join('');
1333 | }
1334 |
1335 | /**
1336 | * Color lines for `str`, using the color `name`.
1337 | *
1338 | * @param {String} name
1339 | * @param {String} str
1340 | * @return {String}
1341 | * @api private
1342 | */
1343 |
1344 | function colorLines(name, str) {
1345 | return str.split('\n').map(function(str){
1346 | return color(name, str);
1347 | }).join('\n');
1348 | }
1349 |
1350 | }); // module: reporters/base.js
1351 |
1352 | require.register("reporters/doc.js", function(module, exports, require){
1353 |
1354 | /**
1355 | * Module dependencies.
1356 | */
1357 |
1358 | var Base = require('./base')
1359 | , utils = require('../utils');
1360 |
1361 | /**
1362 | * Expose `Doc`.
1363 | */
1364 |
1365 | exports = module.exports = Doc;
1366 |
1367 | /**
1368 | * Initialize a new `Doc` reporter.
1369 | *
1370 | * @param {Runner} runner
1371 | * @api public
1372 | */
1373 |
1374 | function Doc(runner) {
1375 | Base.call(this, runner);
1376 |
1377 | var self = this
1378 | , stats = this.stats
1379 | , total = runner.total
1380 | , indents = 2;
1381 |
1382 | function indent() {
1383 | return Array(indents).join(' ');
1384 | }
1385 |
1386 | runner.on('suite', function(suite){
1387 | if (suite.root) return;
1388 | ++indents;
1389 | console.log('%s', indent());
1390 | ++indents;
1391 | console.log('%s%s ', indent(), suite.title);
1392 | console.log('%s', indent());
1393 | });
1394 |
1395 | runner.on('suite end', function(suite){
1396 | if (suite.root) return;
1397 | console.log('%s ', indent());
1398 | --indents;
1399 | console.log('%s ', indent());
1400 | --indents;
1401 | });
1402 |
1403 | runner.on('pass', function(test){
1404 | console.log('%s %s ', indent(), test.title);
1405 | var code = utils.escape(clean(test.fn.toString()));
1406 | console.log('%s %s'
1565 | + 'passes: 0 '
1567 | + 'failures: 0 '
1568 | + 'duration: 0 s '
1569 | + ' ';
1570 |
1571 | /**
1572 | * Initialize a new `Doc` reporter.
1573 | *
1574 | * @param {Runner} runner
1575 | * @api public
1576 | */
1577 |
1578 | function HTML(runner) {
1579 | Base.call(this, runner);
1580 |
1581 | var self = this
1582 | , stats = this.stats
1583 | , total = runner.total
1584 | , root = document.getElementById('mocha')
1585 | , stat = fragment(statsTemplate)
1586 | , items = stat.getElementsByTagName('li')
1587 | , passes = items[1].getElementsByTagName('em')[0]
1588 | , failures = items[2].getElementsByTagName('em')[0]
1589 | , duration = items[3].getElementsByTagName('em')[0]
1590 | , canvas = stat.getElementsByTagName('canvas')[0]
1591 | , stack = [root]
1592 | , progress
1593 | , ctx
1594 |
1595 | if (canvas.getContext) {
1596 | ctx = canvas.getContext('2d');
1597 | progress = new Progress;
1598 | }
1599 |
1600 | if (!root) return error('#mocha div missing, add it to your document');
1601 |
1602 | root.appendChild(stat);
1603 |
1604 | if (progress) progress.size(40);
1605 |
1606 | runner.on('suite', function(suite){
1607 | if (suite.root) return;
1608 |
1609 | // suite
1610 | var el = fragment('
%s ', suite.title);
1611 |
1612 | // container
1613 | stack[0].appendChild(el);
1614 | stack.unshift(document.createElement('div'));
1615 | el.appendChild(stack[0]);
1616 | });
1617 |
1618 | runner.on('suite end', function(suite){
1619 | if (suite.root) return;
1620 | stack.shift();
1621 | });
1622 |
1623 | runner.on('fail', function(test, err){
1624 | if ('hook' == test.type || err.uncaught) runner.emit('test end', test);
1625 | });
1626 |
1627 | runner.on('test end', function(test){
1628 | // TODO: add to stats
1629 | var percent = stats.tests / total * 100 | 0;
1630 | if (progress) progress.update(percent).draw(ctx);
1631 |
1632 | // update stats
1633 | var ms = new Date - stats.start;
1634 | text(passes, stats.passes);
1635 | text(failures, stats.failures);
1636 | text(duration, (ms / 1000).toFixed(2));
1637 |
1638 | // test
1639 | if ('passed' == test.state) {
1640 | var el = fragment('
%e ', test.title);
1641 | } else if (test.pending) {
1642 | var el = fragment('
%e ', test.title);
1643 | } else {
1644 | var el = fragment('
%e ', test.title);
1645 | var str = test.err.stack || test.err.toString();
1646 |
1647 | // FF / Opera do not add the message
1648 | if (!~str.indexOf(test.err.message)) {
1649 | str = test.err.message + '\n' + str;
1650 | }
1651 |
1652 | // <=IE7 stringifies to [Object Error]. Since it can be overloaded, we
1653 | // check for the result of the stringifying.
1654 | if ('[object Error]' == str) str = test.err.message;
1655 |
1656 | // Safari doesn't give you a stack. Let's at least provide a source line.
1657 | if (!test.err.stack && test.err.sourceURL && test.err.line !== undefined) {
1658 | str += "\n(" + test.err.sourceURL + ":" + test.err.line + ")";
1659 | }
1660 |
1661 | el.appendChild(fragment('%e ', str));
1662 | }
1663 |
1664 | // toggle code
1665 | var h2 = el.getElementsByTagName('h2')[0];
1666 |
1667 | on(h2, 'click', function(){
1668 | pre.style.display = 'none' == pre.style.display
1669 | ? 'block'
1670 | : 'none';
1671 | });
1672 |
1673 | // code
1674 | // TODO: defer
1675 | if (!test.pending) {
1676 | var pre = fragment('%e%s
', msg));
1691 | }
1692 |
1693 | /**
1694 | * Return a DOM fragment from `html`.
1695 | */
1696 |
1697 | function fragment(html) {
1698 | var args = arguments
1699 | , div = document.createElement('div')
1700 | , i = 1;
1701 |
1702 | div.innerHTML = html.replace(/%([se])/g, function(_, type){
1703 | switch (type) {
1704 | case 's': return String(args[i++]);
1705 | case 'e': return escape(args[i++]);
1706 | }
1707 | });
1708 |
1709 | return div.firstChild;
1710 | }
1711 |
1712 | /**
1713 | * Set `el` text to `str`.
1714 | */
1715 |
1716 | function text(el, str) {
1717 | if (el.textContent) {
1718 | el.textContent = str;
1719 | } else {
1720 | el.innerText = str;
1721 | }
1722 | }
1723 |
1724 | /**
1725 | * Listen on `event` with callback `fn`.
1726 | */
1727 |
1728 | function on(el, event, fn) {
1729 | if (el.addEventListener) {
1730 | el.addEventListener(event, fn, false);
1731 | } else {
1732 | el.attachEvent('on' + event, fn);
1733 | }
1734 | }
1735 |
1736 | /**
1737 | * Strip the function definition from `str`,
1738 | * and re-indent for pre whitespace.
1739 | */
1740 |
1741 | function clean(str) {
1742 | str = str
1743 | .replace(/^function *\(.*\) *{/, '')
1744 | .replace(/\s+\}$/, '');
1745 |
1746 | var spaces = str.match(/^\n?( *)/)[1].length
1747 | , re = new RegExp('^ {' + spaces + '}', 'gm');
1748 |
1749 | str = str
1750 | .replace(re, '')
1751 | .replace(/^\s+/, '');
1752 |
1753 | return str;
1754 | }
1755 |
1756 | }); // module: reporters/html.js
1757 |
1758 | require.register("reporters/index.js", function(module, exports, require){
1759 |
1760 | exports.Base = require('./base');
1761 | exports.Dot = require('./dot');
1762 | exports.Doc = require('./doc');
1763 | exports.TAP = require('./tap');
1764 | exports.JSON = require('./json');
1765 | exports.HTML = require('./html');
1766 | exports.List = require('./list');
1767 | exports.Min = require('./min');
1768 | exports.Spec = require('./spec');
1769 | exports.Progress = require('./progress');
1770 | exports.Landing = require('./landing');
1771 | exports.JSONCov = require('./json-cov');
1772 | exports.HTMLCov = require('./html-cov');
1773 | exports.JSONStream = require('./json-stream');
1774 | exports.XUnit = require('./xunit')
1775 | exports.Teamcity = require('./teamcity')
1776 |
1777 | }); // module: reporters/index.js
1778 |
1779 | require.register("reporters/json-cov.js", function(module, exports, require){
1780 |
1781 | /**
1782 | * Module dependencies.
1783 | */
1784 |
1785 | var Base = require('./base');
1786 |
1787 | /**
1788 | * Expose `JSONCov`.
1789 | */
1790 |
1791 | exports = module.exports = JSONCov;
1792 |
1793 | /**
1794 | * Initialize a new `JsCoverage` reporter.
1795 | *
1796 | * @param {Runner} runner
1797 | * @param {Boolean} output
1798 | * @api public
1799 | */
1800 |
1801 | function JSONCov(runner, output) {
1802 | var self = this
1803 | , output = 1 == arguments.length ? true : output;
1804 |
1805 | Base.call(this, runner);
1806 |
1807 | var tests = []
1808 | , failures = []
1809 | , passes = [];
1810 |
1811 | runner.on('test end', function(test){
1812 | tests.push(test);
1813 | });
1814 |
1815 | runner.on('pass', function(test){
1816 | passes.push(test);
1817 | });
1818 |
1819 | runner.on('fail', function(test){
1820 | failures.push(test);
1821 | });
1822 |
1823 | runner.on('end', function(){
1824 | var cov = global._$jscoverage || {};
1825 | var result = self.cov = map(cov);
1826 | result.stats = self.stats;
1827 | result.tests = tests.map(clean);
1828 | result.failures = failures.map(clean);
1829 | result.passes = passes.map(clean);
1830 | if (!output) return;
1831 | process.stdout.write(JSON.stringify(result, null, 2 ));
1832 | });
1833 | }
1834 |
1835 | /**
1836 | * Map jscoverage data to a JSON structure
1837 | * suitable for reporting.
1838 | *
1839 | * @param {Object} cov
1840 | * @return {Object}
1841 | * @api private
1842 | */
1843 |
1844 | function map(cov) {
1845 | var ret = {
1846 | instrumentation: 'node-jscoverage'
1847 | , sloc: 0
1848 | , hits: 0
1849 | , misses: 0
1850 | , coverage: 0
1851 | , files: []
1852 | };
1853 |
1854 | for (var filename in cov) {
1855 | var data = coverage(filename, cov[filename]);
1856 | ret.files.push(data);
1857 | ret.hits += data.hits;
1858 | ret.misses += data.misses;
1859 | ret.sloc += data.sloc;
1860 | }
1861 |
1862 | if (ret.sloc > 0) {
1863 | ret.coverage = (ret.hits / ret.sloc) * 100;
1864 | }
1865 |
1866 | return ret;
1867 | };
1868 |
1869 | /**
1870 | * Map jscoverage data for a single source file
1871 | * to a JSON structure suitable for reporting.
1872 | *
1873 | * @param {String} filename name of the source file
1874 | * @param {Object} data jscoverage coverage data
1875 | * @return {Object}
1876 | * @api private
1877 | */
1878 |
1879 | function coverage(filename, data) {
1880 | var ret = {
1881 | filename: filename,
1882 | coverage: 0,
1883 | hits: 0,
1884 | misses: 0,
1885 | sloc: 0,
1886 | source: {}
1887 | };
1888 |
1889 | data.source.forEach(function(line, num){
1890 | num++;
1891 |
1892 | if (data[num] === 0) {
1893 | ret.misses++;
1894 | ret.sloc++;
1895 | } else if (data[num] !== undefined) {
1896 | ret.hits++;
1897 | ret.sloc++;
1898 | }
1899 |
1900 | ret.source[num] = {
1901 | source: line
1902 | , coverage: data[num] === undefined
1903 | ? ''
1904 | : data[num]
1905 | };
1906 | });
1907 |
1908 | ret.coverage = ret.hits / ret.sloc * 100;
1909 |
1910 | return ret;
1911 | }
1912 |
1913 | /**
1914 | * Return a plain-object representation of `test`
1915 | * free of cyclic properties etc.
1916 | *
1917 | * @param {Object} test
1918 | * @return {Object}
1919 | * @api private
1920 | */
1921 |
1922 | function clean(test) {
1923 | return {
1924 | title: test.title
1925 | , fullTitle: test.fullTitle()
1926 | , duration: test.duration
1927 | }
1928 | }
1929 |
1930 | }); // module: reporters/json-cov.js
1931 |
1932 | require.register("reporters/json-stream.js", function(module, exports, require){
1933 |
1934 | /**
1935 | * Module dependencies.
1936 | */
1937 |
1938 | var Base = require('./base')
1939 | , color = Base.color;
1940 |
1941 | /**
1942 | * Expose `List`.
1943 | */
1944 |
1945 | exports = module.exports = List;
1946 |
1947 | /**
1948 | * Initialize a new `List` test reporter.
1949 | *
1950 | * @param {Runner} runner
1951 | * @api public
1952 | */
1953 |
1954 | function List(runner) {
1955 | Base.call(this, runner);
1956 |
1957 | var self = this
1958 | , stats = this.stats
1959 | , total = runner.total;
1960 |
1961 | runner.on('start', function(){
1962 | console.log(JSON.stringify(['start', { total: total }]));
1963 | });
1964 |
1965 | runner.on('pass', function(test){
1966 | console.log(JSON.stringify(['pass', clean(test)]));
1967 | });
1968 |
1969 | runner.on('fail', function(test, err){
1970 | console.log(JSON.stringify(['fail', clean(test)]));
1971 | });
1972 |
1973 | runner.on('end', function(){
1974 | process.stdout.write(JSON.stringify(['end', self.stats]));
1975 | });
1976 | }
1977 |
1978 | /**
1979 | * Return a plain-object representation of `test`
1980 | * free of cyclic properties etc.
1981 | *
1982 | * @param {Object} test
1983 | * @return {Object}
1984 | * @api private
1985 | */
1986 |
1987 | function clean(test) {
1988 | return {
1989 | title: test.title
1990 | , fullTitle: test.fullTitle()
1991 | , duration: test.duration
1992 | }
1993 | }
1994 | }); // module: reporters/json-stream.js
1995 |
1996 | require.register("reporters/json.js", function(module, exports, require){
1997 |
1998 | /**
1999 | * Module dependencies.
2000 | */
2001 |
2002 | var Base = require('./base')
2003 | , cursor = Base.cursor
2004 | , color = Base.color;
2005 |
2006 | /**
2007 | * Expose `JSON`.
2008 | */
2009 |
2010 | exports = module.exports = JSONReporter;
2011 |
2012 | /**
2013 | * Initialize a new `JSON` reporter.
2014 | *
2015 | * @param {Runner} runner
2016 | * @api public
2017 | */
2018 |
2019 | function JSONReporter(runner) {
2020 | var self = this;
2021 | Base.call(this, runner);
2022 |
2023 | var tests = []
2024 | , failures = []
2025 | , passes = [];
2026 |
2027 | runner.on('test end', function(test){
2028 | tests.push(test);
2029 | });
2030 |
2031 | runner.on('pass', function(test){
2032 | passes.push(test);
2033 | });
2034 |
2035 | runner.on('fail', function(test){
2036 | failures.push(test);
2037 | });
2038 |
2039 | runner.on('end', function(){
2040 | var obj = {
2041 | stats: self.stats
2042 | , tests: tests.map(clean)
2043 | , failures: failures.map(clean)
2044 | , passes: passes.map(clean)
2045 | };
2046 |
2047 | process.stdout.write(JSON.stringify(obj, null, 2));
2048 | });
2049 | }
2050 |
2051 | /**
2052 | * Return a plain-object representation of `test`
2053 | * free of cyclic properties etc.
2054 | *
2055 | * @param {Object} test
2056 | * @return {Object}
2057 | * @api private
2058 | */
2059 |
2060 | function clean(test) {
2061 | return {
2062 | title: test.title
2063 | , fullTitle: test.fullTitle()
2064 | , duration: test.duration
2065 | }
2066 | }
2067 | }); // module: reporters/json.js
2068 |
2069 | require.register("reporters/landing.js", function(module, exports, require){
2070 |
2071 | /**
2072 | * Module dependencies.
2073 | */
2074 |
2075 | var Base = require('./base')
2076 | , cursor = Base.cursor
2077 | , color = Base.color;
2078 |
2079 | /**
2080 | * Expose `Landing`.
2081 | */
2082 |
2083 | exports = module.exports = Landing;
2084 |
2085 | /**
2086 | * Airplane color.
2087 | */
2088 |
2089 | Base.colors.plane = 0;
2090 |
2091 | /**
2092 | * Airplane crash color.
2093 | */
2094 |
2095 | Base.colors['plane crash'] = 31;
2096 |
2097 | /**
2098 | * Runway color.
2099 | */
2100 |
2101 | Base.colors.runway = 90;
2102 |
2103 | /**
2104 | * Initialize a new `Landing` reporter.
2105 | *
2106 | * @param {Runner} runner
2107 | * @api public
2108 | */
2109 |
2110 | function Landing(runner) {
2111 | Base.call(this, runner);
2112 |
2113 | var self = this
2114 | , stats = this.stats
2115 | , width = Base.window.width * .75 | 0
2116 | , total = runner.total
2117 | , stream = process.stdout
2118 | , plane = color('plane', '✈')
2119 | , crashed = -1
2120 | , n = 0;
2121 |
2122 | function runway() {
2123 | var buf = Array(width).join('-');
2124 | return ' ' + color('runway', buf);
2125 | }
2126 |
2127 | runner.on('start', function(){
2128 | stream.write('\n ');
2129 | cursor.hide();
2130 | });
2131 |
2132 | runner.on('test end', function(test){
2133 | // check if the plane crashed
2134 | var col = -1 == crashed
2135 | ? width * ++n / total | 0
2136 | : crashed;
2137 |
2138 | // show the crash
2139 | if ('failed' == test.state) {
2140 | plane = color('plane crash', '✈');
2141 | crashed = col;
2142 | }
2143 |
2144 | // render landing strip
2145 | stream.write('\033[4F\n\n');
2146 | stream.write(runway());
2147 | stream.write('\n ');
2148 | stream.write(color('runway', Array(col).join('⋅')));
2149 | stream.write(plane)
2150 | stream.write(color('runway', Array(width - col).join('⋅') + '\n'));
2151 | stream.write(runway());
2152 | stream.write('\033[0m');
2153 | });
2154 |
2155 | runner.on('end', function(){
2156 | cursor.show();
2157 | console.log();
2158 | self.epilogue();
2159 | });
2160 | }
2161 |
2162 | /**
2163 | * Inherit from `Base.prototype`.
2164 | */
2165 |
2166 | Landing.prototype = new Base;
2167 | Landing.prototype.constructor = Landing;
2168 |
2169 | }); // module: reporters/landing.js
2170 |
2171 | require.register("reporters/list.js", function(module, exports, require){
2172 |
2173 | /**
2174 | * Module dependencies.
2175 | */
2176 |
2177 | var Base = require('./base')
2178 | , cursor = Base.cursor
2179 | , color = Base.color;
2180 |
2181 | /**
2182 | * Expose `List`.
2183 | */
2184 |
2185 | exports = module.exports = List;
2186 |
2187 | /**
2188 | * Initialize a new `List` test reporter.
2189 | *
2190 | * @param {Runner} runner
2191 | * @api public
2192 | */
2193 |
2194 | function List(runner) {
2195 | Base.call(this, runner);
2196 |
2197 | var self = this
2198 | , stats = this.stats
2199 | , n = 0;
2200 |
2201 | runner.on('start', function(){
2202 | console.log();
2203 | });
2204 |
2205 | runner.on('test', function(test){
2206 | process.stdout.write(color('pass', ' ' + test.fullTitle() + ': '));
2207 | });
2208 |
2209 | runner.on('pending', function(test){
2210 | var fmt = color('checkmark', ' -')
2211 | + color('pending', ' %s');
2212 | console.log(fmt, test.fullTitle());
2213 | });
2214 |
2215 | runner.on('pass', function(test){
2216 | var fmt = color('checkmark', ' ✓')
2217 | + color('pass', ' %s: ')
2218 | + color(test.speed, '%dms');
2219 | cursor.CR();
2220 | console.log(fmt, test.fullTitle(), test.duration);
2221 | });
2222 |
2223 | runner.on('fail', function(test, err){
2224 | cursor.CR();
2225 | console.log(color('fail', ' %d) %s'), ++n, test.fullTitle());
2226 | });
2227 |
2228 | runner.on('end', self.epilogue.bind(self));
2229 | }
2230 |
2231 | /**
2232 | * Inherit from `Base.prototype`.
2233 | */
2234 |
2235 | List.prototype = new Base;
2236 | List.prototype.constructor = List;
2237 |
2238 |
2239 | }); // module: reporters/list.js
2240 |
2241 | require.register("reporters/markdown.js", function(module, exports, require){
2242 |
2243 | /**
2244 | * Module dependencies.
2245 | */
2246 |
2247 | var Base = require('./base')
2248 | , utils = require('../utils');
2249 |
2250 | /**
2251 | * Expose `Markdown`.
2252 | */
2253 |
2254 | exports = module.exports = Markdown;
2255 |
2256 | /**
2257 | * Initialize a new `Markdown` reporter.
2258 | *
2259 | * @param {Runner} runner
2260 | * @api public
2261 | */
2262 |
2263 | function Markdown(runner) {
2264 | Base.call(this, runner);
2265 |
2266 | var self = this
2267 | , stats = this.stats
2268 | , total = runner.total
2269 | , level = 0
2270 | , buf = '';
2271 |
2272 | function title(str) {
2273 | return Array(level).join('#') + ' ' + str;
2274 | }
2275 |
2276 | function indent() {
2277 | return Array(level).join(' ');
2278 | }
2279 |
2280 | function mapTOC(suite, obj) {
2281 | var ret = obj;
2282 | obj = obj[suite.title] = obj[suite.title] || { suite: suite };
2283 | suite.suites.forEach(function(suite){
2284 | mapTOC(suite, obj);
2285 | });
2286 | return ret;
2287 | }
2288 |
2289 | function stringifyTOC(obj, level) {
2290 | ++level;
2291 | var buf = '';
2292 | var link;
2293 | for (var key in obj) {
2294 | if ('suite' == key) continue;
2295 | if (key) link = ' - [' + key + '](#' + utils.slug(obj[key].suite.fullTitle()) + ')\n';
2296 | if (key) buf += Array(level).join(' ') + link;
2297 | buf += stringifyTOC(obj[key], level);
2298 | }
2299 | --level;
2300 | return buf;
2301 | }
2302 |
2303 | function generateTOC(suite) {
2304 | var obj = mapTOC(suite, {});
2305 | return stringifyTOC(obj, 0);
2306 | }
2307 |
2308 | generateTOC(runner.suite);
2309 |
2310 | runner.on('suite', function(suite){
2311 | ++level;
2312 | var slug = utils.slug(suite.fullTitle());
2313 | buf += ''
3768 | : val;
3769 | }, 2);
3770 | };
3771 | }); // module: test.js
3772 |
3773 | require.register("utils.js", function(module, exports, require){
3774 |
3775 | /**
3776 | * Module dependencies.
3777 | */
3778 |
3779 | var fs = require('browser/fs')
3780 | , path = require('browser/path')
3781 | , join = path.join
3782 | , debug = require('browser/debug')('watch');
3783 |
3784 | /**
3785 | * Ignored directories.
3786 | */
3787 |
3788 | var ignore = ['node_modules', '.git'];
3789 |
3790 | /**
3791 | * Escape special characters in the given string of html.
3792 | *
3793 | * @param {String} html
3794 | * @return {String}
3795 | * @api private
3796 | */
3797 |
3798 | exports.escape = function(html) {
3799 | return String(html)
3800 | .replace(/&/g, '&')
3801 | .replace(/"/g, '"')
3802 | .replace(//g, '>');
3804 | };
3805 |
3806 | /**
3807 | * Array#forEach (<=IE8)
3808 | *
3809 | * @param {Array} array
3810 | * @param {Function} fn
3811 | * @param {Object} scope
3812 | * @api private
3813 | */
3814 |
3815 | exports.forEach = function(arr, fn, scope) {
3816 | for (var i = 0, l = arr.length; i < l; i++)
3817 | fn.call(scope, arr[i], i);
3818 | };
3819 |
3820 | /**
3821 | * Array#indexOf (<=IE8)
3822 | *
3823 | * @parma {Array} arr
3824 | * @param {Object} obj to find index of
3825 | * @param {Number} start
3826 | * @api private
3827 | */
3828 |
3829 | exports.indexOf = function (arr, obj, start) {
3830 | for (var i = start || 0, l = arr.length; i < l; i++) {
3831 | if (arr[i] === obj)
3832 | return i;
3833 | }
3834 | return -1;
3835 | };
3836 |
3837 | /**
3838 | * Array#reduce (<=IE8)
3839 | *
3840 | * @param {Array} array
3841 | * @param {Function} fn
3842 | * @param {Object} initial value
3843 | * @param {Object} scope
3844 | * @api private
3845 | */
3846 |
3847 | exports.reduce = function(arr, fn, val, scope) {
3848 | var rval = val;
3849 |
3850 | for (var i = 0, l = arr.length; i < l; i++) {
3851 | rval = fn.call(scope, rval, arr[i], i, arr);
3852 | }
3853 |
3854 | return rval;
3855 | };
3856 |
3857 | /**
3858 | * Array#filter (<=IE8)
3859 | *
3860 | * @param {Array} array
3861 | * @param {Function} fn
3862 | * @param {Object} scope
3863 | * @api private
3864 | */
3865 |
3866 | exports.filter = function(arr, fn, scope) {
3867 | var ret = [];
3868 |
3869 | for (var i = 0, l = arr.length; i < l; i++) {
3870 | var val = arr[i];
3871 | if (fn.call(scope, val, i, arr))
3872 | ret.push(val);
3873 | }
3874 |
3875 | return ret;
3876 | };
3877 |
3878 | /**
3879 | * Object.keys (<=IE8)
3880 | *
3881 | * @param {Object} obj
3882 | * @return {Array} keys
3883 | * @api private
3884 | */
3885 |
3886 | exports.keys = Object.keys || function(obj) {
3887 | var keys = []
3888 | , has = Object.prototype.hasOwnProperty // for `window` on <=IE8
3889 |
3890 | for (var key in obj) {
3891 | if (has.call(obj, key)) {
3892 | keys.push(key);
3893 | }
3894 | }
3895 |
3896 | return keys;
3897 | };
3898 |
3899 | /**
3900 | * Watch the given `files` for changes
3901 | * and invoke `fn(file)` on modification.
3902 | *
3903 | * @param {Array} files
3904 | * @param {Function} fn
3905 | * @api private
3906 | */
3907 |
3908 | exports.watch = function(files, fn){
3909 | var options = { interval: 100 };
3910 | files.forEach(function(file){
3911 | debug('file %s', file);
3912 | fs.watchFile(file, options, function(curr, prev){
3913 | if (prev.mtime < curr.mtime) fn(file);
3914 | });
3915 | });
3916 | };
3917 |
3918 | /**
3919 | * Ignored files.
3920 | */
3921 |
3922 | function ignored(path){
3923 | return !~ignore.indexOf(path);
3924 | }
3925 |
3926 | /**
3927 | * Lookup files in the given `dir`.
3928 | *
3929 | * @return {Array}
3930 | * @api private
3931 | */
3932 |
3933 | exports.files = function(dir, ret){
3934 | ret = ret || [];
3935 |
3936 | fs.readdirSync(dir)
3937 | .filter(ignored)
3938 | .forEach(function(path){
3939 | path = join(dir, path);
3940 | if (fs.statSync(path).isDirectory()) {
3941 | exports.files(path, ret);
3942 | } else if (path.match(/\.(js|coffee)$/)) {
3943 | ret.push(path);
3944 | }
3945 | });
3946 |
3947 | return ret;
3948 | };
3949 |
3950 | /**
3951 | * Compute a slug from the given `str`.
3952 | *
3953 | * @param {String} str
3954 | * @return {String}
3955 | */
3956 |
3957 | exports.slug = function(str){
3958 | return str
3959 | .toLowerCase()
3960 | .replace(/ +/g, '-')
3961 | .replace(/[^-\w]/g, '');
3962 | };
3963 | }); // module: utils.js
3964 | /**
3965 | * Node shims.
3966 | *
3967 | * These are meant only to allow
3968 | * mocha.js to run untouched, not
3969 | * to allow running node code in
3970 | * the browser.
3971 | */
3972 |
3973 | process = {};
3974 | process.exit = function(status){};
3975 | process.stdout = {};
3976 | global = window;
3977 |
3978 | /**
3979 | * next tick implementation.
3980 | */
3981 |
3982 | process.nextTick = (function(){
3983 | // postMessage behaves badly on IE8
3984 | if (window.ActiveXObject || !window.postMessage) {
3985 | return function(fn){ fn() };
3986 | }
3987 |
3988 | // based on setZeroTimeout by David Baron
3989 | // - http://dbaron.org/log/20100309-faster-timeouts
3990 | var timeouts = []
3991 | , name = 'mocha-zero-timeout'
3992 |
3993 | return function(fn){
3994 | timeouts.push(fn);
3995 | window.postMessage(name, '*');
3996 | window.addEventListener('message', function(e){
3997 | if (e.source == window && e.data == name) {
3998 | if (e.stopPropagation) e.stopPropagation();
3999 | if (timeouts.length) timeouts.shift()();
4000 | }
4001 | }, true);
4002 | }
4003 | })();
4004 |
4005 | /**
4006 | * Remove uncaughtException listener.
4007 | */
4008 |
4009 | process.removeListener = function(e){
4010 | if ('uncaughtException' == e) {
4011 | window.onerror = null;
4012 | }
4013 | };
4014 |
4015 | /**
4016 | * Implements uncaughtException listener.
4017 | */
4018 |
4019 | process.on = function(e, fn){
4020 | if ('uncaughtException' == e) {
4021 | window.onerror = fn;
4022 | }
4023 | };
4024 |
4025 | /**
4026 | * Expose mocha.
4027 | */
4028 |
4029 | window.mocha = require('mocha');
4030 |
4031 | // boot
4032 | ;(function(){
4033 | var suite = new mocha.Suite('', new mocha.Context)
4034 | , utils = mocha.utils
4035 | , options = {}
4036 |
4037 | /**
4038 | * Highlight the given string of `js`.
4039 | */
4040 |
4041 | function highlight(js) {
4042 | return js
4043 | .replace(//g, '>')
4045 | .replace(/\/\/(.*)/gm, '')
4046 | .replace(/('.*?')/gm, '$1 ')
4047 | .replace(/(\d+\.\d+)/gm, '$1 ')
4048 | .replace(/(\d+)/gm, '$1 ')
4049 | .replace(/\bnew *(\w+)/gm, 'new $1 ')
4050 | .replace(/\b(function|new|throw|return|var|if|else)\b/gm, '$1 ')
4051 | }
4052 |
4053 | /**
4054 | * Highlight code contents.
4055 | */
4056 |
4057 | function highlightCode() {
4058 | var code = document.getElementsByTagName('code');
4059 | for (var i = 0, len = code.length; i < len; ++i) {
4060 | code[i].innerHTML = highlight(code[i].innerHTML);
4061 | }
4062 | }
4063 |
4064 | /**
4065 | * Parse the given `qs`.
4066 | */
4067 |
4068 | function parse(qs) {
4069 | return utils.reduce(qs.replace('?', '').split('&'), function(obj, pair){
4070 | var i = pair.indexOf('=')
4071 | , key = pair.slice(0, i)
4072 | , val = pair.slice(++i);
4073 |
4074 | obj[key] = decodeURIComponent(val);
4075 | return obj;
4076 | }, {});
4077 | }
4078 |
4079 | /**
4080 | * Setup mocha with the given setting options.
4081 | */
4082 |
4083 | mocha.setup = function(opts){
4084 | if ('string' === typeof opts) options.ui = opts;
4085 | else options = opts;
4086 |
4087 | ui = mocha.interfaces[options.ui];
4088 | if (!ui) throw new Error('invalid mocha interface "' + ui + '"');
4089 | if (options.timeout) suite.timeout(options.timeout);
4090 | ui(suite);
4091 | suite.emit('pre-require', window);
4092 | };
4093 |
4094 | /**
4095 | * Run mocha, returning the Runner.
4096 | */
4097 |
4098 | mocha.run = function(fn){
4099 | suite.emit('run');
4100 | var runner = new mocha.Runner(suite);
4101 | var Reporter = options.reporter || mocha.reporters.HTML;
4102 | var reporter = new Reporter(runner);
4103 | var query = parse(window.location.search || "");
4104 | if (query.grep) runner.grep(new RegExp(query.grep));
4105 | if (options.ignoreLeaks) runner.ignoreLeaks = true;
4106 | if (options.globals) runner.globals(options.globals);
4107 | runner.globals(['location']);
4108 | runner.on('end', highlightCode);
4109 | return runner.run(fn);
4110 | };
4111 | })();
4112 | })();
--------------------------------------------------------------------------------