11 | * Copyright 2011 OpenGamma Inc. and the OpenGamma group of companies 12 | * Licensed under the Apache License, Version 2.0 (the "License"); 13 | * you may not use this file except in compliance with the License. 14 | * You may obtain a copy of the License at 15 | * 16 | * http://www.apache.org/licenses/LICENSE-2.0 17 | * 18 | * Unless required by applicable law or agreed to in writing, software 19 | * distributed under the License is distributed on an "AS IS" BASIS, 20 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 21 | * See the License for the specific language governing permissions and 22 | * limitations under the License. 23 | *

{ 144 | * page:'/foo', 145 | * rules:{ 146 | * keyvals:[{name: 'type', required: false}], 147 | * scalars:[{name: 'id', required: true}], 148 | * star:'rest' // false if not defined 149 | * } 150 | * } 151 | * @see RouteMap.add 152 | * @see RouteMap.hash 153 | * @see RouteMap.remove 154 | */ 155 | compile = (function (memo) { // compile is slow so cache compiled objects in a memo 156 | return function (orig) { 157 | var self = 'compile', compiled, index, names = {}, 158 | route = orig[0] === SL ? orig : ~(index = orig.indexOf(SL)) ? orig.slice(index) : 0, 159 | /** @ignore */ 160 | valid_name = function (name) { 161 | if (names[has](name) || (names[name] = 0)) 162 | throw new SyntaxError(self + ': "' + name + '" is repeated in: ' + orig); 163 | }; 164 | if (!route) throw new SyntaxError(self + ': the route ' + orig + ' was not understood'); 165 | if (memo[route]) return memo[route]; 166 | compiled = route.split(SL).reduce(function (acc, val) { 167 | var rules = acc.rules, scalars = rules.scalars, keyvals = rules.keyvals; 168 | if (rules.star) throw new SyntaxError(self + ': no rules can follow a * directive in: ' + orig); 169 | // construct the name of the page 170 | if (!~val.search(token_exp) && !scalars.length && !keyvals.length) return acc.page.push(val), acc; 171 | // construct the parameters 172 | if (val.match(star_exp)) return (rules.star = RegExp.$2 || RegExp.$3), valid_name(rules.star), acc; 173 | if (val.match(scalar_exp)) { 174 | if (acc.has_optional_scalar) // no scalars can follow optional scalars 175 | throw new SyntaxError(self + ': "' + val + '" cannot follow an optional rule in: ' + orig); 176 | if (!!RegExp.$2) acc.has_optional_scalar = val; 177 | return scalars.push({name: RegExp.$1, required: !RegExp.$2}), valid_name(RegExp.$1), acc; 178 | } 179 | if (val.match(keyval_exp)) 180 | return keyvals.push({name: RegExp.$1, required: !RegExp.$2}), valid_name(RegExp.$1), acc; 181 | throw new SyntaxError(self + ': the rule "' + val + '" was not understood in: ' + orig); 182 | }, {page: [], rules: {scalars: [], keyvals: [], star: false}, has_optional_scalar: ''}); 183 | delete compiled.has_optional_scalar; // this is just a temporary value and should not be exposed 184 | compiled.page = compiled.page.join(SL).replace(new RegExp(SL + '$'), '') || SL; 185 | return memo[route] = compiled; 186 | }; 187 | })({}); 188 | pub[namespace] = (routes) = { // parens around routes to satisfy JSDoc's caprice 189 | /** 190 | * adds a rule to the internal table of routes and methods 191 | * @name RouteMap.add 192 | * @function 193 | * @type undefined 194 | * @param {Object} rule rule specification 195 | * @param {String} rule.route route pattern definition; there are three types of pattern arguments: scalars, 196 | * keyvals, and stars; scalars are individual values in a URL (all URL values are separate by the 197 | * '/' character), keyvals are named values, e.g. 'foo=bar', and star values are wildcards; so for 198 | * example, the following pattern represents all the possible options:

199 | * '/foo/:id/:sub?/attr:/subattr:?/rest:*'

the ? means that argument is 200 | * optional, the star rule is named rest but it could have just simply been left as *, 201 | * which means the resultant dictionary would have put the wildcard remainder into args['*'] 202 | * instead of args.rest; so the following URL would match the pattern above:

203 | * /foo/23/45/attr=something/subattr=something_else

204 | * when its method is called, it will receive this arguments dictionary:

205 | * { 206 | * id:'23', 207 | * subid:'45', 208 | * attr:'something', 209 | * subattr:'something_else', 210 | * rest:'' 211 | * }

212 | * add uses {@link #compile} and does not catch any errors thrown by that function 213 | * @param {String} rule.method listener method for this route 214 | * @throws {TypeError} if rule.route or rule.method are not strings or empty strings 215 | * @throws {Error} if rule has already been added 216 | * @see RouteMap.post_add 217 | */ 218 | add: function (rule) { 219 | var self = 'add', method = rule.method, route = rule.route, compiled, id = fingerprint(rule); 220 | if ([route, method].some(invalid_str)) 221 | throw new TypeError(self + ': rule.route and rule.method must both be non-empty strings'); 222 | if (added_routes[id]) throw new Error(self + ': ' + route + ' to ' + method + ' already exists'); 223 | compiled = compile(route); 224 | added_routes[id] = true; 225 | if (!active_routes[compiled.page] && (active_routes[compiled.page] = [])) // add route to list and sort 226 | flat_pages = flat_pages.concat(compiled.page).sort(function (a, b) {return b.length - a.length;}); 227 | active_routes[compiled.page].push(routes.post_add({method: method, rules: compiled.rules, raw: route})); 228 | }, 229 | /** 230 | * overrides the context where listener methods are sought, the default scope is window 231 | * (in a browser setting), returns the current context, if no scope object is passed in, just 232 | * returns current context without setting context 233 | * @name RouteMap.context 234 | * @function 235 | * @type {Object} 236 | * @returns {Object} the current context within which RouteMap searches for handlers 237 | * @param {Object} scope the scope within which methods for mapped routes will be looked for 238 | */ 239 | context: function (scope) {return context = typeof scope === 'object' ? scope : context;}, 240 | /** 241 | * returns the parsed (see {@link #parse}) currently accessed route; after listeners have finished 242 | * firing, current and last are the same 243 | * @name RouteMap.current 244 | * @function 245 | * @type Object 246 | * @returns {Object} the current parsed URL object 247 | * @see RouteMap.last 248 | */ 249 | current: function () {return current ? merge(current) : null;}, 250 | /** 251 | * this function is fired when no rule is matched by a URL, by default it does nothing, but it could be set up 252 | * to handle things like 404 responses on the server-side or bad hash fragments in the browser 253 | * @name RouteMap.default_handler 254 | * @function 255 | * @type undefined 256 | */ 257 | default_handler: function () {}, 258 | /** 259 | * URL grabber function, defaults to checking the URL fragment (hash); this function should be 260 | * overwritten in a server-side environment; this method is called by {@link RouteMap.handler}; without 261 | * window.location.hash it will return '/' 262 | * @name RouteMap.get 263 | * @function 264 | * @returns {String} by default, this returns a subset of the URL hash (everything after the first 265 | * '/' character ... if nothing follows a slash, it returns '/'); if overwritten, it 266 | * must be a function that returns URL path strings (beginning with '/') to match added rules 267 | * @type String 268 | */ 269 | get: function () { 270 | if (typeof window === 'undefined') return SL; 271 | var hash = window.location.hash, index = hash.indexOf(SL); 272 | return ~index ? hash.slice(index) : SL; 273 | }, 274 | /** 275 | * in a browser setting, it changes window.location.hash, in other settings, it should be 276 | * overwritten to do something useful (if necessary); it will not throw an error if window does 277 | * not exist 278 | * @name RouteMap.go 279 | * @function 280 | * @type undefined 281 | * @param {String} hash the hash fragment to go to 282 | */ 283 | go: function (hash) { 284 | if (typeof window !== 'undefined') window.location.hash = (hash.indexOf(PR) === 0 ? '' : PR) + hash; 285 | }, 286 | /** 287 | * main handler function for routing, this should be bound to hashchange events in the browser, or 288 | * (in conjunction with updating {@link RouteMap.get}) used with the HTML5 history API, it detects 289 | * all the matching route patterns, parses the URL parameters and fires their methods with the arguments from 290 | * the parsed URL; the timing of {@link RouteMap.current} and {@link RouteMap.last} being set is as follows 291 | * (pseudo-code): 292 | *

293 |          * path: get_route             // {@link RouteMap.get}
294 |          * parsed: parse path          // {@link #parse}
295 |          * current: longest parsed     // {@link RouteMap.current}
296 |          * parsed: pre_dispatch parsed // {@link RouteMap.pre_dispatch}
297 |          * current: longest parsed     // reset current
298 |          * fire matched rules in parsed
299 |          * last: current               // {@link RouteMap.last}
300 |          *

301 | * RouteMap.handler calls {@link #parse} and does not catch any errors that function throws 302 | * @name RouteMap.handler 303 | * @function 304 | * @type undefined 305 | * @see RouteMap.pre_dispatch 306 | */ 307 | handler: function () { 308 | var url = routes.get(), parsed = parse(url), args = Array.prototype.slice.call(arguments); 309 | if (!parsed.length) return routes.default_handler.apply(null, [url].concat(args)); 310 | current = parsed[0]; // set current to the longest hash before pre_dispatch touches it 311 | parsed = routes.pre_dispatch(parsed); // pre_dispatch might change the contents of parsed 312 | current = parsed[0]; // set current to the longest hash again after pre_dispatch 313 | parsed.forEach(function (val) {val.method.apply(null, [val.args].concat(args));}); // fire requested methods 314 | last = parsed[0]; 315 | }, 316 | /** 317 | * returns a URL fragment by applying parameters to a rule; uses {@link #compile} and does not catch any errors 318 | * thrown by that function 319 | * @name RouteMap.hash 320 | * @function 321 | * @type String 322 | * @param {Object} rule the rule specification; it typically looks like:

323 | * {route:'/foo', method:'bar'}

but only route is strictly necessary 324 | * @param {Object} params a dictionary of argument key/value pairs required by the rule 325 | * @returns {String} URL fragment resulting from applying arguments to rule pattern 326 | * @throws {TypeError} if a required parameter is not present 327 | */ 328 | hash: function (rule, params) { 329 | var self = 'hash', hash, compiled, params = params || {}; 330 | if (invalid_str(rule.route)) throw new TypeError(self + ': rule.route must be a non-empty string'); 331 | compiled = compile(rule.route); 332 | hash = compiled.page + (compiled.page === SL ? '' : SL) + // 1. start with page, then add params 333 | compiled.rules.scalars.map(function (val) { // 2. add scalar values next 334 | var value = encode(params[val.name]), bad_param = params[val.name] === void 0 || invalid_str(value); 335 | if (val.required && bad_param) 336 | throw new TypeError(self + ': params.' + val.name + ' is undefined, route: ' + rule.route); 337 | return bad_param ? 0 : value; 338 | }) 339 | .concat(compiled.rules.keyvals.map(function (val) { // 3. then concat keyval values 340 | var value = encode(params[val.name]), bad_param = params[val.name] === void 0 || invalid_str(value); 341 | if (val.required && bad_param) 342 | throw new TypeError(self + ': params.' + val.name + ' is undefined, route: ' + rule.route); 343 | return bad_param ? 0 : val.name + EQ + value; 344 | })) 345 | .filter(Boolean).join(SL); // remove empty (0) values 346 | if (compiled.rules.star && params[compiled.rules.star]) // 4. add star value if it exists 347 | hash += (hash[hash.length - 1] === SL ? '' : SL) + params[compiled.rules.star]; 348 | return hash; 349 | }, 350 | /** 351 | * returns the parsed (see {@link #parse}) last accessed route; when route listeners are being called, 352 | * last is the previously accessed route, after listeners have finished firing, the current parsed 353 | * route replaces last's value 354 | * @name RouteMap.last 355 | * @function 356 | * @type Object 357 | * @returns {Object} the last parsed URL object, will be null on first load 358 | * @see RouteMap.current 359 | */ 360 | last: function () {return last ? merge(last) : null;}, 361 | /** 362 | * parses a URL fragment into a data structure only if there is a route whose pattern matches the fragment 363 | * @name RouteMap.parse 364 | * @function 365 | * @type Object 366 | * @returns {Object} of the form:

{page:'/foo', args:{bar:'some_value'}}

367 | * only if a rule with the route: '/foo/:bar' has already been added 368 | * @throws {TypeError} if hash is not a string, is empty, or does not contain a '/' character 369 | * @throws {SyntaxError} if hash cannot be parsed by {@link #parse} 370 | */ 371 | parse: function (hash) { 372 | var self = 'parse', parsed, index = hash.indexOf(SL); 373 | hash = ~index ? hash.slice(index) : ''; 374 | if (invalid_str(hash)) throw new TypeError(self + ': hash must be a string with a ' + SL + ' character'); 375 | if (!(parsed = parse(hash)).length) throw new SyntaxError(self + ': ' + hash + ' cannot be parsed'); 376 | return {page: parsed[0].page, args: parsed[0].args}; 377 | }, 378 | /** 379 | * this function is called by {@link RouteMap.add}, it receives a compiled rule object, e.g. for the rule: 380 | *

{route:'/foo/:id/:sub?/attr:/subattr:?/rest:*', method:'console.log'}

381 | * post_add would receive the following object: 382 | *

{ 383 | * method:'console.log', 384 | * rules:{ 385 | * scalars:[{name:'id',required:true},{name:'sub',required:false}], 386 | * keyvals:[{name:'attr',required:true},{name:'subattr',required:false}], 387 | * star:'rest' 388 | * }, 389 | * raw:'/foo/:id/:sub?/attr:/subattr:?/rest:*' 390 | * }

391 | * and it is expected to pass back an object of the same format; it can be overwritten to post-process added 392 | * rules e.g. to add extra default application-wide parameters; by default, it simply returns what was passed 393 | * into it 394 | * @name RouteMap.post_add 395 | * @function 396 | * @type Object 397 | * @returns {Object} the default function returns the exact object it received; a custom function needs to 398 | * an object that is of the same form (but could possibly have more or fewer parameters, etc.) 399 | * @param {Object} compiled the compiled rule 400 | */ 401 | post_add: function (compiled) {return compiled;}, 402 | /** 403 | * like {@link RouteMap.post_add} this function can be overwritten to add application-specific code into 404 | * route mapping, it is called before a route begins being dispatched to all matching rules; it receives the 405 | * list of matching parsed route objects ({@link #parse}) and is expected to return it; one application of this 406 | * function might be to set application-wide variables like debug flags 407 | * @name RouteMap.pre_dispatch 408 | * @function 409 | * @type Array 410 | * @returns {Array} a list of the same form as the one it receives 411 | * @param {Array} parsed the parsed request 412 | */ 413 | pre_dispatch: function (parsed) {return parsed;}, 414 | /** 415 | * if a string is passed in, it overwrites the prefix that is removed from each URL before parsing; primarily 416 | * used for hashbang (#!); either way, it returns the current prefix 417 | * @name RouteMap.prefix 418 | * @function 419 | * @type undefined 420 | * @param {String} prefix (optional) the prefix string 421 | */ 422 | prefix: function (prefix) {return PR = typeof prefix !== 'undefined' ? prefix + '' : PR;}, 423 | /** 424 | * counterpart to {@link RouteMap.add}, removes a rule specification; * remove uses 425 | * {@link #compile} and does not catch any errors thrown by that function 426 | * @name RouteMap.remove 427 | * @function 428 | * @type undefined 429 | * @param {Object} rule the rule specification that was used in {@link RouteMap.add} 430 | * @throws {TypeError} if rule.route or rule.method are not strings or empty strings 431 | */ 432 | remove: function (rule) { 433 | var self = 'remove', method = rule.method, route = rule.route, compiled, id = fingerprint(rule), index; 434 | if ([route, method].some(invalid_str)) 435 | throw new TypeError(self + ': rule.route and rule.method must both be non-empty strings'); 436 | if (!added_routes[id]) return; 437 | compiled = compile(route); 438 | delete added_routes[id]; 439 | active_routes[compiled.page] = active_routes[compiled.page] 440 | .filter(function (rule) {return (rule.raw !== route) || (rule.method !== method);}); 441 | if (!active_routes[compiled.page].length && (delete active_routes[compiled.page])) // delete active route 442 | if (~(index = flat_pages.indexOf(compiled.page))) flat_pages.splice(index, 1); // then flat page 443 | } 444 | }; 445 | })(typeof exports === 'undefined' ? window : exports, 'RouteMap'); -------------------------------------------------------------------------------- /docs/index.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | 7 | 8 | JsDoc Reference - RouteMap 9 | 10 | 174 | 175 | 176 | 177 | 178 | 179 | 181 | 182 | 183 | 184 |

185 | 186 |

187 | 188 | Namespace RouteMap 189 |

190 | 191 | 192 |

193 | 194 | 195 | 196 | RouteMap 197 | 198 | 199 |
Defined in: routemap.js. 200 | 201 |

202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | 210 | 211 | 212 | 213 | 214 | 215 | 216 | 223 | 224 | 225 |

Namespace Summary
Constructor Attributes	Constructor Name and Description
	217 \| 218 \| RouteMap 219 \| 220 \| RouteMap holds an internal table of route patterns and method names in addition to some 221 \| adding/removing/utility methods and a handler for request routing. 222 \|

226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239 | 240 | 241 | 242 | 243 | 244 | 245 | 246 | 247 | 252 | 253 | 254 | 255 | 256 | 261 | 262 | 263 | 264 | 265 | 272 | 273 | 274 | 275 | 276 | 282 | 283 | 284 | 285 | 286 | 292 | 293 | 294 | 295 | 296 | 303 | 304 | 305 | 306 | 307 | 314 | 315 | 316 | 317 | 318 | 337 | 338 | 339 | 340 | 341 | 347 | 348 | 349 | 350 | 351 | 358 | 359 | 360 | 361 | 362 | 367 | 368 | 369 | 370 | 371 | 376 | 377 | 378 | 379 | 380 | 385 | 386 | 387 | 388 | 389 | 394 | 395 | 396 | 397 | 398 | 406 | 407 | 408 | 409 | 410 | 416 | 417 | 418 | 419 | 420 | 426 | 427 | 428 | 429 |

Method Summary
Method Attributes	Method Name and Description
<static>	248 \| RouteMap.add(rule) 249 \| 250 \| adds a rule to the internal table of routes and methods 251 \|
<private>	257 \| compile(route) 258 \| 259 \| builds the internal representation of a rule based on the route definition 260 \|
<static>	266 \| RouteMap.context(scope) 267 \| 268 \| overrides the context where listener methods are sought, the default scope is `window` 269 \| (in a browser setting), returns the current context, if no `scope` object is passed in, just 270 \| returns current context without setting context 271 \|
<static>	277 \| RouteMap.current() 278 \| 279 \| returns the parsed (see #parse) currently accessed route; after listeners have finished 280 \| firing, `current` and `last` are the same 281 \|
<static>	287 \| RouteMap.default_handler() 288 \| 289 \| this function is fired when no rule is matched by a URL, by default it does nothing, but it could be set up 290 \| to handle things like `404` responses on the server-side or bad hash fragments in the browser 291 \|
<static>	297 \| RouteMap.get() 298 \| 299 \| URL grabber function, defaults to checking the URL fragment (`hash`); this function should be 300 \| overwritten in a server-side environment; this method is called by RouteMap.handler; without 301 \| `window.location.hash` it will return `'/'` 302 \|
<static>	308 \| RouteMap.go(hash) 309 \| 310 \| in a browser setting, it changes `window.location.hash`, in other settings, it should be 311 \| overwritten to do something useful (if necessary); it will not throw an error if `window` does 312 \| not exist 313 \|
<static>	319 \| RouteMap.handler() 320 \| 321 \| main handler function for routing, this should be bound to `hashchange` events in the browser, or 322 \| (in conjunction with updating RouteMap.get) used with the HTML5 `history` API, it detects 323 \| all the matching route patterns, parses the URL parameters and fires their methods with the arguments from 324 \| the parsed URL; the timing of RouteMap.current and RouteMap.last being set is as follows 325 \| (pseudo-code): 326 \| 327 \| path: get_route // RouteMap.get 328 \| parsed: parse path // #parse 329 \| current: longest parsed // RouteMap.current 330 \| parsed: pre_dispatch parsed // RouteMap.pre_dispatch 331 \| current: longest parsed // reset current 332 \| fire matched rules in parsed 333 \| last: current // RouteMap.last 334 \| 335 \| `RouteMap.handler` calls #parse and does not catch any errors that function throws 336 \|
<static>	342 \| RouteMap.hash(rule, params) 343 \| 344 \| returns a URL fragment by applying parameters to a rule; uses #compile and does not catch any errors 345 \| thrown by that function 346 \|
<static>	352 \| RouteMap.last() 353 \| 354 \| returns the parsed (see #parse) last accessed route; when route listeners are being called, 355 \| `last` is the previously accessed route, after listeners have finished firing, the current parsed 356 \| route replaces `last`'s value 357 \|
<private>	363 \| merge() 364 \| 365 \| merges one or more objects into a new object by value (nothing is a reference), useful for cloning 366 \|
<static>	372 \| RouteMap.parse() 373 \| 374 \| parses a URL fragment into a data structure only if there is a route whose pattern matches the fragment 375 \|
<private>	381 \| parse(path) 382 \| 383 \| parses a path and returns a list of objects that contain argument dictionaries, methods, and raw hash values 384 \|
<static>	390 \| RouteMap.post_add(compiled) 391 \| 392 \| this function is called by RouteMap.add, it receives a compiled rule object, e.g. 393 \|
<static>	399 \| RouteMap.pre_dispatch(parsed) 400 \| 401 \| like RouteMap.post_add this function can be overwritten to add application-specific code into 402 \| route mapping, it is called before a route begins being dispatched to all matching rules; it receives the 403 \| list of matching parsed route objects (#parse) and is expected to return it; one application of this 404 \| function might be to set application-wide variables like debug flags 405 \|
<static>	411 \| RouteMap.prefix(prefix) 412 \| 413 \| if a string is passed in, it overwrites the prefix that is removed from each URL before parsing; primarily 414 \| used for hashbang (`#!`); either way, it returns the current prefix 415 \|
<static>	421 \| RouteMap.remove(rule) 422 \| 423 \| counterpart to RouteMap.add, removes a rule specification; * `remove` uses 424 \| #compile and does not catch any errors thrown by that function 425 \|

430 | 431 | 432 | 433 | 434 | 435 | 436 | 437 | 438 | 439 |

440 |

441 | Namespace Detail 442 |

443 | 444 |

445 | RouteMap 446 |

447 | 448 |

449 |

RouteMap holds an internal table of route patterns and method names in addition to some 450 | adding/removing/utility methods and a handler for request routing.

451 |

It does not have any dependencies and is written in "plain old" JS, but it does require JS 1.8 array methods, so 452 | if the environment it will run in does not have those, the reference implementations from 453 | Mozilla should be 454 | supplied external to this library.

455 |

It is designed to be used in both a browser setting and a server-side context (for example in node.js).

456 | LICENSING INFORMATION: 457 |

 458 | Copyright 2011 OpenGamma Inc. and the OpenGamma group of companies
 459 | Licensed under the Apache License, Version 2.0 (the "License");
 460 | you may not use this file except in compliance with the License.
 461 | You may obtain a copy of the License at
 462 | 
 463 |     http://www.apache.org/licenses/LICENSE-2.0
 464 | 
 465 | Unless required by applicable law or agreed to in writing, software
 466 | distributed under the License is distributed on an "AS IS" BASIS,
 467 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 468 | See the License for the specific language governing permissions and
 469 | limitations under the License.
 470 |

471 |
Author: Afshin Darian. 472 |

473 | 474 | 475 | 476 | 477 | 478 | 479 | 480 | 481 |

Throws:
485 | {Error} 486 |: if JS 1.8 Array.prototype methods don't exist

490 | 491 | 492 | 493 | 494 |

See:: OpenGamma; Apache License, Version 2.0; Mozilla Developer 502 | Network

505 | 506 | 507 |

508 | 509 | 510 | 511 | 512 | 513 | 514 | 515 |

516 | Method Detail 517 |

518 | 519 | 520 |

<static> 521 | 522 | {undefined} 523 | RouteMap.add(rule) 524 | 525 |

526 |

527 | adds a rule to the internal table of routes and methods 528 | 529 | 530 |

531 | 532 | 533 | 534 | 535 |

Parameters:

539 | {Object} rule 540 | 541 |

rule specification

545 | {String} rule.route 546 | 547 |

route pattern definition; there are three types of pattern arguments: scalars, 549 | keyvals, and stars; scalars are individual values in a URL (all URL values are separate by the 550 | '/' character), keyvals are named values, e.g. 'foo=bar', and star values are wildcards; so for 551 | example, the following pattern represents all the possible options:

552 | '/foo/:id/:sub?/attr:/subattr:?/rest:*'

the ? means that argument is 553 | optional, the star rule is named rest but it could have just simply been left as *, 554 | which means the resultant dictionary would have put the wildcard remainder into args['*'] 555 | instead of args.rest; so the following URL would match the pattern above:

556 | /foo/23/45/attr=something/subattr=something_else

557 | when its method is called, it will receive this arguments dictionary:

558 | { 559 | id:'23', 560 | subid:'45', 561 | attr:'something', 562 | subattr:'something_else', 563 | rest:'' 564 | }

565 | add uses #compile and does not catch any errors thrown by that function

568 | {String} rule.method 569 | 570 |

listener method for this route

574 | 575 | 576 | 577 | 578 |

Throws:
582 | {TypeError} 583 |: if rule.route or rule.method are not strings or empty strings
587 | {Error} 588 |: if rule has already been added

592 | 593 | 594 | 595 | 596 |

See:: RouteMap.post_add

602 | 603 | 604 |

605 | 606 | 607 |

<private> 608 | 609 | 610 | compile(route) 611 | 612 |

613 |

614 | builds the internal representation of a rule based on the route definition 615 | 616 | 617 |

618 | 619 | 620 | 621 | 622 |

Parameters:
626 | {String} route 627 | 628 |

632 | 633 | 634 | 635 | 636 |

Throws:
640 | {SyntaxError} 641 |: if any portion of a rule definition follows a * directive
645 | {SyntaxError} 646 |: if a required scalar follows an optional scalar
650 | {SyntaxError} 651 |: if a rule cannot be parsed

655 | 656 | 657 |

Returns:

{Object} a compiled object, for example, the rule '/foo/:id/type:?/rest:*' would return 661 | an object of the form:

{
 662 |     page:'/foo',
 663 |     rules:{
 664 |         keyvals:[{name: 'type', required: false}],
 665 |         scalars:[{name: 'id', required: true}],
 666 |         star:'rest' // false if not defined
 667 |     }
 668 | }

671 | 672 | 673 | 674 |

See:: RouteMap.add; RouteMap.hash; RouteMap.remove

684 | 685 | 686 |

687 | 688 | 689 |

<static> 690 | 691 | 692 | RouteMap.context(scope) 693 | 694 |

695 |

696 | overrides the context where listener methods are sought, the default scope is window 697 | (in a browser setting), returns the current context, if no scope object is passed in, just 698 | returns current context without setting context 699 | 700 | 701 |

702 | 703 | 704 | 705 | 706 |

Parameters:
710 | {Object} scope 711 | 712 |: the scope within which methods for mapped routes will be looked for

716 | 717 | 718 | 719 | 720 | 721 |

Returns:: {Object} the current context within which RouteMap searches for handlers

727 | 728 | 729 | 730 | 731 |

732 | 733 | 734 |

<static> 735 | 736 | {Object} 737 | RouteMap.current() 738 | 739 |

740 |

741 | returns the parsed (see #parse) currently accessed route; after listeners have finished 742 | firing, current and last are the same 743 | 744 | 745 |

746 | 747 | 748 | 749 | 750 | 751 | 752 | 753 | 754 |

Returns:: {Object} the current parsed URL object

760 | 761 | 762 | 763 |

See:: RouteMap.last

769 | 770 | 771 |

772 | 773 | 774 |

<static> 775 | 776 | {undefined} 777 | RouteMap.default_handler() 778 | 779 |

780 |

781 | this function is fired when no rule is matched by a URL, by default it does nothing, but it could be set up 782 | to handle things like 404 responses on the server-side or bad hash fragments in the browser 783 | 784 | 785 |

786 | 787 | 788 | 789 | 790 | 791 | 792 | 793 | 794 | 795 | 796 | 797 |

798 | 799 | 800 |

<static> 801 | 802 | {String} 803 | RouteMap.get() 804 | 805 |

806 |

807 | URL grabber function, defaults to checking the URL fragment (hash); this function should be 808 | overwritten in a server-side environment; this method is called by RouteMap.handler; without 809 | window.location.hash it will return '/' 810 | 811 | 812 |

813 | 814 | 815 | 816 | 817 | 818 | 819 | 820 | 821 |

Returns:: {String} by default, this returns a subset of the URL hash (everything after the first 825 | '/' character ... if nothing follows a slash, it returns '/'); if overwritten, it 826 | must be a function that returns URL path strings (beginning with '/') to match added rules

829 | 830 | 831 | 832 | 833 |

834 | 835 | 836 |

<static> 837 | 838 | {undefined} 839 | RouteMap.go(hash) 840 | 841 |

842 |

843 | in a browser setting, it changes window.location.hash, in other settings, it should be 844 | overwritten to do something useful (if necessary); it will not throw an error if window does 845 | not exist 846 | 847 | 848 |

849 | 850 | 851 | 852 | 853 |

Parameters:
857 | {String} hash 858 | 859 |: the hash fragment to go to

863 | 864 | 865 | 866 | 867 | 868 | 869 | 870 | 871 |

872 | 873 | 874 |

<static> 875 | 876 | {undefined} 877 | RouteMap.handler() 878 | 879 |

880 |

881 | main handler function for routing, this should be bound to hashchange events in the browser, or 882 | (in conjunction with updating RouteMap.get) used with the HTML5 history API, it detects 883 | all the matching route patterns, parses the URL parameters and fires their methods with the arguments from 884 | the parsed URL; the timing of RouteMap.current and RouteMap.last being set is as follows 885 | (pseudo-code): 886 |

 887 | path: get_route             // RouteMap.get
 888 | parsed: parse path          // #parse
 889 | current: longest parsed     // RouteMap.current
 890 | parsed: pre_dispatch parsed // RouteMap.pre_dispatch
 891 | current: longest parsed     // reset current
 892 | fire matched rules in parsed
 893 | last: current               // RouteMap.last
 894 |

895 | RouteMap.handler calls #parse and does not catch any errors that function throws 896 | 897 | 898 |

899 | 900 | 901 | 902 | 903 | 904 | 905 | 906 | 907 | 908 | 909 |

See:: RouteMap.pre_dispatch

915 | 916 | 917 |

918 | 919 | 920 |

<static> 921 | 922 | {String} 923 | RouteMap.hash(rule, params) 924 | 925 |

926 |

927 | returns a URL fragment by applying parameters to a rule; uses #compile and does not catch any errors 928 | thrown by that function 929 | 930 | 931 |

932 | 933 | 934 | 935 | 936 |

Parameters:
940 | {Object} rule 941 | 942 |: the rule specification; it typically looks like:
944 | {route:'/foo', method:'bar'}
but only route is strictly necessary
947 | {Object} params 948 | 949 |: a dictionary of argument key/value pairs required by the rule

953 | 954 | 955 | 956 | 957 |

Throws:
961 | {TypeError} 962 |: if a required parameter is not present

966 | 967 | 968 |

Returns:: {String} URL fragment resulting from applying arguments to rule pattern

974 | 975 | 976 | 977 | 978 |

979 | 980 | 981 |

<static> 982 | 983 | {Object} 984 | RouteMap.last() 985 | 986 |

987 |

988 | returns the parsed (see #parse) last accessed route; when route listeners are being called, 989 | last is the previously accessed route, after listeners have finished firing, the current parsed 990 | route replaces last's value 991 | 992 | 993 |

994 | 995 | 996 | 997 | 998 | 999 | 1000 | 1001 | 1002 |

Returns:: {Object} the last parsed URL object, will be null on first load

1008 | 1009 | 1010 | 1011 |

See:: RouteMap.current

1017 | 1018 | 1019 |

1020 | 1021 | 1022 |

<private> 1023 | 1024 | {Object} 1025 | merge() 1026 | 1027 |

1028 |

1029 | merges one or more objects into a new object by value (nothing is a reference), useful for cloning 1030 | 1031 | 1032 |

1033 | 1034 | 1035 | 1036 | 1037 | 1038 | 1039 | 1040 |

Throws:
1044 | {TypeError} 1045 |: if one of the arguments is not a mergeable object (i.e. a primitive, null or array)

1049 | 1050 | 1051 |

Returns:: {Object} a merged object

1057 | 1058 | 1059 | 1060 | 1061 |

1062 | 1063 | 1064 |

<static> 1065 | 1066 | {Object} 1067 | RouteMap.parse() 1068 | 1069 |

1070 |

1071 | parses a URL fragment into a data structure only if there is a route whose pattern matches the fragment 1072 | 1073 | 1074 |

1075 | 1076 | 1077 | 1078 | 1079 | 1080 | 1081 | 1082 |

Throws:
1086 | {TypeError} 1087 |: if hash is not a string, is empty, or does not contain a '/' character
1091 | {SyntaxError} 1092 |: if hash cannot be parsed by #parse

1096 | 1097 | 1098 |

Returns:: {Object} of the form:
{page:'/foo', args:{bar:'some_value'}}
1102 | only if a rule with the route: '/foo/:bar' has already been added

1105 | 1106 | 1107 | 1108 | 1109 |

1110 | 1111 | 1112 |

<private> 1113 | 1114 | {Array} 1115 | parse(path) 1116 | 1117 |

1118 |

1119 | parses a path and returns a list of objects that contain argument dictionaries, methods, and raw hash values 1120 | 1121 | 1122 |

1123 | 1124 | 1125 | 1126 | 1127 |

Parameters:
1131 | {String} path 1132 | 1133 |

1137 | 1138 | 1139 | 1140 | 1141 |

Throws:
1145 | {TypeError} 1146 |: if the method specified by a rule specification does not exist during parse time

1150 | 1151 | 1152 |

Returns:: {Array} a list of parsed objects in descending order of matched hash length

1158 | 1159 | 1160 | 1161 | 1162 |

1163 | 1164 | 1165 |

<static> 1166 | 1167 | {Object} 1168 | RouteMap.post_add(compiled) 1169 | 1170 |

1171 |

1172 | this function is called by RouteMap.add, it receives a compiled rule object, e.g. for the rule: 1173 |

{route:'/foo/:id/:sub?/attr:/subattr:?/rest:*', method:'console.log'}

1174 | post_add would receive the following object: 1175 |

{ 1176 | method:'console.log', 1177 | rules:{ 1178 | scalars:[{name:'id',required:true},{name:'sub',required:false}], 1179 | keyvals:[{name:'attr',required:true},{name:'subattr',required:false}], 1180 | star:'rest' 1181 | }, 1182 | raw:'/foo/:id/:sub?/attr:/subattr:?/rest:*' 1183 | }

1184 | and it is expected to pass back an object of the same format; it can be overwritten to post-process added 1185 | rules e.g. to add extra default application-wide parameters; by default, it simply returns what was passed 1186 | into it 1187 | 1188 | 1189 |

1190 | 1191 | 1192 | 1193 | 1194 |

Parameters:
1198 | {Object} compiled 1199 | 1200 |: the compiled rule

1204 | 1205 | 1206 | 1207 | 1208 | 1209 |

Returns:: {Object} the default function returns the exact object it received; a custom function needs to 1213 | an object that is of the same form (but could possibly have more or fewer parameters, etc.)

1216 | 1217 | 1218 | 1219 | 1220 |

1221 | 1222 | 1223 |

<static> 1224 | 1225 | {Array} 1226 | RouteMap.pre_dispatch(parsed) 1227 | 1228 |

1229 |

1230 | like RouteMap.post_add this function can be overwritten to add application-specific code into 1231 | route mapping, it is called before a route begins being dispatched to all matching rules; it receives the 1232 | list of matching parsed route objects (#parse) and is expected to return it; one application of this 1233 | function might be to set application-wide variables like debug flags 1234 | 1235 | 1236 |

1237 | 1238 | 1239 | 1240 | 1241 |

Parameters:
1245 | {Array} parsed 1246 | 1247 |: the parsed request

1251 | 1252 | 1253 | 1254 | 1255 | 1256 |

Returns:: {Array} a list of the same form as the one it receives

1262 | 1263 | 1264 | 1265 | 1266 |

1267 | 1268 | 1269 |

<static> 1270 | 1271 | {undefined} 1272 | RouteMap.prefix(prefix) 1273 | 1274 |

1275 |

1276 | if a string is passed in, it overwrites the prefix that is removed from each URL before parsing; primarily 1277 | used for hashbang (#!); either way, it returns the current prefix 1278 | 1279 | 1280 |

1281 | 1282 | 1283 | 1284 | 1285 |

Parameters:
1289 | {String} prefix 1290 | 1291 |: (optional) the prefix string

1295 | 1296 | 1297 | 1298 | 1299 | 1300 | 1301 | 1302 | 1303 |

1304 | 1305 | 1306 |

<static> 1307 | 1308 | {undefined} 1309 | RouteMap.remove(rule) 1310 | 1311 |

1312 |

1313 | counterpart to RouteMap.add, removes a rule specification; * remove uses 1314 | #compile and does not catch any errors thrown by that function 1315 | 1316 | 1317 |

1318 | 1319 | 1320 | 1321 | 1322 |

Parameters:
1326 | {Object} rule 1327 | 1328 |: the rule specification that was used in RouteMap.add

1332 | 1333 | 1334 | 1335 | 1336 |

Throws:
1340 | {TypeError} 1341 |: if rule.route or rule.method are not strings or empty strings

1345 | 1346 | 1347 | 1348 | 1349 | 1350 | 1351 | 1352 | 1353 | 1354 | 1355 | 1356 | 1357 |

1358 |

1359 | 1360 | 1361 | 1362 |

1363 | 1364 | Documentation generated by JsDoc Toolkit 2.4.0 on Wed Apr 18 2012 13:03:13 GMT+0100 (BST) 1365 |

1366 | 1367 | 1368 | -------------------------------------------------------------------------------- /tests/lib/qunit/qunit.js: -------------------------------------------------------------------------------- 1 | /** 2 | * QUnit - A JavaScript Unit Testing Framework 3 | * 4 | * http://docs.jquery.com/QUnit 5 | * 6 | * Copyright (c) 2011 John Resig, Jörn Zaefferer 7 | * Dual licensed under the MIT (MIT-LICENSE.txt) 8 | * or GPL (GPL-LICENSE.txt) licenses. 9 | * Pulled Live from Git Thu Aug 4 13:45:01 UTC 2011 10 | * Last Commit: 244c198ee73c1992ab005e0ac5f20fdcd50f14d9 11 | */ 12 | 13 | (function(window) { 14 | 15 | var defined = { 16 | setTimeout: typeof window.setTimeout !== "undefined", 17 | sessionStorage: (function() { 18 | try { 19 | return !!sessionStorage.getItem; 20 | } catch(e){ 21 | return false; 22 | } 23 | })() 24 | }; 25 | 26 | var testId = 0; 27 | 28 | var Test = function(name, testName, expected, testEnvironmentArg, async, callback) { 29 | this.name = name; 30 | this.testName = testName; 31 | this.expected = expected; 32 | this.testEnvironmentArg = testEnvironmentArg; 33 | this.async = async; 34 | this.callback = callback; 35 | this.assertions = []; 36 | }; 37 | Test.prototype = { 38 | init: function() { 39 | var tests = id("qunit-tests"); 40 | if (tests) { 41 | var b = document.createElement("strong"); 42 | b.innerHTML = "Running " + this.name; 43 | var li = document.createElement("li"); 44 | li.appendChild( b ); 45 | li.className = "running"; 46 | li.id = this.id = "test-output" + testId++; 47 | tests.appendChild( li ); 48 | } 49 | }, 50 | setup: function() { 51 | if (this.module != config.previousModule) { 52 | if ( config.previousModule ) { 53 | QUnit.moduleDone( { 54 | name: config.previousModule, 55 | failed: config.moduleStats.bad, 56 | passed: config.moduleStats.all - config.moduleStats.bad, 57 | total: config.moduleStats.all 58 | } ); 59 | } 60 | config.previousModule = this.module; 61 | config.moduleStats = { all: 0, bad: 0 }; 62 | QUnit.moduleStart( { 63 | name: this.module 64 | } ); 65 | } 66 | 67 | config.current = this; 68 | this.testEnvironment = extend({ 69 | setup: function() {}, 70 | teardown: function() {} 71 | }, this.moduleTestEnvironment); 72 | if (this.testEnvironmentArg) { 73 | extend(this.testEnvironment, this.testEnvironmentArg); 74 | } 75 | 76 | QUnit.testStart( { 77 | name: this.testName 78 | } ); 79 | 80 | // allow utility functions to access the current test environment 81 | // TODO why?? 82 | QUnit.current_testEnvironment = this.testEnvironment; 83 | 84 | try { 85 | if ( !config.pollution ) { 86 | saveGlobal(); 87 | } 88 | 89 | this.testEnvironment.setup.call(this.testEnvironment); 90 | } catch(e) { 91 | QUnit.ok( false, "Setup failed on " + this.testName + ": " + e.message ); 92 | } 93 | }, 94 | run: function() { 95 | if ( this.async ) { 96 | QUnit.stop(); 97 | } 98 | 99 | if ( config.notrycatch ) { 100 | this.callback.call(this.testEnvironment); 101 | return; 102 | } 103 | try { 104 | this.callback.call(this.testEnvironment); 105 | } catch(e) { 106 | fail("Test " + this.testName + " died, exception and test follows", e, this.callback); 107 | QUnit.ok( false, "Died on test #" + (this.assertions.length + 1) + ": " + e.message + " - " + QUnit.jsDump.parse(e) ); 108 | // else next test will carry the responsibility 109 | saveGlobal(); 110 | 111 | // Restart the tests if they're blocking 112 | if ( config.blocking ) { 113 | start(); 114 | } 115 | } 116 | }, 117 | teardown: function() { 118 | try { 119 | this.testEnvironment.teardown.call(this.testEnvironment); 120 | checkPollution(); 121 | } catch(e) { 122 | QUnit.ok( false, "Teardown failed on " + this.testName + ": " + e.message ); 123 | } 124 | }, 125 | finish: function() { 126 | if ( this.expected && this.expected != this.assertions.length ) { 127 | QUnit.ok( false, "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run" ); 128 | } 129 | 130 | var good = 0, bad = 0, 131 | tests = id("qunit-tests"); 132 | 133 | config.stats.all += this.assertions.length; 134 | config.moduleStats.all += this.assertions.length; 135 | 136 | if ( tests ) { 137 | var ol = document.createElement("ol"); 138 | 139 | for ( var i = 0; i < this.assertions.length; i++ ) { 140 | var assertion = this.assertions[i]; 141 | 142 | var li = document.createElement("li"); 143 | li.className = assertion.result ? "pass" : "fail"; 144 | li.innerHTML = assertion.message || (assertion.result ? "okay" : "failed"); 145 | ol.appendChild( li ); 146 | 147 | if ( assertion.result ) { 148 | good++; 149 | } else { 150 | bad++; 151 | config.stats.bad++; 152 | config.moduleStats.bad++; 153 | } 154 | } 155 | 156 | // store result when possible 157 | if ( QUnit.config.reorder && defined.sessionStorage ) { 158 | if (bad) { 159 | sessionStorage.setItem("qunit-" + this.module + "-" + this.testName, bad); 160 | } else { 161 | sessionStorage.removeItem("qunit-" + this.module + "-" + this.testName); 162 | } 163 | } 164 | 165 | if (bad == 0) { 166 | ol.style.display = "none"; 167 | } 168 | 169 | var b = document.createElement("strong"); 170 | b.innerHTML = this.name + " (" + bad + ", " + good + ", " + this.assertions.length + ")"; 171 | 172 | var a = document.createElement("a"); 173 | a.innerHTML = "Rerun"; 174 | a.href = QUnit.url({ filter: getText([b]).replace(/$[^)]+$$/, "").replace(/(^\s*|\s*$)/g, "") }); 175 | 176 | addEvent(b, "click", function() { 177 | var next = b.nextSibling.nextSibling, 178 | display = next.style.display; 179 | next.style.display = display === "none" ? "block" : "none"; 180 | }); 181 | 182 | addEvent(b, "dblclick", function(e) { 183 | var target = e && e.target ? e.target : window.event.srcElement; 184 | if ( target.nodeName.toLowerCase() == "span" || target.nodeName.toLowerCase() == "b" ) { 185 | target = target.parentNode; 186 | } 187 | if ( window.location && target.nodeName.toLowerCase() === "strong" ) { 188 | window.location = QUnit.url({ filter: getText([target]).replace(/$[^)]+$$/, "").replace(/(^\s*|\s*$)/g, "") }); 189 | } 190 | }); 191 | 192 | var li = id(this.id); 193 | li.className = bad ? "fail" : "pass"; 194 | li.removeChild( li.firstChild ); 195 | li.appendChild( b ); 196 | li.appendChild( a ); 197 | li.appendChild( ol ); 198 | 199 | } else { 200 | for ( var i = 0; i < this.assertions.length; i++ ) { 201 | if ( !this.assertions[i].result ) { 202 | bad++; 203 | config.stats.bad++; 204 | config.moduleStats.bad++; 205 | } 206 | } 207 | } 208 | 209 | try { 210 | QUnit.reset(); 211 | } catch(e) { 212 | fail("reset() failed, following Test " + this.testName + ", exception and reset fn follows", e, QUnit.reset); 213 | } 214 | 215 | QUnit.testDone( { 216 | name: this.testName, 217 | failed: bad, 218 | passed: this.assertions.length - bad, 219 | total: this.assertions.length 220 | } ); 221 | }, 222 | 223 | queue: function() { 224 | var test = this; 225 | synchronize(function() { 226 | test.init(); 227 | }); 228 | function run() { 229 | // each of these can by async 230 | synchronize(function() { 231 | test.setup(); 232 | }); 233 | synchronize(function() { 234 | test.run(); 235 | }); 236 | synchronize(function() { 237 | test.teardown(); 238 | }); 239 | synchronize(function() { 240 | test.finish(); 241 | }); 242 | } 243 | // defer when previous test run passed, if storage is available 244 | var bad = QUnit.config.reorder && defined.sessionStorage && +sessionStorage.getItem("qunit-" + this.module + "-" + this.testName); 245 | if (bad) { 246 | run(); 247 | } else { 248 | synchronize(run); 249 | }; 250 | } 251 | 252 | }; 253 | 254 | var QUnit = { 255 | 256 | // call on start of module test to prepend name to all tests 257 | module: function(name, testEnvironment) { 258 | config.currentModule = name; 259 | config.currentModuleTestEnviroment = testEnvironment; 260 | }, 261 | 262 | asyncTest: function(testName, expected, callback) { 263 | if ( arguments.length === 2 ) { 264 | callback = expected; 265 | expected = 0; 266 | } 267 | 268 | QUnit.test(testName, expected, callback, true); 269 | }, 270 | 271 | test: function(testName, expected, callback, async) { 272 | var name = '' + testName + '', testEnvironmentArg; 273 | 274 | if ( arguments.length === 2 ) { 275 | callback = expected; 276 | expected = null; 277 | } 278 | // is 2nd argument a testEnvironment? 279 | if ( expected && typeof expected === 'object') { 280 | testEnvironmentArg = expected; 281 | expected = null; 282 | } 283 | 284 | if ( config.currentModule ) { 285 | name = '' + config.currentModule + ": " + name; 286 | } 287 | 288 | if ( !validTest(config.currentModule + ": " + testName) ) { 289 | return; 290 | } 291 | 292 | var test = new Test(name, testName, expected, testEnvironmentArg, async, callback); 293 | test.module = config.currentModule; 294 | test.moduleTestEnvironment = config.currentModuleTestEnviroment; 295 | test.queue(); 296 | }, 297 | 298 | /** 299 | * Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through. 300 | */ 301 | expect: function(asserts) { 302 | config.current.expected = asserts; 303 | }, 304 | 305 | /** 306 | * Asserts true. 307 | * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" ); 308 | */ 309 | ok: function(a, msg) { 310 | a = !!a; 311 | var details = { 312 | result: a, 313 | message: msg 314 | }; 315 | msg = escapeHtml(msg); 316 | QUnit.log(details); 317 | config.current.assertions.push({ 318 | result: a, 319 | message: msg 320 | }); 321 | }, 322 | 323 | /** 324 | * Checks that the first two arguments are equal, with an optional message. 325 | * Prints out both actual and expected values. 326 | * 327 | * Prefered to ok( actual == expected, message ) 328 | * 329 | * @example equal( format("Received {0} bytes.", 2), "Received 2 bytes." ); 330 | * 331 | * @param Object actual 332 | * @param Object expected 333 | * @param String message (optional) 334 | */ 335 | equal: function(actual, expected, message) { 336 | QUnit.push(expected == actual, actual, expected, message); 337 | }, 338 | 339 | notEqual: function(actual, expected, message) { 340 | QUnit.push(expected != actual, actual, expected, message); 341 | }, 342 | 343 | deepEqual: function(actual, expected, message) { 344 | QUnit.push(QUnit.equiv(actual, expected), actual, expected, message); 345 | }, 346 | 347 | notDeepEqual: function(actual, expected, message) { 348 | QUnit.push(!QUnit.equiv(actual, expected), actual, expected, message); 349 | }, 350 | 351 | strictEqual: function(actual, expected, message) { 352 | QUnit.push(expected === actual, actual, expected, message); 353 | }, 354 | 355 | notStrictEqual: function(actual, expected, message) { 356 | QUnit.push(expected !== actual, actual, expected, message); 357 | }, 358 | 359 | raises: function(block, expected, message) { 360 | var actual, ok = false; 361 | 362 | if (typeof expected === 'string') { 363 | message = expected; 364 | expected = null; 365 | } 366 | 367 | try { 368 | block(); 369 | } catch (e) { 370 | actual = e; 371 | } 372 | 373 | if (actual) { 374 | // we don't want to validate thrown error 375 | if (!expected) { 376 | ok = true; 377 | // expected is a regexp 378 | } else if (QUnit.objectType(expected) === "regexp") { 379 | ok = expected.test(actual); 380 | // expected is a constructor 381 | } else if (actual instanceof expected) { 382 | ok = true; 383 | // expected is a validation function which returns true is validation passed 384 | } else if (expected.call({}, actual) === true) { 385 | ok = true; 386 | } 387 | } 388 | 389 | QUnit.ok(ok, message); 390 | }, 391 | 392 | start: function() { 393 | config.semaphore--; 394 | if (config.semaphore > 0) { 395 | // don't start until equal number of stop-calls 396 | return; 397 | } 398 | if (config.semaphore < 0) { 399 | // ignore if start is called more often then stop 400 | config.semaphore = 0; 401 | } 402 | // A slight delay, to avoid any current callbacks 403 | if ( defined.setTimeout ) { 404 | window.setTimeout(function() { 405 | if ( config.timeout ) { 406 | clearTimeout(config.timeout); 407 | } 408 | 409 | config.blocking = false; 410 | process(); 411 | }, 13); 412 | } else { 413 | config.blocking = false; 414 | process(); 415 | } 416 | }, 417 | 418 | stop: function(timeout) { 419 | config.semaphore++; 420 | config.blocking = true; 421 | 422 | if ( timeout && defined.setTimeout ) { 423 | clearTimeout(config.timeout); 424 | config.timeout = window.setTimeout(function() { 425 | QUnit.ok( false, "Test timed out" ); 426 | QUnit.start(); 427 | }, timeout); 428 | } 429 | } 430 | }; 431 | 432 | // Backwards compatibility, deprecated 433 | QUnit.equals = QUnit.equal; 434 | QUnit.same = QUnit.deepEqual; 435 | 436 | // Maintain internal state 437 | var config = { 438 | // The queue of tests to run 439 | queue: [], 440 | 441 | // block until document ready 442 | blocking: true, 443 | 444 | // by default, run previously failed tests first 445 | // very useful in combination with "Hide passed tests" checked 446 | reorder: true, 447 | 448 | noglobals: false, 449 | notrycatch: false 450 | }; 451 | 452 | // Load paramaters 453 | (function() { 454 | var location = window.location || { search: "", protocol: "file:" }, 455 | params = location.search.slice( 1 ).split( "&" ), 456 | length = params.length, 457 | urlParams = {}, 458 | current; 459 | 460 | if ( params[ 0 ] ) { 461 | for ( var i = 0; i < length; i++ ) { 462 | current = params[ i ].split( "=" ); 463 | current[ 0 ] = decodeURIComponent( current[ 0 ] ); 464 | // allow just a key to turn on a flag, e.g., test.html?noglobals 465 | current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true; 466 | urlParams[ current[ 0 ] ] = current[ 1 ]; 467 | if ( current[ 0 ] in config ) { 468 | config[ current[ 0 ] ] = current[ 1 ]; 469 | } 470 | } 471 | } 472 | 473 | QUnit.urlParams = urlParams; 474 | config.filter = urlParams.filter; 475 | 476 | // Figure out if we're running the tests from a server or not 477 | QUnit.isLocal = !!(location.protocol === 'file:'); 478 | })(); 479 | 480 | // Expose the API as global variables, unless an 'exports' 481 | // object exists, in that case we assume we're in CommonJS 482 | if ( typeof exports === "undefined" || typeof require === "undefined" ) { 483 | extend(window, QUnit); 484 | window.QUnit = QUnit; 485 | } else { 486 | extend(exports, QUnit); 487 | exports.QUnit = QUnit; 488 | } 489 | 490 | // define these after exposing globals to keep them in these QUnit namespace only 491 | extend(QUnit, { 492 | config: config, 493 | 494 | // Initialize the configuration options 495 | init: function() { 496 | extend(config, { 497 | stats: { all: 0, bad: 0 }, 498 | moduleStats: { all: 0, bad: 0 }, 499 | started: +new Date, 500 | updateRate: 1000, 501 | blocking: false, 502 | autostart: true, 503 | autorun: false, 504 | filter: "", 505 | queue: [], 506 | semaphore: 0 507 | }); 508 | 509 | var tests = id( "qunit-tests" ), 510 | banner = id( "qunit-banner" ), 511 | result = id( "qunit-testresult" ); 512 | 513 | if ( tests ) { 514 | tests.innerHTML = ""; 515 | } 516 | 517 | if ( banner ) { 518 | banner.className = ""; 519 | } 520 | 521 | if ( result ) { 522 | result.parentNode.removeChild( result ); 523 | } 524 | 525 | if ( tests ) { 526 | result = document.createElement( "p" ); 527 | result.id = "qunit-testresult"; 528 | result.className = "result"; 529 | tests.parentNode.insertBefore( result, tests ); 530 | result.innerHTML = 'Running...
'; 531 | } 532 | }, 533 | 534 | /** 535 | * Resets the test setup. Useful for tests that modify the DOM. 536 | * 537 | * If jQuery is available, uses jQuery's html(), otherwise just innerHTML. 538 | */ 539 | reset: function() { 540 | if ( window.jQuery ) { 541 | jQuery( "#qunit-fixture" ).html( config.fixture ); 542 | } else { 543 | var main = id( 'qunit-fixture' ); 544 | if ( main ) { 545 | main.innerHTML = config.fixture; 546 | } 547 | } 548 | }, 549 | 550 | /** 551 | * Trigger an event on an element. 552 | * 553 | * @example triggerEvent( document.body, "click" ); 554 | * 555 | * @param DOMElement elem 556 | * @param String type 557 | */ 558 | triggerEvent: function( elem, type, event ) { 559 | if ( document.createEvent ) { 560 | event = document.createEvent("MouseEvents"); 561 | event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView, 562 | 0, 0, 0, 0, 0, false, false, false, false, 0, null); 563 | elem.dispatchEvent( event ); 564 | 565 | } else if ( elem.fireEvent ) { 566 | elem.fireEvent("on"+type); 567 | } 568 | }, 569 | 570 | // Safe object type checking 571 | is: function( type, obj ) { 572 | return QUnit.objectType( obj ) == type; 573 | }, 574 | 575 | objectType: function( obj ) { 576 | if (typeof obj === "undefined") { 577 | return "undefined"; 578 | 579 | // consider: typeof null === object 580 | } 581 | if (obj === null) { 582 | return "null"; 583 | } 584 | 585 | var type = Object.prototype.toString.call( obj ) 586 | .match(/^\[object\s(.*)\]$/)[1] || ''; 587 | 588 | switch (type) { 589 | case 'Number': 590 | if (isNaN(obj)) { 591 | return "nan"; 592 | } else { 593 | return "number"; 594 | } 595 | case 'String': 596 | case 'Boolean': 597 | case 'Array': 598 | case 'Date': 599 | case 'RegExp': 600 | case 'Function': 601 | return type.toLowerCase(); 602 | } 603 | if (typeof obj === "object") { 604 | return "object"; 605 | } 606 | return undefined; 607 | }, 608 | 609 | push: function(result, actual, expected, message) { 610 | var details = { 611 | result: result, 612 | message: message, 613 | actual: actual, 614 | expected: expected 615 | }; 616 | 617 | message = escapeHtml(message) || (result ? "okay" : "failed"); 618 | message = '' + message + ""; 619 | expected = escapeHtml(QUnit.jsDump.parse(expected)); 620 | actual = escapeHtml(QUnit.jsDump.parse(actual)); 621 | var output = message + ''; 622 | if (actual != expected) { 623 | output += ''; 624 | output += ''; 625 | } 626 | if (!result) { 627 | var source = sourceFromStacktrace(); 628 | if (source) { 629 | details.source = source; 630 | output += ''; 631 | } 632 | } 633 | output += "

Expected:	' + expected + '
Result:	' + actual + '
Diff:	' + QUnit.diff(expected, actual) +'
Source:	' + escapeHtml(source) + '

"; 634 | 635 | QUnit.log(details); 636 | 637 | config.current.assertions.push({ 638 | result: !!result, 639 | message: output 640 | }); 641 | }, 642 | 643 | url: function( params ) { 644 | params = extend( extend( {}, QUnit.urlParams ), params ); 645 | var querystring = "?", 646 | key; 647 | for ( key in params ) { 648 | querystring += encodeURIComponent( key ) + "=" + 649 | encodeURIComponent( params[ key ] ) + "&"; 650 | } 651 | return window.location.pathname + querystring.slice( 0, -1 ); 652 | }, 653 | 654 | extend: extend, 655 | id: id, 656 | addEvent: addEvent, 657 | 658 | // Logging callbacks; all receive a single argument with the listed properties 659 | // run test/logs.html for any related changes 660 | begin: function() {}, 661 | // done: { failed, passed, total, runtime } 662 | done: function() {}, 663 | // log: { result, actual, expected, message } 664 | log: function() {}, 665 | // testStart: { name } 666 | testStart: function() {}, 667 | // testDone: { name, failed, passed, total } 668 | testDone: function() {}, 669 | // moduleStart: { name } 670 | moduleStart: function() {}, 671 | // moduleDone: { name, failed, passed, total } 672 | moduleDone: function() {} 673 | }); 674 | 675 | if ( typeof document === "undefined" || document.readyState === "complete" ) { 676 | config.autorun = true; 677 | } 678 | 679 | addEvent(window, "load", function() { 680 | QUnit.begin({}); 681 | 682 | // Initialize the config, saving the execution queue 683 | var oldconfig = extend({}, config); 684 | QUnit.init(); 685 | extend(config, oldconfig); 686 | 687 | config.blocking = false; 688 | 689 | var userAgent = id("qunit-userAgent"); 690 | if ( userAgent ) { 691 | userAgent.innerHTML = navigator.userAgent; 692 | } 693 | var banner = id("qunit-header"); 694 | if ( banner ) { 695 | banner.innerHTML = ' ' + banner.innerHTML + ' ' + 696 | 'noglobals' + 697 | 'notrycatch'; 698 | addEvent( banner, "change", function( event ) { 699 | var params = {}; 700 | params[ event.target.name ] = event.target.checked ? true : undefined; 701 | window.location = QUnit.url( params ); 702 | }); 703 | } 704 | 705 | var toolbar = id("qunit-testrunner-toolbar"); 706 | if ( toolbar ) { 707 | var filter = document.createElement("input"); 708 | filter.type = "checkbox"; 709 | filter.id = "qunit-filter-pass"; 710 | addEvent( filter, "click", function() { 711 | var ol = document.getElementById("qunit-tests"); 712 | if ( filter.checked ) { 713 | ol.className = ol.className + " hidepass"; 714 | } else { 715 | var tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " "; 716 | ol.className = tmp.replace(/ hidepass /, " "); 717 | } 718 | if ( defined.sessionStorage ) { 719 | if (filter.checked) { 720 | sessionStorage.setItem("qunit-filter-passed-tests", "true"); 721 | } else { 722 | sessionStorage.removeItem("qunit-filter-passed-tests"); 723 | } 724 | } 725 | }); 726 | if ( defined.sessionStorage && sessionStorage.getItem("qunit-filter-passed-tests") ) { 727 | filter.checked = true; 728 | var ol = document.getElementById("qunit-tests"); 729 | ol.className = ol.className + " hidepass"; 730 | } 731 | toolbar.appendChild( filter ); 732 | 733 | var label = document.createElement("label"); 734 | label.setAttribute("for", "qunit-filter-pass"); 735 | label.innerHTML = "Hide passed tests"; 736 | toolbar.appendChild( label ); 737 | } 738 | 739 | var main = id('qunit-fixture'); 740 | if ( main ) { 741 | config.fixture = main.innerHTML; 742 | } 743 | 744 | if (config.autostart) { 745 | QUnit.start(); 746 | } 747 | }); 748 | 749 | function done() { 750 | config.autorun = true; 751 | 752 | // Log the last module results 753 | if ( config.currentModule ) { 754 | QUnit.moduleDone( { 755 | name: config.currentModule, 756 | failed: config.moduleStats.bad, 757 | passed: config.moduleStats.all - config.moduleStats.bad, 758 | total: config.moduleStats.all 759 | } ); 760 | } 761 | 762 | var banner = id("qunit-banner"), 763 | tests = id("qunit-tests"), 764 | runtime = +new Date - config.started, 765 | passed = config.stats.all - config.stats.bad, 766 | html = [ 767 | 'Tests completed in ', 768 | runtime, 769 | ' milliseconds.
', 770 | '', 771 | passed, 772 | ' tests of ', 773 | config.stats.all, 774 | ' passed, ', 775 | config.stats.bad, 776 | ' failed.' 777 | ].join(''); 778 | 779 | if ( banner ) { 780 | banner.className = (config.stats.bad ? "qunit-fail" : "qunit-pass"); 781 | } 782 | 783 | if ( tests ) { 784 | id( "qunit-testresult" ).innerHTML = html; 785 | } 786 | 787 | if ( typeof document !== "undefined" && document.title ) { 788 | // show ✖ for bad, ✔ for good suite result in title 789 | // use escape sequences in case file gets loaded with non-utf-8-charset 790 | document.title = (config.stats.bad ? "\u2716" : "\u2714") + " " + document.title; 791 | } 792 | 793 | QUnit.done( { 794 | failed: config.stats.bad, 795 | passed: passed, 796 | total: config.stats.all, 797 | runtime: runtime 798 | } ); 799 | } 800 | 801 | function validTest( name ) { 802 | var filter = config.filter, 803 | run = false; 804 | 805 | if ( !filter ) { 806 | return true; 807 | } 808 | 809 | var not = filter.charAt( 0 ) === "!"; 810 | if ( not ) { 811 | filter = filter.slice( 1 ); 812 | } 813 | 814 | if ( name.indexOf( filter ) !== -1 ) { 815 | return !not; 816 | } 817 | 818 | if ( not ) { 819 | run = true; 820 | } 821 | 822 | return run; 823 | } 824 | 825 | // so far supports only Firefox, Chrome and Opera (buggy) 826 | // could be extended in the future to use something like https://github.com/csnover/TraceKit 827 | function sourceFromStacktrace() { 828 | try { 829 | throw new Error(); 830 | } catch ( e ) { 831 | if (e.stacktrace) { 832 | // Opera 833 | return e.stacktrace.split("\n")[6]; 834 | } else if (e.stack) { 835 | // Firefox, Chrome 836 | return e.stack.split("\n")[4]; 837 | } 838 | } 839 | } 840 | 841 | function escapeHtml(s) { 842 | if (!s) { 843 | return ""; 844 | } 845 | s = s + ""; 846 | return s.replace(/[\&"<>\\]/g, function(s) { 847 | switch(s) { 848 | case "&": return "&"; 849 | case "\\": return "\\\\"; 850 | case '"': return '\"'; 851 | case "<": return "<"; 852 | case ">": return ">"; 853 | default: return s; 854 | } 855 | }); 856 | } 857 | 858 | function synchronize( callback ) { 859 | config.queue.push( callback ); 860 | 861 | if ( config.autorun && !config.blocking ) { 862 | process(); 863 | } 864 | } 865 | 866 | function process() { 867 | var start = (new Date()).getTime(); 868 | 869 | while ( config.queue.length && !config.blocking ) { 870 | if ( config.updateRate <= 0 || (((new Date()).getTime() - start) < config.updateRate) ) { 871 | config.queue.shift()(); 872 | } else { 873 | window.setTimeout( process, 13 ); 874 | break; 875 | } 876 | } 877 | if (!config.blocking && !config.queue.length) { 878 | done(); 879 | } 880 | } 881 | 882 | function saveGlobal() { 883 | config.pollution = []; 884 | 885 | if ( config.noglobals ) { 886 | for ( var key in window ) { 887 | config.pollution.push( key ); 888 | } 889 | } 890 | } 891 | 892 | function checkPollution( name ) { 893 | var old = config.pollution; 894 | saveGlobal(); 895 | 896 | var newGlobals = diff( config.pollution, old ); 897 | if ( newGlobals.length > 0 ) { 898 | ok( false, "Introduced global variable(s): " + newGlobals.join(", ") ); 899 | } 900 | 901 | var deletedGlobals = diff( old, config.pollution ); 902 | if ( deletedGlobals.length > 0 ) { 903 | ok( false, "Deleted global variable(s): " + deletedGlobals.join(", ") ); 904 | } 905 | } 906 | 907 | // returns a new Array with the elements that are in a but not in b 908 | function diff( a, b ) { 909 | var result = a.slice(); 910 | for ( var i = 0; i < result.length; i++ ) { 911 | for ( var j = 0; j < b.length; j++ ) { 912 | if ( result[i] === b[j] ) { 913 | result.splice(i, 1); 914 | i--; 915 | break; 916 | } 917 | } 918 | } 919 | return result; 920 | } 921 | 922 | function fail(message, exception, callback) { 923 | if ( typeof console !== "undefined" && console.error && console.warn ) { 924 | console.error(message); 925 | console.error(exception); 926 | console.warn(callback.toString()); 927 | 928 | } else if ( window.opera && opera.postError ) { 929 | opera.postError(message, exception, callback.toString); 930 | } 931 | } 932 | 933 | function extend(a, b) { 934 | for ( var prop in b ) { 935 | if ( b[prop] === undefined ) { 936 | delete a[prop]; 937 | } else { 938 | a[prop] = b[prop]; 939 | } 940 | } 941 | 942 | return a; 943 | } 944 | 945 | function addEvent(elem, type, fn) { 946 | if ( elem.addEventListener ) { 947 | elem.addEventListener( type, fn, false ); 948 | } else if ( elem.attachEvent ) { 949 | elem.attachEvent( "on" + type, fn ); 950 | } else { 951 | fn(); 952 | } 953 | } 954 | 955 | function id(name) { 956 | return !!(typeof document !== "undefined" && document && document.getElementById) && 957 | document.getElementById( name ); 958 | } 959 | 960 | // Test for equality any JavaScript type. 961 | // Discussions and reference: http://philrathe.com/articles/equiv 962 | // Test suites: http://philrathe.com/tests/equiv 963 | // Author: Philippe Rathé 964 | QUnit.equiv = function () { 965 | 966 | var innerEquiv; // the real equiv function 967 | var callers = []; // stack to decide between skip/abort functions 968 | var parents = []; // stack to avoiding loops from circular referencing 969 | 970 | // Call the o related callback with the given arguments. 971 | function bindCallbacks(o, callbacks, args) { 972 | var prop = QUnit.objectType(o); 973 | if (prop) { 974 | if (QUnit.objectType(callbacks[prop]) === "function") { 975 | return callbacks[prop].apply(callbacks, args); 976 | } else { 977 | return callbacks[prop]; // or undefined 978 | } 979 | } 980 | } 981 | 982 | var callbacks = function () { 983 | 984 | // for string, boolean, number and null 985 | function useStrictEquality(b, a) { 986 | if (b instanceof a.constructor || a instanceof b.constructor) { 987 | // to catch short annotaion VS 'new' annotation of a declaration 988 | // e.g. var i = 1; 989 | // var j = new Number(1); 990 | return a == b; 991 | } else { 992 | return a === b; 993 | } 994 | } 995 | 996 | return { 997 | "string": useStrictEquality, 998 | "boolean": useStrictEquality, 999 | "number": useStrictEquality, 1000 | "null": useStrictEquality, 1001 | "undefined": useStrictEquality, 1002 | 1003 | "nan": function (b) { 1004 | return isNaN(b); 1005 | }, 1006 | 1007 | "date": function (b, a) { 1008 | return QUnit.objectType(b) === "date" && a.valueOf() === b.valueOf(); 1009 | }, 1010 | 1011 | "regexp": function (b, a) { 1012 | return QUnit.objectType(b) === "regexp" && 1013 | a.source === b.source && // the regex itself 1014 | a.global === b.global && // and its modifers (gmi) ... 1015 | a.ignoreCase === b.ignoreCase && 1016 | a.multiline === b.multiline; 1017 | }, 1018 | 1019 | // - skip when the property is a method of an instance (OOP) 1020 | // - abort otherwise, 1021 | // initial === would have catch identical references anyway 1022 | "function": function () { 1023 | var caller = callers[callers.length - 1]; 1024 | return caller !== Object && 1025 | typeof caller !== "undefined"; 1026 | }, 1027 | 1028 | "array": function (b, a) { 1029 | var i, j, loop; 1030 | var len; 1031 | 1032 | // b could be an object literal here 1033 | if ( ! (QUnit.objectType(b) === "array")) { 1034 | return false; 1035 | } 1036 | 1037 | len = a.length; 1038 | if (len !== b.length) { // safe and faster 1039 | return false; 1040 | } 1041 | 1042 | //track reference to avoid circular references 1043 | parents.push(a); 1044 | for (i = 0; i < len; i++) { 1045 | loop = false; 1046 | for(j=0;j= 0) { 1191 | type = "array"; 1192 | } else { 1193 | type = typeof obj; 1194 | } 1195 | return type; 1196 | }, 1197 | separator:function() { 1198 | return this.multiline ? this.HTML ? '
' : '\n' : this.HTML ? ' ' : ' '; 1199 | }, 1200 | indent:function( extra ) {// extra can be a number, shortcut for increasing-calling-decreasing 1201 | if ( !this.multiline ) 1202 | return ''; 1203 | var chr = this.indentChar; 1204 | if ( this.HTML ) 1205 | chr = chr.replace(/\t/g,' ').replace(/ /g,' '); 1206 | return Array( this._depth_ + (extra||0) ).join(chr); 1207 | }, 1208 | up:function( a ) { 1209 | this._depth_ += a || 1; 1210 | }, 1211 | down:function( a ) { 1212 | this._depth_ -= a || 1; 1213 | }, 1214 | setParser:function( name, parser ) { 1215 | this.parsers[name] = parser; 1216 | }, 1217 | // The next 3 are exposed so you can use them 1218 | quote:quote, 1219 | literal:literal, 1220 | join:join, 1221 | // 1222 | _depth_: 1, 1223 | // This is the list of parsers, to modify them, use jsDump.setParser 1224 | parsers:{ 1225 | window: '[Window]', 1226 | document: '[Document]', 1227 | error:'[ERROR]', //when no parser is found, shouldn't happen 1228 | unknown: '[Unknown]', 1229 | 'null':'null', 1230 | 'undefined':'undefined', 1231 | 'function':function( fn ) { 1232 | var ret = 'function', 1233 | name = 'name' in fn ? fn.name : (reName.exec(fn)||[])[1];//functions never have name in IE 1234 | if ( name ) 1235 | ret += ' ' + name; 1236 | ret += '('; 1237 | 1238 | ret = [ ret, QUnit.jsDump.parse( fn, 'functionArgs' ), '){'].join(''); 1239 | return join( ret, QUnit.jsDump.parse(fn,'functionCode'), '}' ); 1240 | }, 1241 | array: array, 1242 | nodelist: array, 1243 | arguments: array, 1244 | object:function( map ) { 1245 | var ret = [ ]; 1246 | QUnit.jsDump.up(); 1247 | for ( var key in map ) 1248 | ret.push( QUnit.jsDump.parse(key,'key') + ': ' + QUnit.jsDump.parse(map[key]) ); 1249 | QUnit.jsDump.down(); 1250 | return join( '{', ret, '}' ); 1251 | }, 1252 | node:function( node ) { 1253 | var open = QUnit.jsDump.HTML ? '<' : '<', 1254 | close = QUnit.jsDump.HTML ? '>' : '>'; 1255 | 1256 | var tag = node.nodeName.toLowerCase(), 1257 | ret = open + tag; 1258 | 1259 | for ( var a in QUnit.jsDump.DOMAttrs ) { 1260 | var val = node[QUnit.jsDump.DOMAttrs[a]]; 1261 | if ( val ) 1262 | ret += ' ' + a + '=' + QUnit.jsDump.parse( val, 'attribute' ); 1263 | } 1264 | return ret + close + open + '/' + tag + close; 1265 | }, 1266 | functionArgs:function( fn ) {//function calls it internally, it's the arguments part of the function 1267 | var l = fn.length; 1268 | if ( !l ) return ''; 1269 | 1270 | var args = Array(l); 1271 | while ( l-- ) 1272 | args[l] = String.fromCharCode(97+l);//97 is 'a' 1273 | return ' ' + args.join(', ') + ' '; 1274 | }, 1275 | key:quote, //object calls it internally, the key part of an item in a map 1276 | functionCode:'[code]', //function calls it internally, it's the content of the function 1277 | attribute:quote, //node calls it internally, it's an html attribute value 1278 | string:quote, 1279 | date:quote, 1280 | regexp:literal, //regex 1281 | number:literal, 1282 | 'boolean':literal 1283 | }, 1284 | DOMAttrs:{//attributes to dump from nodes, name=>realName 1285 | id:'id', 1286 | name:'name', 1287 | 'class':'className' 1288 | }, 1289 | HTML:false,//if true, entities are escaped ( <, >, \t, space and \n ) 1290 | indentChar:' ',//indentation unit 1291 | multiline:true //if true, items in a collection, are separated by a \n, else just a space. 1292 | }; 1293 | 1294 | return jsDump; 1295 | })(); 1296 | 1297 | // from Sizzle.js 1298 | function getText( elems ) { 1299 | var ret = "", elem; 1300 | 1301 | for ( var i = 0; elems[i]; i++ ) { 1302 | elem = elems[i]; 1303 | 1304 | // Get the text from text nodes and CDATA nodes 1305 | if ( elem.nodeType === 3 || elem.nodeType === 4 ) { 1306 | ret += elem.nodeValue; 1307 | 1308 | // Traverse everything else, except comment nodes 1309 | } else if ( elem.nodeType !== 8 ) { 1310 | ret += getText( elem.childNodes ); 1311 | } 1312 | } 1313 | 1314 | return ret; 1315 | }; 1316 | 1317 | /* 1318 | * Javascript Diff Algorithm 1319 | * By John Resig (http://ejohn.org/) 1320 | * Modified by Chu Alan "sprite" 1321 | * 1322 | * Released under the MIT license. 1323 | * 1324 | * More Info: 1325 | * http://ejohn.org/projects/javascript-diff-algorithm/ 1326 | * 1327 | * Usage: QUnit.diff(expected, actual) 1328 | * 1329 | * QUnit.diff("the quick brown fox jumped over", "the quick fox jumps over") == "the quick ~~brown~~ fox ~~jumped~~ jumps over" 1330 | */ 1331 | QUnit.diff = (function() { 1332 | function diff(o, n){ 1333 | var ns = new Object(); 1334 | var os = new Object(); 1335 | 1336 | for (var i = 0; i < n.length; i++) { 1337 | if (ns[n[i]] == null) 1338 | ns[n[i]] = { 1339 | rows: new Array(), 1340 | o: null 1341 | }; 1342 | ns[n[i]].rows.push(i); 1343 | } 1344 | 1345 | for (var i = 0; i < o.length; i++) { 1346 | if (os[o[i]] == null) 1347 | os[o[i]] = { 1348 | rows: new Array(), 1349 | n: null 1350 | }; 1351 | os[o[i]].rows.push(i); 1352 | } 1353 | 1354 | for (var i in ns) { 1355 | if (ns[i].rows.length == 1 && typeof(os[i]) != "undefined" && os[i].rows.length == 1) { 1356 | n[ns[i].rows[0]] = { 1357 | text: n[ns[i].rows[0]], 1358 | row: os[i].rows[0] 1359 | }; 1360 | o[os[i].rows[0]] = { 1361 | text: o[os[i].rows[0]], 1362 | row: ns[i].rows[0] 1363 | }; 1364 | } 1365 | } 1366 | 1367 | for (var i = 0; i < n.length - 1; i++) { 1368 | if (n[i].text != null && n[i + 1].text == null && n[i].row + 1 < o.length && o[n[i].row + 1].text == null && 1369 | n[i + 1] == o[n[i].row + 1]) { 1370 | n[i + 1] = { 1371 | text: n[i + 1], 1372 | row: n[i].row + 1 1373 | }; 1374 | o[n[i].row + 1] = { 1375 | text: o[n[i].row + 1], 1376 | row: i + 1 1377 | }; 1378 | } 1379 | } 1380 | 1381 | for (var i = n.length - 1; i > 0; i--) { 1382 | if (n[i].text != null && n[i - 1].text == null && n[i].row > 0 && o[n[i].row - 1].text == null && 1383 | n[i - 1] == o[n[i].row - 1]) { 1384 | n[i - 1] = { 1385 | text: n[i - 1], 1386 | row: n[i].row - 1 1387 | }; 1388 | o[n[i].row - 1] = { 1389 | text: o[n[i].row - 1], 1390 | row: i - 1 1391 | }; 1392 | } 1393 | } 1394 | 1395 | return { 1396 | o: o, 1397 | n: n 1398 | }; 1399 | } 1400 | 1401 | return function(o, n){ 1402 | o = o.replace(/\s+$/, ''); 1403 | n = n.replace(/\s+$/, ''); 1404 | var out = diff(o == "" ? [] : o.split(/\s+/), n == "" ? [] : n.split(/\s+/)); 1405 | 1406 | var str = ""; 1407 | 1408 | var oSpace = o.match(/\s+/g); 1409 | if (oSpace == null) { 1410 | oSpace = [" "]; 1411 | } 1412 | else { 1413 | oSpace.push(" "); 1414 | } 1415 | var nSpace = n.match(/\s+/g); 1416 | if (nSpace == null) { 1417 | nSpace = [" "]; 1418 | } 1419 | else { 1420 | nSpace.push(" "); 1421 | } 1422 | 1423 | if (out.n.length == 0) { 1424 | for (var i = 0; i < out.o.length; i++) { 1425 | str += '~~' + out.o[i] + oSpace[i] + "~~"; 1426 | } 1427 | } 1428 | else { 1429 | if (out.n[0].text == null) { 1430 | for (n = 0; n < out.o.length && out.o[n].text == null; n++) { 1431 | str += '~~' + out.o[n] + oSpace[n] + "~~"; 1432 | } 1433 | } 1434 | 1435 | for (var i = 0; i < out.n.length; i++) { 1436 | if (out.n[i].text == null) { 1437 | str += '' + out.n[i] + nSpace[i] + ""; 1438 | } 1439 | else { 1440 | var pre = ""; 1441 | 1442 | for (n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++) { 1443 | pre += '~~' + out.o[n] + oSpace[n] + "~~"; 1444 | } 1445 | str += " " + out.n[i].text + nSpace[i] + pre; 1446 | } 1447 | } 1448 | } 1449 | 1450 | return str; 1451 | }; 1452 | })(); 1453 | 1454 | })(this); --------------------------------------------------------------------------------

RouteMap Tests

187 | 188 | Namespace RouteMap 189 |