├── .gitignore
├── .travis.yml
├── README.md
├── grunt.js
├── package.json
├── tests
    ├── mocha.css
    ├── mocha.js
    └── recursion.html
└── tracekit.js


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/
2 | TraceKit.iml
3 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - 0.8


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | TraceKit - Cross browser stack traces.
 2 | =====================================
 3 | 
 4 | [![Build Status](https://travis-ci.org/occ/TraceKit.png?branch=master)](https://travis-ci.org/occ/TraceKit)
 5 | 
 6 | ### Supports all major browsers, from IE6 to Opera, the Andriod webiew and everywhere in between.
 7 | 
 8 | Not all browsers support stack traces on error objects, but TraceKit squeezes
 9 | out as much useful information as possible and normalizes it. 3kB minified + gzipped
10 | 
11 | 
12 | ## Install
13 | 
14 | ```
15 | bower install tracekit
16 | ```
17 | This places TraceKit at `components/tracekit/tracekit.js`. Install [bower](http://twitter.github.com/bower/): `npm install bower -g`, download npm with Node: http://nodejs.org
18 | 
19 | Then include the `<script>` to your page
20 | 
21 | ## Usage
22 | 
23 | First, register a subscriber for error reports:
24 | ```javascript
25 | TraceKit.report.subscribe(function yourLogger(errorReport) {
26 |   //send via ajax to server, or use console.error in development
27 |   //to get you started see: https://gist.github.com/4491219
28 | });
29 | ```
30 | 
31 | Then, make sure all your code is in a try/catch block:
32 | ```javascript
33 | try {
34 |   /*
35 |    * your application code here
36 |    *
37 |    */
38 |   throw new Error('oops');
39 | } catch (e) {
40 |   TraceKit.report(e); //error with stack trace gets normalized and sent to subscriber
41 | }
42 | ```
43 | 
44 | In order to get stack traces, you need to wrap your code in a try/catch block like above. Otherwise the error hits `window.onerror` handler and will only contain the error message, line number, and column number.
45 | 
46 | You also need to throw errors with `throw new Error('foo')` instead of `throw 'foo'`.
47 | 
48 | You can unsubscribe some subscriber function by doing `TraceKit.report.unsubscribe(someFunction)`
49 | 
50 | #### Eliminating (anonymous function)'s
51 | 
52 | ```javascript
53 | Api.foo = function Api_foo() {
54 | };
55 | var bar = function barFn() { //'Fn' is to avoid errors in IE
56 | };
57 | ```
58 | 
59 | We recommend the above convention of function naming, `Api_foo` always corresponds to `Api.foo`, `barFn` corresponds to `bar` - just as long as the function name is not the same as the identifier. Otherwise, you can have bugs in IE.
60 | 
61 | ## Options
62 | 
63 | TraceKit will attempt to fetch an analyze source files, but you can turn this off using:
64 | 
65 | ```javascript
66 | TraceKit.remoteFetching = false;
67 | ```
68 | 
69 | You can also tell TraceKit to ignore global window errors with:
70 | 
71 | ```javascript
72 | TraceKit.collectWindowErrors = false;
73 | ```
74 | 
75 | View the source for more details and examples.
76 | 
77 | ![Stacktrace or GTFO](http://i.imgur.com/jacoj.jpg)
78 | 
79 | ## Contributing
80 | 
81 | Right now the project is being over-hauled, please jump into #shieldjs on freenode to discuss before submitting a big/medium PR (this saves us all time)
82 | 
83 | All code must pass JSHint and tests, run `grunt` for this. New features need accompanying documentation in the README, changes to existing api's need updated documentation. In general, open an issue for whatever it is you're thinking, get some quick feedback, make good stuff, and we'll accept the PR.
84 | 
85 | ## License
86 | 
87 | (The MIT License)
88 | 
89 | Copyright (c) 2013 Onur Can Cakmak <onur.cakmak@gmail.com> and all TraceKit contributors.
90 | 
91 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
92 | 
93 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
94 | 
95 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
96 | 


--------------------------------------------------------------------------------
/grunt.js:
--------------------------------------------------------------------------------
 1 | /*global module:false*/
 2 | module.exports = function(grunt) {
 3 |   'use strict';
 4 |   
 5 |   // Project configuration.
 6 |   grunt.initConfig({
 7 |     lint: {
 8 |       files: ['grunt.js', 'tracekit.js']
 9 |     },
10 |     watch: {
11 |       files: '<config:lint.files>',
12 |       tasks: 'lint'
13 |     },
14 |     jshint: {
15 |       options: {
16 |         // Uncommented are default grunt options
17 |         bitwise: true, //Added from site
18 |         curly: true,
19 |         eqeqeq: true,
20 |         immed: true,
21 |         latedef: true,
22 |         newcap: true,
23 |         noarg: true,
24 |         noempty: true, //Added from site
25 |         nonew: true, //Added
26 |         quotmark: 'single', //Added
27 |         /* regexp: true, */
28 |         undef: true,
29 |         unused: true, //Added from site
30 |         /* strict: true, //Added from site */
31 |         sub: true,
32 |         boss: true, //dont' allow assignments to be evaluated as truthy/falsey */
33 |         eqnull: true, //Allow == null
34 |         browser: true,
35 |         /* indent: 4, //Added from site */
36 |         devel: true, //Added
37 |         white: false,
38 |         
39 |         es5:       true,
40 |         onecase:   true,
41 |         
42 |         //Adding a few of nice restrictions:
43 |         trailing: true,
44 |         maxparams: 6,
45 |         maxdepth: 9,
46 |         maxerr: 20
47 |       },
48 |       globals: {
49 |         ActiveXObject: false
50 |       }
51 |     }
52 |   });
53 | 
54 |   // Default task.
55 |   grunt.registerTask('default', 'lint watch');
56 | 
57 |   // Travis-CI task.
58 |   grunt.registerTask('travis', 'lint');
59 | };
60 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "TraceKit",
 3 |   "version": "0.1.0",
 4 |   "devDependencies": {
 5 |     "grunt": "~0.3.17"
 6 |   },
 7 |   "scripts": {
 8 |     "test": "grunt travis --verbose"
 9 |   }
10 | }


--------------------------------------------------------------------------------
/tests/mocha.css:
--------------------------------------------------------------------------------
  1 | 
  2 | body {
  3 |   font: 20px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif;
  4 |   padding: 60px 50px;
  5 | }
  6 | 
  7 | #mocha ul, #mocha li {
  8 |   margin: 0;
  9 |   padding: 0;
 10 | }
 11 | 
 12 | #mocha ul {
 13 |   list-style: none;
 14 | }
 15 | 
 16 | #mocha h1, #mocha h2 {
 17 |   margin: 0;
 18 | }
 19 | 
 20 | #mocha h1 {
 21 |   margin-top: 15px;
 22 |   font-size: 1em;
 23 |   font-weight: 200;
 24 | }
 25 | 
 26 | #mocha h1 a {
 27 |   text-decoration: none;
 28 |   color: inherit;
 29 | }
 30 | 
 31 | #mocha h1 a:hover {
 32 |   text-decoration: underline;
 33 | }
 34 | 
 35 | #mocha .suite .suite h1 {
 36 |   margin-top: 0;
 37 |   font-size: .8em;
 38 | }
 39 | 
 40 | #mocha h2 {
 41 |   font-size: 12px;
 42 |   font-weight: normal;
 43 |   cursor: pointer;
 44 | }
 45 | 
 46 | #mocha .suite {
 47 |   margin-left: 15px;
 48 | }
 49 | 
 50 | #mocha .test {
 51 |   margin-left: 15px;
 52 | }
 53 | 
 54 | #mocha .test:hover h2::after {
 55 |   position: relative;
 56 |   top: 0;
 57 |   right: -10px;
 58 |   content: '(view source)';
 59 |   font-size: 12px;
 60 |   font-family: arial;
 61 |   color: #888;
 62 | }
 63 | 
 64 | #mocha .test.pending:hover h2::after {
 65 |   content: '(pending)';
 66 |   font-family: arial;
 67 | }
 68 | 
 69 | #mocha .test.pass.medium .duration {
 70 |   background: #C09853;
 71 | }
 72 | 
 73 | #mocha .test.pass.slow .duration {
 74 |   background: #B94A48;
 75 | }
 76 | 
 77 | #mocha .test.pass::before {
 78 |   content: '✓';
 79 |   font-size: 12px;
 80 |   display: block;
 81 |   float: left;
 82 |   margin-right: 5px;
 83 |   color: #00d6b2;
 84 | }
 85 | 
 86 | #mocha .test.pass .duration {
 87 |   font-size: 9px;
 88 |   margin-left: 5px;
 89 |   padding: 2px 5px;
 90 |   color: white;
 91 |   -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
 92 |   -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
 93 |   box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
 94 |   -webkit-border-radius: 5px;
 95 |   -moz-border-radius: 5px;
 96 |   -ms-border-radius: 5px;
 97 |   -o-border-radius: 5px;
 98 |   border-radius: 5px;
 99 | }
100 | 
101 | #mocha .test.pass.fast .duration {
102 |   display: none;
103 | }
104 | 
105 | #mocha .test.pending {
106 |   color: #0b97c4;
107 | }
108 | 
109 | #mocha .test.pending::before {
110 |   content: '◦';
111 |   color: #0b97c4;
112 | }
113 | 
114 | #mocha .test.fail {
115 |   color: #c00;
116 | }
117 | 
118 | #mocha .test.fail pre {
119 |   color: black;
120 | }
121 | 
122 | #mocha .test.fail::before {
123 |   content: '✖';
124 |   font-size: 12px;
125 |   display: block;
126 |   float: left;
127 |   margin-right: 5px;
128 |   color: #c00;
129 | }
130 | 
131 | #mocha .test pre.error {
132 |   color: #c00;
133 | }
134 | 
135 | #mocha .test pre {
136 |   display: inline-block;
137 |   font: 12px/1.5 monaco, monospace;
138 |   margin: 5px;
139 |   padding: 15px;
140 |   border: 1px solid #eee;
141 |   border-bottom-color: #ddd;
142 |   -webkit-border-radius: 3px;
143 |   -webkit-box-shadow: 0 1px 3px #eee;
144 | }
145 | 
146 | #error {
147 |   color: #c00;
148 |   font-size: 1.5  em;
149 |   font-weight: 100;
150 |   letter-spacing: 1px;
151 | }
152 | 
153 | #stats {
154 |   position: fixed;
155 |   top: 15px;
156 |   right: 10px;
157 |   font-size: 12px;
158 |   margin: 0;
159 |   color: #888;
160 | }
161 | 
162 | #stats .progress {
163 |   float: right;
164 |   padding-top: 0;
165 | }
166 | 
167 | #stats em {
168 |   color: black;
169 | }
170 | 
171 | #stats li {
172 |   display: inline-block;
173 |   margin: 0 5px;
174 |   list-style: none;
175 |   padding-top: 11px;
176 | }
177 | 
178 | code .comment { color: #ddd }
179 | code .init { color: #2F6FAD }
180 | code .string { color: #5890AD }
181 | code .keyword { color: #8A6343 }
182 | code .number { color: #2F6FAD }
183 | 


--------------------------------------------------------------------------------
/tests/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 public
 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 or get 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 |   if (0 == arguments.length) return this._runnable;
 419 |   this.test = this._runnable = runnable;
 420 |   return this;
 421 | };
 422 | 
 423 | /**
 424 |  * Set test timeout `ms`.
 425 |  *
 426 |  * @param {Number} ms
 427 |  * @return {Context} self
 428 |  * @api private
 429 |  */
 430 | 
 431 | Context.prototype.timeout = function(ms){
 432 |   this.runnable().timeout(ms);
 433 |   return this;
 434 | };
 435 | 
 436 | /**
 437 |  * Set test slowness threshold `ms`.
 438 |  *
 439 |  * @param {Number} ms
 440 |  * @return {Context} self
 441 |  * @api private
 442 |  */
 443 | 
 444 | Context.prototype.slow = function(ms){
 445 |   this.runnable().slow(ms);
 446 |   return this;
 447 | };
 448 | 
 449 | /**
 450 |  * Inspect the context void of `._runnable`.
 451 |  *
 452 |  * @return {String}
 453 |  * @api private
 454 |  */
 455 | 
 456 | Context.prototype.inspect = function(){
 457 |   return JSON.stringify(this, function(key, val){
 458 |     if ('_runnable' == key) return;
 459 |     if ('test' == key) return;
 460 |     return val;
 461 |   }, 2);
 462 | };
 463 | 
 464 | }); // module: context.js
 465 | 
 466 | require.register("hook.js", function(module, exports, require){
 467 | 
 468 | /**
 469 |  * Module dependencies.
 470 |  */
 471 | 
 472 | var Runnable = require('./runnable');
 473 | 
 474 | /**
 475 |  * Expose `Hook`.
 476 |  */
 477 | 
 478 | module.exports = Hook;
 479 | 
 480 | /**
 481 |  * Initialize a new `Hook` with the given `title` and callback `fn`.
 482 |  *
 483 |  * @param {String} title
 484 |  * @param {Function} fn
 485 |  * @api private
 486 |  */
 487 | 
 488 | function Hook(title, fn) {
 489 |   Runnable.call(this, title, fn);
 490 |   this.type = 'hook';
 491 | }
 492 | 
 493 | /**
 494 |  * Inherit from `Runnable.prototype`.
 495 |  */
 496 | 
 497 | Hook.prototype = new Runnable;
 498 | Hook.prototype.constructor = Hook;
 499 | 
 500 | 
 501 | /**
 502 |  * Get or set the test `err`.
 503 |  *
 504 |  * @param {Error} err
 505 |  * @return {Error}
 506 |  * @api public
 507 |  */
 508 | 
 509 | Hook.prototype.error = function(err){
 510 |   if (0 == arguments.length) {
 511 |     var err = this._error;
 512 |     this._error = null;
 513 |     return err;
 514 |   }
 515 | 
 516 |   this._error = err;
 517 | };
 518 | 
 519 | 
 520 | }); // module: hook.js
 521 | 
 522 | require.register("interfaces/bdd.js", function(module, exports, require){
 523 | 
 524 | /**
 525 |  * Module dependencies.
 526 |  */
 527 | 
 528 | var Suite = require('../suite')
 529 |   , Test = require('../test');
 530 | 
 531 | /**
 532 |  * BDD-style interface:
 533 |  * 
 534 |  *      describe('Array', function(){
 535 |  *        describe('#indexOf()', function(){
 536 |  *          it('should return -1 when not present', function(){
 537 |  *
 538 |  *          });
 539 |  *
 540 |  *          it('should return the index when present', function(){
 541 |  *
 542 |  *          });
 543 |  *        });
 544 |  *      });
 545 |  * 
 546 |  */
 547 | 
 548 | module.exports = function(suite){
 549 |   var suites = [suite];
 550 | 
 551 |   suite.on('pre-require', function(context, file, mocha){
 552 | 
 553 |     /**
 554 |      * Execute before running tests.
 555 |      */
 556 | 
 557 |     context.before = function(fn){
 558 |       suites[0].beforeAll(fn);
 559 |     };
 560 | 
 561 |     /**
 562 |      * Execute after running tests.
 563 |      */
 564 | 
 565 |     context.after = function(fn){
 566 |       suites[0].afterAll(fn);
 567 |     };
 568 | 
 569 |     /**
 570 |      * Execute before each test case.
 571 |      */
 572 | 
 573 |     context.beforeEach = function(fn){
 574 |       suites[0].beforeEach(fn);
 575 |     };
 576 | 
 577 |     /**
 578 |      * Execute after each test case.
 579 |      */
 580 | 
 581 |     context.afterEach = function(fn){
 582 |       suites[0].afterEach(fn);
 583 |     };
 584 | 
 585 |     /**
 586 |      * Describe a "suite" with the given `title`
 587 |      * and callback `fn` containing nested suites
 588 |      * and/or tests.
 589 |      */
 590 |   
 591 |     context.describe = context.context = function(title, fn){
 592 |       var suite = Suite.create(suites[0], title);
 593 |       suites.unshift(suite);
 594 |       fn.call(suite);
 595 |       suites.shift();
 596 |       return suite;
 597 |     };
 598 | 
 599 |     /**
 600 |      * Pending describe.
 601 |      */
 602 | 
 603 |     context.xdescribe =
 604 |     context.xcontext =
 605 |     context.describe.skip = function(title, fn){
 606 |       var suite = Suite.create(suites[0], title);
 607 |       suite.pending = true;
 608 |       suites.unshift(suite);
 609 |       fn.call(suite);
 610 |       suites.shift();
 611 |     };
 612 | 
 613 |     /**
 614 |      * Exclusive suite.
 615 |      */
 616 | 
 617 |     context.describe.only = function(title, fn){
 618 |       var suite = context.describe(title, fn);
 619 |       mocha.grep(suite.fullTitle());
 620 |     };
 621 | 
 622 |     /**
 623 |      * Describe a specification or test-case
 624 |      * with the given `title` and callback `fn`
 625 |      * acting as a thunk.
 626 |      */
 627 | 
 628 |     context.it = context.specify = function(title, fn){
 629 |       var suite = suites[0];
 630 |       if (suite.pending) var fn = null;
 631 |       var test = new Test(title, fn);
 632 |       suite.addTest(test);
 633 |       return test;
 634 |     };
 635 | 
 636 |     /**
 637 |      * Exclusive test-case.
 638 |      */
 639 | 
 640 |     context.it.only = function(title, fn){
 641 |       var test = context.it(title, fn);
 642 |       mocha.grep(test.fullTitle());
 643 |     };
 644 | 
 645 |     /**
 646 |      * Pending test case.
 647 |      */
 648 | 
 649 |     context.xit =
 650 |     context.xspecify =
 651 |     context.it.skip = function(title){
 652 |       context.it(title);
 653 |     };
 654 |   });
 655 | };
 656 | 
 657 | }); // module: interfaces/bdd.js
 658 | 
 659 | require.register("interfaces/exports.js", function(module, exports, require){
 660 | 
 661 | /**
 662 |  * Module dependencies.
 663 |  */
 664 | 
 665 | var Suite = require('../suite')
 666 |   , Test = require('../test');
 667 | 
 668 | /**
 669 |  * TDD-style interface:
 670 |  * 
 671 |  *     exports.Array = {
 672 |  *       '#indexOf()': {
 673 |  *         'should return -1 when the value is not present': function(){
 674 |  *           
 675 |  *         },
 676 |  *
 677 |  *         'should return the correct index when the value is present': function(){
 678 |  *           
 679 |  *         }
 680 |  *       }
 681 |  *     };
 682 |  * 
 683 |  */
 684 | 
 685 | module.exports = function(suite){
 686 |   var suites = [suite];
 687 | 
 688 |   suite.on('require', visit);
 689 | 
 690 |   function visit(obj) {
 691 |     var suite;
 692 |     for (var key in obj) {
 693 |       if ('function' == typeof obj[key]) {
 694 |         var fn = obj[key];
 695 |         switch (key) {
 696 |           case 'before':
 697 |             suites[0].beforeAll(fn);
 698 |             break;
 699 |           case 'after':
 700 |             suites[0].afterAll(fn);
 701 |             break;
 702 |           case 'beforeEach':
 703 |             suites[0].beforeEach(fn);
 704 |             break;
 705 |           case 'afterEach':
 706 |             suites[0].afterEach(fn);
 707 |             break;
 708 |           default:
 709 |             suites[0].addTest(new Test(key, fn));
 710 |         }
 711 |       } else {
 712 |         var suite = Suite.create(suites[0], key);
 713 |         suites.unshift(suite);
 714 |         visit(obj[key]);
 715 |         suites.shift();
 716 |       }
 717 |     }
 718 |   }
 719 | };
 720 | }); // module: interfaces/exports.js
 721 | 
 722 | require.register("interfaces/index.js", function(module, exports, require){
 723 | 
 724 | exports.bdd = require('./bdd');
 725 | exports.tdd = require('./tdd');
 726 | exports.qunit = require('./qunit');
 727 | exports.exports = require('./exports');
 728 | 
 729 | }); // module: interfaces/index.js
 730 | 
 731 | require.register("interfaces/qunit.js", function(module, exports, require){
 732 | 
 733 | /**
 734 |  * Module dependencies.
 735 |  */
 736 | 
 737 | var Suite = require('../suite')
 738 |   , Test = require('../test');
 739 | 
 740 | /**
 741 |  * QUnit-style interface:
 742 |  * 
 743 |  *     suite('Array');
 744 |  *     
 745 |  *     test('#length', function(){
 746 |  *       var arr = [1,2,3];
 747 |  *       ok(arr.length == 3);
 748 |  *     });
 749 |  *     
 750 |  *     test('#indexOf()', function(){
 751 |  *       var arr = [1,2,3];
 752 |  *       ok(arr.indexOf(1) == 0);
 753 |  *       ok(arr.indexOf(2) == 1);
 754 |  *       ok(arr.indexOf(3) == 2);
 755 |  *     });
 756 |  *     
 757 |  *     suite('String');
 758 |  *     
 759 |  *     test('#length', function(){
 760 |  *       ok('foo'.length == 3);
 761 |  *     });
 762 |  * 
 763 |  */
 764 | 
 765 | module.exports = function(suite){
 766 |   var suites = [suite];
 767 | 
 768 |   suite.on('pre-require', function(context){
 769 | 
 770 |     /**
 771 |      * Execute before running tests.
 772 |      */
 773 | 
 774 |     context.before = function(fn){
 775 |       suites[0].beforeAll(fn);
 776 |     };
 777 | 
 778 |     /**
 779 |      * Execute after running tests.
 780 |      */
 781 | 
 782 |     context.after = function(fn){
 783 |       suites[0].afterAll(fn);
 784 |     };
 785 | 
 786 |     /**
 787 |      * Execute before each test case.
 788 |      */
 789 | 
 790 |     context.beforeEach = function(fn){
 791 |       suites[0].beforeEach(fn);
 792 |     };
 793 | 
 794 |     /**
 795 |      * Execute after each test case.
 796 |      */
 797 | 
 798 |     context.afterEach = function(fn){
 799 |       suites[0].afterEach(fn);
 800 |     };
 801 | 
 802 |     /**
 803 |      * Describe a "suite" with the given `title`.
 804 |      */
 805 |   
 806 |     context.suite = function(title){
 807 |       if (suites.length > 1) suites.shift();
 808 |       var suite = Suite.create(suites[0], title);
 809 |       suites.unshift(suite);
 810 |     };
 811 | 
 812 |     /**
 813 |      * Describe a specification or test-case
 814 |      * with the given `title` and callback `fn`
 815 |      * acting as a thunk.
 816 |      */
 817 | 
 818 |     context.test = function(title, fn){
 819 |       suites[0].addTest(new Test(title, fn));
 820 |     };
 821 |   });
 822 | };
 823 | 
 824 | }); // module: interfaces/qunit.js
 825 | 
 826 | require.register("interfaces/tdd.js", function(module, exports, require){
 827 | 
 828 | /**
 829 |  * Module dependencies.
 830 |  */
 831 | 
 832 | var Suite = require('../suite')
 833 |   , Test = require('../test');
 834 | 
 835 | /**
 836 |  * TDD-style interface:
 837 |  *
 838 |  *      suite('Array', function(){
 839 |  *        suite('#indexOf()', function(){
 840 |  *          suiteSetup(function(){
 841 |  *
 842 |  *          });
 843 |  *          
 844 |  *          test('should return -1 when not present', function(){
 845 |  *
 846 |  *          });
 847 |  *
 848 |  *          test('should return the index when present', function(){
 849 |  *
 850 |  *          });
 851 |  *
 852 |  *          suiteTeardown(function(){
 853 |  *
 854 |  *          });
 855 |  *        });
 856 |  *      });
 857 |  *
 858 |  */
 859 | 
 860 | module.exports = function(suite){
 861 |   var suites = [suite];
 862 | 
 863 |   suite.on('pre-require', function(context, file, mocha){
 864 | 
 865 |     /**
 866 |      * Execute before each test case.
 867 |      */
 868 | 
 869 |     context.setup = function(fn){
 870 |       suites[0].beforeEach(fn);
 871 |     };
 872 | 
 873 |     /**
 874 |      * Execute after each test case.
 875 |      */
 876 | 
 877 |     context.teardown = function(fn){
 878 |       suites[0].afterEach(fn);
 879 |     };
 880 | 
 881 |     /**
 882 |      * Execute before the suite.
 883 |      */
 884 | 
 885 |     context.suiteSetup = function(fn){
 886 |       suites[0].beforeAll(fn);
 887 |     };
 888 | 
 889 |     /**
 890 |      * Execute after the suite.
 891 |      */
 892 | 
 893 |     context.suiteTeardown = function(fn){
 894 |       suites[0].afterAll(fn);
 895 |     };
 896 | 
 897 |     /**
 898 |      * Describe a "suite" with the given `title`
 899 |      * and callback `fn` containing nested suites
 900 |      * and/or tests.
 901 |      */
 902 | 
 903 |     context.suite = function(title, fn){
 904 |       var suite = Suite.create(suites[0], title);
 905 |       suites.unshift(suite);
 906 |       fn.call(suite);
 907 |       suites.shift();
 908 |       return suite;
 909 |     };
 910 | 
 911 |     /**
 912 |      * Exclusive test-case.
 913 |      */
 914 | 
 915 |     context.suite.only = function(title, fn){
 916 |       var suite = context.suite(title, fn);
 917 |       mocha.grep(suite.fullTitle());
 918 |     };
 919 | 
 920 |     /**
 921 |      * Describe a specification or test-case
 922 |      * with the given `title` and callback `fn`
 923 |      * acting as a thunk.
 924 |      */
 925 | 
 926 |     context.test = function(title, fn){
 927 |       var test = new Test(title, fn);
 928 |       suites[0].addTest(test);
 929 |       return test;
 930 |     };
 931 | 
 932 |     /**
 933 |      * Exclusive test-case.
 934 |      */
 935 | 
 936 |     context.test.only = function(title, fn){
 937 |       var test = context.test(title, fn);
 938 |       mocha.grep(test.fullTitle());
 939 |     };
 940 |   });
 941 | };
 942 | 
 943 | }); // module: interfaces/tdd.js
 944 | 
 945 | require.register("mocha.js", function(module, exports, require){
 946 | /*!
 947 |  * mocha
 948 |  * Copyright(c) 2011 TJ Holowaychuk <tj@vision-media.ca>
 949 |  * MIT Licensed
 950 |  */
 951 | 
 952 | /**
 953 |  * Module dependencies.
 954 |  */
 955 | 
 956 | var path = require('browser/path')
 957 |   , utils = require('./utils');
 958 | 
 959 | /**
 960 |  * Expose `Mocha`.
 961 |  */
 962 | 
 963 | exports = module.exports = Mocha;
 964 | 
 965 | /**
 966 |  * Expose internals.
 967 |  */
 968 | 
 969 | exports.utils = utils;
 970 | exports.interfaces = require('./interfaces');
 971 | exports.reporters = require('./reporters');
 972 | exports.Runnable = require('./runnable');
 973 | exports.Context = require('./context');
 974 | exports.Runner = require('./runner');
 975 | exports.Suite = require('./suite');
 976 | exports.Hook = require('./hook');
 977 | exports.Test = require('./test');
 978 | 
 979 | /**
 980 |  * Return image `name` path.
 981 |  *
 982 |  * @param {String} name
 983 |  * @return {String}
 984 |  * @api private
 985 |  */
 986 | 
 987 | function image(name) {
 988 |   return __dirname + '/../images/' + name + '.png';
 989 | }
 990 | 
 991 | /**
 992 |  * Setup mocha with `options`.
 993 |  *
 994 |  * Options:
 995 |  *
 996 |  *   - `ui` name "bdd", "tdd", "exports" etc
 997 |  *   - `reporter` reporter instance, defaults to `mocha.reporters.Dot`
 998 |  *   - `globals` array of accepted globals
 999 |  *   - `timeout` timeout in milliseconds
1000 |  *   - `slow` milliseconds to wait before considering a test slow
1001 |  *   - `ignoreLeaks` ignore global leaks
1002 |  *   - `grep` string or regexp to filter tests with
1003 |  *
1004 |  * @param {Object} options
1005 |  * @api public
1006 |  */
1007 | 
1008 | function Mocha(options) {
1009 |   options = options || {};
1010 |   this.files = [];
1011 |   this.options = options;
1012 |   this.grep(options.grep);
1013 |   this.suite = new exports.Suite('', new exports.Context);
1014 |   this.ui(options.ui);
1015 |   this.reporter(options.reporter);
1016 |   if (options.timeout) this.timeout(options.timeout);
1017 |   if (options.slow) this.slow(options.slow);
1018 | }
1019 | 
1020 | /**
1021 |  * Add test `file`.
1022 |  *
1023 |  * @param {String} file
1024 |  * @api public
1025 |  */
1026 | 
1027 | Mocha.prototype.addFile = function(file){
1028 |   this.files.push(file);
1029 |   return this;
1030 | };
1031 | 
1032 | /**
1033 |  * Set reporter to `reporter`, defaults to "dot".
1034 |  *
1035 |  * @param {String|Function} reporter name of a reporter or a reporter constructor
1036 |  * @api public
1037 |  */
1038 | 
1039 | Mocha.prototype.reporter = function(reporter){
1040 |   if ('function' == typeof reporter) {
1041 |     this._reporter = reporter;
1042 |   } else {
1043 |     reporter = reporter || 'dot';
1044 |     try {
1045 |       this._reporter = require('./reporters/' + reporter);
1046 |     } catch (err) {
1047 |       this._reporter = require(reporter);
1048 |     }
1049 |     if (!this._reporter) throw new Error('invalid reporter "' + reporter + '"');
1050 |   }
1051 |   return this;
1052 | };
1053 | 
1054 | /**
1055 |  * Set test UI `name`, defaults to "bdd".
1056 |  *
1057 |  * @param {String} bdd
1058 |  * @api public
1059 |  */
1060 | 
1061 | Mocha.prototype.ui = function(name){
1062 |   name = name || 'bdd';
1063 |   this._ui = exports.interfaces[name];
1064 |   if (!this._ui) throw new Error('invalid interface "' + name + '"');
1065 |   this._ui = this._ui(this.suite);
1066 |   return this;
1067 | };
1068 | 
1069 | /**
1070 |  * Load registered files.
1071 |  *
1072 |  * @api private
1073 |  */
1074 | 
1075 | Mocha.prototype.loadFiles = function(fn){
1076 |   var self = this;
1077 |   var suite = this.suite;
1078 |   var pending = this.files.length;
1079 |   this.files.forEach(function(file){
1080 |     file = path.resolve(file);
1081 |     suite.emit('pre-require', global, file, self);
1082 |     suite.emit('require', require(file), file, self);
1083 |     suite.emit('post-require', global, file, self);
1084 |     --pending || (fn && fn());
1085 |   });
1086 | };
1087 | 
1088 | /**
1089 |  * Enable growl support.
1090 |  *
1091 |  * @api private
1092 |  */
1093 | 
1094 | Mocha.prototype._growl = function(runner, reporter) {
1095 |   var notify = require('growl');
1096 | 
1097 |   runner.on('end', function(){
1098 |     var stats = reporter.stats;
1099 |     if (stats.failures) {
1100 |       var msg = stats.failures + ' of ' + runner.total + ' tests failed';
1101 |       notify(msg, { name: 'mocha', title: 'Failed', image: image('error') });
1102 |     } else {
1103 |       notify(stats.passes + ' tests passed in ' + stats.duration + 'ms', {
1104 |           name: 'mocha'
1105 |         , title: 'Passed'
1106 |         , image: image('ok')
1107 |       });
1108 |     }
1109 |   });
1110 | };
1111 | 
1112 | /**
1113 |  * Add regexp to grep, if `re` is a string it is escaped.
1114 |  *
1115 |  * @param {RegExp|String} re
1116 |  * @return {Mocha}
1117 |  * @api public
1118 |  */
1119 | 
1120 | Mocha.prototype.grep = function(re){
1121 |   this.options.grep = 'string' == typeof re
1122 |     ? new RegExp(utils.escapeRegexp(re))
1123 |     : re;
1124 |   return this;
1125 | };
1126 | 
1127 | /**
1128 |  * Invert `.grep()` matches.
1129 |  *
1130 |  * @return {Mocha}
1131 |  * @api public
1132 |  */
1133 | 
1134 | Mocha.prototype.invert = function(){
1135 |   this.options.invert = true;
1136 |   return this;
1137 | };
1138 | 
1139 | /**
1140 |  * Ignore global leaks.
1141 |  *
1142 |  * @return {Mocha}
1143 |  * @api public
1144 |  */
1145 | 
1146 | Mocha.prototype.ignoreLeaks = function(){
1147 |   this.options.ignoreLeaks = true;
1148 |   return this;
1149 | };
1150 | 
1151 | /**
1152 |  * Enable global leak checking.
1153 |  *
1154 |  * @return {Mocha}
1155 |  * @api public
1156 |  */
1157 | 
1158 | Mocha.prototype.checkLeaks = function(){
1159 |   this.options.ignoreLeaks = false;
1160 |   return this;
1161 | };
1162 | 
1163 | /**
1164 |  * Enable growl support.
1165 |  *
1166 |  * @return {Mocha}
1167 |  * @api public
1168 |  */
1169 | 
1170 | Mocha.prototype.growl = function(){
1171 |   this.options.growl = true;
1172 |   return this;
1173 | };
1174 | 
1175 | /**
1176 |  * Ignore `globals` array or string.
1177 |  *
1178 |  * @param {Array|String} globals
1179 |  * @return {Mocha}
1180 |  * @api public
1181 |  */
1182 | 
1183 | Mocha.prototype.globals = function(globals){
1184 |   this.options.globals = (this.options.globals || []).concat(globals);
1185 |   return this;
1186 | };
1187 | 
1188 | /**
1189 |  * Set the timeout in milliseconds.
1190 |  *
1191 |  * @param {Number} timeout
1192 |  * @return {Mocha}
1193 |  * @api public
1194 |  */
1195 | 
1196 | Mocha.prototype.timeout = function(timeout){
1197 |   this.suite.timeout(timeout);
1198 |   return this;
1199 | };
1200 | 
1201 | /**
1202 |  * Set slowness threshold in milliseconds.
1203 |  *
1204 |  * @param {Number} slow
1205 |  * @return {Mocha}
1206 |  * @api public
1207 |  */
1208 | 
1209 | Mocha.prototype.slow = function(slow){
1210 |   this.suite.slow(slow);
1211 |   return this;
1212 | };
1213 | 
1214 | /**
1215 |  * Run tests and invoke `fn()` when complete.
1216 |  *
1217 |  * @param {Function} fn
1218 |  * @return {Runner}
1219 |  * @api public
1220 |  */
1221 | 
1222 | Mocha.prototype.run = function(fn){
1223 |   if (this.files.length) this.loadFiles();
1224 |   var suite = this.suite;
1225 |   var options = this.options;
1226 |   var runner = new exports.Runner(suite);
1227 |   var reporter = new this._reporter(runner);
1228 |   runner.ignoreLeaks = options.ignoreLeaks;
1229 |   if (options.grep) runner.grep(options.grep, options.invert);
1230 |   if (options.globals) runner.globals(options.globals);
1231 |   if (options.growl) this._growl(runner, reporter);
1232 |   return runner.run(fn);
1233 | };
1234 | 
1235 | }); // module: mocha.js
1236 | 
1237 | require.register("ms.js", function(module, exports, require){
1238 | 
1239 | /**
1240 |  * Helpers.
1241 |  */
1242 | 
1243 | var s = 1000;
1244 | var m = s * 60;
1245 | var h = m * 60;
1246 | var d = h * 24;
1247 | 
1248 | /**
1249 |  * Parse or format the given `val`.
1250 |  *
1251 |  * @param {String|Number} val
1252 |  * @return {String|Number}
1253 |  * @api public
1254 |  */
1255 | 
1256 | module.exports = function(val){
1257 |   if ('string' == typeof val) return parse(val);
1258 |   return format(val);
1259 | }
1260 | 
1261 | /**
1262 |  * Parse the given `str` and return milliseconds.
1263 |  *
1264 |  * @param {String} str
1265 |  * @return {Number}
1266 |  * @api private
1267 |  */
1268 | 
1269 | function parse(str) {
1270 |   var m = /^((?:\d+)?\.?\d+) *(ms|seconds?|s|minutes?|m|hours?|h|days?|d|years?|y)?$/i.exec(str);
1271 |   if (!m) return;
1272 |   var n = parseFloat(m[1]);
1273 |   var type = (m[2] || 'ms').toLowerCase();
1274 |   switch (type) {
1275 |     case 'years':
1276 |     case 'year':
1277 |     case 'y':
1278 |       return n * 31557600000;
1279 |     case 'days':
1280 |     case 'day':
1281 |     case 'd':
1282 |       return n * 86400000;
1283 |     case 'hours':
1284 |     case 'hour':
1285 |     case 'h':
1286 |       return n * 3600000;
1287 |     case 'minutes':
1288 |     case 'minute':
1289 |     case 'm':
1290 |       return n * 60000;
1291 |     case 'seconds':
1292 |     case 'second':
1293 |     case 's':
1294 |       return n * 1000;
1295 |     case 'ms':
1296 |       return n;
1297 |   }
1298 | }
1299 | 
1300 | /**
1301 |  * Format the given `ms`.
1302 |  *
1303 |  * @param {Number} ms
1304 |  * @return {String}
1305 |  * @api public
1306 |  */
1307 | 
1308 | function format(ms) {
1309 |   if (ms == d) return (ms / d) + ' day';
1310 |   if (ms > d) return (ms / d) + ' days';
1311 |   if (ms == h) return (ms / h) + ' hour';
1312 |   if (ms > h) return (ms / h) + ' hours';
1313 |   if (ms == m) return (ms / m) + ' minute';
1314 |   if (ms > m) return (ms / m) + ' minutes';
1315 |   if (ms == s) return (ms / s) + ' second';
1316 |   if (ms > s) return (ms / s) + ' seconds';
1317 |   return ms + ' ms';
1318 | }
1319 | }); // module: ms.js
1320 | 
1321 | require.register("reporters/base.js", function(module, exports, require){
1322 | 
1323 | /**
1324 |  * Module dependencies.
1325 |  */
1326 | 
1327 | var tty = require('browser/tty')
1328 |   , diff = require('browser/diff')
1329 |   , ms = require('../ms');
1330 | 
1331 | /**
1332 |  * Save timer references to avoid Sinon interfering (see GH-237).
1333 |  */
1334 | 
1335 | var Date = global.Date
1336 |   , setTimeout = global.setTimeout
1337 |   , setInterval = global.setInterval
1338 |   , clearTimeout = global.clearTimeout
1339 |   , clearInterval = global.clearInterval;
1340 | 
1341 | /**
1342 |  * Check if both stdio streams are associated with a tty.
1343 |  */
1344 | 
1345 | var isatty = tty.isatty(1) && tty.isatty(2);
1346 | 
1347 | /**
1348 |  * Expose `Base`.
1349 |  */
1350 | 
1351 | exports = module.exports = Base;
1352 | 
1353 | /**
1354 |  * Enable coloring by default.
1355 |  */
1356 | 
1357 | exports.useColors = isatty;
1358 | 
1359 | /**
1360 |  * Default color map.
1361 |  */
1362 | 
1363 | exports.colors = {
1364 |     'pass': 90
1365 |   , 'fail': 31
1366 |   , 'bright pass': 92
1367 |   , 'bright fail': 91
1368 |   , 'bright yellow': 93
1369 |   , 'pending': 36
1370 |   , 'suite': 0
1371 |   , 'error title': 0
1372 |   , 'error message': 31
1373 |   , 'error stack': 90
1374 |   , 'checkmark': 32
1375 |   , 'fast': 90
1376 |   , 'medium': 33
1377 |   , 'slow': 31
1378 |   , 'green': 32
1379 |   , 'light': 90
1380 |   , 'diff gutter': 90
1381 |   , 'diff added': 42
1382 |   , 'diff removed': 41
1383 | };
1384 | 
1385 | /**
1386 |  * Color `str` with the given `type`,
1387 |  * allowing colors to be disabled,
1388 |  * as well as user-defined color
1389 |  * schemes.
1390 |  *
1391 |  * @param {String} type
1392 |  * @param {String} str
1393 |  * @return {String}
1394 |  * @api private
1395 |  */
1396 | 
1397 | var color = exports.color = function(type, str) {
1398 |   if (!exports.useColors) return str;
1399 |   return '\u001b[' + exports.colors[type] + 'm' + str + '\u001b[0m';
1400 | };
1401 | 
1402 | /**
1403 |  * Expose term window size, with some
1404 |  * defaults for when stderr is not a tty.
1405 |  */
1406 | 
1407 | exports.window = {
1408 |   width: isatty
1409 |     ? process.stdout.getWindowSize
1410 |       ? process.stdout.getWindowSize(1)[0]
1411 |       : tty.getWindowSize()[1]
1412 |     : 75
1413 | };
1414 | 
1415 | /**
1416 |  * Expose some basic cursor interactions
1417 |  * that are common among reporters.
1418 |  */
1419 | 
1420 | exports.cursor = {
1421 |   hide: function(){
1422 |     process.stdout.write('\u001b[?25l');
1423 |   },
1424 | 
1425 |   show: function(){
1426 |     process.stdout.write('\u001b[?25h');
1427 |   },
1428 | 
1429 |   deleteLine: function(){
1430 |     process.stdout.write('\u001b[2K');
1431 |   },
1432 | 
1433 |   beginningOfLine: function(){
1434 |     process.stdout.write('\u001b[0G');
1435 |   },
1436 | 
1437 |   CR: function(){
1438 |     exports.cursor.deleteLine();
1439 |     exports.cursor.beginningOfLine();
1440 |   }
1441 | };
1442 | 
1443 | /**
1444 |  * Outut the given `failures` as a list.
1445 |  *
1446 |  * @param {Array} failures
1447 |  * @api public
1448 |  */
1449 | 
1450 | exports.list = function(failures){
1451 |   console.error();
1452 |   failures.forEach(function(test, i){
1453 |     // format
1454 |     var fmt = color('error title', '  %s) %s:\n')
1455 |       + color('error message', '     %s')
1456 |       + color('error stack', '\n%s\n');
1457 | 
1458 |     // msg
1459 |     var err = test.err
1460 |       , message = err.message || ''
1461 |       , stack = err.stack || message
1462 |       , index = stack.indexOf(message) + message.length
1463 |       , msg = stack.slice(0, index)
1464 |       , actual = err.actual
1465 |       , expected = err.expected
1466 |       , escape = true;
1467 | 
1468 |     // explicitly show diff
1469 |     if (err.showDiff) {
1470 |       escape = false;
1471 |       err.actual = actual = JSON.stringify(actual, null, 2);
1472 |       err.expected = expected = JSON.stringify(expected, null, 2);
1473 |     }
1474 | 
1475 |     // actual / expected diff
1476 |     if ('string' == typeof actual && 'string' == typeof expected) {
1477 |       var len = Math.max(actual.length, expected.length);
1478 | 
1479 |       if (len < 20) msg = errorDiff(err, 'Chars', escape);
1480 |       else msg = errorDiff(err, 'Words', escape);
1481 | 
1482 |       // linenos
1483 |       var lines = msg.split('\n');
1484 |       if (lines.length > 4) {
1485 |         var width = String(lines.length).length;
1486 |         msg = lines.map(function(str, i){
1487 |           return pad(++i, width) + ' |' + ' ' + str;
1488 |         }).join('\n');
1489 |       }
1490 | 
1491 |       // legend
1492 |       msg = '\n'
1493 |         + color('diff removed', 'actual')
1494 |         + ' '
1495 |         + color('diff added', 'expected')
1496 |         + '\n\n'
1497 |         + msg
1498 |         + '\n';
1499 | 
1500 |       // indent
1501 |       msg = msg.replace(/^/gm, '      ');
1502 | 
1503 |       fmt = color('error title', '  %s) %s:\n%s')
1504 |         + color('error stack', '\n%s\n');
1505 |     }
1506 | 
1507 |     // indent stack trace without msg
1508 |     stack = stack.slice(index ? index + 1 : index)
1509 |       .replace(/^/gm, '  ');
1510 | 
1511 |     console.error(fmt, (i + 1), test.fullTitle(), msg, stack);
1512 |   });
1513 | };
1514 | 
1515 | /**
1516 |  * Initialize a new `Base` reporter.
1517 |  *
1518 |  * All other reporters generally
1519 |  * inherit from this reporter, providing
1520 |  * stats such as test duration, number
1521 |  * of tests passed / failed etc.
1522 |  *
1523 |  * @param {Runner} runner
1524 |  * @api public
1525 |  */
1526 | 
1527 | function Base(runner) {
1528 |   var self = this
1529 |     , stats = this.stats = { suites: 0, tests: 0, passes: 0, pending: 0, failures: 0 }
1530 |     , failures = this.failures = [];
1531 | 
1532 |   if (!runner) return;
1533 |   this.runner = runner;
1534 | 
1535 |   runner.stats = stats;
1536 | 
1537 |   runner.on('start', function(){
1538 |     stats.start = new Date;
1539 |   });
1540 | 
1541 |   runner.on('suite', function(suite){
1542 |     stats.suites = stats.suites || 0;
1543 |     suite.root || stats.suites++;
1544 |   });
1545 | 
1546 |   runner.on('test end', function(test){
1547 |     stats.tests = stats.tests || 0;
1548 |     stats.tests++;
1549 |   });
1550 | 
1551 |   runner.on('pass', function(test){
1552 |     stats.passes = stats.passes || 0;
1553 | 
1554 |     var medium = test.slow() / 2;
1555 |     test.speed = test.duration > test.slow()
1556 |       ? 'slow'
1557 |       : test.duration > medium
1558 |         ? 'medium'
1559 |         : 'fast';
1560 | 
1561 |     stats.passes++;
1562 |   });
1563 | 
1564 |   runner.on('fail', function(test, err){
1565 |     stats.failures = stats.failures || 0;
1566 |     stats.failures++;
1567 |     test.err = err;
1568 |     failures.push(test);
1569 |   });
1570 | 
1571 |   runner.on('end', function(){
1572 |     stats.end = new Date;
1573 |     stats.duration = new Date - stats.start;
1574 |   });
1575 | 
1576 |   runner.on('pending', function(){
1577 |     stats.pending++;
1578 |   });
1579 | }
1580 | 
1581 | /**
1582 |  * Output common epilogue used by many of
1583 |  * the bundled reporters.
1584 |  *
1585 |  * @api public
1586 |  */
1587 | 
1588 | Base.prototype.epilogue = function(){
1589 |   var stats = this.stats
1590 |     , fmt
1591 |     , tests;
1592 | 
1593 |   console.log();
1594 | 
1595 |   function pluralize(n) {
1596 |     return 1 == n ? 'test' : 'tests';
1597 |   }
1598 | 
1599 |   // failure
1600 |   if (stats.failures) {
1601 |     fmt = color('bright fail', '  ✖')
1602 |       + color('fail', ' %d of %d %s failed')
1603 |       + color('light', ':')
1604 | 
1605 |     console.error(fmt,
1606 |       stats.failures,
1607 |       this.runner.total,
1608 |       pluralize(this.runner.total));
1609 | 
1610 |     Base.list(this.failures);
1611 |     console.error();
1612 |     return;
1613 |   }
1614 | 
1615 |   // pass
1616 |   fmt = color('bright pass', '  ✔')
1617 |     + color('green', ' %d %s complete')
1618 |     + color('light', ' (%s)');
1619 | 
1620 |   console.log(fmt,
1621 |     stats.tests || 0,
1622 |     pluralize(stats.tests),
1623 |     ms(stats.duration));
1624 | 
1625 |   // pending
1626 |   if (stats.pending) {
1627 |     fmt = color('pending', '  •')
1628 |       + color('pending', ' %d %s pending');
1629 | 
1630 |     console.log(fmt, stats.pending, pluralize(stats.pending));
1631 |   }
1632 | 
1633 |   console.log();
1634 | };
1635 | 
1636 | /**
1637 |  * Pad the given `str` to `len`.
1638 |  *
1639 |  * @param {String} str
1640 |  * @param {String} len
1641 |  * @return {String}
1642 |  * @api private
1643 |  */
1644 | 
1645 | function pad(str, len) {
1646 |   str = String(str);
1647 |   return Array(len - str.length + 1).join(' ') + str;
1648 | }
1649 | 
1650 | /**
1651 |  * Return a character diff for `err`.
1652 |  *
1653 |  * @param {Error} err
1654 |  * @return {String}
1655 |  * @api private
1656 |  */
1657 | 
1658 | function errorDiff(err, type, escape) {
1659 |   return diff['diff' + type](err.actual, err.expected).map(function(str){
1660 |     if (escape) {
1661 |       str.value = str.value
1662 |         .replace(/\t/g, '<tab>')
1663 |         .replace(/\r/g, '<CR>')
1664 |         .replace(/\n/g, '<LF>\n');
1665 |     }
1666 |     if (str.added) return colorLines('diff added', str.value);
1667 |     if (str.removed) return colorLines('diff removed', str.value);
1668 |     return str.value;
1669 |   }).join('');
1670 | }
1671 | 
1672 | /**
1673 |  * Color lines for `str`, using the color `name`.
1674 |  *
1675 |  * @param {String} name
1676 |  * @param {String} str
1677 |  * @return {String}
1678 |  * @api private
1679 |  */
1680 | 
1681 | function colorLines(name, str) {
1682 |   return str.split('\n').map(function(str){
1683 |     return color(name, str);
1684 |   }).join('\n');
1685 | }
1686 | 
1687 | }); // module: reporters/base.js
1688 | 
1689 | require.register("reporters/doc.js", function(module, exports, require){
1690 | 
1691 | /**
1692 |  * Module dependencies.
1693 |  */
1694 | 
1695 | var Base = require('./base')
1696 |   , utils = require('../utils');
1697 | 
1698 | /**
1699 |  * Expose `Doc`.
1700 |  */
1701 | 
1702 | exports = module.exports = Doc;
1703 | 
1704 | /**
1705 |  * Initialize a new `Doc` reporter.
1706 |  *
1707 |  * @param {Runner} runner
1708 |  * @api public
1709 |  */
1710 | 
1711 | function Doc(runner) {
1712 |   Base.call(this, runner);
1713 | 
1714 |   var self = this
1715 |     , stats = this.stats
1716 |     , total = runner.total
1717 |     , indents = 2;
1718 | 
1719 |   function indent() {
1720 |     return Array(indents).join('  ');
1721 |   }
1722 | 
1723 |   runner.on('suite', function(suite){
1724 |     if (suite.root) return;
1725 |     ++indents;
1726 |     console.log('%s<section class="suite">', indent());
1727 |     ++indents;
1728 |     console.log('%s<h1>%s</h1>', indent(), utils.escape(suite.title));
1729 |     console.log('%s<dl>', indent());
1730 |   });
1731 | 
1732 |   runner.on('suite end', function(suite){
1733 |     if (suite.root) return;
1734 |     console.log('%s</dl>', indent());
1735 |     --indents;
1736 |     console.log('%s</section>', indent());
1737 |     --indents;
1738 |   });
1739 | 
1740 |   runner.on('pass', function(test){
1741 |     console.log('%s  <dt>%s</dt>', indent(), utils.escape(test.title));
1742 |     var code = utils.escape(utils.clean(test.fn.toString()));
1743 |     console.log('%s  <dd><pre><code>%s</code></pre></dd>', indent(), code);
1744 |   });
1745 | }
1746 | 
1747 | }); // module: reporters/doc.js
1748 | 
1749 | require.register("reporters/dot.js", function(module, exports, require){
1750 | 
1751 | /**
1752 |  * Module dependencies.
1753 |  */
1754 | 
1755 | var Base = require('./base')
1756 |   , color = Base.color;
1757 | 
1758 | /**
1759 |  * Expose `Dot`.
1760 |  */
1761 | 
1762 | exports = module.exports = Dot;
1763 | 
1764 | /**
1765 |  * Initialize a new `Dot` matrix test reporter.
1766 |  *
1767 |  * @param {Runner} runner
1768 |  * @api public
1769 |  */
1770 | 
1771 | function Dot(runner) {
1772 |   Base.call(this, runner);
1773 | 
1774 |   var self = this
1775 |     , stats = this.stats
1776 |     , width = Base.window.width * .75 | 0
1777 |     , c = '․'
1778 |     , n = 0;
1779 | 
1780 |   runner.on('start', function(){
1781 |     process.stdout.write('\n  ');
1782 |   });
1783 | 
1784 |   runner.on('pending', function(test){
1785 |     process.stdout.write(color('pending', c));
1786 |   });
1787 | 
1788 |   runner.on('pass', function(test){
1789 |     if (++n % width == 0) process.stdout.write('\n  ');
1790 |     if ('slow' == test.speed) {
1791 |       process.stdout.write(color('bright yellow', c));
1792 |     } else {
1793 |       process.stdout.write(color(test.speed, c));
1794 |     }
1795 |   });
1796 | 
1797 |   runner.on('fail', function(test, err){
1798 |     if (++n % width == 0) process.stdout.write('\n  ');
1799 |     process.stdout.write(color('fail', c));
1800 |   });
1801 | 
1802 |   runner.on('end', function(){
1803 |     console.log();
1804 |     self.epilogue();
1805 |   });
1806 | }
1807 | 
1808 | /**
1809 |  * Inherit from `Base.prototype`.
1810 |  */
1811 | 
1812 | Dot.prototype = new Base;
1813 | Dot.prototype.constructor = Dot;
1814 | 
1815 | }); // module: reporters/dot.js
1816 | 
1817 | require.register("reporters/html-cov.js", function(module, exports, require){
1818 | 
1819 | /**
1820 |  * Module dependencies.
1821 |  */
1822 | 
1823 | var JSONCov = require('./json-cov')
1824 |   , fs = require('browser/fs');
1825 | 
1826 | /**
1827 |  * Expose `HTMLCov`.
1828 |  */
1829 | 
1830 | exports = module.exports = HTMLCov;
1831 | 
1832 | /**
1833 |  * Initialize a new `JsCoverage` reporter.
1834 |  *
1835 |  * @param {Runner} runner
1836 |  * @api public
1837 |  */
1838 | 
1839 | function HTMLCov(runner) {
1840 |   var jade = require('jade')
1841 |     , file = __dirname + '/templates/coverage.jade'
1842 |     , str = fs.readFileSync(file, 'utf8')
1843 |     , fn = jade.compile(str, { filename: file })
1844 |     , self = this;
1845 | 
1846 |   JSONCov.call(this, runner, false);
1847 | 
1848 |   runner.on('end', function(){
1849 |     process.stdout.write(fn({
1850 |         cov: self.cov
1851 |       , coverageClass: coverageClass
1852 |     }));
1853 |   });
1854 | }
1855 | 
1856 | /**
1857 |  * Return coverage class for `n`.
1858 |  *
1859 |  * @return {String}
1860 |  * @api private
1861 |  */
1862 | 
1863 | function coverageClass(n) {
1864 |   if (n >= 75) return 'high';
1865 |   if (n >= 50) return 'medium';
1866 |   if (n >= 25) return 'low';
1867 |   return 'terrible';
1868 | }
1869 | }); // module: reporters/html-cov.js
1870 | 
1871 | require.register("reporters/html.js", function(module, exports, require){
1872 | 
1873 | /**
1874 |  * Module dependencies.
1875 |  */
1876 | 
1877 | var Base = require('./base')
1878 |   , utils = require('../utils')
1879 |   , Progress = require('../browser/progress')
1880 |   , escape = utils.escape;
1881 | 
1882 | /**
1883 |  * Save timer references to avoid Sinon interfering (see GH-237).
1884 |  */
1885 | 
1886 | var Date = global.Date
1887 |   , setTimeout = global.setTimeout
1888 |   , setInterval = global.setInterval
1889 |   , clearTimeout = global.clearTimeout
1890 |   , clearInterval = global.clearInterval;
1891 | 
1892 | /**
1893 |  * Expose `Doc`.
1894 |  */
1895 | 
1896 | exports = module.exports = HTML;
1897 | 
1898 | /**
1899 |  * Stats template.
1900 |  */
1901 | 
1902 | var statsTemplate = '<ul id="stats">'
1903 |   + '<li class="progress"><canvas width="40" height="40"></canvas></li>'
1904 |   + '<li class="passes"><a href="#">passes:</a> <em>0</em></li>'
1905 |   + '<li class="failures"><a href="#">failures:</a> <em>0</em></li>'
1906 |   + '<li class="duration">duration: <em>0</em>s</li>'
1907 |   + '</ul>';
1908 | 
1909 | /**
1910 |  * Initialize a new `Doc` reporter.
1911 |  *
1912 |  * @param {Runner} runner
1913 |  * @api public
1914 |  */
1915 | 
1916 | function HTML(runner, root) {
1917 |   Base.call(this, runner);
1918 | 
1919 |   var self = this
1920 |     , stats = this.stats
1921 |     , total = runner.total
1922 |     , stat = fragment(statsTemplate)
1923 |     , items = stat.getElementsByTagName('li')
1924 |     , passes = items[1].getElementsByTagName('em')[0]
1925 |     , passesLink = items[1].getElementsByTagName('a')[0]
1926 |     , failures = items[2].getElementsByTagName('em')[0]
1927 |     , failuresLink = items[2].getElementsByTagName('a')[0]
1928 |     , duration = items[3].getElementsByTagName('em')[0]
1929 |     , canvas = stat.getElementsByTagName('canvas')[0]
1930 |     , report = fragment('<ul id="report"></ul>')
1931 |     , stack = [report]
1932 |     , progress
1933 |     , ctx
1934 | 
1935 |   root = root || document.getElementById('mocha');
1936 | 
1937 |   if (canvas.getContext) {
1938 |     var ratio = window.devicePixelRatio || 1;
1939 |     canvas.style.width = canvas.width;
1940 |     canvas.style.height = canvas.height;
1941 |     canvas.width *= ratio;
1942 |     canvas.height *= ratio;
1943 |     ctx = canvas.getContext('2d');
1944 |     ctx.scale(ratio, ratio);
1945 |     progress = new Progress;
1946 |   }
1947 | 
1948 |   if (!root) return error('#mocha div missing, add it to your document');
1949 | 
1950 |   // pass toggle
1951 |   on(passesLink, 'click', function(){
1952 |     unhide();
1953 |     var name = /pass/.test(report.className) ? '' : ' pass';
1954 |     report.className = report.className.replace(/fail|pass/g, '') + name;
1955 |     if (report.className.trim()) hideSuitesWithout('test pass');
1956 |   });
1957 | 
1958 |   // failure toggle
1959 |   on(failuresLink, 'click', function(){
1960 |     unhide();
1961 |     var name = /fail/.test(report.className) ? '' : ' fail';
1962 |     report.className = report.className.replace(/fail|pass/g, '') + name;
1963 |     if (report.className.trim()) hideSuitesWithout('test fail');
1964 |   });
1965 | 
1966 |   root.appendChild(stat);
1967 |   root.appendChild(report);
1968 | 
1969 |   if (progress) progress.size(40);
1970 | 
1971 |   runner.on('suite', function(suite){
1972 |     if (suite.root) return;
1973 | 
1974 |     // suite
1975 |     var url = '?grep=' + encodeURIComponent(suite.fullTitle());
1976 |     var el = fragment('<li class="suite"><h1><a href="%s">%s</a></h1></li>', url, escape(suite.title));
1977 | 
1978 |     // container
1979 |     stack[0].appendChild(el);
1980 |     stack.unshift(document.createElement('ul'));
1981 |     el.appendChild(stack[0]);
1982 |   });
1983 | 
1984 |   runner.on('suite end', function(suite){
1985 |     if (suite.root) return;
1986 |     stack.shift();
1987 |   });
1988 | 
1989 |   runner.on('fail', function(test, err){
1990 |     if ('hook' == test.type || err.uncaught) runner.emit('test end', test);
1991 |   });
1992 | 
1993 |   runner.on('test end', function(test){
1994 |     window.scrollTo(0, document.body.scrollHeight);
1995 | 
1996 |     // TODO: add to stats
1997 |     var percent = stats.tests / total * 100 | 0;
1998 |     if (progress) progress.update(percent).draw(ctx);
1999 | 
2000 |     // update stats
2001 |     var ms = new Date - stats.start;
2002 |     text(passes, stats.passes);
2003 |     text(failures, stats.failures);
2004 |     text(duration, (ms / 1000).toFixed(2));
2005 | 
2006 |     // test
2007 |     if ('passed' == test.state) {
2008 |       var el = fragment('<li class="test pass %e"><h2>%e<span class="duration">%ems</span></h2></li>', test.speed, test.title, test.duration);
2009 |     } else if (test.pending) {
2010 |       var el = fragment('<li class="test pass pending"><h2>%e</h2></li>', test.title);
2011 |     } else {
2012 |       var el = fragment('<li class="test fail"><h2>%e</h2></li>', test.title);
2013 |       var str = test.err.stack || test.err.toString();
2014 | 
2015 |       // FF / Opera do not add the message
2016 |       if (!~str.indexOf(test.err.message)) {
2017 |         str = test.err.message + '\n' + str;
2018 |       }
2019 | 
2020 |       // <=IE7 stringifies to [Object Error]. Since it can be overloaded, we
2021 |       // check for the result of the stringifying.
2022 |       if ('[object Error]' == str) str = test.err.message;
2023 | 
2024 |       // Safari doesn't give you a stack. Let's at least provide a source line.
2025 |       if (!test.err.stack && test.err.sourceURL && test.err.line !== undefined) {
2026 |         str += "\n(" + test.err.sourceURL + ":" + test.err.line + ")";
2027 |       }
2028 | 
2029 |       el.appendChild(fragment('<pre class="error">%e</pre>', str));
2030 |     }
2031 | 
2032 |     // toggle code
2033 |     // TODO: defer
2034 |     if (!test.pending) {
2035 |       var h2 = el.getElementsByTagName('h2')[0];
2036 | 
2037 |       on(h2, 'click', function(){
2038 |         pre.style.display = 'none' == pre.style.display
2039 |           ? 'inline-block'
2040 |           : 'none';
2041 |       });
2042 | 
2043 |       var pre = fragment('<pre><code>%e</code></pre>', utils.clean(test.fn.toString()));
2044 |       el.appendChild(pre);
2045 |       pre.style.display = 'none';
2046 |     }
2047 | 
2048 |     stack[0].appendChild(el);
2049 |   });
2050 | }
2051 | 
2052 | /**
2053 |  * Display error `msg`.
2054 |  */
2055 | 
2056 | function error(msg) {
2057 |   document.body.appendChild(fragment('<div id="error">%s</div>', msg));
2058 | }
2059 | 
2060 | /**
2061 |  * Return a DOM fragment from `html`.
2062 |  */
2063 | 
2064 | function fragment(html) {
2065 |   var args = arguments
2066 |     , div = document.createElement('div')
2067 |     , i = 1;
2068 | 
2069 |   div.innerHTML = html.replace(/%([se])/g, function(_, type){
2070 |     switch (type) {
2071 |       case 's': return String(args[i++]);
2072 |       case 'e': return escape(args[i++]);
2073 |     }
2074 |   });
2075 | 
2076 |   return div.firstChild;
2077 | }
2078 | 
2079 | /**
2080 |  * Check for suites that do not have elements
2081 |  * with `classname`, and hide them.
2082 |  */
2083 | 
2084 | function hideSuitesWithout(classname) {
2085 |   var suites = document.getElementsByClassName('suite');
2086 |   for (var i = 0; i < suites.length; i++) {
2087 |     var els = suites[i].getElementsByClassName(classname);
2088 |     if (0 == els.length) suites[i].className += ' hidden';
2089 |   }
2090 | }
2091 | 
2092 | /**
2093 |  * Unhide .hidden suites.
2094 |  */
2095 | 
2096 | function unhide() {
2097 |   var els = document.getElementsByClassName('suite hidden');
2098 |   for (var i = 0; i < els.length; ++i) {
2099 |     els[i].className = els[i].className.replace('suite hidden', 'suite');
2100 |   }
2101 | }
2102 | 
2103 | /**
2104 |  * Set `el` text to `str`.
2105 |  */
2106 | 
2107 | function text(el, str) {
2108 |   if (el.textContent) {
2109 |     el.textContent = str;
2110 |   } else {
2111 |     el.innerText = str;
2112 |   }
2113 | }
2114 | 
2115 | /**
2116 |  * Listen on `event` with callback `fn`.
2117 |  */
2118 | 
2119 | function on(el, event, fn) {
2120 |   if (el.addEventListener) {
2121 |     el.addEventListener(event, fn, false);
2122 |   } else {
2123 |     el.attachEvent('on' + event, fn);
2124 |   }
2125 | }
2126 | 
2127 | }); // module: reporters/html.js
2128 | 
2129 | require.register("reporters/index.js", function(module, exports, require){
2130 | 
2131 | exports.Base = require('./base');
2132 | exports.Dot = require('./dot');
2133 | exports.Doc = require('./doc');
2134 | exports.TAP = require('./tap');
2135 | exports.JSON = require('./json');
2136 | exports.HTML = require('./html');
2137 | exports.List = require('./list');
2138 | exports.Min = require('./min');
2139 | exports.Spec = require('./spec');
2140 | exports.Nyan = require('./nyan');
2141 | exports.XUnit = require('./xunit');
2142 | exports.Markdown = require('./markdown');
2143 | exports.Progress = require('./progress');
2144 | exports.Landing = require('./landing');
2145 | exports.JSONCov = require('./json-cov');
2146 | exports.HTMLCov = require('./html-cov');
2147 | exports.JSONStream = require('./json-stream');
2148 | exports.Teamcity = require('./teamcity');
2149 | 
2150 | }); // module: reporters/index.js
2151 | 
2152 | require.register("reporters/json-cov.js", function(module, exports, require){
2153 | 
2154 | /**
2155 |  * Module dependencies.
2156 |  */
2157 | 
2158 | var Base = require('./base');
2159 | 
2160 | /**
2161 |  * Expose `JSONCov`.
2162 |  */
2163 | 
2164 | exports = module.exports = JSONCov;
2165 | 
2166 | /**
2167 |  * Initialize a new `JsCoverage` reporter.
2168 |  *
2169 |  * @param {Runner} runner
2170 |  * @param {Boolean} output
2171 |  * @api public
2172 |  */
2173 | 
2174 | function JSONCov(runner, output) {
2175 |   var self = this
2176 |     , output = 1 == arguments.length ? true : output;
2177 | 
2178 |   Base.call(this, runner);
2179 | 
2180 |   var tests = []
2181 |     , failures = []
2182 |     , passes = [];
2183 | 
2184 |   runner.on('test end', function(test){
2185 |     tests.push(test);
2186 |   });
2187 | 
2188 |   runner.on('pass', function(test){
2189 |     passes.push(test);
2190 |   });
2191 | 
2192 |   runner.on('fail', function(test){
2193 |     failures.push(test);
2194 |   });
2195 | 
2196 |   runner.on('end', function(){
2197 |     var cov = global._$jscoverage || {};
2198 |     var result = self.cov = map(cov);
2199 |     result.stats = self.stats;
2200 |     result.tests = tests.map(clean);
2201 |     result.failures = failures.map(clean);
2202 |     result.passes = passes.map(clean);
2203 |     if (!output) return;
2204 |     process.stdout.write(JSON.stringify(result, null, 2 ));
2205 |   });
2206 | }
2207 | 
2208 | /**
2209 |  * Map jscoverage data to a JSON structure
2210 |  * suitable for reporting.
2211 |  *
2212 |  * @param {Object} cov
2213 |  * @return {Object}
2214 |  * @api private
2215 |  */
2216 | 
2217 | function map(cov) {
2218 |   var ret = {
2219 |       instrumentation: 'node-jscoverage'
2220 |     , sloc: 0
2221 |     , hits: 0
2222 |     , misses: 0
2223 |     , coverage: 0
2224 |     , files: []
2225 |   };
2226 | 
2227 |   for (var filename in cov) {
2228 |     var data = coverage(filename, cov[filename]);
2229 |     ret.files.push(data);
2230 |     ret.hits += data.hits;
2231 |     ret.misses += data.misses;
2232 |     ret.sloc += data.sloc;
2233 |   }
2234 | 
2235 |   if (ret.sloc > 0) {
2236 |     ret.coverage = (ret.hits / ret.sloc) * 100;
2237 |   }
2238 | 
2239 |   return ret;
2240 | };
2241 | 
2242 | /**
2243 |  * Map jscoverage data for a single source file
2244 |  * to a JSON structure suitable for reporting.
2245 |  *
2246 |  * @param {String} filename name of the source file
2247 |  * @param {Object} data jscoverage coverage data
2248 |  * @return {Object}
2249 |  * @api private
2250 |  */
2251 | 
2252 | function coverage(filename, data) {
2253 |   var ret = {
2254 |     filename: filename,
2255 |     coverage: 0,
2256 |     hits: 0,
2257 |     misses: 0,
2258 |     sloc: 0,
2259 |     source: {}
2260 |   };
2261 | 
2262 |   data.source.forEach(function(line, num){
2263 |     num++;
2264 | 
2265 |     if (data[num] === 0) {
2266 |       ret.misses++;
2267 |       ret.sloc++;
2268 |     } else if (data[num] !== undefined) {
2269 |       ret.hits++;
2270 |       ret.sloc++;
2271 |     }
2272 | 
2273 |     ret.source[num] = {
2274 |         source: line
2275 |       , coverage: data[num] === undefined
2276 |         ? ''
2277 |         : data[num]
2278 |     };
2279 |   });
2280 | 
2281 |   ret.coverage = ret.hits / ret.sloc * 100;
2282 | 
2283 |   return ret;
2284 | }
2285 | 
2286 | /**
2287 |  * Return a plain-object representation of `test`
2288 |  * free of cyclic properties etc.
2289 |  *
2290 |  * @param {Object} test
2291 |  * @return {Object}
2292 |  * @api private
2293 |  */
2294 | 
2295 | function clean(test) {
2296 |   return {
2297 |       title: test.title
2298 |     , fullTitle: test.fullTitle()
2299 |     , duration: test.duration
2300 |   }
2301 | }
2302 | 
2303 | }); // module: reporters/json-cov.js
2304 | 
2305 | require.register("reporters/json-stream.js", function(module, exports, require){
2306 | 
2307 | /**
2308 |  * Module dependencies.
2309 |  */
2310 | 
2311 | var Base = require('./base')
2312 |   , color = Base.color;
2313 | 
2314 | /**
2315 |  * Expose `List`.
2316 |  */
2317 | 
2318 | exports = module.exports = List;
2319 | 
2320 | /**
2321 |  * Initialize a new `List` test reporter.
2322 |  *
2323 |  * @param {Runner} runner
2324 |  * @api public
2325 |  */
2326 | 
2327 | function List(runner) {
2328 |   Base.call(this, runner);
2329 | 
2330 |   var self = this
2331 |     , stats = this.stats
2332 |     , total = runner.total;
2333 | 
2334 |   runner.on('start', function(){
2335 |     console.log(JSON.stringify(['start', { total: total }]));
2336 |   });
2337 | 
2338 |   runner.on('pass', function(test){
2339 |     console.log(JSON.stringify(['pass', clean(test)]));
2340 |   });
2341 | 
2342 |   runner.on('fail', function(test, err){
2343 |     console.log(JSON.stringify(['fail', clean(test)]));
2344 |   });
2345 | 
2346 |   runner.on('end', function(){
2347 |     process.stdout.write(JSON.stringify(['end', self.stats]));
2348 |   });
2349 | }
2350 | 
2351 | /**
2352 |  * Return a plain-object representation of `test`
2353 |  * free of cyclic properties etc.
2354 |  *
2355 |  * @param {Object} test
2356 |  * @return {Object}
2357 |  * @api private
2358 |  */
2359 | 
2360 | function clean(test) {
2361 |   return {
2362 |       title: test.title
2363 |     , fullTitle: test.fullTitle()
2364 |     , duration: test.duration
2365 |   }
2366 | }
2367 | }); // module: reporters/json-stream.js
2368 | 
2369 | require.register("reporters/json.js", function(module, exports, require){
2370 | 
2371 | /**
2372 |  * Module dependencies.
2373 |  */
2374 | 
2375 | var Base = require('./base')
2376 |   , cursor = Base.cursor
2377 |   , color = Base.color;
2378 | 
2379 | /**
2380 |  * Expose `JSON`.
2381 |  */
2382 | 
2383 | exports = module.exports = JSONReporter;
2384 | 
2385 | /**
2386 |  * Initialize a new `JSON` reporter.
2387 |  *
2388 |  * @param {Runner} runner
2389 |  * @api public
2390 |  */
2391 | 
2392 | function JSONReporter(runner) {
2393 |   var self = this;
2394 |   Base.call(this, runner);
2395 | 
2396 |   var tests = []
2397 |     , failures = []
2398 |     , passes = [];
2399 | 
2400 |   runner.on('test end', function(test){
2401 |     tests.push(test);
2402 |   });
2403 | 
2404 |   runner.on('pass', function(test){
2405 |     passes.push(test);
2406 |   });
2407 | 
2408 |   runner.on('fail', function(test){
2409 |     failures.push(test);
2410 |   });
2411 | 
2412 |   runner.on('end', function(){
2413 |     var obj = {
2414 |         stats: self.stats
2415 |       , tests: tests.map(clean)
2416 |       , failures: failures.map(clean)
2417 |       , passes: passes.map(clean)
2418 |     };
2419 | 
2420 |     process.stdout.write(JSON.stringify(obj, null, 2));
2421 |   });
2422 | }
2423 | 
2424 | /**
2425 |  * Return a plain-object representation of `test`
2426 |  * free of cyclic properties etc.
2427 |  *
2428 |  * @param {Object} test
2429 |  * @return {Object}
2430 |  * @api private
2431 |  */
2432 | 
2433 | function clean(test) {
2434 |   return {
2435 |       title: test.title
2436 |     , fullTitle: test.fullTitle()
2437 |     , duration: test.duration
2438 |   }
2439 | }
2440 | }); // module: reporters/json.js
2441 | 
2442 | require.register("reporters/landing.js", function(module, exports, require){
2443 | 
2444 | /**
2445 |  * Module dependencies.
2446 |  */
2447 | 
2448 | var Base = require('./base')
2449 |   , cursor = Base.cursor
2450 |   , color = Base.color;
2451 | 
2452 | /**
2453 |  * Expose `Landing`.
2454 |  */
2455 | 
2456 | exports = module.exports = Landing;
2457 | 
2458 | /**
2459 |  * Airplane color.
2460 |  */
2461 | 
2462 | Base.colors.plane = 0;
2463 | 
2464 | /**
2465 |  * Airplane crash color.
2466 |  */
2467 | 
2468 | Base.colors['plane crash'] = 31;
2469 | 
2470 | /**
2471 |  * Runway color.
2472 |  */
2473 | 
2474 | Base.colors.runway = 90;
2475 | 
2476 | /**
2477 |  * Initialize a new `Landing` reporter.
2478 |  *
2479 |  * @param {Runner} runner
2480 |  * @api public
2481 |  */
2482 | 
2483 | function Landing(runner) {
2484 |   Base.call(this, runner);
2485 | 
2486 |   var self = this
2487 |     , stats = this.stats
2488 |     , width = Base.window.width * .75 | 0
2489 |     , total = runner.total
2490 |     , stream = process.stdout
2491 |     , plane = color('plane', '✈')
2492 |     , crashed = -1
2493 |     , n = 0;
2494 | 
2495 |   function runway() {
2496 |     var buf = Array(width).join('-');
2497 |     return '  ' + color('runway', buf);
2498 |   }
2499 | 
2500 |   runner.on('start', function(){
2501 |     stream.write('\n  ');
2502 |     cursor.hide();
2503 |   });
2504 | 
2505 |   runner.on('test end', function(test){
2506 |     // check if the plane crashed
2507 |     var col = -1 == crashed
2508 |       ? width * ++n / total | 0
2509 |       : crashed;
2510 | 
2511 |     // show the crash
2512 |     if ('failed' == test.state) {
2513 |       plane = color('plane crash', '✈');
2514 |       crashed = col;
2515 |     }
2516 | 
2517 |     // render landing strip
2518 |     stream.write('\u001b[4F\n\n');
2519 |     stream.write(runway());
2520 |     stream.write('\n  ');
2521 |     stream.write(color('runway', Array(col).join('⋅')));
2522 |     stream.write(plane)
2523 |     stream.write(color('runway', Array(width - col).join('⋅') + '\n'));
2524 |     stream.write(runway());
2525 |     stream.write('\u001b[0m');
2526 |   });
2527 | 
2528 |   runner.on('end', function(){
2529 |     cursor.show();
2530 |     console.log();
2531 |     self.epilogue();
2532 |   });
2533 | }
2534 | 
2535 | /**
2536 |  * Inherit from `Base.prototype`.
2537 |  */
2538 | 
2539 | Landing.prototype = new Base;
2540 | Landing.prototype.constructor = Landing;
2541 | 
2542 | }); // module: reporters/landing.js
2543 | 
2544 | require.register("reporters/list.js", function(module, exports, require){
2545 | 
2546 | /**
2547 |  * Module dependencies.
2548 |  */
2549 | 
2550 | var Base = require('./base')
2551 |   , cursor = Base.cursor
2552 |   , color = Base.color;
2553 | 
2554 | /**
2555 |  * Expose `List`.
2556 |  */
2557 | 
2558 | exports = module.exports = List;
2559 | 
2560 | /**
2561 |  * Initialize a new `List` test reporter.
2562 |  *
2563 |  * @param {Runner} runner
2564 |  * @api public
2565 |  */
2566 | 
2567 | function List(runner) {
2568 |   Base.call(this, runner);
2569 | 
2570 |   var self = this
2571 |     , stats = this.stats
2572 |     , n = 0;
2573 | 
2574 |   runner.on('start', function(){
2575 |     console.log();
2576 |   });
2577 | 
2578 |   runner.on('test', function(test){
2579 |     process.stdout.write(color('pass', '    ' + test.fullTitle() + ': '));
2580 |   });
2581 | 
2582 |   runner.on('pending', function(test){
2583 |     var fmt = color('checkmark', '  -')
2584 |       + color('pending', ' %s');
2585 |     console.log(fmt, test.fullTitle());
2586 |   });
2587 | 
2588 |   runner.on('pass', function(test){
2589 |     var fmt = color('checkmark', '  ✓')
2590 |       + color('pass', ' %s: ')
2591 |       + color(test.speed, '%dms');
2592 |     cursor.CR();
2593 |     console.log(fmt, test.fullTitle(), test.duration);
2594 |   });
2595 | 
2596 |   runner.on('fail', function(test, err){
2597 |     cursor.CR();
2598 |     console.log(color('fail', '  %d) %s'), ++n, test.fullTitle());
2599 |   });
2600 | 
2601 |   runner.on('end', self.epilogue.bind(self));
2602 | }
2603 | 
2604 | /**
2605 |  * Inherit from `Base.prototype`.
2606 |  */
2607 | 
2608 | List.prototype = new Base;
2609 | List.prototype.constructor = List;
2610 | 
2611 | 
2612 | }); // module: reporters/list.js
2613 | 
2614 | require.register("reporters/markdown.js", function(module, exports, require){
2615 | /**
2616 |  * Module dependencies.
2617 |  */
2618 | 
2619 | var Base = require('./base')
2620 |   , utils = require('../utils');
2621 | 
2622 | /**
2623 |  * Expose `Markdown`.
2624 |  */
2625 | 
2626 | exports = module.exports = Markdown;
2627 | 
2628 | /**
2629 |  * Initialize a new `Markdown` reporter.
2630 |  *
2631 |  * @param {Runner} runner
2632 |  * @api public
2633 |  */
2634 | 
2635 | function Markdown(runner) {
2636 |   Base.call(this, runner);
2637 | 
2638 |   var self = this
2639 |     , stats = this.stats
2640 |     , total = runner.total
2641 |     , level = 0
2642 |     , buf = '';
2643 | 
2644 |   function title(str) {
2645 |     return Array(level).join('#') + ' ' + str;
2646 |   }
2647 | 
2648 |   function indent() {
2649 |     return Array(level).join('  ');
2650 |   }
2651 | 
2652 |   function mapTOC(suite, obj) {
2653 |     var ret = obj;
2654 |     obj = obj[suite.title] = obj[suite.title] || { suite: suite };
2655 |     suite.suites.forEach(function(suite){
2656 |       mapTOC(suite, obj);
2657 |     });
2658 |     return ret;
2659 |   }
2660 | 
2661 |   function stringifyTOC(obj, level) {
2662 |     ++level;
2663 |     var buf = '';
2664 |     var link;
2665 |     for (var key in obj) {
2666 |       if ('suite' == key) continue;
2667 |       if (key) link = ' - [' + key + '](#' + utils.slug(obj[key].suite.fullTitle()) + ')\n';
2668 |       if (key) buf += Array(level).join('  ') + link;
2669 |       buf += stringifyTOC(obj[key], level);
2670 |     }
2671 |     --level;
2672 |     return buf;
2673 |   }
2674 | 
2675 |   function generateTOC(suite) {
2676 |     var obj = mapTOC(suite, {});
2677 |     return stringifyTOC(obj, 0);
2678 |   }
2679 | 
2680 |   generateTOC(runner.suite);
2681 | 
2682 |   runner.on('suite', function(suite){
2683 |     ++level;
2684 |     var slug = utils.slug(suite.fullTitle());
2685 |     buf += '<a name="' + slug + '" />' + '\n';
2686 |     buf += title(suite.title) + '\n';
2687 |   });
2688 | 
2689 |   runner.on('suite end', function(suite){
2690 |     --level;
2691 |   });
2692 | 
2693 |   runner.on('pass', function(test){
2694 |     var code = utils.clean(test.fn.toString());
2695 |     buf += test.title + '.\n';
2696 |     buf += '\n```js\n';
2697 |     buf += code + '\n';
2698 |     buf += '```\n\n';
2699 |   });
2700 | 
2701 |   runner.on('end', function(){
2702 |     process.stdout.write('# TOC\n');
2703 |     process.stdout.write(generateTOC(runner.suite));
2704 |     process.stdout.write(buf);
2705 |   });
2706 | }
2707 | }); // module: reporters/markdown.js
2708 | 
2709 | require.register("reporters/min.js", function(module, exports, require){
2710 | 
2711 | /**
2712 |  * Module dependencies.
2713 |  */
2714 | 
2715 | var Base = require('./base');
2716 | 
2717 | /**
2718 |  * Expose `Min`.
2719 |  */
2720 | 
2721 | exports = module.exports = Min;
2722 | 
2723 | /**
2724 |  * Initialize a new `Min` minimal test reporter (best used with --watch).
2725 |  *
2726 |  * @param {Runner} runner
2727 |  * @api public
2728 |  */
2729 | 
2730 | function Min(runner) {
2731 |   Base.call(this, runner);
2732 |   
2733 |   runner.on('start', function(){
2734 |     // clear screen
2735 |     process.stdout.write('\u001b[2J');
2736 |     // set cursor position
2737 |     process.stdout.write('\u001b[1;3H');
2738 |   });
2739 | 
2740 |   runner.on('end', this.epilogue.bind(this));
2741 | }
2742 | 
2743 | /**
2744 |  * Inherit from `Base.prototype`.
2745 |  */
2746 | 
2747 | Min.prototype = new Base;
2748 | Min.prototype.constructor = Min;
2749 | 
2750 | }); // module: reporters/min.js
2751 | 
2752 | require.register("reporters/nyan.js", function(module, exports, require){
2753 | 
2754 | /**
2755 |  * Module dependencies.
2756 |  */
2757 | 
2758 | var Base = require('./base')
2759 |   , color = Base.color;
2760 | 
2761 | /**
2762 |  * Expose `Dot`.
2763 |  */
2764 | 
2765 | exports = module.exports = NyanCat;
2766 | 
2767 | /**
2768 |  * Initialize a new `Dot` matrix test reporter.
2769 |  *
2770 |  * @param {Runner} runner
2771 |  * @api public
2772 |  */
2773 | 
2774 | function NyanCat(runner) {
2775 |   Base.call(this, runner);
2776 | 
2777 |   var self = this
2778 |     , stats = this.stats
2779 |     , width = Base.window.width * .75 | 0
2780 |     , rainbowColors = this.rainbowColors = self.generateColors()
2781 |     , colorIndex = this.colorIndex = 0
2782 |     , numerOfLines = this.numberOfLines = 4
2783 |     , trajectories = this.trajectories = [[], [], [], []]
2784 |     , nyanCatWidth = this.nyanCatWidth = 11
2785 |     , trajectoryWidthMax = this.trajectoryWidthMax = (width - nyanCatWidth)
2786 |     , scoreboardWidth = this.scoreboardWidth = 5
2787 |     , tick = this.tick = 0
2788 |     , n = 0;
2789 | 
2790 |   runner.on('start', function(){
2791 |     Base.cursor.hide();
2792 |     self.draw('start');
2793 |   });
2794 | 
2795 |   runner.on('pending', function(test){
2796 |     self.draw('pending');
2797 |   });
2798 | 
2799 |   runner.on('pass', function(test){
2800 |     self.draw('pass');
2801 |   });
2802 | 
2803 |   runner.on('fail', function(test, err){
2804 |     self.draw('fail');
2805 |   });
2806 | 
2807 |   runner.on('end', function(){
2808 |     Base.cursor.show();
2809 |     for (var i = 0; i < self.numberOfLines; i++) write('\n');
2810 |     self.epilogue();
2811 |   });
2812 | }
2813 | 
2814 | /**
2815 |  * Draw the nyan cat with runner `status`.
2816 |  *
2817 |  * @param {String} status
2818 |  * @api private
2819 |  */
2820 | 
2821 | NyanCat.prototype.draw = function(status){
2822 |   this.appendRainbow();
2823 |   this.drawScoreboard();
2824 |   this.drawRainbow();
2825 |   this.drawNyanCat(status);
2826 |   this.tick = !this.tick;
2827 | };
2828 | 
2829 | /**
2830 |  * Draw the "scoreboard" showing the number
2831 |  * of passes, failures and pending tests.
2832 |  *
2833 |  * @api private
2834 |  */
2835 | 
2836 | NyanCat.prototype.drawScoreboard = function(){
2837 |   var stats = this.stats;
2838 |   var colors = Base.colors;
2839 | 
2840 |   function draw(color, n) {
2841 |     write(' ');
2842 |     write('\u001b[' + color + 'm' + n + '\u001b[0m');
2843 |     write('\n');
2844 |   }
2845 | 
2846 |   draw(colors.green, stats.passes);
2847 |   draw(colors.fail, stats.failures);
2848 |   draw(colors.pending, stats.pending);
2849 |   write('\n');
2850 | 
2851 |   this.cursorUp(this.numberOfLines);
2852 | };
2853 | 
2854 | /**
2855 |  * Append the rainbow.
2856 |  *
2857 |  * @api private
2858 |  */
2859 | 
2860 | NyanCat.prototype.appendRainbow = function(){
2861 |   var segment = this.tick ? '_' : '-';
2862 |   var rainbowified = this.rainbowify(segment);
2863 | 
2864 |   for (var index = 0; index < this.numberOfLines; index++) {
2865 |     var trajectory = this.trajectories[index];
2866 |     if (trajectory.length >= this.trajectoryWidthMax) trajectory.shift();
2867 |     trajectory.push(rainbowified);
2868 |   }
2869 | };
2870 | 
2871 | /**
2872 |  * Draw the rainbow.
2873 |  *
2874 |  * @api private
2875 |  */
2876 | 
2877 | NyanCat.prototype.drawRainbow = function(){
2878 |   var self = this;
2879 | 
2880 |   this.trajectories.forEach(function(line, index) {
2881 |     write('\u001b[' + self.scoreboardWidth + 'C');
2882 |     write(line.join(''));
2883 |     write('\n');
2884 |   });
2885 | 
2886 |   this.cursorUp(this.numberOfLines);
2887 | };
2888 | 
2889 | /**
2890 |  * Draw the nyan cat with `status`.
2891 |  *
2892 |  * @param {String} status
2893 |  * @api private
2894 |  */
2895 | 
2896 | NyanCat.prototype.drawNyanCat = function(status) {
2897 |   var self = this;
2898 |   var startWidth = this.scoreboardWidth + this.trajectories[0].length;
2899 | 
2900 |   [0, 1, 2, 3].forEach(function(index) {
2901 |     write('\u001b[' + startWidth + 'C');
2902 | 
2903 |     switch (index) {
2904 |       case 0:
2905 |         write('_,------,');
2906 |         write('\n');
2907 |         break;
2908 |       case 1:
2909 |         var padding = self.tick ? '  ' : '   ';
2910 |         write('_|' + padding + '/\\_/\\ ');
2911 |         write('\n');
2912 |         break;
2913 |       case 2:
2914 |         var padding = self.tick ? '_' : '__';
2915 |         var tail = self.tick ? '~' : '^';
2916 |         var face;
2917 |         switch (status) {
2918 |           case 'pass':
2919 |             face = '( ^ .^)';
2920 |             break;
2921 |           case 'fail':
2922 |             face = '( o .o)';
2923 |             break;
2924 |           default:
2925 |             face = '( - .-)';
2926 |         }
2927 |         write(tail + '|' + padding + face + ' ');
2928 |         write('\n');
2929 |         break;
2930 |       case 3:
2931 |         var padding = self.tick ? ' ' : '  ';
2932 |         write(padding + '""  "" ');
2933 |         write('\n');
2934 |         break;
2935 |     }
2936 |   });
2937 | 
2938 |   this.cursorUp(this.numberOfLines);
2939 | };
2940 | 
2941 | /**
2942 |  * Move cursor up `n`.
2943 |  *
2944 |  * @param {Number} n
2945 |  * @api private
2946 |  */
2947 | 
2948 | NyanCat.prototype.cursorUp = function(n) {
2949 |   write('\u001b[' + n + 'A');
2950 | };
2951 | 
2952 | /**
2953 |  * Move cursor down `n`.
2954 |  *
2955 |  * @param {Number} n
2956 |  * @api private
2957 |  */
2958 | 
2959 | NyanCat.prototype.cursorDown = function(n) {
2960 |   write('\u001b[' + n + 'B');
2961 | };
2962 | 
2963 | /**
2964 |  * Generate rainbow colors.
2965 |  *
2966 |  * @return {Array}
2967 |  * @api private
2968 |  */
2969 | 
2970 | NyanCat.prototype.generateColors = function(){
2971 |   var colors = [];
2972 | 
2973 |   for (var i = 0; i < (6 * 7); i++) {
2974 |     var pi3 = Math.floor(Math.PI / 3);
2975 |     var n = (i * (1.0 / 6));
2976 |     var r = Math.floor(3 * Math.sin(n) + 3);
2977 |     var g = Math.floor(3 * Math.sin(n + 2 * pi3) + 3);
2978 |     var b = Math.floor(3 * Math.sin(n + 4 * pi3) + 3);
2979 |     colors.push(36 * r + 6 * g + b + 16);
2980 |   }
2981 | 
2982 |   return colors;
2983 | };
2984 | 
2985 | /**
2986 |  * Apply rainbow to the given `str`.
2987 |  *
2988 |  * @param {String} str
2989 |  * @return {String}
2990 |  * @api private
2991 |  */
2992 | 
2993 | NyanCat.prototype.rainbowify = function(str){
2994 |   var color = this.rainbowColors[this.colorIndex % this.rainbowColors.length];
2995 |   this.colorIndex += 1;
2996 |   return '\u001b[38;5;' + color + 'm' + str + '\u001b[0m';
2997 | };
2998 | 
2999 | /**
3000 |  * Stdout helper.
3001 |  */
3002 | 
3003 | function write(string) {
3004 |   process.stdout.write(string);
3005 | }
3006 | 
3007 | /**
3008 |  * Inherit from `Base.prototype`.
3009 |  */
3010 | 
3011 | NyanCat.prototype = new Base;
3012 | NyanCat.prototype.constructor = NyanCat;
3013 | 
3014 | 
3015 | }); // module: reporters/nyan.js
3016 | 
3017 | require.register("reporters/progress.js", function(module, exports, require){
3018 | 
3019 | /**
3020 |  * Module dependencies.
3021 |  */
3022 | 
3023 | var Base = require('./base')
3024 |   , cursor = Base.cursor
3025 |   , color = Base.color;
3026 | 
3027 | /**
3028 |  * Expose `Progress`.
3029 |  */
3030 | 
3031 | exports = module.exports = Progress;
3032 | 
3033 | /**
3034 |  * General progress bar color.
3035 |  */
3036 | 
3037 | Base.colors.progress = 90;
3038 | 
3039 | /**
3040 |  * Initialize a new `Progress` bar test reporter.
3041 |  *
3042 |  * @param {Runner} runner
3043 |  * @param {Object} options
3044 |  * @api public
3045 |  */
3046 | 
3047 | function Progress(runner, options) {
3048 |   Base.call(this, runner);
3049 | 
3050 |   var self = this
3051 |     , options = options || {}
3052 |     , stats = this.stats
3053 |     , width = Base.window.width * .50 | 0
3054 |     , total = runner.total
3055 |     , complete = 0
3056 |     , max = Math.max;
3057 | 
3058 |   // default chars
3059 |   options.open = options.open || '[';
3060 |   options.complete = options.complete || '▬';
3061 |   options.incomplete = options.incomplete || '⋅';
3062 |   options.close = options.close || ']';
3063 |   options.verbose = false;
3064 | 
3065 |   // tests started
3066 |   runner.on('start', function(){
3067 |     console.log();
3068 |     cursor.hide();
3069 |   });
3070 | 
3071 |   // tests complete
3072 |   runner.on('test end', function(){
3073 |     complete++;
3074 |     var incomplete = total - complete
3075 |       , percent = complete / total
3076 |       , n = width * percent | 0
3077 |       , i = width - n;
3078 | 
3079 |     cursor.CR();
3080 |     process.stdout.write('\u001b[J');
3081 |     process.stdout.write(color('progress', '  ' + options.open));
3082 |     process.stdout.write(Array(n).join(options.complete));
3083 |     process.stdout.write(Array(i).join(options.incomplete));
3084 |     process.stdout.write(color('progress', options.close));
3085 |     if (options.verbose) {
3086 |       process.stdout.write(color('progress', ' ' + complete + ' of ' + total));
3087 |     }
3088 |   });
3089 | 
3090 |   // tests are complete, output some stats
3091 |   // and the failures if any
3092 |   runner.on('end', function(){
3093 |     cursor.show();
3094 |     console.log();
3095 |     self.epilogue();
3096 |   });
3097 | }
3098 | 
3099 | /**
3100 |  * Inherit from `Base.prototype`.
3101 |  */
3102 | 
3103 | Progress.prototype = new Base;
3104 | Progress.prototype.constructor = Progress;
3105 | 
3106 | 
3107 | }); // module: reporters/progress.js
3108 | 
3109 | require.register("reporters/spec.js", function(module, exports, require){
3110 | 
3111 | /**
3112 |  * Module dependencies.
3113 |  */
3114 | 
3115 | var Base = require('./base')
3116 |   , cursor = Base.cursor
3117 |   , color = Base.color;
3118 | 
3119 | /**
3120 |  * Expose `Spec`.
3121 |  */
3122 | 
3123 | exports = module.exports = Spec;
3124 | 
3125 | /**
3126 |  * Initialize a new `Spec` test reporter.
3127 |  *
3128 |  * @param {Runner} runner
3129 |  * @api public
3130 |  */
3131 | 
3132 | function Spec(runner) {
3133 |   Base.call(this, runner);
3134 | 
3135 |   var self = this
3136 |     , stats = this.stats
3137 |     , indents = 0
3138 |     , n = 0;
3139 | 
3140 |   function indent() {
3141 |     return Array(indents).join('  ')
3142 |   }
3143 | 
3144 |   runner.on('start', function(){
3145 |     console.log();
3146 |   });
3147 | 
3148 |   runner.on('suite', function(suite){
3149 |     ++indents;
3150 |     console.log(color('suite', '%s%s'), indent(), suite.title);
3151 |   });
3152 | 
3153 |   runner.on('suite end', function(suite){
3154 |     --indents;
3155 |     if (1 == indents) console.log();
3156 |   });
3157 | 
3158 |   runner.on('test', function(test){
3159 |     process.stdout.write(indent() + color('pass', '  ◦ ' + test.title + ': '));
3160 |   });
3161 | 
3162 |   runner.on('pending', function(test){
3163 |     var fmt = indent() + color('pending', '  - %s');
3164 |     console.log(fmt, test.title);
3165 |   });
3166 | 
3167 |   runner.on('pass', function(test){
3168 |     if ('fast' == test.speed) {
3169 |       var fmt = indent()
3170 |         + color('checkmark', '  ✓')
3171 |         + color('pass', ' %s ');
3172 |       cursor.CR();
3173 |       console.log(fmt, test.title);
3174 |     } else {
3175 |       var fmt = indent()
3176 |         + color('checkmark', '  ✓')
3177 |         + color('pass', ' %s ')
3178 |         + color(test.speed, '(%dms)');
3179 |       cursor.CR();
3180 |       console.log(fmt, test.title, test.duration);
3181 |     }
3182 |   });
3183 | 
3184 |   runner.on('fail', function(test, err){
3185 |     cursor.CR();
3186 |     console.log(indent() + color('fail', '  %d) %s'), ++n, test.title);
3187 |   });
3188 | 
3189 |   runner.on('end', self.epilogue.bind(self));
3190 | }
3191 | 
3192 | /**
3193 |  * Inherit from `Base.prototype`.
3194 |  */
3195 | 
3196 | Spec.prototype = new Base;
3197 | Spec.prototype.constructor = Spec;
3198 | 
3199 | 
3200 | }); // module: reporters/spec.js
3201 | 
3202 | require.register("reporters/tap.js", function(module, exports, require){
3203 | 
3204 | /**
3205 |  * Module dependencies.
3206 |  */
3207 | 
3208 | var Base = require('./base')
3209 |   , cursor = Base.cursor
3210 |   , color = Base.color;
3211 | 
3212 | /**
3213 |  * Expose `TAP`.
3214 |  */
3215 | 
3216 | exports = module.exports = TAP;
3217 | 
3218 | /**
3219 |  * Initialize a new `TAP` reporter.
3220 |  *
3221 |  * @param {Runner} runner
3222 |  * @api public
3223 |  */
3224 | 
3225 | function TAP(runner) {
3226 |   Base.call(this, runner);
3227 | 
3228 |   var self = this
3229 |     , stats = this.stats
3230 |     , n = 1;
3231 | 
3232 |   runner.on('start', function(){
3233 |     var total = runner.grepTotal(runner.suite);
3234 |     console.log('%d..%d', 1, total);
3235 |   });
3236 | 
3237 |   runner.on('test end', function(){
3238 |     ++n;
3239 |   });
3240 | 
3241 |   runner.on('pending', function(test){
3242 |     console.log('ok %d %s # SKIP -', n, title(test));
3243 |   });
3244 | 
3245 |   runner.on('pass', function(test){
3246 |     console.log('ok %d %s', n, title(test));
3247 |   });
3248 | 
3249 |   runner.on('fail', function(test, err){
3250 |     console.log('not ok %d %s', n, title(test));
3251 |     console.log(err.stack.replace(/^/gm, '  '));
3252 |   });
3253 | }
3254 | 
3255 | /**
3256 |  * Return a TAP-safe title of `test`
3257 |  *
3258 |  * @param {Object} test
3259 |  * @return {String}
3260 |  * @api private
3261 |  */
3262 | 
3263 | function title(test) {
3264 |   return test.fullTitle().replace(/#/g, '');
3265 | }
3266 | 
3267 | }); // module: reporters/tap.js
3268 | 
3269 | require.register("reporters/teamcity.js", function(module, exports, require){
3270 | 
3271 | /**
3272 |  * Module dependencies.
3273 |  */
3274 | 
3275 | var Base = require('./base');
3276 | 
3277 | /**
3278 |  * Expose `Teamcity`.
3279 |  */
3280 | 
3281 | exports = module.exports = Teamcity;
3282 | 
3283 | /**
3284 |  * Initialize a new `Teamcity` reporter.
3285 |  *
3286 |  * @param {Runner} runner
3287 |  * @api public
3288 |  */
3289 | 
3290 | function Teamcity(runner) {
3291 |   Base.call(this, runner);
3292 |   var stats = this.stats;
3293 | 
3294 |   runner.on('start', function() {
3295 |     console.log("##teamcity[testSuiteStarted name='mocha.suite']");
3296 |   });
3297 | 
3298 |   runner.on('test', function(test) {
3299 |     console.log("##teamcity[testStarted name='" + escape(test.fullTitle()) + "']");
3300 |   });
3301 | 
3302 |   runner.on('fail', function(test, err) {
3303 |     console.log("##teamcity[testFailed name='" + escape(test.fullTitle()) + "' message='" + escape(err.message) + "']");
3304 |   });
3305 | 
3306 |   runner.on('pending', function(test) {
3307 |     console.log("##teamcity[testIgnored name='" + escape(test.fullTitle()) + "' message='pending']");
3308 |   });
3309 | 
3310 |   runner.on('test end', function(test) {
3311 |     console.log("##teamcity[testFinished name='" + escape(test.fullTitle()) + "' duration='" + test.duration + "']");
3312 |   });
3313 | 
3314 |   runner.on('end', function() {
3315 |     console.log("##teamcity[testSuiteFinished name='mocha.suite' duration='" + stats.duration + "']");
3316 |   });
3317 | }
3318 | 
3319 | /**
3320 |  * Escape the given `str`.
3321 |  */
3322 | 
3323 | function escape(str) {
3324 |   return str
3325 |     .replace(/\|/g, "||")
3326 |     .replace(/\n/g, "|n")
3327 |     .replace(/\r/g, "|r")
3328 |     .replace(/\[/g, "|[")
3329 |     .replace(/\]/g, "|]")
3330 |     .replace(/\u0085/g, "|x")
3331 |     .replace(/\u2028/g, "|l")
3332 |     .replace(/\u2029/g, "|p")
3333 |     .replace(/'/g, "|'");
3334 | }
3335 | 
3336 | }); // module: reporters/teamcity.js
3337 | 
3338 | require.register("reporters/xunit.js", function(module, exports, require){
3339 | 
3340 | /**
3341 |  * Module dependencies.
3342 |  */
3343 | 
3344 | var Base = require('./base')
3345 |   , utils = require('../utils')
3346 |   , escape = utils.escape;
3347 | 
3348 | /**
3349 |  * Save timer references to avoid Sinon interfering (see GH-237).
3350 |  */
3351 | 
3352 | var Date = global.Date
3353 |   , setTimeout = global.setTimeout
3354 |   , setInterval = global.setInterval
3355 |   , clearTimeout = global.clearTimeout
3356 |   , clearInterval = global.clearInterval;
3357 | 
3358 | /**
3359 |  * Expose `XUnit`.
3360 |  */
3361 | 
3362 | exports = module.exports = XUnit;
3363 | 
3364 | /**
3365 |  * Initialize a new `XUnit` reporter.
3366 |  *
3367 |  * @param {Runner} runner
3368 |  * @api public
3369 |  */
3370 | 
3371 | function XUnit(runner) {
3372 |   Base.call(this, runner);
3373 |   var stats = this.stats
3374 |     , tests = []
3375 |     , self = this;
3376 | 
3377 |   runner.on('pass', function(test){
3378 |     tests.push(test);
3379 |   });
3380 |   
3381 |   runner.on('fail', function(test){
3382 |     tests.push(test);
3383 |   });
3384 | 
3385 |   runner.on('end', function(){
3386 |     console.log(tag('testsuite', {
3387 |         name: 'Mocha Tests'
3388 |       , tests: stats.tests
3389 |       , failures: stats.failures
3390 |       , errors: stats.failures
3391 |       , skip: stats.tests - stats.failures - stats.passes
3392 |       , timestamp: (new Date).toUTCString()
3393 |       , time: stats.duration / 1000
3394 |     }, false));
3395 | 
3396 |     tests.forEach(test);
3397 |     console.log('</testsuite>');    
3398 |   });
3399 | }
3400 | 
3401 | /**
3402 |  * Inherit from `Base.prototype`.
3403 |  */
3404 | 
3405 | XUnit.prototype = new Base;
3406 | XUnit.prototype.constructor = XUnit;
3407 | 
3408 | 
3409 | /**
3410 |  * Output tag for the given `test.`
3411 |  */
3412 | 
3413 | function test(test) {
3414 |   var attrs = {
3415 |       classname: test.parent.fullTitle()
3416 |     , name: test.title
3417 |     , time: test.duration / 1000
3418 |   };
3419 | 
3420 |   if ('failed' == test.state) {
3421 |     var err = test.err;
3422 |     attrs.message = escape(err.message);
3423 |     console.log(tag('testcase', attrs, false, tag('failure', attrs, false, cdata(err.stack))));
3424 |   } else if (test.pending) {
3425 |     console.log(tag('testcase', attrs, false, tag('skipped', {}, true)));
3426 |   } else {
3427 |     console.log(tag('testcase', attrs, true) );
3428 |   }
3429 | }
3430 | 
3431 | /**
3432 |  * HTML tag helper.
3433 |  */
3434 | 
3435 | function tag(name, attrs, close, content) {
3436 |   var end = close ? '/>' : '>'
3437 |     , pairs = []
3438 |     , tag;
3439 | 
3440 |   for (var key in attrs) {
3441 |     pairs.push(key + '="' + escape(attrs[key]) + '"');
3442 |   }
3443 | 
3444 |   tag = '<' + name + (pairs.length ? ' ' + pairs.join(' ') : '') + end;
3445 |   if (content) tag += content + '</' + name + end;
3446 |   return tag;
3447 | }
3448 | 
3449 | /**
3450 |  * Return cdata escaped CDATA `str`.
3451 |  */
3452 | 
3453 | function cdata(str) {
3454 |   return '<![CDATA[' + escape(str) + ']]>';
3455 | }
3456 | 
3457 | }); // module: reporters/xunit.js
3458 | 
3459 | require.register("runnable.js", function(module, exports, require){
3460 | 
3461 | /**
3462 |  * Module dependencies.
3463 |  */
3464 | 
3465 | var EventEmitter = require('browser/events').EventEmitter
3466 |   , debug = require('browser/debug')('mocha:runnable')
3467 |   , milliseconds = require('./ms');
3468 | 
3469 | /**
3470 |  * Save timer references to avoid Sinon interfering (see GH-237).
3471 |  */
3472 | 
3473 | var Date = global.Date
3474 |   , setTimeout = global.setTimeout
3475 |   , setInterval = global.setInterval
3476 |   , clearTimeout = global.clearTimeout
3477 |   , clearInterval = global.clearInterval;
3478 | 
3479 | /**
3480 |  * Expose `Runnable`.
3481 |  */
3482 | 
3483 | module.exports = Runnable;
3484 | 
3485 | /**
3486 |  * Initialize a new `Runnable` with the given `title` and callback `fn`.
3487 |  *
3488 |  * @param {String} title
3489 |  * @param {Function} fn
3490 |  * @api private
3491 |  */
3492 | 
3493 | function Runnable(title, fn) {
3494 |   this.title = title;
3495 |   this.fn = fn;
3496 |   this.async = fn && fn.length;
3497 |   this.sync = ! this.async;
3498 |   this._timeout = 2000;
3499 |   this._slow = 75;
3500 |   this.timedOut = false;
3501 | }
3502 | 
3503 | /**
3504 |  * Inherit from `EventEmitter.prototype`.
3505 |  */
3506 | 
3507 | Runnable.prototype = new EventEmitter;
3508 | Runnable.prototype.constructor = Runnable;
3509 | 
3510 | 
3511 | /**
3512 |  * Set & get timeout `ms`.
3513 |  *
3514 |  * @param {Number|String} ms
3515 |  * @return {Runnable|Number} ms or self
3516 |  * @api private
3517 |  */
3518 | 
3519 | Runnable.prototype.timeout = function(ms){
3520 |   if (0 == arguments.length) return this._timeout;
3521 |   if ('string' == typeof ms) ms = milliseconds(ms);
3522 |   debug('timeout %d', ms);
3523 |   this._timeout = ms;
3524 |   if (this.timer) this.resetTimeout();
3525 |   return this;
3526 | };
3527 | 
3528 | /**
3529 |  * Set & get slow `ms`.
3530 |  *
3531 |  * @param {Number|String} ms
3532 |  * @return {Runnable|Number} ms or self
3533 |  * @api private
3534 |  */
3535 | 
3536 | Runnable.prototype.slow = function(ms){
3537 |   if (0 === arguments.length) return this._slow;
3538 |   if ('string' == typeof ms) ms = milliseconds(ms);
3539 |   debug('timeout %d', ms);
3540 |   this._slow = ms;
3541 |   return this;
3542 | };
3543 | 
3544 | /**
3545 |  * Return the full title generated by recursively
3546 |  * concatenating the parent's full title.
3547 |  *
3548 |  * @return {String}
3549 |  * @api public
3550 |  */
3551 | 
3552 | Runnable.prototype.fullTitle = function(){
3553 |   return this.parent.fullTitle() + ' ' + this.title;
3554 | };
3555 | 
3556 | /**
3557 |  * Clear the timeout.
3558 |  *
3559 |  * @api private
3560 |  */
3561 | 
3562 | Runnable.prototype.clearTimeout = function(){
3563 |   clearTimeout(this.timer);
3564 | };
3565 | 
3566 | /**
3567 |  * Inspect the runnable void of private properties.
3568 |  *
3569 |  * @return {String}
3570 |  * @api private
3571 |  */
3572 | 
3573 | Runnable.prototype.inspect = function(){
3574 |   return JSON.stringify(this, function(key, val){
3575 |     if ('_' == key[0]) return;
3576 |     if ('parent' == key) return '#<Suite>';
3577 |     if ('ctx' == key) return '#<Context>';
3578 |     return val;
3579 |   }, 2);
3580 | };
3581 | 
3582 | /**
3583 |  * Reset the timeout.
3584 |  *
3585 |  * @api private
3586 |  */
3587 | 
3588 | Runnable.prototype.resetTimeout = function(){
3589 |   var self = this
3590 |     , ms = this.timeout();
3591 | 
3592 |   this.clearTimeout();
3593 |   if (ms) {
3594 |     this.timer = setTimeout(function(){
3595 |       self.callback(new Error('timeout of ' + ms + 'ms exceeded'));
3596 |       self.timedOut = true;
3597 |     }, ms);
3598 |   }
3599 | };
3600 | 
3601 | /**
3602 |  * Run the test and invoke `fn(err)`.
3603 |  *
3604 |  * @param {Function} fn
3605 |  * @api private
3606 |  */
3607 | 
3608 | Runnable.prototype.run = function(fn){
3609 |   var self = this
3610 |     , ms = this.timeout()
3611 |     , start = new Date
3612 |     , ctx = this.ctx
3613 |     , finished
3614 |     , emitted;
3615 | 
3616 |   if (ctx) ctx.runnable(this);
3617 | 
3618 |   // timeout
3619 |   if (this.async) {
3620 |     if (ms) {
3621 |       this.timer = setTimeout(function(){
3622 |         done(new Error('timeout of ' + ms + 'ms exceeded'));
3623 |         self.timedOut = true;
3624 |       }, ms);
3625 |     }
3626 |   }
3627 | 
3628 |   // called multiple times
3629 |   function multiple(err) {
3630 |     if (emitted) return;
3631 |     emitted = true;
3632 |     self.emit('error', err || new Error('done() called multiple times'));
3633 |   }
3634 | 
3635 |   // finished
3636 |   function done(err) {
3637 |     if (self.timedOut) return;
3638 |     if (finished) return multiple(err);
3639 |     self.clearTimeout();
3640 |     self.duration = new Date - start;
3641 |     finished = true;
3642 |     fn(err);
3643 |   }
3644 | 
3645 |   // for .resetTimeout()
3646 |   this.callback = done;
3647 | 
3648 |   // async
3649 |   if (this.async) {
3650 |     try {
3651 |       this.fn.call(ctx, function(err){
3652 |         if (err instanceof Error) return done(err);
3653 |         if (null != err) return done(new Error('done() invoked with non-Error: ' + err));
3654 |         done();
3655 |       });
3656 |     } catch (err) {
3657 |       done(err);
3658 |     }
3659 |     return;
3660 |   }
3661 |   
3662 |   // sync
3663 |   try {
3664 |     if (!this.pending) this.fn.call(ctx);
3665 |     this.duration = new Date - start;
3666 |     fn();
3667 |   } catch (err) {
3668 |     fn(err);
3669 |   }
3670 | };
3671 | 
3672 | }); // module: runnable.js
3673 | 
3674 | require.register("runner.js", function(module, exports, require){
3675 | 
3676 | /**
3677 |  * Module dependencies.
3678 |  */
3679 | 
3680 | var EventEmitter = require('browser/events').EventEmitter
3681 |   , debug = require('browser/debug')('mocha:runner')
3682 |   , Test = require('./test')
3683 |   , utils = require('./utils')
3684 |   , filter = utils.filter
3685 |   , keys = utils.keys
3686 |   , noop = function(){};
3687 | 
3688 | /**
3689 |  * Expose `Runner`.
3690 |  */
3691 | 
3692 | module.exports = Runner;
3693 | 
3694 | /**
3695 |  * Initialize a `Runner` for the given `suite`.
3696 |  *
3697 |  * Events:
3698 |  *
3699 |  *   - `start`  execution started
3700 |  *   - `end`  execution complete
3701 |  *   - `suite`  (suite) test suite execution started
3702 |  *   - `suite end`  (suite) all tests (and sub-suites) have finished
3703 |  *   - `test`  (test) test execution started
3704 |  *   - `test end`  (test) test completed
3705 |  *   - `hook`  (hook) hook execution started
3706 |  *   - `hook end`  (hook) hook complete
3707 |  *   - `pass`  (test) test passed
3708 |  *   - `fail`  (test, err) test failed
3709 |  *
3710 |  * @api public
3711 |  */
3712 | 
3713 | function Runner(suite) {
3714 |   var self = this;
3715 |   this._globals = [];
3716 |   this.suite = suite;
3717 |   this.total = suite.total();
3718 |   this.failures = 0;
3719 |   this.on('test end', function(test){ self.checkGlobals(test); });
3720 |   this.on('hook end', function(hook){ self.checkGlobals(hook); });
3721 |   this.grep(/.*/);
3722 |   this.globals(utils.keys(global).concat(['errno']));
3723 | }
3724 | 
3725 | /**
3726 |  * Inherit from `EventEmitter.prototype`.
3727 |  */
3728 | 
3729 | Runner.prototype = new EventEmitter;
3730 | Runner.prototype.constructor = Runner;
3731 | 
3732 | 
3733 | /**
3734 |  * Run tests with full titles matching `re`. Updates runner.total
3735 |  * with number of tests matched.
3736 |  *
3737 |  * @param {RegExp} re
3738 |  * @param {Boolean} invert
3739 |  * @return {Runner} for chaining
3740 |  * @api public
3741 |  */
3742 | 
3743 | Runner.prototype.grep = function(re, invert){
3744 |   debug('grep %s', re);
3745 |   this._grep = re;
3746 |   this._invert = invert;
3747 |   this.total = this.grepTotal(this.suite);
3748 |   return this;
3749 | };
3750 | 
3751 | /**
3752 |  * Returns the number of tests matching the grep search for the
3753 |  * given suite.
3754 |  *
3755 |  * @param {Suite} suite
3756 |  * @return {Number}
3757 |  * @api public
3758 |  */
3759 | 
3760 | Runner.prototype.grepTotal = function(suite) {
3761 |   var self = this;
3762 |   var total = 0;
3763 | 
3764 |   suite.eachTest(function(test){
3765 |     var match = self._grep.test(test.fullTitle());
3766 |     if (self._invert) match = !match;
3767 |     if (match) total++;
3768 |   });
3769 | 
3770 |   return total;
3771 | };
3772 | 
3773 | /**
3774 |  * Allow the given `arr` of globals.
3775 |  *
3776 |  * @param {Array} arr
3777 |  * @return {Runner} for chaining
3778 |  * @api public
3779 |  */
3780 | 
3781 | Runner.prototype.globals = function(arr){
3782 |   if (0 == arguments.length) return this._globals;
3783 |   debug('globals %j', arr);
3784 |   utils.forEach(arr, function(arr){
3785 |     this._globals.push(arr);
3786 |   }, this);
3787 |   return this;
3788 | };
3789 | 
3790 | /**
3791 |  * Check for global variable leaks.
3792 |  *
3793 |  * @api private
3794 |  */
3795 | 
3796 | Runner.prototype.checkGlobals = function(test){
3797 |   if (this.ignoreLeaks) return;
3798 |   var ok = this._globals;
3799 |   var globals = keys(global);
3800 |   var isNode = process.kill;
3801 |   var leaks;
3802 | 
3803 |   // check length - 2 ('errno' and 'location' globals)
3804 |   if (isNode && 1 == ok.length - globals.length) return
3805 |   else if (2 == ok.length - globals.length) return;
3806 | 
3807 |   leaks = filterLeaks(ok, globals);
3808 |   this._globals = this._globals.concat(leaks);
3809 | 
3810 |   if (leaks.length > 1) {
3811 |     this.fail(test, new Error('global leaks detected: ' + leaks.join(', ') + ''));
3812 |   } else if (leaks.length) {
3813 |     this.fail(test, new Error('global leak detected: ' + leaks[0]));
3814 |   }
3815 | };
3816 | 
3817 | /**
3818 |  * Fail the given `test`.
3819 |  *
3820 |  * @param {Test} test
3821 |  * @param {Error} err
3822 |  * @api private
3823 |  */
3824 | 
3825 | Runner.prototype.fail = function(test, err){
3826 |   ++this.failures;
3827 |   test.state = 'failed';
3828 |   if ('string' == typeof err) {
3829 |     err = new Error('the string "' + err + '" was thrown, throw an Error :)');
3830 |   }
3831 |   this.emit('fail', test, err);
3832 | };
3833 | 
3834 | /**
3835 |  * Fail the given `hook` with `err`.
3836 |  *
3837 |  * Hook failures (currently) hard-end due
3838 |  * to that fact that a failing hook will
3839 |  * surely cause subsequent tests to fail,
3840 |  * causing jumbled reporting.
3841 |  *
3842 |  * @param {Hook} hook
3843 |  * @param {Error} err
3844 |  * @api private
3845 |  */
3846 | 
3847 | Runner.prototype.failHook = function(hook, err){
3848 |   this.fail(hook, err);
3849 |   this.emit('end');
3850 | };
3851 | 
3852 | /**
3853 |  * Run hook `name` callbacks and then invoke `fn()`.
3854 |  *
3855 |  * @param {String} name
3856 |  * @param {Function} function
3857 |  * @api private
3858 |  */
3859 | 
3860 | Runner.prototype.hook = function(name, fn){
3861 |   var suite = this.suite
3862 |     , hooks = suite['_' + name]
3863 |     , self = this
3864 |     , timer;
3865 | 
3866 |   function next(i) {
3867 |     var hook = hooks[i];
3868 |     if (!hook) return fn();
3869 |     self.currentRunnable = hook;
3870 | 
3871 |     self.emit('hook', hook);
3872 | 
3873 |     hook.on('error', function(err){
3874 |       self.failHook(hook, err);
3875 |     });
3876 | 
3877 |     hook.run(function(err){
3878 |       hook.removeAllListeners('error');
3879 |       var testError = hook.error();
3880 |       if (testError) self.fail(self.test, testError);
3881 |       if (err) return self.failHook(hook, err);
3882 |       self.emit('hook end', hook);
3883 |       next(++i);
3884 |     });
3885 |   }
3886 | 
3887 |   process.nextTick(function(){
3888 |     next(0);
3889 |   });
3890 | };
3891 | 
3892 | /**
3893 |  * Run hook `name` for the given array of `suites`
3894 |  * in order, and callback `fn(err)`.
3895 |  *
3896 |  * @param {String} name
3897 |  * @param {Array} suites
3898 |  * @param {Function} fn
3899 |  * @api private
3900 |  */
3901 | 
3902 | Runner.prototype.hooks = function(name, suites, fn){
3903 |   var self = this
3904 |     , orig = this.suite;
3905 | 
3906 |   function next(suite) {
3907 |     self.suite = suite;
3908 | 
3909 |     if (!suite) {
3910 |       self.suite = orig;
3911 |       return fn();
3912 |     }
3913 | 
3914 |     self.hook(name, function(err){
3915 |       if (err) {
3916 |         self.suite = orig;
3917 |         return fn(err);
3918 |       }
3919 | 
3920 |       next(suites.pop());
3921 |     });
3922 |   }
3923 | 
3924 |   next(suites.pop());
3925 | };
3926 | 
3927 | /**
3928 |  * Run hooks from the top level down.
3929 |  *
3930 |  * @param {String} name
3931 |  * @param {Function} fn
3932 |  * @api private
3933 |  */
3934 | 
3935 | Runner.prototype.hookUp = function(name, fn){
3936 |   var suites = [this.suite].concat(this.parents()).reverse();
3937 |   this.hooks(name, suites, fn);
3938 | };
3939 | 
3940 | /**
3941 |  * Run hooks from the bottom up.
3942 |  *
3943 |  * @param {String} name
3944 |  * @param {Function} fn
3945 |  * @api private
3946 |  */
3947 | 
3948 | Runner.prototype.hookDown = function(name, fn){
3949 |   var suites = [this.suite].concat(this.parents());
3950 |   this.hooks(name, suites, fn);
3951 | };
3952 | 
3953 | /**
3954 |  * Return an array of parent Suites from
3955 |  * closest to furthest.
3956 |  *
3957 |  * @return {Array}
3958 |  * @api private
3959 |  */
3960 | 
3961 | Runner.prototype.parents = function(){
3962 |   var suite = this.suite
3963 |     , suites = [];
3964 |   while (suite = suite.parent) suites.push(suite);
3965 |   return suites;
3966 | };
3967 | 
3968 | /**
3969 |  * Run the current test and callback `fn(err)`.
3970 |  *
3971 |  * @param {Function} fn
3972 |  * @api private
3973 |  */
3974 | 
3975 | Runner.prototype.runTest = function(fn){
3976 |   var test = this.test
3977 |     , self = this;
3978 | 
3979 |   try {
3980 |     test.on('error', function(err){
3981 |       self.fail(test, err);
3982 |     });
3983 |     test.run(fn);
3984 |   } catch (err) {
3985 |     fn(err);
3986 |   }
3987 | };
3988 | 
3989 | /**
3990 |  * Run tests in the given `suite` and invoke
3991 |  * the callback `fn()` when complete.
3992 |  *
3993 |  * @param {Suite} suite
3994 |  * @param {Function} fn
3995 |  * @api private
3996 |  */
3997 | 
3998 | Runner.prototype.runTests = function(suite, fn){
3999 |   var self = this
4000 |     , tests = suite.tests.slice()
4001 |     , test;
4002 | 
4003 |   function next(err) {
4004 |     // if we bail after first err
4005 |     if (self.failures && suite._bail) return fn();
4006 | 
4007 |     // next test
4008 |     test = tests.shift();
4009 | 
4010 |     // all done
4011 |     if (!test) return fn();
4012 | 
4013 |     // grep
4014 |     var match = self._grep.test(test.fullTitle());
4015 |     if (self._invert) match = !match;
4016 |     if (!match) return next();
4017 | 
4018 |     // pending
4019 |     if (test.pending) {
4020 |       self.emit('pending', test);
4021 |       self.emit('test end', test);
4022 |       return next();
4023 |     }
4024 | 
4025 |     // execute test and hook(s)
4026 |     self.emit('test', self.test = test);
4027 |     self.hookDown('beforeEach', function(){
4028 |       self.currentRunnable = self.test;
4029 |       self.runTest(function(err){
4030 |         test = self.test;
4031 | 
4032 |         if (err) {
4033 |           self.fail(test, err);
4034 |           self.emit('test end', test);
4035 |           return self.hookUp('afterEach', next);
4036 |         }
4037 | 
4038 |         test.state = 'passed';
4039 |         self.emit('pass', test);
4040 |         self.emit('test end', test);
4041 |         self.hookUp('afterEach', next);
4042 |       });
4043 |     });
4044 |   }
4045 | 
4046 |   this.next = next;
4047 |   next();
4048 | };
4049 | 
4050 | /**
4051 |  * Run the given `suite` and invoke the
4052 |  * callback `fn()` when complete.
4053 |  *
4054 |  * @param {Suite} suite
4055 |  * @param {Function} fn
4056 |  * @api private
4057 |  */
4058 | 
4059 | Runner.prototype.runSuite = function(suite, fn){
4060 |   var total = this.grepTotal(suite)
4061 |     , self = this
4062 |     , i = 0;
4063 | 
4064 |   debug('run suite %s', suite.fullTitle());
4065 | 
4066 |   if (!total) return fn();
4067 | 
4068 |   this.emit('suite', this.suite = suite);
4069 | 
4070 |   function next() {
4071 |     var curr = suite.suites[i++];
4072 |     if (!curr) return done();
4073 |     self.runSuite(curr, next);
4074 |   }
4075 | 
4076 |   function done() {
4077 |     self.suite = suite;
4078 |     self.hook('afterAll', function(){
4079 |       self.emit('suite end', suite);
4080 |       fn();
4081 |     });
4082 |   }
4083 | 
4084 |   this.hook('beforeAll', function(){
4085 |     self.runTests(suite, next);
4086 |   });
4087 | };
4088 | 
4089 | /**
4090 |  * Handle uncaught exceptions.
4091 |  *
4092 |  * @param {Error} err
4093 |  * @api private
4094 |  */
4095 | 
4096 | Runner.prototype.uncaught = function(err){
4097 |   debug('uncaught exception %s', err.message);
4098 |   var runnable = this.currentRunnable;
4099 |   if (!runnable || 'failed' == runnable.state) return;
4100 |   runnable.clearTimeout();
4101 |   err.uncaught = true;
4102 |   this.fail(runnable, err);
4103 | 
4104 |   // recover from test
4105 |   if ('test' == runnable.type) {
4106 |     this.emit('test end', runnable);
4107 |     this.hookUp('afterEach', this.next);
4108 |     return;
4109 |   }
4110 | 
4111 |   // bail on hooks
4112 |   this.emit('end');
4113 | };
4114 | 
4115 | /**
4116 |  * Run the root suite and invoke `fn(failures)`
4117 |  * on completion.
4118 |  *
4119 |  * @param {Function} fn
4120 |  * @return {Runner} for chaining
4121 |  * @api public
4122 |  */
4123 | 
4124 | Runner.prototype.run = function(fn){
4125 |   var self = this
4126 |     , fn = fn || function(){};
4127 | 
4128 |   debug('start');
4129 | 
4130 |   // uncaught callback
4131 |   function uncaught(err) {
4132 |     self.uncaught(err);
4133 |   }
4134 | 
4135 |   // callback
4136 |   this.on('end', function(){
4137 |     debug('end');
4138 |     process.removeListener('uncaughtException', uncaught);
4139 |     fn(self.failures);
4140 |   });
4141 | 
4142 |   // run suites
4143 |   this.emit('start');
4144 |   this.runSuite(this.suite, function(){
4145 |     debug('finished running');
4146 |     self.emit('end');
4147 |   });
4148 | 
4149 |   // uncaught exception
4150 |   process.on('uncaughtException', uncaught);
4151 | 
4152 |   return this;
4153 | };
4154 | 
4155 | /**
4156 |  * Filter leaks with the given globals flagged as `ok`.
4157 |  *
4158 |  * @param {Array} ok
4159 |  * @param {Array} globals
4160 |  * @return {Array}
4161 |  * @api private
4162 |  */
4163 | 
4164 | function filterLeaks(ok, globals) {
4165 |   return filter(globals, function(key){
4166 |     var matched = filter(ok, function(ok){
4167 |       if (~ok.indexOf('*')) return 0 == key.indexOf(ok.split('*')[0]);
4168 |       return key == ok;
4169 |     });
4170 |     return matched.length == 0 && (!global.navigator || 'onerror' !== key);
4171 |   });
4172 | }
4173 | 
4174 | }); // module: runner.js
4175 | 
4176 | require.register("suite.js", function(module, exports, require){
4177 | 
4178 | /**
4179 |  * Module dependencies.
4180 |  */
4181 | 
4182 | var EventEmitter = require('browser/events').EventEmitter
4183 |   , debug = require('browser/debug')('mocha:suite')
4184 |   , milliseconds = require('./ms')
4185 |   , utils = require('./utils')
4186 |   , Hook = require('./hook');
4187 | 
4188 | /**
4189 |  * Expose `Suite`.
4190 |  */
4191 | 
4192 | exports = module.exports = Suite;
4193 | 
4194 | /**
4195 |  * Create a new `Suite` with the given `title`
4196 |  * and parent `Suite`. When a suite with the
4197 |  * same title is already present, that suite
4198 |  * is returned to provide nicer reporter
4199 |  * and more flexible meta-testing.
4200 |  *
4201 |  * @param {Suite} parent
4202 |  * @param {String} title
4203 |  * @return {Suite}
4204 |  * @api public
4205 |  */
4206 | 
4207 | exports.create = function(parent, title){
4208 |   var suite = new Suite(title, parent.ctx);
4209 |   suite.parent = parent;
4210 |   if (parent.pending) suite.pending = true;
4211 |   title = suite.fullTitle();
4212 |   parent.addSuite(suite);
4213 |   return suite;
4214 | };
4215 | 
4216 | /**
4217 |  * Initialize a new `Suite` with the given
4218 |  * `title` and `ctx`.
4219 |  *
4220 |  * @param {String} title
4221 |  * @param {Context} ctx
4222 |  * @api private
4223 |  */
4224 | 
4225 | function Suite(title, ctx) {
4226 |   this.title = title;
4227 |   this.ctx = ctx;
4228 |   this.suites = [];
4229 |   this.tests = [];
4230 |   this.pending = false;
4231 |   this._beforeEach = [];
4232 |   this._beforeAll = [];
4233 |   this._afterEach = [];
4234 |   this._afterAll = [];
4235 |   this.root = !title;
4236 |   this._timeout = 2000;
4237 |   this._slow = 75;
4238 |   this._bail = false;
4239 | }
4240 | 
4241 | /**
4242 |  * Inherit from `EventEmitter.prototype`.
4243 |  */
4244 | 
4245 | Suite.prototype = new EventEmitter;
4246 | Suite.prototype.constructor = Suite;
4247 | 
4248 | 
4249 | /**
4250 |  * Return a clone of this `Suite`.
4251 |  *
4252 |  * @return {Suite}
4253 |  * @api private
4254 |  */
4255 | 
4256 | Suite.prototype.clone = function(){
4257 |   var suite = new Suite(this.title);
4258 |   debug('clone');
4259 |   suite.ctx = this.ctx;
4260 |   suite.timeout(this.timeout());
4261 |   suite.slow(this.slow());
4262 |   suite.bail(this.bail());
4263 |   return suite;
4264 | };
4265 | 
4266 | /**
4267 |  * Set timeout `ms` or short-hand such as "2s".
4268 |  *
4269 |  * @param {Number|String} ms
4270 |  * @return {Suite|Number} for chaining
4271 |  * @api private
4272 |  */
4273 | 
4274 | Suite.prototype.timeout = function(ms){
4275 |   if (0 == arguments.length) return this._timeout;
4276 |   if ('string' == typeof ms) ms = milliseconds(ms);
4277 |   debug('timeout %d', ms);
4278 |   this._timeout = parseInt(ms, 10);
4279 |   return this;
4280 | };
4281 | 
4282 | /**
4283 |  * Set slow `ms` or short-hand such as "2s".
4284 |  *
4285 |  * @param {Number|String} ms
4286 |  * @return {Suite|Number} for chaining
4287 |  * @api private
4288 |  */
4289 | 
4290 | Suite.prototype.slow = function(ms){
4291 |   if (0 === arguments.length) return this._slow;
4292 |   if ('string' == typeof ms) ms = milliseconds(ms);
4293 |   debug('slow %d', ms);
4294 |   this._slow = ms;
4295 |   return this;
4296 | };
4297 | 
4298 | /**
4299 |  * Sets whether to bail after first error.
4300 |  *
4301 |  * @parma {Boolean} bail
4302 |  * @return {Suite|Number} for chaining
4303 |  * @api private
4304 |  */
4305 | 
4306 | Suite.prototype.bail = function(bail){
4307 |   if (0 == arguments.length) return this._bail;
4308 |   debug('bail %s', bail);
4309 |   this._bail = bail;
4310 |   return this;
4311 | };
4312 | 
4313 | /**
4314 |  * Run `fn(test[, done])` before running tests.
4315 |  *
4316 |  * @param {Function} fn
4317 |  * @return {Suite} for chaining
4318 |  * @api private
4319 |  */
4320 | 
4321 | Suite.prototype.beforeAll = function(fn){
4322 |   if (this.pending) return this;
4323 |   var hook = new Hook('"before all" hook', fn);
4324 |   hook.parent = this;
4325 |   hook.timeout(this.timeout());
4326 |   hook.slow(this.slow());
4327 |   hook.ctx = this.ctx;
4328 |   this._beforeAll.push(hook);
4329 |   this.emit('beforeAll', hook);
4330 |   return this;
4331 | };
4332 | 
4333 | /**
4334 |  * Run `fn(test[, done])` after running tests.
4335 |  *
4336 |  * @param {Function} fn
4337 |  * @return {Suite} for chaining
4338 |  * @api private
4339 |  */
4340 | 
4341 | Suite.prototype.afterAll = function(fn){
4342 |   if (this.pending) return this;
4343 |   var hook = new Hook('"after all" hook', fn);
4344 |   hook.parent = this;
4345 |   hook.timeout(this.timeout());
4346 |   hook.slow(this.slow());
4347 |   hook.ctx = this.ctx;
4348 |   this._afterAll.push(hook);
4349 |   this.emit('afterAll', hook);
4350 |   return this;
4351 | };
4352 | 
4353 | /**
4354 |  * Run `fn(test[, done])` before each test case.
4355 |  *
4356 |  * @param {Function} fn
4357 |  * @return {Suite} for chaining
4358 |  * @api private
4359 |  */
4360 | 
4361 | Suite.prototype.beforeEach = function(fn){
4362 |   if (this.pending) return this;
4363 |   var hook = new Hook('"before each" hook', fn);
4364 |   hook.parent = this;
4365 |   hook.timeout(this.timeout());
4366 |   hook.slow(this.slow());
4367 |   hook.ctx = this.ctx;
4368 |   this._beforeEach.push(hook);
4369 |   this.emit('beforeEach', hook);
4370 |   return this;
4371 | };
4372 | 
4373 | /**
4374 |  * Run `fn(test[, done])` after each test case.
4375 |  *
4376 |  * @param {Function} fn
4377 |  * @return {Suite} for chaining
4378 |  * @api private
4379 |  */
4380 | 
4381 | Suite.prototype.afterEach = function(fn){
4382 |   if (this.pending) return this;
4383 |   var hook = new Hook('"after each" hook', fn);
4384 |   hook.parent = this;
4385 |   hook.timeout(this.timeout());
4386 |   hook.slow(this.slow());
4387 |   hook.ctx = this.ctx;
4388 |   this._afterEach.push(hook);
4389 |   this.emit('afterEach', hook);
4390 |   return this;
4391 | };
4392 | 
4393 | /**
4394 |  * Add a test `suite`.
4395 |  *
4396 |  * @param {Suite} suite
4397 |  * @return {Suite} for chaining
4398 |  * @api private
4399 |  */
4400 | 
4401 | Suite.prototype.addSuite = function(suite){
4402 |   suite.parent = this;
4403 |   suite.timeout(this.timeout());
4404 |   suite.slow(this.slow());
4405 |   suite.bail(this.bail());
4406 |   this.suites.push(suite);
4407 |   this.emit('suite', suite);
4408 |   return this;
4409 | };
4410 | 
4411 | /**
4412 |  * Add a `test` to this suite.
4413 |  *
4414 |  * @param {Test} test
4415 |  * @return {Suite} for chaining
4416 |  * @api private
4417 |  */
4418 | 
4419 | Suite.prototype.addTest = function(test){
4420 |   test.parent = this;
4421 |   test.timeout(this.timeout());
4422 |   test.slow(this.slow());
4423 |   test.ctx = this.ctx;
4424 |   this.tests.push(test);
4425 |   this.emit('test', test);
4426 |   return this;
4427 | };
4428 | 
4429 | /**
4430 |  * Return the full title generated by recursively
4431 |  * concatenating the parent's full title.
4432 |  *
4433 |  * @return {String}
4434 |  * @api public
4435 |  */
4436 | 
4437 | Suite.prototype.fullTitle = function(){
4438 |   if (this.parent) {
4439 |     var full = this.parent.fullTitle();
4440 |     if (full) return full + ' ' + this.title;
4441 |   }
4442 |   return this.title;
4443 | };
4444 | 
4445 | /**
4446 |  * Return the total number of tests.
4447 |  *
4448 |  * @return {Number}
4449 |  * @api public
4450 |  */
4451 | 
4452 | Suite.prototype.total = function(){
4453 |   return utils.reduce(this.suites, function(sum, suite){
4454 |     return sum + suite.total();
4455 |   }, 0) + this.tests.length;
4456 | };
4457 | 
4458 | /**
4459 |  * Iterates through each suite recursively to find
4460 |  * all tests. Applies a function in the format
4461 |  * `fn(test)`.
4462 |  *
4463 |  * @param {Function} fn
4464 |  * @return {Suite}
4465 |  * @api private
4466 |  */
4467 | 
4468 | Suite.prototype.eachTest = function(fn){
4469 |   utils.forEach(this.tests, fn);
4470 |   utils.forEach(this.suites, function(suite){
4471 |     suite.eachTest(fn);
4472 |   });
4473 |   return this;
4474 | };
4475 | 
4476 | }); // module: suite.js
4477 | 
4478 | require.register("test.js", function(module, exports, require){
4479 | 
4480 | /**
4481 |  * Module dependencies.
4482 |  */
4483 | 
4484 | var Runnable = require('./runnable');
4485 | 
4486 | /**
4487 |  * Expose `Test`.
4488 |  */
4489 | 
4490 | module.exports = Test;
4491 | 
4492 | /**
4493 |  * Initialize a new `Test` with the given `title` and callback `fn`.
4494 |  *
4495 |  * @param {String} title
4496 |  * @param {Function} fn
4497 |  * @api private
4498 |  */
4499 | 
4500 | function Test(title, fn) {
4501 |   Runnable.call(this, title, fn);
4502 |   this.pending = !fn;
4503 |   this.type = 'test';
4504 | }
4505 | 
4506 | /**
4507 |  * Inherit from `Runnable.prototype`.
4508 |  */
4509 | 
4510 | Test.prototype = new Runnable;
4511 | Test.prototype.constructor = Test;
4512 | 
4513 | 
4514 | }); // module: test.js
4515 | 
4516 | require.register("utils.js", function(module, exports, require){
4517 | 
4518 | /**
4519 |  * Module dependencies.
4520 |  */
4521 | 
4522 | var fs = require('browser/fs')
4523 |   , path = require('browser/path')
4524 |   , join = path.join
4525 |   , debug = require('browser/debug')('mocha:watch');
4526 | 
4527 | /**
4528 |  * Ignored directories.
4529 |  */
4530 | 
4531 | var ignore = ['node_modules', '.git'];
4532 | 
4533 | /**
4534 |  * Escape special characters in the given string of html.
4535 |  *
4536 |  * @param  {String} html
4537 |  * @return {String}
4538 |  * @api private
4539 |  */
4540 | 
4541 | exports.escape = function(html){
4542 |   return String(html)
4543 |     .replace(/&/g, '&amp;')
4544 |     .replace(/"/g, '&quot;')
4545 |     .replace(/</g, '&lt;')
4546 |     .replace(/>/g, '&gt;');
4547 | };
4548 | 
4549 | /**
4550 |  * Array#forEach (<=IE8)
4551 |  *
4552 |  * @param {Array} array
4553 |  * @param {Function} fn
4554 |  * @param {Object} scope
4555 |  * @api private
4556 |  */
4557 | 
4558 | exports.forEach = function(arr, fn, scope){
4559 |   for (var i = 0, l = arr.length; i < l; i++)
4560 |     fn.call(scope, arr[i], i);
4561 | };
4562 | 
4563 | /**
4564 |  * Array#indexOf (<=IE8)
4565 |  *
4566 |  * @parma {Array} arr
4567 |  * @param {Object} obj to find index of
4568 |  * @param {Number} start
4569 |  * @api private
4570 |  */
4571 | 
4572 | exports.indexOf = function(arr, obj, start){
4573 |   for (var i = start || 0, l = arr.length; i < l; i++) {
4574 |     if (arr[i] === obj)
4575 |       return i;
4576 |   }
4577 |   return -1;
4578 | };
4579 | 
4580 | /**
4581 |  * Array#reduce (<=IE8)
4582 |  * 
4583 |  * @param {Array} array
4584 |  * @param {Function} fn
4585 |  * @param {Object} initial value
4586 |  * @api private
4587 |  */
4588 | 
4589 | exports.reduce = function(arr, fn, val){
4590 |   var rval = val;
4591 | 
4592 |   for (var i = 0, l = arr.length; i < l; i++) {
4593 |     rval = fn(rval, arr[i], i, arr);
4594 |   }
4595 | 
4596 |   return rval;
4597 | };
4598 | 
4599 | /**
4600 |  * Array#filter (<=IE8)
4601 |  *
4602 |  * @param {Array} array
4603 |  * @param {Function} fn
4604 |  * @api private
4605 |  */
4606 | 
4607 | exports.filter = function(arr, fn){
4608 |   var ret = [];
4609 | 
4610 |   for (var i = 0, l = arr.length; i < l; i++) {
4611 |     var val = arr[i];
4612 |     if (fn(val, i, arr)) ret.push(val);
4613 |   }
4614 | 
4615 |   return ret;
4616 | };
4617 | 
4618 | /**
4619 |  * Object.keys (<=IE8)
4620 |  *
4621 |  * @param {Object} obj
4622 |  * @return {Array} keys
4623 |  * @api private
4624 |  */
4625 | 
4626 | exports.keys = Object.keys || function(obj) {
4627 |   var keys = []
4628 |     , has = Object.prototype.hasOwnProperty // for `window` on <=IE8
4629 | 
4630 |   for (var key in obj) {
4631 |     if (has.call(obj, key)) {
4632 |       keys.push(key);
4633 |     }
4634 |   }
4635 | 
4636 |   return keys;
4637 | };
4638 | 
4639 | /**
4640 |  * Watch the given `files` for changes
4641 |  * and invoke `fn(file)` on modification.
4642 |  *
4643 |  * @param {Array} files
4644 |  * @param {Function} fn
4645 |  * @api private
4646 |  */
4647 | 
4648 | exports.watch = function(files, fn){
4649 |   var options = { interval: 100 };
4650 |   files.forEach(function(file){
4651 |     debug('file %s', file);
4652 |     fs.watchFile(file, options, function(curr, prev){
4653 |       if (prev.mtime < curr.mtime) fn(file);
4654 |     });
4655 |   });
4656 | };
4657 | 
4658 | /**
4659 |  * Ignored files.
4660 |  */
4661 | 
4662 | function ignored(path){
4663 |   return !~ignore.indexOf(path);
4664 | }
4665 | 
4666 | /**
4667 |  * Lookup files in the given `dir`.
4668 |  *
4669 |  * @return {Array}
4670 |  * @api private
4671 |  */
4672 | 
4673 | exports.files = function(dir, ret){
4674 |   ret = ret || [];
4675 | 
4676 |   fs.readdirSync(dir)
4677 |   .filter(ignored)
4678 |   .forEach(function(path){
4679 |     path = join(dir, path);
4680 |     if (fs.statSync(path).isDirectory()) {
4681 |       exports.files(path, ret);
4682 |     } else if (path.match(/\.(js|coffee)$/)) {
4683 |       ret.push(path);
4684 |     }
4685 |   });
4686 | 
4687 |   return ret;
4688 | };
4689 | 
4690 | /**
4691 |  * Compute a slug from the given `str`.
4692 |  *
4693 |  * @param {String} str
4694 |  * @return {String}
4695 |  * @api private
4696 |  */
4697 | 
4698 | exports.slug = function(str){
4699 |   return str
4700 |     .toLowerCase()
4701 |     .replace(/ +/g, '-')
4702 |     .replace(/[^-\w]/g, '');
4703 | };
4704 | 
4705 | /**
4706 |  * Strip the function definition from `str`,
4707 |  * and re-indent for pre whitespace.
4708 |  */
4709 | 
4710 | exports.clean = function(str) {
4711 |   str = str
4712 |     .replace(/^function *\(.*\) *{/, '')
4713 |     .replace(/\s+\}$/, '');
4714 | 
4715 |   var spaces = str.match(/^\n?( *)/)[1].length
4716 |     , re = new RegExp('^ {' + spaces + '}', 'gm');
4717 | 
4718 |   str = str.replace(re, '');
4719 | 
4720 |   return exports.trim(str);
4721 | };
4722 | 
4723 | /**
4724 |  * Escape regular expression characters in `str`.
4725 |  *
4726 |  * @param {String} str
4727 |  * @return {String}
4728 |  * @api private
4729 |  */
4730 | 
4731 | exports.escapeRegexp = function(str){
4732 |   return str.replace(/[-\\^$*+?.()|[\]{}]/g, "\\$&");
4733 | };
4734 | 
4735 | /**
4736 |  * Trim the given `str`.
4737 |  *
4738 |  * @param {String} str
4739 |  * @return {String}
4740 |  * @api private
4741 |  */
4742 | 
4743 | exports.trim = function(str){
4744 |   return str.replace(/^\s+|\s+$/g, '');
4745 | };
4746 | 
4747 | /**
4748 |  * Parse the given `qs`.
4749 |  *
4750 |  * @param {String} qs
4751 |  * @return {Object}
4752 |  * @api private
4753 |  */
4754 | 
4755 | exports.parseQuery = function(qs){
4756 |   return exports.reduce(qs.replace('?', '').split('&'), function(obj, pair){
4757 |     var i = pair.indexOf('=')
4758 |       , key = pair.slice(0, i)
4759 |       , val = pair.slice(++i);
4760 | 
4761 |     obj[key] = decodeURIComponent(val);
4762 |     return obj;
4763 |   }, {});
4764 | };
4765 | 
4766 | /**
4767 |  * Highlight the given string of `js`.
4768 |  *
4769 |  * @param {String} js
4770 |  * @return {String}
4771 |  * @api private
4772 |  */
4773 | 
4774 | function highlight(js) {
4775 |   return js
4776 |     .replace(/</g, '&lt;')
4777 |     .replace(/>/g, '&gt;')
4778 |     .replace(/\/\/(.*)/gm, '<span class="comment">//$1</span>')
4779 |     .replace(/('.*?')/gm, '<span class="string">$1</span>')
4780 |     .replace(/(\d+\.\d+)/gm, '<span class="number">$1</span>')
4781 |     .replace(/(\d+)/gm, '<span class="number">$1</span>')
4782 |     .replace(/\bnew *(\w+)/gm, '<span class="keyword">new</span> <span class="init">$1</span>')
4783 |     .replace(/\b(function|new|throw|return|var|if|else)\b/gm, '<span class="keyword">$1</span>')
4784 | }
4785 | 
4786 | /**
4787 |  * Highlight the contents of tag `name`.
4788 |  *
4789 |  * @param {String} name
4790 |  * @api private
4791 |  */
4792 | 
4793 | exports.highlightTags = function(name) {
4794 |   var code = document.getElementsByTagName(name);
4795 |   for (var i = 0, len = code.length; i < len; ++i) {
4796 |     code[i].innerHTML = highlight(code[i].innerHTML);
4797 |   }
4798 | };
4799 | 
4800 | }); // module: utils.js
4801 | /**
4802 |  * Node shims.
4803 |  *
4804 |  * These are meant only to allow
4805 |  * mocha.js to run untouched, not
4806 |  * to allow running node code in
4807 |  * the browser.
4808 |  */
4809 | 
4810 | process = {};
4811 | process.exit = function(status){};
4812 | process.stdout = {};
4813 | global = window;
4814 | 
4815 | /**
4816 |  * next tick implementation.
4817 |  */
4818 | 
4819 | process.nextTick = (function(){
4820 |   // postMessage behaves badly on IE8
4821 |   if (window.ActiveXObject || !window.postMessage) {
4822 |     return function(fn){ fn() };
4823 |   }
4824 | 
4825 |   // based on setZeroTimeout by David Baron
4826 |   // - http://dbaron.org/log/20100309-faster-timeouts
4827 |   var timeouts = []
4828 |     , name = 'mocha-zero-timeout'
4829 | 
4830 |   window.addEventListener('message', function(e){
4831 |     if (e.source == window && e.data == name) {
4832 |       if (e.stopPropagation) e.stopPropagation();
4833 |       if (timeouts.length) timeouts.shift()();
4834 |     }
4835 |   }, true);
4836 | 
4837 |   return function(fn){
4838 |     timeouts.push(fn);
4839 |     window.postMessage(name, '*');
4840 |   }
4841 | })();
4842 | 
4843 | /**
4844 |  * Remove uncaughtException listener.
4845 |  */
4846 | 
4847 | process.removeListener = function(e){
4848 |   if ('uncaughtException' == e) {
4849 |     window.onerror = null;
4850 |   }
4851 | };
4852 | 
4853 | /**
4854 |  * Implements uncaughtException listener.
4855 |  */
4856 | 
4857 | process.on = function(e, fn){
4858 |   if ('uncaughtException' == e) {
4859 |     window.onerror = fn;
4860 |   }
4861 | };
4862 | 
4863 | // boot
4864 | ;(function(){
4865 | 
4866 |   /**
4867 |    * Expose mocha.
4868 |    */
4869 | 
4870 |   var Mocha = window.Mocha = require('mocha'),
4871 |       mocha = window.mocha = new Mocha({ reporter: 'html' });
4872 | 
4873 |   /**
4874 |    * Override ui to ensure that the ui functions are initialized.
4875 |    * Normally this would happen in Mocha.prototype.loadFiles.
4876 |    */
4877 | 
4878 |   mocha.ui = function(ui){
4879 |     Mocha.prototype.ui.call(this, ui);
4880 |     this.suite.emit('pre-require', window, null, this);
4881 |     return this;
4882 |   };
4883 | 
4884 |   /**
4885 |    * Setup mocha with the given setting options.
4886 |    */
4887 | 
4888 |   mocha.setup = function(opts){
4889 |     if ('string' == typeof opts) opts = { ui: opts };
4890 |     for (var opt in opts) this[opt](opts[opt]);
4891 |     return this;
4892 |   };
4893 | 
4894 |   /**
4895 |    * Run mocha, returning the Runner.
4896 |    */
4897 | 
4898 |   mocha.run = function(fn){
4899 |     var options = mocha.options;
4900 |     mocha.globals('location');
4901 | 
4902 |     var query = Mocha.utils.parseQuery(window.location.search || '');
4903 |     if (query.grep) mocha.grep(query.grep);
4904 | 
4905 |     return Mocha.prototype.run.call(mocha, function(){
4906 |       Mocha.utils.highlightTags('code');
4907 |       if (fn) fn();
4908 |     });
4909 |   };
4910 | })();
4911 | })();


--------------------------------------------------------------------------------
/tests/recursion.html:
--------------------------------------------------------------------------------
 1 | <!--
 2 | If you run this file under IE9, it will make the browser become unresponsive because TraceKit will be stuck in an infinite loop in the function `computeStackTraceByWalkingCallerChain` prior to the fix.
 3 | 
 4 | -->
 5 | <!doctype html>
 6 | <html>
 7 | <head>
 8 | <title>TraceKit Recursion Test</title>
 9 | <script src="../tracekit.js"></script>
10 | <link href="mocha.css" rel="stylesheet">
11 | <script src="mocha.js"></script>
12 | <script>
13 | 
14 | setupTraceKit()
15 | function setupTraceKit(){
16 |     function indent(text){
17 |         return text.split('\n').map(function(line){
18 |             return '    ' + line
19 |         }).join('\n')
20 |     }
21 | 
22 |     TraceKit.report.subscribe(function(stackInfo){
23 |         console.log(stackInfo.name + ' : ' + stackInfo.message)
24 |         var stack = stackInfo.stack
25 |         if (!stack || stack.length === 0) return
26 |         if (stack[0].context){
27 |             console.log(indent(stack[0].context.join('\n')))
28 |         }
29 |         for (var i = 0; i < stack.length; i++){
30 |             var line = stack[i]
31 | 
32 |             console.log('    at ' + line.func + ' (' + [line.url, line.line, line.column].join(':') + ')')
33 |         }
34 |     })
35 | }
36 | 
37 | interceptMochaRunner()
38 | function interceptMochaRunner(){
39 |     var Runner = mocha.Runner || Mocha.Runner
40 |     var oEmit = Runner.prototype.emit
41 |     Runner.prototype.emit = function(evt, test){
42 |         if (evt === 'test end'){
43 |             if (test.err) TraceKit.report(test.err)
44 |         }
45 |         oEmit.apply(this, arguments)
46 |     }
47 | }
48 | 
49 | </script>
50 | <script>mocha.setup('bdd')</script>
51 | <script>
52 | describe('crash', function(){
53 | 
54 |     it('it should not go into an infinite loop', function(){
55 |         throw new Error('Boom!');
56 |     });
57 |     
58 | });
59 | </script>
60 | </head>
61 | <body>
62 | <h1>TraceKit Recursion Test</h1>
63 | <div id="mocha"></div>
64 | <script>
65 | mocha.run()
66 | </script>
67 | </body>
68 | </html>


--------------------------------------------------------------------------------
/tracekit.js:
--------------------------------------------------------------------------------
   1 | /*
   2 |  TraceKit - Cross brower stack traces - github.com/occ/TraceKit
   3 |  MIT license
   4 | */
   5 | 
   6 | ;(function(window, undefined) {
   7 | 
   8 | 
   9 | var TraceKit = {};
  10 | var _oldTraceKit = window.TraceKit;
  11 | 
  12 | // global reference to slice
  13 | var _slice = [].slice;
  14 | var UNKNOWN_FUNCTION = '?';
  15 | 
  16 | 
  17 | /**
  18 |  * _has, a better form of hasOwnProperty
  19 |  * Example: _has(MainHostObject, property) === true/false
  20 |  *
  21 |  * @param {Object} host object to check property
  22 |  * @param {string} key to check
  23 |  */
  24 | function _has(object, key) {
  25 |     return Object.prototype.hasOwnProperty.call(object, key);
  26 | }
  27 | 
  28 | function _isUndefined(what) {
  29 |     return typeof what === 'undefined';
  30 | }
  31 | 
  32 | /**
  33 |  * TraceKit.noConflict: Export TraceKit out to another variable
  34 |  * Example: var TK = TraceKit.noConflict()
  35 |  */
  36 | TraceKit.noConflict = function noConflict() {
  37 |     window.TraceKit = _oldTraceKit;
  38 |     return TraceKit;
  39 | };
  40 | 
  41 | /**
  42 |  * TraceKit.wrap: Wrap any function in a TraceKit reporter
  43 |  * Example: func = TraceKit.wrap(func);
  44 |  *
  45 |  * @param {Function} func Function to be wrapped
  46 |  * @return {Function} The wrapped func
  47 |  */
  48 | TraceKit.wrap = function traceKitWrapper(func) {
  49 |     function wrapped() {
  50 |         try {
  51 |             return func.apply(this, arguments);
  52 |         } catch (e) {
  53 |             TraceKit.report(e);
  54 |             throw e;
  55 |         }
  56 |     }
  57 |     return wrapped;
  58 | };
  59 | 
  60 | /**
  61 |  * TraceKit.report: cross-browser processing of unhandled exceptions
  62 |  *
  63 |  * Syntax:
  64 |  *   TraceKit.report.subscribe(function(stackInfo) { ... })
  65 |  *   TraceKit.report.unsubscribe(function(stackInfo) { ... })
  66 |  *   TraceKit.report(exception)
  67 |  *   try { ...code... } catch(ex) { TraceKit.report(ex); }
  68 |  *
  69 |  * Supports:
  70 |  *   - Firefox: full stack trace with line numbers, plus column number
  71 |  *              on top frame; column number is not guaranteed
  72 |  *   - Opera:   full stack trace with line and column numbers
  73 |  *   - Chrome:  full stack trace with line and column numbers
  74 |  *   - Safari:  line and column number for the top frame only; some frames
  75 |  *              may be missing, and column number is not guaranteed
  76 |  *   - IE:      line and column number for the top frame only; some frames
  77 |  *              may be missing, and column number is not guaranteed
  78 |  *
  79 |  * In theory, TraceKit should work on all of the following versions:
  80 |  *   - IE5.5+ (only 8.0 tested)
  81 |  *   - Firefox 0.9+ (only 3.5+ tested)
  82 |  *   - Opera 7+ (only 10.50 tested; versions 9 and earlier may require
  83 |  *     Exceptions Have Stacktrace to be enabled in opera:config)
  84 |  *   - Safari 3+ (only 4+ tested)
  85 |  *   - Chrome 1+ (only 5+ tested)
  86 |  *   - Konqueror 3.5+ (untested)
  87 |  *
  88 |  * Requires TraceKit.computeStackTrace.
  89 |  *
  90 |  * Tries to catch all unhandled exceptions and report them to the
  91 |  * subscribed handlers. Please note that TraceKit.report will rethrow the
  92 |  * exception. This is REQUIRED in order to get a useful stack trace in IE.
  93 |  * If the exception does not reach the top of the browser, you will only
  94 |  * get a stack trace from the point where TraceKit.report was called.
  95 |  *
  96 |  * Handlers receive a stackInfo object as described in the
  97 |  * TraceKit.computeStackTrace docs.
  98 |  */
  99 | TraceKit.report = (function reportModuleWrapper() {
 100 |     var handlers = [],
 101 |         lastException = null,
 102 |         lastExceptionStack = null;
 103 | 
 104 |     /**
 105 |      * Add a crash handler.
 106 |      * @param {Function} handler
 107 |      */
 108 |     function subscribe(handler) {
 109 |         installGlobalHandler();
 110 |         handlers.push(handler);
 111 |     }
 112 | 
 113 |     /**
 114 |      * Remove a crash handler.
 115 |      * @param {Function} handler
 116 |      */
 117 |     function unsubscribe(handler) {
 118 |         for (var i = handlers.length - 1; i >= 0; --i) {
 119 |             if (handlers[i] === handler) {
 120 |                 handlers.splice(i, 1);
 121 |             }
 122 |         }
 123 |     }
 124 | 
 125 |     /**
 126 |      * Dispatch stack information to all handlers.
 127 |      * @param {Object.<string, *>} stack
 128 |      */
 129 |     function notifyHandlers(stack, windowError) {
 130 |         var exception = null;
 131 |         if (windowError && !TraceKit.collectWindowErrors) {
 132 |           return;
 133 |         }
 134 |         for (var i in handlers) {
 135 |             if (_has(handlers, i)) {
 136 |                 try {
 137 |                     handlers[i].apply(null, [stack].concat(_slice.call(arguments, 2)));
 138 |                 } catch (inner) {
 139 |                     exception = inner;
 140 |                 }
 141 |             }
 142 |         }
 143 | 
 144 |         if (exception) {
 145 |             throw exception;
 146 |         }
 147 |     }
 148 | 
 149 |     var _oldOnerrorHandler, _onErrorHandlerInstalled;
 150 | 
 151 |     /**
 152 |      * Ensures all global unhandled exceptions are recorded.
 153 |      * Supported by Gecko and IE.
 154 |      * @param {string} message Error message.
 155 |      * @param {string} url URL of script that generated the exception.
 156 |      * @param {(number|string)} lineNo The line number at which the error
 157 |      * occurred.
 158 |      */
 159 |     function traceKitWindowOnError(message, url, lineNo) {
 160 |         var stack = null;
 161 | 
 162 |         if (lastExceptionStack) {
 163 |             TraceKit.computeStackTrace.augmentStackTraceWithInitialElement(lastExceptionStack, url, lineNo, message);
 164 |             stack = lastExceptionStack;
 165 |             lastExceptionStack = null;
 166 |             lastException = null;
 167 |         } else {
 168 |             var location = {
 169 |                 'url': url,
 170 |                 'line': lineNo
 171 |             };
 172 |             location.func = TraceKit.computeStackTrace.guessFunctionName(location.url, location.line);
 173 |             location.context = TraceKit.computeStackTrace.gatherContext(location.url, location.line);
 174 |             stack = {
 175 |                 'mode': 'onerror',
 176 |                 'message': message,
 177 |                 'url': document.location.href,
 178 |                 'stack': [location],
 179 |                 'useragent': navigator.userAgent
 180 |             };
 181 |         }
 182 | 
 183 |         notifyHandlers(stack, 'from window.onerror');
 184 | 
 185 |         if (_oldOnerrorHandler) {
 186 |             return _oldOnerrorHandler.apply(this, arguments);
 187 |         }
 188 | 
 189 |         return false;
 190 |     }
 191 | 
 192 |     function installGlobalHandler ()
 193 |     {
 194 |         if (_onErrorHandlerInstalled === true) {
 195 |             return;
 196 |         }
 197 |         _oldOnerrorHandler = window.onerror;
 198 |         window.onerror = traceKitWindowOnError;
 199 |         _onErrorHandlerInstalled = true;
 200 |     }
 201 | 
 202 |     /**
 203 |      * Reports an unhandled Error to TraceKit.
 204 |      * @param {Error} ex
 205 |      */
 206 |     function report(ex) {
 207 |         var args = _slice.call(arguments, 1);
 208 |         if (lastExceptionStack) {
 209 |             if (lastException === ex) {
 210 |                 return; // already caught by an inner catch block, ignore
 211 |             } else {
 212 |                 var s = lastExceptionStack;
 213 |                 lastExceptionStack = null;
 214 |                 lastException = null;
 215 |                 notifyHandlers.apply(null, [s, null].concat(args));
 216 |             }
 217 |         }
 218 | 
 219 |         var stack = TraceKit.computeStackTrace(ex);
 220 |         lastExceptionStack = stack;
 221 |         lastException = ex;
 222 | 
 223 |         // If the stack trace is incomplete, wait for 2 seconds for
 224 |         // slow slow IE to see if onerror occurs or not before reporting
 225 |         // this exception; otherwise, we will end up with an incomplete
 226 |         // stack trace
 227 |         window.setTimeout(function () {
 228 |             if (lastException === ex) {
 229 |                 lastExceptionStack = null;
 230 |                 lastException = null;
 231 |                 notifyHandlers.apply(null, [stack, null].concat(args));
 232 |             }
 233 |         }, (stack.incomplete ? 2000 : 0));
 234 | 
 235 |         throw ex; // re-throw to propagate to the top level (and cause window.onerror)
 236 |     }
 237 | 
 238 |     report.subscribe = subscribe;
 239 |     report.unsubscribe = unsubscribe;
 240 |     return report;
 241 | }());
 242 | 
 243 | /**
 244 |  * TraceKit.computeStackTrace: cross-browser stack traces in JavaScript
 245 |  *
 246 |  * Syntax:
 247 |  *   s = TraceKit.computeStackTrace.ofCaller([depth])
 248 |  *   s = TraceKit.computeStackTrace(exception) // consider using TraceKit.report instead (see below)
 249 |  * Returns:
 250 |  *   s.name              - exception name
 251 |  *   s.message           - exception message
 252 |  *   s.stack[i].url      - JavaScript or HTML file URL
 253 |  *   s.stack[i].func     - function name, or empty for anonymous functions (if guessing did not work)
 254 |  *   s.stack[i].args     - arguments passed to the function, if known
 255 |  *   s.stack[i].line     - line number, if known
 256 |  *   s.stack[i].column   - column number, if known
 257 |  *   s.stack[i].context  - an array of source code lines; the middle element corresponds to the correct line#
 258 |  *   s.mode              - 'stack', 'stacktrace', 'multiline', 'callers', 'onerror', or 'failed' -- method used to collect the stack trace
 259 |  *
 260 |  * Supports:
 261 |  *   - Firefox:  full stack trace with line numbers and unreliable column
 262 |  *               number on top frame
 263 |  *   - Opera 10: full stack trace with line and column numbers
 264 |  *   - Opera 9-: full stack trace with line numbers
 265 |  *   - Chrome:   full stack trace with line and column numbers
 266 |  *   - Safari:   line and column number for the topmost stacktrace element
 267 |  *               only
 268 |  *   - IE:       no line numbers whatsoever
 269 |  *
 270 |  * Tries to guess names of anonymous functions by looking for assignments
 271 |  * in the source code. In IE and Safari, we have to guess source file names
 272 |  * by searching for function bodies inside all page scripts. This will not
 273 |  * work for scripts that are loaded cross-domain.
 274 |  * Here be dragons: some function names may be guessed incorrectly, and
 275 |  * duplicate functions may be mismatched.
 276 |  *
 277 |  * TraceKit.computeStackTrace should only be used for tracing purposes.
 278 |  * Logging of unhandled exceptions should be done with TraceKit.report,
 279 |  * which builds on top of TraceKit.computeStackTrace and provides better
 280 |  * IE support by utilizing the window.onerror event to retrieve information
 281 |  * about the top of the stack.
 282 |  *
 283 |  * Note: In IE and Safari, no stack trace is recorded on the Error object,
 284 |  * so computeStackTrace instead walks its *own* chain of callers.
 285 |  * This means that:
 286 |  *  * in Safari, some methods may be missing from the stack trace;
 287 |  *  * in IE, the topmost function in the stack trace will always be the
 288 |  *    caller of computeStackTrace.
 289 |  *
 290 |  * This is okay for tracing (because you are likely to be calling
 291 |  * computeStackTrace from the function you want to be the topmost element
 292 |  * of the stack trace anyway), but not okay for logging unhandled
 293 |  * exceptions (because your catch block will likely be far away from the
 294 |  * inner function that actually caused the exception).
 295 |  *
 296 |  * Tracing example:
 297 |  *     function trace(message) {
 298 |  *         var stackInfo = TraceKit.computeStackTrace.ofCaller();
 299 |  *         var data = message + "\n";
 300 |  *         for(var i in stackInfo.stack) {
 301 |  *             var item = stackInfo.stack[i];
 302 |  *             data += (item.func || '[anonymous]') + "() in " + item.url + ":" + (item.line || '0') + "\n";
 303 |  *         }
 304 |  *         if (window.console)
 305 |  *             console.info(data);
 306 |  *         else
 307 |  *             alert(data);
 308 |  *     }
 309 |  */
 310 | TraceKit.computeStackTrace = (function computeStackTraceWrapper() {
 311 |     var debug = false,
 312 |         sourceCache = {};
 313 | 
 314 |     /**
 315 |      * Attempts to retrieve source code via XMLHttpRequest, which is used
 316 |      * to look up anonymous function names.
 317 |      * @param {string} url URL of source code.
 318 |      * @return {string} Source contents.
 319 |      */
 320 |     function loadSource(url) {
 321 |         if (!TraceKit.remoteFetching) { //Only attempt request if remoteFetching is on.
 322 |             return '';
 323 |         }
 324 |         try {
 325 |             function getXHR() {
 326 |                 try {
 327 |                     return new window.XMLHttpRequest();
 328 |                 } catch (e) {
 329 |                     // explicitly bubble up the exception if not found
 330 |                     return new window.ActiveXObject('Microsoft.XMLHTTP');
 331 |                 }
 332 |             }
 333 | 
 334 |             var request = getXHR();
 335 |             request.open('GET', url, false);
 336 |             request.send('');
 337 |             return request.responseText;
 338 |         } catch (e) {
 339 |             return '';
 340 |         }
 341 |     }
 342 | 
 343 |     /**
 344 |      * Retrieves source code from the source code cache.
 345 |      * @param {string} url URL of source code.
 346 |      * @return {Array.<string>} Source contents.
 347 |      */
 348 |     function getSource(url) {
 349 |         if (!_has(sourceCache, url)) {
 350 |             // URL needs to be able to fetched within the acceptable domain.  Otherwise,
 351 |             // cross-domain errors will be triggered.
 352 |             var source = '';
 353 |             if (url.indexOf(document.domain) !== -1) {
 354 |                 source = loadSource(url);
 355 |             }
 356 |             sourceCache[url] = source ? source.split('\n') : [];
 357 |         }
 358 | 
 359 |         return sourceCache[url];
 360 |     }
 361 | 
 362 |     /**
 363 |      * Tries to use an externally loaded copy of source code to determine
 364 |      * the name of a function by looking at the name of the variable it was
 365 |      * assigned to, if any.
 366 |      * @param {string} url URL of source code.
 367 |      * @param {(string|number)} lineNo Line number in source code.
 368 |      * @return {string} The function name, if discoverable.
 369 |      */
 370 |     function guessFunctionName(url, lineNo) {
 371 |         var reFunctionArgNames = /function ([^(]*)\(([^)]*)\)/,
 372 |             reGuessFunction = /['"]?([0-9A-Za-z$_]+)['"]?\s*[:=]\s*(function|eval|new Function)/,
 373 |             line = '',
 374 |             maxLines = 10,
 375 |             source = getSource(url),
 376 |             m;
 377 | 
 378 |         if (!source.length) {
 379 |             return UNKNOWN_FUNCTION;
 380 |         }
 381 | 
 382 |         // Walk backwards from the first line in the function until we find the line which
 383 |         // matches the pattern above, which is the function definition
 384 |         for (var i = 0; i < maxLines; ++i) {
 385 |             line = source[lineNo - i] + line;
 386 | 
 387 |             if (!_isUndefined(line)) {
 388 |                 if ((m = reGuessFunction.exec(line))) {
 389 |                     return m[1];
 390 |                 } else if ((m = reFunctionArgNames.exec(line))) {
 391 |                     return m[1];
 392 |                 }
 393 |             }
 394 |         }
 395 | 
 396 |         return UNKNOWN_FUNCTION;
 397 |     }
 398 | 
 399 |     /**
 400 |      * Retrieves the surrounding lines from where an exception occurred.
 401 |      * @param {string} url URL of source code.
 402 |      * @param {(string|number)} line Line number in source code to centre
 403 |      * around for context.
 404 |      * @return {?Array.<string>} Lines of source code.
 405 |      */
 406 |     function gatherContext(url, line) {
 407 |         var source = getSource(url);
 408 | 
 409 |         if (!source.length) {
 410 |             return null;
 411 |         }
 412 | 
 413 |         var context = [],
 414 |             // linesBefore & linesAfter are inclusive with the offending line.
 415 |             // if linesOfContext is even, there will be one extra line
 416 |             //   *before* the offending line.
 417 |             linesBefore = Math.floor(TraceKit.linesOfContext / 2),
 418 |             // Add one extra line if linesOfContext is odd
 419 |             linesAfter = linesBefore + (TraceKit.linesOfContext % 2),
 420 |             start = Math.max(0, line - linesBefore - 1),
 421 |             end = Math.min(source.length, line + linesAfter - 1);
 422 | 
 423 |         line -= 1; // convert to 0-based index
 424 | 
 425 |         for (var i = start; i < end; ++i) {
 426 |             if (!_isUndefined(source[i])) {
 427 |                 context.push(source[i]);
 428 |             }
 429 |         }
 430 | 
 431 |         return context.length > 0 ? context : null;
 432 |     }
 433 | 
 434 |     /**
 435 |      * Escapes special characters, except for whitespace, in a string to be
 436 |      * used inside a regular expression as a string literal.
 437 |      * @param {string} text The string.
 438 |      * @return {string} The escaped string literal.
 439 |      */
 440 |     function escapeRegExp(text) {
 441 |         return text.replace(/[\-\[\]{}()*+?.,\\\^$|#]/g, '\\$&');
 442 |     }
 443 | 
 444 |     /**
 445 |      * Escapes special characters in a string to be used inside a regular
 446 |      * expression as a string literal. Also ensures that HTML entities will
 447 |      * be matched the same as their literal friends.
 448 |      * @param {string} body The string.
 449 |      * @return {string} The escaped string.
 450 |      */
 451 |     function escapeCodeAsRegExpForMatchingInsideHTML(body) {
 452 |         return escapeRegExp(body).replace('<', '(?:<|&lt;)').replace('>', '(?:>|&gt;)').replace('&', '(?:&|&amp;)').replace('"', '(?:"|&quot;)').replace(/\s+/g, '\\s+');
 453 |     }
 454 | 
 455 |     /**
 456 |      * Determines where a code fragment occurs in the source code.
 457 |      * @param {RegExp} re The function definition.
 458 |      * @param {Array.<string>} urls A list of URLs to search.
 459 |      * @return {?Object.<string, (string|number)>} An object containing
 460 |      * the url, line, and column number of the defined function.
 461 |      */
 462 |     function findSourceInUrls(re, urls) {
 463 |         var source, m;
 464 |         for (var i = 0, j = urls.length; i < j; ++i) {
 465 |             // console.log('searching', urls[i]);
 466 |             if ((source = getSource(urls[i])).length) {
 467 |                 source = source.join('\n');
 468 |                 if ((m = re.exec(source))) {
 469 |                     // console.log('Found function in ' + urls[i]);
 470 | 
 471 |                     return {
 472 |                         'url': urls[i],
 473 |                         'line': source.substring(0, m.index).split('\n').length,
 474 |                         'column': m.index - source.lastIndexOf('\n', m.index) - 1
 475 |                     };
 476 |                 }
 477 |             }
 478 |         }
 479 | 
 480 |         // console.log('no match');
 481 | 
 482 |         return null;
 483 |     }
 484 | 
 485 |     /**
 486 |      * Determines at which column a code fragment occurs on a line of the
 487 |      * source code.
 488 |      * @param {string} fragment The code fragment.
 489 |      * @param {string} url The URL to search.
 490 |      * @param {(string|number)} line The line number to examine.
 491 |      * @return {?number} The column number.
 492 |      */
 493 |     function findSourceInLine(fragment, url, line) {
 494 |         var source = getSource(url),
 495 |             re = new RegExp('\\b' + escapeRegExp(fragment) + '\\b'),
 496 |             m;
 497 | 
 498 |         line -= 1;
 499 | 
 500 |         if (source && source.length > line && (m = re.exec(source[line]))) {
 501 |             return m.index;
 502 |         }
 503 | 
 504 |         return null;
 505 |     }
 506 | 
 507 |     /**
 508 |      * Determines where a function was defined within the source code.
 509 |      * @param {(Function|string)} func A function reference or serialized
 510 |      * function definition.
 511 |      * @return {?Object.<string, (string|number)>} An object containing
 512 |      * the url, line, and column number of the defined function.
 513 |      */
 514 |     function findSourceByFunctionBody(func) {
 515 |         var urls = [window.location.href],
 516 |             scripts = document.getElementsByTagName('script'),
 517 |             body,
 518 |             code = '' + func,
 519 |             codeRE = /^function(?:\s+([\w$]+))?\s*\(([\w\s,]*)\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/,
 520 |             eventRE = /^function on([\w$]+)\s*\(event\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/,
 521 |             re,
 522 |             parts,
 523 |             result;
 524 | 
 525 |         for (var i = 0; i < scripts.length; ++i) {
 526 |             var script = scripts[i];
 527 |             if (script.src) {
 528 |                 urls.push(script.src);
 529 |             }
 530 |         }
 531 | 
 532 |         if (!(parts = codeRE.exec(code))) {
 533 |             re = new RegExp(escapeRegExp(code).replace(/\s+/g, '\\s+'));
 534 |         }
 535 | 
 536 |         // not sure if this is really necessary, but I don’t have a test
 537 |         // corpus large enough to confirm that and it was in the original.
 538 |         else {
 539 |             var name = parts[1] ? '\\s+' + parts[1] : '',
 540 |                 args = parts[2].split(',').join('\\s*,\\s*');
 541 | 
 542 |             body = escapeRegExp(parts[3]).replace(/;$/, ';?'); // semicolon is inserted if the function ends with a comment.replace(/\s+/g, '\\s+');
 543 |             re = new RegExp('function' + name + '\\s*\\(\\s*' + args + '\\s*\\)\\s*{\\s*' + body + '\\s*}');
 544 |         }
 545 | 
 546 |         // look for a normal function definition
 547 |         if ((result = findSourceInUrls(re, urls))) {
 548 |             return result;
 549 |         }
 550 | 
 551 |         // look for an old-school event handler function
 552 |         if ((parts = eventRE.exec(code))) {
 553 |             var event = parts[1];
 554 |             body = escapeCodeAsRegExpForMatchingInsideHTML(parts[2]);
 555 | 
 556 |             // look for a function defined in HTML as an onXXX handler
 557 |             re = new RegExp('on' + event + '=[\\\'"]\\s*' + body + '\\s*[\\\'"]', 'i');
 558 | 
 559 |             if ((result = findSourceInUrls(re, urls[0]))) {
 560 |                 return result;
 561 |             }
 562 | 
 563 |             // look for ???
 564 |             re = new RegExp(body);
 565 | 
 566 |             if ((result = findSourceInUrls(re, urls))) {
 567 |                 return result;
 568 |             }
 569 |         }
 570 | 
 571 |         return null;
 572 |     }
 573 | 
 574 |     // Contents of Exception in various browsers.
 575 |     //
 576 |     // SAFARI:
 577 |     // ex.message = Can't find variable: qq
 578 |     // ex.line = 59
 579 |     // ex.sourceId = 580238192
 580 |     // ex.sourceURL = http://...
 581 |     // ex.expressionBeginOffset = 96
 582 |     // ex.expressionCaretOffset = 98
 583 |     // ex.expressionEndOffset = 98
 584 |     // ex.name = ReferenceError
 585 |     //
 586 |     // FIREFOX:
 587 |     // ex.message = qq is not defined
 588 |     // ex.fileName = http://...
 589 |     // ex.lineNumber = 59
 590 |     // ex.stack = ...stack trace... (see the example below)
 591 |     // ex.name = ReferenceError
 592 |     //
 593 |     // CHROME:
 594 |     // ex.message = qq is not defined
 595 |     // ex.name = ReferenceError
 596 |     // ex.type = not_defined
 597 |     // ex.arguments = ['aa']
 598 |     // ex.stack = ...stack trace...
 599 |     //
 600 |     // INTERNET EXPLORER:
 601 |     // ex.message = ...
 602 |     // ex.name = ReferenceError
 603 |     //
 604 |     // OPERA:
 605 |     // ex.message = ...message... (see the example below)
 606 |     // ex.name = ReferenceError
 607 |     // ex.opera#sourceloc = 11  (pretty much useless, duplicates the info in ex.message)
 608 |     // ex.stacktrace = n/a; see 'opera:config#UserPrefs|Exceptions Have Stacktrace'
 609 | 
 610 |     /**
 611 |      * Computes stack trace information from the stack property.
 612 |      * Chrome and Gecko use this property.
 613 |      * @param {Error} ex
 614 |      * @return {?Object.<string, *>} Stack trace information.
 615 |      */
 616 |     function computeStackTraceFromStackProp(ex) {
 617 |         if (!ex.stack) {
 618 |             return null;
 619 |         }
 620 | 
 621 |         var chrome = /^\s*at (?:((?:\[object object\])?\S+) )?\(?((?:file|http|https):.*?):(\d+)(?::(\d+))?\)?\s*$/i,
 622 |             gecko = /^\s*(\S*)(?:\((.*?)\))?@((?:file|http|https).*?):(\d+)(?::(\d+))?\s*$/i,
 623 |             lines = ex.stack.split('\n'),
 624 |             stack = [],
 625 |             parts,
 626 |             element,
 627 |             reference = /^(.*) is undefined$/.exec(ex.message);
 628 | 
 629 |         for (var i = 0, j = lines.length; i < j; ++i) {
 630 |             if ((parts = gecko.exec(lines[i]))) {
 631 |                 element = {
 632 |                     'url': parts[3],
 633 |                     'func': parts[1] || UNKNOWN_FUNCTION,
 634 |                     'args': parts[2] ? parts[2].split(',') : '',
 635 |                     'line': +parts[4],
 636 |                     'column': parts[5] ? +parts[5] : null
 637 |                 };
 638 |             } else if ((parts = chrome.exec(lines[i]))) {
 639 |                 element = {
 640 |                     'url': parts[2],
 641 |                     'func': parts[1] || UNKNOWN_FUNCTION,
 642 |                     'line': +parts[3],
 643 |                     'column': parts[4] ? +parts[4] : null
 644 |                 };
 645 |             } else {
 646 |                 continue;
 647 |             }
 648 | 
 649 |             if (!element.func && element.line) {
 650 |                 element.func = guessFunctionName(element.url, element.line);
 651 |             }
 652 | 
 653 |             if (element.line) {
 654 |                 element.context = gatherContext(element.url, element.line);
 655 |             }
 656 | 
 657 |             stack.push(element);
 658 |         }
 659 | 
 660 |         if (stack[0] && stack[0].line && !stack[0].column && reference) {
 661 |             stack[0].column = findSourceInLine(reference[1], stack[0].url, stack[0].line);
 662 |         }
 663 | 
 664 |         if (!stack.length) {
 665 |             return null;
 666 |         }
 667 | 
 668 |         return {
 669 |             'mode': 'stack',
 670 |             'name': ex.name,
 671 |             'message': ex.message,
 672 |             'url': document.location.href,
 673 |             'stack': stack,
 674 |             'useragent': navigator.userAgent
 675 |         };
 676 |     }
 677 | 
 678 |     /**
 679 |      * Computes stack trace information from the stacktrace property.
 680 |      * Opera 10 uses this property.
 681 |      * @param {Error} ex
 682 |      * @return {?Object.<string, *>} Stack trace information.
 683 |      */
 684 |     function computeStackTraceFromStacktraceProp(ex) {
 685 |         // Access and store the stacktrace property before doing ANYTHING
 686 |         // else to it because Opera is not very good at providing it
 687 |         // reliably in other circumstances.
 688 |         var stacktrace = ex.stacktrace;
 689 | 
 690 |         var testRE = / line (\d+), column (\d+) in (?:<anonymous function: ([^>]+)>|([^\)]+))\((.*)\) in (.*):\s*$/i,
 691 |             lines = stacktrace.split('\n'),
 692 |             stack = [],
 693 |             parts;
 694 | 
 695 |         for (var i = 0, j = lines.length; i < j; i += 2) {
 696 |             if ((parts = testRE.exec(lines[i]))) {
 697 |                 var element = {
 698 |                     'line': +parts[1],
 699 |                     'column': +parts[2],
 700 |                     'func': parts[3] || parts[4],
 701 |                     'args': parts[5] ? parts[5].split(',') : [],
 702 |                     'url': parts[6]
 703 |                 };
 704 | 
 705 |                 if (!element.func && element.line) {
 706 |                     element.func = guessFunctionName(element.url, element.line);
 707 |                 }
 708 |                 if (element.line) {
 709 |                     try {
 710 |                         element.context = gatherContext(element.url, element.line);
 711 |                     } catch (exc) {}
 712 |                 }
 713 | 
 714 |                 if (!element.context) {
 715 |                     element.context = [lines[i + 1]];
 716 |                 }
 717 | 
 718 |                 stack.push(element);
 719 |             }
 720 |         }
 721 | 
 722 |         if (!stack.length) {
 723 |             return null;
 724 |         }
 725 | 
 726 |         return {
 727 |             'mode': 'stacktrace',
 728 |             'name': ex.name,
 729 |             'message': ex.message,
 730 |             'url': document.location.href,
 731 |             'stack': stack,
 732 |             'useragent': navigator.userAgent
 733 |         };
 734 |     }
 735 | 
 736 |     /**
 737 |      * NOT TESTED.
 738 |      * Computes stack trace information from an error message that includes
 739 |      * the stack trace.
 740 |      * Opera 9 and earlier use this method if the option to show stack
 741 |      * traces is turned on in opera:config.
 742 |      * @param {Error} ex
 743 |      * @return {?Object.<string, *>} Stack information.
 744 |      */
 745 |     function computeStackTraceFromOperaMultiLineMessage(ex) {
 746 |         // Opera includes a stack trace into the exception message. An example is:
 747 |         //
 748 |         // Statement on line 3: Undefined variable: undefinedFunc
 749 |         // Backtrace:
 750 |         //   Line 3 of linked script file://localhost/Users/andreyvit/Projects/TraceKit/javascript-client/sample.js: In function zzz
 751 |         //         undefinedFunc(a);
 752 |         //   Line 7 of inline#1 script in file://localhost/Users/andreyvit/Projects/TraceKit/javascript-client/sample.html: In function yyy
 753 |         //           zzz(x, y, z);
 754 |         //   Line 3 of inline#1 script in file://localhost/Users/andreyvit/Projects/TraceKit/javascript-client/sample.html: In function xxx
 755 |         //           yyy(a, a, a);
 756 |         //   Line 1 of function script
 757 |         //     try { xxx('hi'); return false; } catch(ex) { TraceKit.report(ex); }
 758 |         //   ...
 759 | 
 760 |         var lines = ex.message.split('\n');
 761 |         if (lines.length < 4) {
 762 |             return null;
 763 |         }
 764 | 
 765 |         var lineRE1 = /^\s*Line (\d+) of linked script ((?:file|http|https)\S+)(?:: in function (\S+))?\s*$/i,
 766 |             lineRE2 = /^\s*Line (\d+) of inline#(\d+) script in ((?:file|http|https)\S+)(?:: in function (\S+))?\s*$/i,
 767 |             lineRE3 = /^\s*Line (\d+) of function script\s*$/i,
 768 |             stack = [],
 769 |             scripts = document.getElementsByTagName('script'),
 770 |             inlineScriptBlocks = [],
 771 |             parts,
 772 |             i,
 773 |             len,
 774 |             source;
 775 | 
 776 |         for (i in scripts) {
 777 |             if (_has(scripts, i) && !scripts[i].src) {
 778 |                 inlineScriptBlocks.push(scripts[i]);
 779 |             }
 780 |         }
 781 | 
 782 |         for (i = 2, len = lines.length; i < len; i += 2) {
 783 |             var item = null;
 784 |             if ((parts = lineRE1.exec(lines[i]))) {
 785 |                 item = {
 786 |                     'url': parts[2],
 787 |                     'func': parts[3],
 788 |                     'line': +parts[1]
 789 |                 };
 790 |             } else if ((parts = lineRE2.exec(lines[i]))) {
 791 |                 item = {
 792 |                     'url': parts[3],
 793 |                     'func': parts[4]
 794 |                 };
 795 |                 var relativeLine = (+parts[1]); // relative to the start of the <SCRIPT> block
 796 |                 var script = inlineScriptBlocks[parts[2] - 1];
 797 |                 if (script) {
 798 |                     source = getSource(item.url);
 799 |                     if (source) {
 800 |                         source = source.join('\n');
 801 |                         var pos = source.indexOf(script.innerText);
 802 |                         if (pos >= 0) {
 803 |                             item.line = relativeLine + source.substring(0, pos).split('\n').length;
 804 |                         }
 805 |                     }
 806 |                 }
 807 |             } else if ((parts = lineRE3.exec(lines[i]))) {
 808 |                 var url = window.location.href.replace(/#.*$/, ''),
 809 |                     line = parts[1];
 810 |                 var re = new RegExp(escapeCodeAsRegExpForMatchingInsideHTML(lines[i + 1]));
 811 |                 source = findSourceInUrls(re, [url]);
 812 |                 item = {
 813 |                     'url': url,
 814 |                     'line': source ? source.line : line,
 815 |                     'func': ''
 816 |                 };
 817 |             }
 818 | 
 819 |             if (item) {
 820 |                 if (!item.func) {
 821 |                     item.func = guessFunctionName(item.url, item.line);
 822 |                 }
 823 |                 var context = gatherContext(item.url, item.line);
 824 |                 var midline = (context ? context[Math.floor(context.length / 2)] : null);
 825 |                 if (context && midline.replace(/^\s*/, '') === lines[i + 1].replace(/^\s*/, '')) {
 826 |                     item.context = context;
 827 |                 } else {
 828 |                     // if (context) alert("Context mismatch. Correct midline:\n" + lines[i+1] + "\n\nMidline:\n" + midline + "\n\nContext:\n" + context.join("\n") + "\n\nURL:\n" + item.url);
 829 |                     item.context = [lines[i + 1]];
 830 |                 }
 831 |                 stack.push(item);
 832 |             }
 833 |         }
 834 |         if (!stack.length) {
 835 |             return null; // could not parse multiline exception message as Opera stack trace
 836 |         }
 837 | 
 838 |         return {
 839 |             'mode': 'multiline',
 840 |             'name': ex.name,
 841 |             'message': lines[0],
 842 |             'url': document.location.href,
 843 |             'stack': stack,
 844 |             'useragent': navigator.userAgent
 845 |         };
 846 |     }
 847 | 
 848 |     /**
 849 |      * Adds information about the first frame to incomplete stack traces.
 850 |      * Safari and IE require this to get complete data on the first frame.
 851 |      * @param {Object.<string, *>} stackInfo Stack trace information from
 852 |      * one of the compute* methods.
 853 |      * @param {string} url The URL of the script that caused an error.
 854 |      * @param {(number|string)} lineNo The line number of the script that
 855 |      * caused an error.
 856 |      * @param {string=} message The error generated by the browser, which
 857 |      * hopefully contains the name of the object that caused the error.
 858 |      * @return {boolean} Whether or not the stack information was
 859 |      * augmented.
 860 |      */
 861 |     function augmentStackTraceWithInitialElement(stackInfo, url, lineNo, message) {
 862 |         var initial = {
 863 |             'url': url,
 864 |             'line': lineNo
 865 |         };
 866 | 
 867 |         if (initial.url && initial.line) {
 868 |             stackInfo.incomplete = false;
 869 | 
 870 |             if (!initial.func) {
 871 |                 initial.func = guessFunctionName(initial.url, initial.line);
 872 |             }
 873 | 
 874 |             if (!initial.context) {
 875 |                 initial.context = gatherContext(initial.url, initial.line);
 876 |             }
 877 | 
 878 |             var reference = / '([^']+)' /.exec(message);
 879 |             if (reference) {
 880 |                 initial.column = findSourceInLine(reference[1], initial.url, initial.line);
 881 |             }
 882 | 
 883 |             if (stackInfo.stack.length > 0) {
 884 |                 if (stackInfo.stack[0].url === initial.url) {
 885 |                     if (stackInfo.stack[0].line === initial.line) {
 886 |                         return false; // already in stack trace
 887 |                     } else if (!stackInfo.stack[0].line && stackInfo.stack[0].func === initial.func) {
 888 |                         stackInfo.stack[0].line = initial.line;
 889 |                         stackInfo.stack[0].context = initial.context;
 890 |                         return false;
 891 |                     }
 892 |                 }
 893 |             }
 894 | 
 895 |             stackInfo.stack.unshift(initial);
 896 |             stackInfo.partial = true;
 897 |             return true;
 898 |         } else {
 899 |             stackInfo.incomplete = true;
 900 |         }
 901 | 
 902 |         return false;
 903 |     }
 904 | 
 905 |     /**
 906 |      * Computes stack trace information by walking the arguments.caller
 907 |      * chain at the time the exception occurred. This will cause earlier
 908 |      * frames to be missed but is the only way to get any stack trace in
 909 |      * Safari and IE. The top frame is restored by
 910 |      * {@link augmentStackTraceWithInitialElement}.
 911 |      * @param {Error} ex
 912 |      * @return {?Object.<string, *>} Stack trace information.
 913 |      */
 914 |     function computeStackTraceByWalkingCallerChain(ex, depth) {
 915 |         var functionName = /function\s+([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)?\s*\(/i,
 916 |             stack = [],
 917 |             funcs = {},
 918 |             recursion = false,
 919 |             parts,
 920 |             item,
 921 |             source;
 922 | 
 923 |         for (var curr = computeStackTraceByWalkingCallerChain.caller; curr && !recursion; curr = curr.caller) {
 924 |             if (curr === computeStackTrace || curr === TraceKit.report) {
 925 |                 // console.log('skipping internal function');
 926 |                 continue;
 927 |             }
 928 | 
 929 |             item = {
 930 |                 'url': null,
 931 |                 'func': UNKNOWN_FUNCTION,
 932 |                 'line': null,
 933 |                 'column': null
 934 |             };
 935 | 
 936 |             if (curr.name) {
 937 |                 item.func = curr.name;
 938 |             } else if ((parts = functionName.exec(curr.toString()))) {
 939 |                 item.func = parts[1];
 940 |             }
 941 | 
 942 |             if ((source = findSourceByFunctionBody(curr))) {
 943 |                 item.url = source.url;
 944 |                 item.line = source.line;
 945 | 
 946 |                 if (item.func === UNKNOWN_FUNCTION) {
 947 |                     item.func = guessFunctionName(item.url, item.line);
 948 |                 }
 949 | 
 950 |                 var reference = / '([^']+)' /.exec(ex.message || ex.description);
 951 |                 if (reference) {
 952 |                     item.column = findSourceInLine(reference[1], source.url, source.line);
 953 |                 }
 954 |             }
 955 | 
 956 |             if (funcs['' + curr]) {
 957 |                 recursion = true;
 958 |             }else{
 959 |                 funcs['' + curr] = true;
 960 |             }
 961 | 
 962 |             stack.push(item);
 963 |         }
 964 | 
 965 |         if (depth) {
 966 |             // console.log('depth is ' + depth);
 967 |             // console.log('stack is ' + stack.length);
 968 |             stack.splice(0, depth);
 969 |         }
 970 | 
 971 |         var result = {
 972 |             'mode': 'callers',
 973 |             'name': ex.name,
 974 |             'message': ex.message,
 975 |             'url': document.location.href,
 976 |             'stack': stack,
 977 |             'useragent': navigator.userAgent
 978 |         };
 979 |         augmentStackTraceWithInitialElement(result, ex.sourceURL || ex.fileName, ex.line || ex.lineNumber, ex.message || ex.description);
 980 |         return result;
 981 |     }
 982 | 
 983 |     /**
 984 |      * Computes a stack trace for an exception.
 985 |      * @param {Error} ex
 986 |      * @param {(string|number)=} depth
 987 |      */
 988 |     function computeStackTrace(ex, depth) {
 989 |         var stack = null;
 990 |         depth = (depth == null ? 0 : +depth);
 991 | 
 992 |         try {
 993 |             // This must be tried first because Opera 10 *destroys*
 994 |             // its stacktrace property if you try to access the stack
 995 |             // property first!!
 996 |             stack = computeStackTraceFromStacktraceProp(ex);
 997 |             if (stack) {
 998 |                 return stack;
 999 |             }
1000 |         } catch (e) {
1001 |             if (debug) {
1002 |                 throw e;
1003 |             }
1004 |         }
1005 | 
1006 |         try {
1007 |             stack = computeStackTraceFromStackProp(ex);
1008 |             if (stack) {
1009 |                 return stack;
1010 |             }
1011 |         } catch (e) {
1012 |             if (debug) {
1013 |                 throw e;
1014 |             }
1015 |         }
1016 | 
1017 |         try {
1018 |             stack = computeStackTraceFromOperaMultiLineMessage(ex);
1019 |             if (stack) {
1020 |                 return stack;
1021 |             }
1022 |         } catch (e) {
1023 |             if (debug) {
1024 |                 throw e;
1025 |             }
1026 |         }
1027 | 
1028 |         try {
1029 |             stack = computeStackTraceByWalkingCallerChain(ex, depth + 1);
1030 |             if (stack) {
1031 |                 return stack;
1032 |             }
1033 |         } catch (e) {
1034 |             if (debug) {
1035 |                 throw e;
1036 |             }
1037 |         }
1038 | 
1039 |         return {
1040 |             'mode': 'failed'
1041 |         };
1042 |     }
1043 | 
1044 |     /**
1045 |      * Logs a stacktrace starting from the previous call and working down.
1046 |      * @param {(number|string)=} depth How many frames deep to trace.
1047 |      * @return {Object.<string, *>} Stack trace information.
1048 |      */
1049 |     function computeStackTraceOfCaller(depth) {
1050 |         depth = (depth == null ? 0 : +depth) + 1; // "+ 1" because "ofCaller" should drop one frame
1051 |         try {
1052 |             throw new Error();
1053 |         } catch (ex) {
1054 |             return computeStackTrace(ex, depth + 1);
1055 |         }
1056 | 
1057 |         return null;
1058 |     }
1059 | 
1060 |     computeStackTrace.augmentStackTraceWithInitialElement = augmentStackTraceWithInitialElement;
1061 |     computeStackTrace.guessFunctionName = guessFunctionName;
1062 |     computeStackTrace.gatherContext = gatherContext;
1063 |     computeStackTrace.ofCaller = computeStackTraceOfCaller;
1064 | 
1065 |     return computeStackTrace;
1066 | }());
1067 | 
1068 | 
1069 | //Default options:
1070 | if (!TraceKit.remoteFetching) {
1071 |   TraceKit.remoteFetching = true;
1072 | }
1073 | if (!TraceKit.collectWindowErrors) {
1074 |   TraceKit.collectWindowErrors = true;
1075 | }
1076 | if (!TraceKit.linesOfContext || TraceKit.linesOfContext < 1) {
1077 |   // 3 lines before, the offending line, 3 lines after
1078 |   TraceKit.linesOfContext = 7;
1079 | }
1080 | 
1081 | 
1082 | 
1083 | // Export to global object
1084 | window.TraceKit = TraceKit;
1085 | 
1086 | }(window));
1087 | 


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