archive-gh-me/jsdoc
1
0
Fork 0
mirror of https://github.com/jsdoc/jsdoc.git synced 2025-12-08 19:46:11 +00:00
Code Issues Projects Releases Wiki Activity

Added ejs templates.

Browse Source
This commit is contained in:
Michael Mathews 2011-05-07 22:26:23 +01:00
parent f57d474826
commit 6ba7b8f5b0
42 changed files with 5432 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
node_modules/ejs/.gitignore generated vendored Normal file
View File

@ -0,0 +1,3 @@
# ignore any vim files:
*.sw[a-z]
vim/.netrwhist

3
node_modules/ejs/.gitmodules generated vendored Normal file
View File

@ -0,0 +1,3 @@
[submodule "support/expresso"]
path = support/expresso
url = http://github.com/visionmedia/expresso.git

60
node_modules/ejs/History.md generated vendored Normal file
View File

@ -0,0 +1,60 @@
0.4.1 / 2011-04-21
==================
* Fixed error context
0.4.0 / 2011-04-21
==================
* Added; ported jade's error reporting to ejs. [slaskis]
0.3.1 / 2011-02-23
==================
* Fixed optional `compile()` options
0.3.0 / 2011-02-14
==================
* Added 'json' filter [Yuriy Bogdanov]
* Use exported version of parse function to allow monkey-patching [Anatoliy Chakkaev]
0.2.1 / 2010-10-07
==================
* Added filter support
* Fixed _cache_ option. ~4x performance increase
0.2.0 / 2010-08-05
==================
* Added support for global tag config
* Added custom tag support. Closes #5
* Fixed whitespace bug. Closes #4
0.1.0 / 2010-08-04
==================
* Faster implementation [ashleydev]
0.0.4 / 2010-08-02
==================
* Fixed single quotes for content outside of template tags. [aniero]
* Changed; `exports.compile()` now expects only "locals"
0.0.3 / 2010-07-15
==================
* Fixed single quotes
0.0.2 / 2010-07-09
==================
* Fixed newline preservation
0.0.1 / 2010-07-09
==================
* Initial release

5
node_modules/ejs/Makefile generated vendored Normal file
View File

@ -0,0 +1,5 @@
test:
@./support/expresso/bin/expresso -I lib test/*.test.js
.PHONY: test

137
node_modules/ejs/Readme.md generated vendored Normal file
View File

@ -0,0 +1,137 @@
# EJS
Embedded JavaScript templates.
## Installation
$ npm install ejs
## Features
* Complies with the [Express](http://expressjs.com) view system
* Static caching of intermediate JavaScript
* Unbuffered code for conditionals etc `<% code %>`
* Escapes html by default with `<%= code %>`
* Unescaped buffering with `<%- code %>`
* Supports tag customization
* Filter support for designer-friendly templates
## Example
<% if (user) { %>
<h2><%= user.name %></h2>
<% } %>
## Usage
ejs.compile(str, options);
// => Function
ejs.render(str, options);
// => str
## Options
- `locals` Local variables object
- `cache` Compiled functions are cached, requires `filename`
- `filename` Used by `cache` to key caches
- `scope` Function execution context
- `debug` Output generated function body
- `open` Open tag, defaulting to "<%"
- `close` Closing tag, defaulting to "%>"
## Custom Tags
Custom tags can also be applied globally:
var ejs = require('ejs');
ejs.open = '{{';
ejs.close = '}}';
Which would make the following a valid template:
<h1>{{= title }}</h1>
## Filters
EJS conditionally supports the concept of "filters". A "filter chain"
is a designer friendly api for manipulating data, without writing JavaScript.
Filters can be applied by supplying the _:_ modifier, so for example if we wish to take the array `[{ name: 'tj' }, { name: 'mape' }, { name: 'guillermo' }]` and output a list of names we can do this simply with filters:
Template:
<p><%=: users | map:'name' | join %></p>
Output:
<p>Tj, Mape, Guillermo</p>
Render call:
ejs.render(str, {
locals: {
users: [
{ name: 'tj' },
{ name: 'mape' },
{ name: 'guillermo' }
]
}
});
Or perhaps capitalize the first user's name for display:
<p><%=: users | first | capitalize %></p>
## Filter List
Currently these filters are available:
- first
- last
- capitalize
- downcase
- upcase
- sort
- sort_by:'prop'
- size
- length
- plus:n
- minus:n
- times:n
- divided_by:n
- join:'val'
- truncate:n
- truncate_words:n
- replace:pattern,substitution
- prepend:val
- append:val
- map:'prop'
- reverse
- get:'prop'
## License
(The MIT License)
Copyright (c) 2009-2010 TJ Holowaychuk &lt;tj@vision-media.ca&gt;
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:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
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.

14
node_modules/ejs/benchmark.js generated vendored Normal file
View File

@ -0,0 +1,14 @@
var ejs = require('./lib/ejs'),
str = '<% if (foo) { %><p><%= foo %></p><% } %>',
times = 50000;
console.log('rendering ' + times + ' times');
var start = new Date;
while (times--) {
ejs.render(str, { cache: true, filename: 'test', locals: { foo: 'bar' }});
}
console.log('took ' + (new Date - start) + 'ms');

7
node_modules/ejs/examples/list.ejs generated vendored Normal file
View File

@ -0,0 +1,7 @@
<% if (names.length) { %>
<ul>
<% names.forEach(function(name){ %>
<li><%= name %></li>
<% }) %>
</ul>
<% } %>

16
node_modules/ejs/examples/list.js generated vendored Normal file
View File

@ -0,0 +1,16 @@
/**
* Module dependencies.
*/
var ejs = require('../')
, fs = require('fs')
, str = fs.readFileSync(__dirname + '/list.ejs', 'utf8');
var ret = ejs.render(str, {
locals: {
names: ['foo', 'bar', 'baz']
}
});
console.log(ret);

2
node_modules/ejs/index.js generated vendored Normal file
View File

@ -0,0 +1,2 @@
module.exports = require('./lib/ejs');

249
node_modules/ejs/lib/ejs.js generated vendored Normal file
View File

@ -0,0 +1,249 @@
/*!
* EJS
* Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
* MIT Licensed
*/
/**
* Module dependencies.
*/
var sys = require('sys')
, utils = require('./utils');
/**
* Library version.
*/
exports.version = '0.4.1';
/**
* Filters.
*
* @type Object
*/
var filters = exports.filters = require('./filters');
/**
* Intermediate js cache.
*
* @type Object
*/
var cache = {};
/**
* Clear intermediate js cache.
*
* @api public
*/
exports.clearCache = function(){
cache = {};
};
/**
* Translate filtered code into function calls.
*
* @param {String} js
* @return {String}
* @api private
*/
function filtered(js) {
return js.substr(1).split('|').reduce(function(js, filter){
var parts = filter.split(':')
, name = parts.shift()
, args = parts.shift() || '';
if (args) args = ', ' + args;
return 'filters.' + name + '(' + js + args + ')';
});
};
/**
* Re-throw the given `err` in context to the
* `str` of ejs, `filename`, and `lineno`.
*
* @param {Error} err
* @param {String} str
* @param {String} filename
* @param {String} lineno
* @api private
*/
function rethrow(err, str, filename, lineno){
var lines = str.split('\n')
, start = Math.max(lineno - 3, 0)
, end = Math.min(lines.length, lineno + 3);
// Error context
var context = lines.slice(start, end).map(function(line, i){
var curr = i + start + 1;
return (curr == lineno ? ' >> ' : ' ')
+ curr
+ '| '
+ line;
}).join('\n');
// Alter exception message
err.path = filename;
err.message = (filename || 'ejs') + ':'
+ lineno + '\n'
+ context + '\n\n'
+ err.message;
throw err;
}
/**
* Parse the given `str` of ejs, returning the function body.
*
* @param {String} str
* @return {String}
* @api public
*/
var parse = exports.parse = function(str, options){
var options = options || {}
, open = options.open || exports.open || '<%'
, close = options.close || exports.close || '%>';
var buf = [
"var buf = [];"
, "\nwith (locals) {"
, "\n buf.push('"
];
var lineno = 1;
for (var i = 0, len = str.length; i < len; ++i) {
if (str.slice(i, open.length + i) == open) {
i += open.length
var prefix, postfix, line = '__stack.lineno=' + lineno;
switch (str[i]) {
case '=':
prefix = "', escape((" + line + ', ';
postfix = ")), '";
++i;
break;
case '-':
prefix = "', (" + line + ', ';
postfix = "), '";
++i;
break;
default:
prefix = "');" + line + ';';
postfix = "; buf.push('";
}
var start = i;
var end = str.indexOf(close, i);
var js = str.substring(i, end);
if (js[0] == ':') js = filtered(js);
buf.push(prefix, js, postfix);
i += end - start + close.length - 1;
} else if (str[i] == "\\") {
buf.push("\\\\");
} else if (str[i] == "'") {
buf.push("\\'");
} else if (str[i] == "\r") {
buf.push(" ");
} else if (str[i] == "\n") {
buf.push("\\n");
lineno++;
} else {
buf.push(str[i]);
}
}
buf.push("');\n}\nreturn buf.join('');");
return buf.join('');
};
/**
* Compile the given `str` of ejs into a `Function`.
*
* @param {String} str
* @param {Object} options
* @return {Function}
* @api public
*/
var compile = exports.compile = function(str, options){
options = options || {};
var input = JSON.stringify(str)
, filename = options.filename
? JSON.stringify(options.filename)
: 'undefined';
// Adds the fancy stack trace meta info
str = [
'var __stack = { lineno: 1, input: ' + input + ', filename: ' + filename + ' };',
rethrow.toString(),
'try {',
exports.parse(str, options),
'} catch (err) {',
' rethrow(err, __stack.input, __stack.filename, __stack.lineno);',
'}'
].join("\n");
if (options.debug) sys.puts(str);
var fn = new Function('locals, filters, escape', str);
return function(locals){
return fn.call(this, locals, filters, utils.escape);
}
};
/**
* Render the given `str` of ejs.
*
* Options:
*
* - `locals` Local variables object
* - `cache` Compiled functions are cached, requires `filename`
* - `filename` Used by `cache` to key caches
* - `scope` Function execution context
* - `debug` Output generated function body
* - `open` Open tag, defaulting to "<%"
* - `close` Closing tag, defaulting to "%>"
*
* @param {String} str
* @param {Object} options
* @return {String}
* @api public
*/
exports.render = function(str, options){
var fn
, options = options || {};
if (options.cache) {
if (options.filename) {
fn = cache[options.filename] || (cache[options.filename] = compile(str, options));
} else {
throw new Error('"cache" option requires "filename".');
}
} else {
fn = compile(str, options);
}
return fn.call(options.scope, options.locals || {});
};
/**
* Expose to require().
*/
if (require.extensions) {
require.extensions['.ejs'] = function(module, filename) {
source = require('fs').readFileSync(filename, 'utf-8');
module._compile(compile(source, {}), filename);
};
} else if (require.registerExtension) {
require.registerExtension('.ejs', function(src) {
return compile(src, {});
});
}

198
node_modules/ejs/lib/filters.js generated vendored Normal file
View File

@ -0,0 +1,198 @@
/*!
* EJS - Filters
* Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
* MIT Licensed
*/
/**
* First element of the target `obj`.
*/
exports.first = function(obj) {
return obj[0];
};
/**
* Last element of the target `obj`.
*/
exports.last = function(obj) {
return obj[obj.length - 1];
};
/**
* Capitalize the first letter of the target `str`.
*/
exports.capitalize = function(str){
str = String(str);
return str[0].toUpperCase() + str.substr(1, str.length);
};
/**
* Downcase the target `str`.
*/
exports.downcase = function(str){
return String(str).toLowerCase();
};
/**
* Uppercase the target `str`.
*/
exports.upcase = function(str){
return String(str).toUpperCase();
};
/**
* Sort the target `obj`.
*/
exports.sort = function(obj){
return Object.create(obj).sort();
};
/**
* Sort the target `obj` by the given `prop` ascending.
*/
exports.sort_by = function(obj, prop){
return Object.create(obj).sort(function(a, b){
a = a[prop], b = b[prop];
if (a > b) return 1;
if (a < b) return -1;
return 0;
});
};
/**
* Size or length of the target `obj`.
*/
exports.size = exports.length = function(obj) {
return obj.length;
};
/**
* Add `a` and `b`.
*/
exports.plus = function(a, b){
return Number(a) + Number(b);
};
/**
* Subtract `b` from `a`.
*/
exports.minus = function(a, b){
return Number(a) - Number(b);
};
/**
* Multiply `a` by `b`.
*/
exports.times = function(a, b){
return Number(a) * Number(b);
};
/**
* Divide `a` by `b`.
*/
exports.divided_by = function(a, b){
return Number(a) / Number(b);
};
/**
* Join `obj` with the given `str`.
*/
exports.join = function(obj, str){
return obj.join(str || ', ');
};
/**
* Truncate `str` to `len`.
*/
exports.truncate = function(str, len){
str = String(str);
return str.substr(0, len);
};
/**
* Truncate `str` to `n` words.
*/
exports.truncate_words = function(str, n){
var str = String(str)
, words = str.split(/ +/);
return words.slice(0, n).join(' ');
};
/**
* Replace `pattern` with `substitution` in `str`.
*/
exports.replace = function(str, pattern, substitution){
return String(str).replace(pattern, substitution || '');
};
/**
* Prepend `val` to `obj`.
*/
exports.prepend = function(obj, val){
return Array.isArray(obj)
? [val].concat(obj)
: val + obj;
};
/**
* Append `val` to `obj`.
*/
exports.append = function(obj, val){
return Array.isArray(obj)
? obj.concat(val)
: obj + val;
};
/**
* Map the given `prop`.
*/
exports.map = function(arr, prop){
return arr.map(function(obj){
return obj[prop];
});
};
/**
* Reverse the given `obj`.
*/
exports.reverse = function(obj){
return Array.isArray(obj)
? obj.reverse()
: String(obj).split('').reverse().join('');
};
/**
* Get `prop` of the given `obj`.
*/
exports.get = function(obj, prop){
return obj[prop];
};
/**
* Packs the given `obj` into json string
*/
exports.json = function(obj){
return JSON.stringify(obj);
};

23
node_modules/ejs/lib/utils.js generated vendored Normal file
View File

@ -0,0 +1,23 @@
/*!
* EJS
* Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
* MIT Licensed
*/
/**
* Escape the given string of `html`.
*
* @param {String} html
* @return {String}
* @api private
*/
exports.escape = function(html){
return String(html)
.replace(/&(?!\w+;)/g, '&amp;')
.replace(/</g, '&lt;')
.replace(/>/g, '&gt;')
.replace(/"/g, '&quot;');
};

8
node_modules/ejs/package.json generated vendored Normal file
View File

@ -0,0 +1,8 @@
{
"name": "ejs",
"description": "Embedded JavaScript templates",
"version": "0.4.1",
"author": "TJ Holowaychuk <tj@vision-media.ca>",
"keywords": ["template", "engine", "ejs"],
"main": "./lib/ejs.js"
}

3
node_modules/ejs/support/expresso/.gitignore generated vendored Normal file
View File

@ -0,0 +1,3 @@
.DS_Store
lib-cov
*.seed

3
node_modules/ejs/support/expresso/.gitmodules generated vendored Normal file
View File

@ -0,0 +1,3 @@
[submodule "deps/jscoverage"]
path = deps/jscoverage
url = git://github.com/visionmedia/node-jscoverage.git

87
node_modules/ejs/support/expresso/History.md generated vendored Normal file
View File

@ -0,0 +1,87 @@
0.6.2 / 2010-08-03
==================
* Added `assert.type()`
* Renamed `assert.isNotUndefined()` to `assert.isDefined()`
* Fixed `assert.includes()` param ordering
0.6.0 / 2010-07-31
==================
* Added _docs/api.html_
* Added -w, --watch
* Added `Array` support to `assert.includes()`
* Added; outputting exceptions immediately. Closes #19
* Fixed `assert.includes()` param ordering
* Fixed `assert.length()` param ordering
* Fixed jscoverage links
0.5.0 / 2010-07-16
==================
* Added support for async exports
* Added timeout support to `assert.response()`. Closes #3
* Added 4th arg callback support to `assert.response()`
* Added `assert.length()`
* Added `assert.match()`
* Added `assert.isUndefined()`
* Added `assert.isNull()`
* Added `assert.includes()`
* Added growlnotify support via -g, --growl
* Added -o, --only TESTS. Ex: --only "test foo()" --only "test foo(), test bar()"
* Removed profanity
0.4.0 / 2010-07-09
==================
* Added reporting source coverage (respects --boring for color haters)
* Added callback to assert.response(). Closes #12
* Fixed; putting exceptions to stderr. Closes #13
0.3.1 / 2010-06-28
==================
* Faster assert.response()
0.3.0 / 2010-06-28
==================
* Added -p, --port NUM flags
* Added assert.response(). Closes #11
0.2.1 / 2010-06-25
==================
* Fixed issue with reporting object assertions
0.2.0 / 2010-06-21
==================
* Added `make uninstall`
* Added better readdir() failure message
* Fixed `make install` for kiwi
0.1.0 / 2010-06-15
==================
* Added better usage docs via --help
* Added better conditional color support
* Added pre exit assertion support
0.0.3 / 2010-06-02
==================
* Added more room for filenames in test coverage
* Added boring output support via --boring (suppress colored output)
* Fixed async failure exit status
0.0.2 / 2010-05-30
==================
* Fixed exit status for CI support
0.0.1 / 2010-05-30
==================
* Initial release

50
node_modules/ejs/support/expresso/Makefile generated vendored Normal file
View File

@ -0,0 +1,50 @@
BIN = bin/expresso
PREFIX = /usr/local
JSCOV = deps/jscoverage/node-jscoverage
DOCS = docs/index.md
HTMLDOCS = $(DOCS:.md=.html)
test: $(BIN)
@./$(BIN) -I lib --growl $(TEST_FLAGS) test/*.test.js
test-cov:
@./$(BIN) -I lib --cov $(TEST_FLAGS) test/*.test.js
install: install-jscov install-expresso
uninstall:
rm -f $(PREFIX)/bin/expresso
rm -f $(PREFIX)/bin/node-jscoverage
install-jscov: $(JSCOV)
install $(JSCOV) $(PREFIX)/bin
install-expresso:
install $(BIN) $(PREFIX)/bin
$(JSCOV):
cd deps/jscoverage && ./configure && make && mv jscoverage node-jscoverage
clean:
@cd deps/jscoverage && git clean -fd
docs: docs/api.html $(HTMLDOCS)
%.html: %.md
@echo "... $< > $@"
@ronn -5 --pipe --fragment $< \
| cat docs/layout/head.html - docs/layout/foot.html \
> $@
docs/api.html: bin/expresso
dox \
--title "Expresso" \
--ribbon "http://github.com/visionmedia/expresso" \
--desc "Insanely fast TDD framework for [node](http://nodejs.org) featuring code coverage reporting." \
$< > $@
docclean:
rm -f docs/*.html
.PHONY: test test-cov install uninstall install-expresso install-jscov clean docs docclean

39
node_modules/ejs/support/expresso/Readme.md generated vendored Normal file
View File

@ -0,0 +1,39 @@
# Expresso
TDD framework for [nodejs](http://nodejs.org).
## Features
- light-weight
- intuitive async support
- intuitive test runner executable
- test coverage support and reporting
- uses the _assert_ module
- `assert.eql()` alias of `assert.deepEqual()`
- `assert.response()` http response utility
- `assert.includes()`
- `assert.type()`
- `assert.isNull()`
- `assert.isUndefined()`
- `assert.isNotNull()`
- `assert.isDefined()`
- `assert.match()`
- `assert.length()`
## Installation
To install both expresso _and_ node-jscoverage run:
$ make install
To install expresso alone (no build required) run:
$ make install-expresso
Install via npm:
$ npm install expresso

775
node_modules/ejs/support/expresso/bin/expresso generated vendored Executable file
View File

@ -0,0 +1,775 @@
#!/usr/bin/env node
/*!
* Expresso
* Copyright(c) TJ Holowaychuk <tj@vision-media.ca>
* (MIT Licensed)
*/
/**
* Module dependencies.
*/
var assert = require('assert'),
childProcess = require('child_process'),
http = require('http'),
path = require('path'),
sys = require('sys'),
cwd = process.cwd(),
fs = require('fs'),
defer;
/**
* Expresso version.
*/
var version = '0.6.1';
/**
* Failure count.
*/
var failures = 0;
/**
* Number of tests executed.
*/
var testcount = 0;
/**
* Whitelist of tests to run.
*/
var only = [];
/**
* Boring output.
*/
var boring = false;
/**
* Growl notifications.
*/
var growl = false;
/**
* Server port.
*/
var port = 5555;
/**
* Watch mode.
*/
var watch = false;
/**
* Usage documentation.
*/
var usage = ''
+ '[bold]{Usage}: expresso [options] <file ...>'
+ '\n'
+ '\n[bold]{Options}:'
+ '\n -w, --watch Watch for modifications and re-execute tests'
+ '\n -g, --growl Enable growl notifications'
+ '\n -c, --coverage Generate and report test coverage'
+ '\n -r, --require PATH Require the given module path'
+ '\n -o, --only TESTS Execute only the comma sperated TESTS (can be set several times)'
+ '\n -I, --include PATH Unshift the given path to require.paths'
+ '\n -p, --port NUM Port number for test servers, starts at 5555'
+ '\n -b, --boring Suppress ansi-escape colors'
+ '\n -v, --version Output version number'
+ '\n -h, --help Display help information'
+ '\n';
// Parse arguments
var files = [],
args = process.argv.slice(2);
while (args.length) {
var arg = args.shift();
switch (arg) {
case '-h':
case '--help':
print(usage + '\n');
process.exit(1);
break;
case '-v':
case '--version':
sys.puts(version);
process.exit(1);
break;
case '-i':
case '-I':
case '--include':
if (arg = args.shift()) {
require.paths.unshift(arg);
} else {
throw new Error('--include requires a path');
}
break;
case '-o':
case '--only':
if (arg = args.shift()) {
only = only.concat(arg.split(/ *, */));
} else {
throw new Error('--only requires comma-separated test names');
}
break;
case '-p':
case '--port':
if (arg = args.shift()) {
port = parseInt(arg, 10);
} else {
throw new Error('--port requires a number');
}
break;
case '-r':
case '--require':
if (arg = args.shift()) {
require(arg);
} else {
throw new Error('--require requires a path');
}
break;
case '-c':
case '--cov':
case '--coverage':
defer = true;
childProcess.exec('rm -fr lib-cov && node-jscoverage lib lib-cov', function(err){
if (err) throw err;
require.paths.unshift('lib-cov');
run(files);
})
break;
case '-b':
case '--boring':
boring = true;
break;
case '-w':
case '--watch':
watch = true;
break;
case '--g':
case '--growl':
growl = true;
break;
default:
if (/\.js$/.test(arg)) {
files.push(arg);
}
break;
}
}
/**
* Colorized sys.error().
*
* @param {String} str
*/
function print(str){
sys.error(colorize(str));
}
/**
* Colorize the given string using ansi-escape sequences.
* Disabled when --boring is set.
*
* @param {String} str
* @return {String}
*/
function colorize(str){
var colors = { bold: 1, red: 31, green: 32, yellow: 33 };
return str.replace(/\[(\w+)\]\{([^]*?)\}/g, function(_, color, str){
return boring
? str
: '\x1B[' + colors[color] + 'm' + str + '\x1B[0m';
});
}
// Alias deepEqual as eql for complex equality
assert.eql = assert.deepEqual;
/**
* Assert that `val` is null.
*
* @param {Mixed} val
* @param {String} msg
*/
assert.isNull = function(val, msg) {
assert.strictEqual(null, val, msg);
};
/**
* Assert that `val` is not null.
*
* @param {Mixed} val
* @param {String} msg
*/
assert.isNotNull = function(val, msg) {
assert.notStrictEqual(null, val, msg);
};
/**
* Assert that `val` is undefined.
*
* @param {Mixed} val
* @param {String} msg
*/
assert.isUndefined = function(val, msg) {
assert.strictEqual(undefined, val, msg);
};
/**
* Assert that `val` is not undefined.
*
* @param {Mixed} val
* @param {String} msg
*/
assert.isDefined = function(val, msg) {
assert.notStrictEqual(undefined, val, msg);
};
/**
* Assert that `obj` is `type`.
*
* @param {Mixed} obj
* @param {String} type
* @api public
*/
assert.type = function(obj, type, msg){
var real = typeof obj;
msg = msg || 'typeof ' + sys.inspect(obj) + ' is ' + real + ', expected ' + type;
assert.ok(type === real, msg);
};
/**
* Assert that `str` matches `regexp`.
*
* @param {String} str
* @param {RegExp} regexp
* @param {String} msg
*/
assert.match = function(str, regexp, msg) {
msg = msg || sys.inspect(str) + ' does not match ' + sys.inspect(regexp);
assert.ok(regexp.test(str), msg);
};
/**
* Assert that `val` is within `obj`.
*
* Examples:
*
* assert.includes('foobar', 'bar');
* assert.includes(['foo', 'bar'], 'foo');
*
* @param {String|Array} obj
* @param {Mixed} val
* @param {String} msg
*/
assert.includes = function(obj, val, msg) {
msg = msg || sys.inspect(obj) + ' does not include ' + sys.inspect(val);
assert.ok(obj.indexOf(val) >= 0, msg);
};
/**
* Assert length of `val` is `n`.
*
* @param {Mixed} val
* @param {Number} n
* @param {String} msg
*/
assert.length = function(val, n, msg) {
msg = msg || sys.inspect(val) + ' has length of ' + val.length + ', expected ' + n;
assert.equal(n, val.length, msg);
};
/**
* Assert response from `server` with
* the given `req` object and `res` assertions object.
*
* @param {Server} server
* @param {Object} req
* @param {Object|Function} res
* @param {String} msg
*/
assert.response = function(server, req, res, msg){
// Callback as third or fourth arg
var callback = typeof res === 'function'
? res
: typeof msg === 'function'
? msg
: function(){};
// Default messate to test title
if (typeof msg === 'function') msg = null;
msg = msg || assert.testTitle;
msg += '. ';
// Pending responses
server.__pending = server.__pending || 0;
server.__pending++;
// Create client
if (!server.fd) {
server.listen(server.__port = port++);
server.client = http.createClient(server.__port);
}
// Issue request
var timer,
client = server.client,
method = req.method || 'GET',
status = res.status || res.statusCode,
data = req.data || req.body,
timeout = req.timeout || 0;
var request = client.request(method, req.url, req.headers);
// Timeout
if (timeout) {
timer = setTimeout(function(){
--server.__pending || server.close();
delete req.timeout;
assert.fail(msg + 'Request timed out after ' + timeout + 'ms.');
}, timeout);
}
if (data) request.write(data);
request.addListener('response', function(response){
response.body = '';
response.setEncoding('utf8');
response.addListener('data', function(chunk){ response.body += chunk; });
response.addListener('end', function(){
--server.__pending || server.close();
if (timer) clearTimeout(timer);
// Assert response body
if (res.body !== undefined) {
assert.equal(
response.body,
res.body,
msg + 'Invalid response body.\n'
+ ' Expected: ' + sys.inspect(res.body) + '\n'
+ ' Got: ' + sys.inspect(response.body)
);
}
// Assert response status
if (typeof status === 'number') {
assert.equal(
response.statusCode,
status,
msg + colorize('Invalid response status code.\n'
+ ' Expected: [green]{' + status + '}\n'
+ ' Got: [red]{' + response.statusCode + '}')
);
}
// Assert response headers
if (res.headers) {
var keys = Object.keys(res.headers);
for (var i = 0, len = keys.length; i < len; ++i) {
var name = keys[i],
actual = response.headers[name.toLowerCase()],
expected = res.headers[name];
assert.equal(
actual,
expected,
msg + colorize('Invalid response header [bold]{' + name + '}.\n'
+ ' Expected: [green]{' + expected + '}\n'
+ ' Got: [red]{' + actual + '}')
);
}
}
// Callback
callback(response);
});
});
request.end();
};
/**
* Pad the given string to the maximum width provided.
*
* @param {String} str
* @param {Number} width
* @return {String}
*/
function lpad(str, width) {
str = String(str);
var n = width - str.length;
if (n < 1) return str;
while (n--) str = ' ' + str;
return str;
}
/**
* Pad the given string to the maximum width provided.
*
* @param {String} str
* @param {Number} width
* @return {String}
*/
function rpad(str, width) {
str = String(str);
var n = width - str.length;
if (n < 1) return str;
while (n--) str = str + ' ';
return str;
}
/**
* Report test coverage.
*
* @param {Object} cov
*/
function reportCoverage(cov) {
populateCoverage(cov);
// Stats
print('\n [bold]{Test Coverage}\n');
var sep = ' +------------------------------------------+----------+------+------+--------+',
lastSep = ' +----------+------+------+--------+';
sys.puts(sep);
sys.puts(' | filename | coverage | LOC | SLOC | missed |');
sys.puts(sep);
for (var name in cov) {
var file = cov[name];
if (Array.isArray(file)) {
sys.print(' | ' + rpad(name, 40));
sys.print(' | ' + lpad(file.coverage.toFixed(2), 8));
sys.print(' | ' + lpad(file.LOC, 4));
sys.print(' | ' + lpad(file.SLOC, 4));
sys.print(' | ' + lpad(file.totalMisses, 6));
sys.print(' |\n');
}
}
sys.puts(sep);
sys.print(' ' + rpad('', 40));
sys.print(' | ' + lpad(cov.coverage.toFixed(2), 8));
sys.print(' | ' + lpad(cov.LOC, 4));
sys.print(' | ' + lpad(cov.SLOC, 4));
sys.print(' | ' + lpad(cov.totalMisses, 6));
sys.print(' |\n');
sys.puts(lastSep);
// Source
for (var name in cov) {
if (name.match(/\.js$/)) {
var file = cov[name];
print('\n [bold]{' + name + '}:');
print(file.source);
sys.print('\n');
}
}
}
/**
* Populate code coverage data.
*
* @param {Object} cov
*/
function populateCoverage(cov) {
cov.LOC =
cov.SLOC =
cov.totalFiles =
cov.totalHits =
cov.totalMisses =
cov.coverage = 0;
for (var name in cov) {
var file = cov[name];
if (Array.isArray(file)) {
// Stats
++cov.totalFiles;
cov.totalHits += file.totalHits = coverage(file, true);
cov.totalMisses += file.totalMisses = coverage(file, false);
file.totalLines = file.totalHits + file.totalMisses;
cov.SLOC += file.SLOC = file.totalLines;
cov.LOC += file.LOC = file.source.length;
file.coverage = (file.totalHits / file.totalLines) * 100;
// Source
var width = file.source.length.toString().length;
file.source = file.source.map(function(line, i){
++i;
var hits = file[i] === 0 ? 0 : (file[i] || ' ');
if (!boring) {
if (hits === 0) {
hits = '\x1b[31m' + hits + '\x1b[0m';
line = '\x1b[41m' + line + '\x1b[0m';
} else {
hits = '\x1b[32m' + hits + '\x1b[0m';
}
}
return '\n ' + lpad(i, width) + ' | ' + hits + ' | ' + line;
}).join('');
}
}
cov.coverage = (cov.totalHits / cov.SLOC) * 100;
}
/**
* Total coverage for the given file data.
*
* @param {Array} data
* @return {Type}
*/
function coverage(data, val) {
var n = 0;
for (var i = 0, len = data.length; i < len; ++i) {
if (data[i] !== undefined && data[i] == val) ++n;
}
return n;
}
/**
* Run the given test `files`, or try _test/*_.
*
* @param {Array} files
*/
function run(files) {
if (!files.length) {
try {
files = fs.readdirSync('test').map(function(file){
return 'test/' + file;
});
} catch (err) {
print('\n failed to load tests in [bold]{./test}\n');
++failures;
process.exit(1);
}
}
if (watch) watchFiles(files);
runFiles(files);
}
/**
* Show the cursor when `show` is true, otherwise hide it.
*
* @param {Boolean} show
*/
function cursor(show) {
if (show) {
sys.print('\x1b[?25h');
} else {
sys.print('\x1b[?25l');
}
}
/**
* Run the given test `files`.
*
* @param {Array} files
*/
function runFiles(files) {
files.forEach(runFile);
}
/**
* Run tests for the given `file`.
*
* @param {String} file
*/
function runFile(file) {
if (file.match(/\.js$/)) {
var title = path.basename(file),
file = path.join(cwd, file),
mod = require(file.replace(/\.js$/, ''));
(function check(){
var len = Object.keys(mod).length;
if (len) {
runSuite(title, mod);
} else {
setTimeout(check, 20);
}
})();
}
}
/**
* Clear the module cache for the given `file`.
*
* @param {String} file
*/
function clearCache(file) {
var keys = Object.keys(module.moduleCache);
for (var i = 0, len = keys.length; i < len; ++i) {
var key = keys[i];
if (key.indexOf(file) === key.length - file.length) {
delete module.moduleCache[key];
}
}
}
/**
* Watch the given `files` for changes.
*
* @param {Array} files
*/
function watchFiles(files) {
var p = 0,
c = ['▫ ', '▫▫ ', '▫▫▫ ', ' ▫▫▫',
' ▫▫', ' ▫', ' ▫', ' ▫▫',
'▫▫▫ ', '▫▫ ', '▫ '],
l = c.length;
cursor(false);
setInterval(function(){
sys.print(colorize(' [green]{' + c[p++ % l] + '} watching\r'));
}, 100);
files.forEach(function(file){
fs.watchFile(file, { interval: 100 }, function(curr, prev){
if (curr.mtime > prev.mtime) {
print(' [yellow]{◦} ' + file);
clearCache(file);
runFile(file);
}
});
});
}
/**
* Report `err` for the given `test` and `suite`.
*
* @param {String} suite
* @param {String} test
* @param {Error} err
*/
function error(suite, test, err) {
++failures;
var name = err.name,
stack = err.stack.replace(err.name, ''),
label = test === 'uncaught'
? test
: suite + ' ' + test;
print('\n [bold]{' + label + '}: [red]{' + name + '}' + stack + '\n');
if (watch) notify(label + ' failed');
}
/**
* Run the given tests.
*
* @param {String} title
* @param {Object} tests
*/
function runSuite(title, tests) {
var keys = only.length
? only.slice(0)
: Object.keys(tests);
(function next(){
if (keys.length) {
var key,
test = tests[key = keys.shift()];
if (test) {
try {
++testcount;
assert.testTitle = key;
test(assert, function(fn){
process.addListener('beforeExit', function(){
try {
fn();
} catch (err) {
error(title, key, err);
}
});
});
} catch (err) {
error(title, key, err);
}
}
next();
}
})();
}
/**
* Report exceptions.
*/
function report() {
process.emit('beforeExit');
if (failures) {
print('\n [bold]{Failures}: [red]{' + failures + '}\n\n');
notify('Failures: ' + failures);
} else {
print('\n [green]{100%} ' + testcount + ' tests\n');
notify('100% ok');
}
if (typeof _$jscoverage === 'object') {
reportCoverage(_$jscoverage);
}
}
/**
* Growl notify the given `msg`.
*
* @param {String} msg
*/
function notify(msg) {
if (growl) {
childProcess.exec('growlnotify -name Expresso -m "' + msg + '"');
}
}
// Report uncaught exceptions
process.addListener('uncaughtException', function(err){
error('uncaught', 'uncaught', err);
});
// Show cursor
['INT', 'TERM', 'QUIT'].forEach(function(sig){
process.addListener('SIG' + sig, function(){
cursor(true);
process.exit(1);
});
});
// Report test coverage when available
// and emit "beforeExit" event to perform
// final assertions
var orig = process.emit;
process.emit = function(event){
if (event === 'exit') {
report();
process.reallyExit(failures);
}
orig.apply(this, arguments);
};
// Run test files
if (!defer) run(files);

989
node_modules/ejs/support/expresso/docs/api.html generated vendored Normal file
View File

@ -0,0 +1,989 @@
<a href="http://github.com/visionmedia/expresso"><img alt="Fork me on GitHub" id="ribbon" src="http://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png"></a><html>
<head>
<title>Expresso</title>
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script>
<style>body {
margin: 0;
padding: 0;
font: 14px/1.5 'Palatino Linotype', 'Book Antiqua', Palatino, FreeSerif, serif;
color: #252519;
}
a {
color: #252519;
}
a:hover {
text-decoration: underline;
color: #19469D;
}
p {
margin: 12px 0;
}
h1, h2, h3 {
margin: 0;
padding: 0;
}
table#source {
width: 100%;
border-collapse: collapse;
}
table#source td:first-child {
padding: 30px 40px 30px 40px;
vertical-align: top;
}
table#source td:first-child,
table#source td:first-child pre {
width: 450px;
}
table#source td:last-child {
padding: 30px 0 30px 40px;
border-left: 1px solid #E5E5EE;
background: #F5F5FF;
}
table#source tr {
border-bottom: 1px solid #E5E5EE;
}
table#source tr.filename {
padding-top: 40px;
border-top: 1px solid #E5E5EE;
}
table#source tr.filename td:first-child {
text-transform: capitalize;
}
table#source tr.filename td:last-child {
font-size: 12px;
}
table#source tr.filename h2 {
margin: 0;
padding: 0;
cursor: pointer;
}
table#source tr.code h1,
table#source tr.code h2,
table#source tr.code h3 {
margin-top: 30px;
font-family: "Lucida Grande", "Helvetica Nueue", Arial, sans-serif;
font-size: 18px;
}
table#source tr.code h2 {
font-size: 16px;
}
table#source tr.code h3 {
font-size: 14px;
}
table#source tr.code ul {
margin: 15px 0 15px 35px;
padding: 0;
}
table#source tr.code ul li {
margin: 0;
padding: 1px 0;
}
table#source tr.code ul li p {
margin: 0;
padding: 0;
}
table#source tr.code td:first-child pre {
padding: 20px;
}
#ribbon {
position: fixed;
top: 0;
right: 0;
}
code .string { color: #219161; }
code .regexp { color: #219161; }
code .keyword { color: #954121; }
code .number { color: #19469D; }
code .comment { color: #bbb; }
code .this { color: #19469D; }</style>
<script>
$(function(){
$('tr.code').hide();
$('tr.filename').toggle(function(){
$(this).nextUntil('.filename').fadeIn();
}, function(){
$(this).nextUntil('.filename').fadeOut();
});
});
</script>
</head>
<body>
<table id="source"><tbody><tr><td><h1>Expresso</h1><p>Insanely fast TDD framework for <a href="http://nodejs.org">node</a> featuring code coverage reporting.</p></td><td></td></tr><tr class="filename"><td><h2 id="bin/expresso"><a href="#">expresso</a></h2></td><td>bin/expresso</td></tr><tr class="code">
<td class="docs">
<h1>!/usr/bin/env node</h1>
</td>
<td class="code">
<pre><code>!
* <span class="class">Expresso</span>
* <span class="class">Copyright</span>(<span class="variable">c</span>) <span class="class">TJ</span> <span class="class">Holowaychuk</span> &<span class="variable">lt</span>;<span class="variable">tj</span>@<span class="variable">vision</span>-<span class="variable">media</span>.<span class="variable">ca</span>&<span class="variable">gt</span>;
* (<span class="class">MIT</span> <span class="class">Licensed</span>)
</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Module dependencies.
</p>
</td>
<td class="code">
<pre><code><span class="keyword">var</span> <span class="variable">assert</span> = <span class="variable">require</span>(<span class="string">'assert'</span>),
<span class="variable">childProcess</span> = <span class="variable">require</span>(<span class="string">'child_process'</span>),
<span class="variable">http</span> = <span class="variable">require</span>(<span class="string">'http'</span>),
<span class="variable">path</span> = <span class="variable">require</span>(<span class="string">'path'</span>),
<span class="variable">sys</span> = <span class="variable">require</span>(<span class="string">'sys'</span>),
<span class="variable">cwd</span> = <span class="variable">process</span>.<span class="variable">cwd</span>(),
<span class="variable">fs</span> = <span class="variable">require</span>(<span class="string">'fs'</span>),
<span class="variable">defer</span>;</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Expresso version.
</p>
</td>
<td class="code">
<pre><code><span class="keyword">var</span> <span class="variable">version</span> = <span class="string">'0.6.0'</span>;</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Failure count.
</p>
</td>
<td class="code">
<pre><code><span class="keyword">var</span> <span class="variable">failures</span> = <span class="number integer">0</span>;</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Whitelist of tests to run.
</p>
</td>
<td class="code">
<pre><code><span class="keyword">var</span> <span class="variable">only</span> = [];</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Boring output.
</p>
</td>
<td class="code">
<pre><code><span class="keyword">var</span> <span class="variable">boring</span> = <span class="variable">false</span>;</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Growl notifications.
</p>
</td>
<td class="code">
<pre><code><span class="keyword">var</span> <span class="variable">growl</span> = <span class="variable">false</span>;</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Server port.
</p>
</td>
<td class="code">
<pre><code><span class="keyword">var</span> <span class="variable">port</span> = <span class="number integer">5555</span>;</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Watch mode.
</p>
</td>
<td class="code">
<pre><code><span class="keyword">var</span> <span class="variable">watch</span> = <span class="variable">false</span>;</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Usage documentation.
</p>
</td>
<td class="code">
<pre><code><span class="keyword">var</span> <span class="variable">usage</span> = <span class="string">''</span>
+ <span class="string">'[bold]{Usage}: expresso [options] &lt;file ...&gt;'</span>
+ <span class="string">'\n'</span>
+ <span class="string">'\n[bold]{Options}:'</span>
+ <span class="string">'\n -w, --watch Watch for modifications and re-execute tests'</span>
+ <span class="string">'\n -g, --growl Enable growl notifications'</span>
+ <span class="string">'\n -c, --coverage Generate and report test coverage'</span>
+ <span class="string">'\n -r, --require PATH Require the given module path'</span>
+ <span class="string">'\n -o, --only TESTS Execute only the comma sperated TESTS (can be set several times)'</span>
+ <span class="string">'\n -I, --include PATH Unshift the given path to require.paths'</span>
+ <span class="string">'\n -p, --port NUM Port number for test servers, starts at 5555'</span>
+ <span class="string">'\n -b, --boring Suppress ansi-escape colors'</span>
+ <span class="string">'\n -v, --version Output version number'</span>
+ <span class="string">'\n -h, --help Display help information'</span>
+ <span class="string">'\n'</span>;
<span class="comment">// Parse arguments</span>
<span class="keyword">var</span> <span class="variable">files</span> = [],
<span class="variable">args</span> = <span class="variable">process</span>.<span class="variable">argv</span>.<span class="variable">slice</span>(<span class="number integer">2</span>);
<span class="keyword">while</span> (<span class="variable">args</span>.<span class="variable">length</span>) {
<span class="keyword">var</span> <span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>();
<span class="keyword">switch</span> (<span class="variable">arg</span>) {
<span class="keyword">case</span> <span class="string">'-h'</span>:
<span class="keyword">case</span> <span class="string">'--help'</span>:
<span class="variable">print</span>(<span class="variable">usage</span> + <span class="string">'\n'</span>);
<span class="variable">process</span>.<span class="variable">exit</span>(<span class="number integer">1</span>);
<span class="keyword">break</span>;
<span class="keyword">case</span> <span class="string">'-v'</span>:
<span class="keyword">case</span> <span class="string">'--version'</span>:
<span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">version</span>);
<span class="variable">process</span>.<span class="variable">exit</span>(<span class="number integer">1</span>);
<span class="keyword">break</span>;
<span class="keyword">case</span> <span class="string">'-i'</span>:
<span class="keyword">case</span> <span class="string">'-I'</span>:
<span class="keyword">case</span> <span class="string">'--include'</span>:
<span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
<span class="variable">require</span>.<span class="variable">paths</span>.<span class="variable">unshift</span>(<span class="variable">arg</span>);
} <span class="keyword">else</span> {
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--include requires a path'</span>);
}
<span class="keyword">break</span>;
<span class="keyword">case</span> <span class="string">'-o'</span>:
<span class="keyword">case</span> <span class="string">'--only'</span>:
<span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
<span class="variable">only</span> = <span class="variable">only</span>.<span class="variable">concat</span>(<span class="variable">arg</span>.<span class="variable">split</span>(<span class="regexp">/ *, */</span>));
} <span class="keyword">else</span> {
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--only requires comma-separated test names'</span>);
}
<span class="keyword">break</span>;
<span class="keyword">case</span> <span class="string">'-p'</span>:
<span class="keyword">case</span> <span class="string">'--port'</span>:
<span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
<span class="variable">port</span> = <span class="variable">parseInt</span>(<span class="variable">arg</span>, <span class="number integer">10</span>);
} <span class="keyword">else</span> {
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--port requires a number'</span>);
}
<span class="keyword">break</span>;
<span class="keyword">case</span> <span class="string">'-r'</span>:
<span class="keyword">case</span> <span class="string">'--require'</span>:
<span class="keyword">if</span> (<span class="variable">arg</span> = <span class="variable">args</span>.<span class="variable">shift</span>()) {
<span class="variable">require</span>(<span class="variable">arg</span>);
} <span class="keyword">else</span> {
<span class="keyword">throw</span> <span class="keyword">new</span> <span class="class">Error</span>(<span class="string">'--require requires a path'</span>);
}
<span class="keyword">break</span>;
<span class="keyword">case</span> <span class="string">'-c'</span>:
<span class="keyword">case</span> <span class="string">'--cov'</span>:
<span class="keyword">case</span> <span class="string">'--coverage'</span>:
<span class="variable">defer</span> = <span class="variable">true</span>;
<span class="variable">childProcess</span>.<span class="variable">exec</span>(<span class="string">'rm -fr lib-cov &amp;&amp; node-jscoverage lib lib-cov'</span>, <span class="keyword">function</span>(<span class="variable">err</span>){
<span class="keyword">if</span> (<span class="variable">err</span>) <span class="keyword">throw</span> <span class="variable">err</span>;
<span class="variable">require</span>.<span class="variable">paths</span>.<span class="variable">unshift</span>(<span class="string">'lib-cov'</span>);
<span class="variable">run</span>(<span class="variable">files</span>);
})
<span class="keyword">break</span>;
<span class="keyword">case</span> <span class="string">'-b'</span>:
<span class="keyword">case</span> <span class="string">'--boring'</span>:
<span class="variable">boring</span> = <span class="variable">true</span>;
<span class="keyword">break</span>;
<span class="keyword">case</span> <span class="string">'-w'</span>:
<span class="keyword">case</span> <span class="string">'--watch'</span>:
<span class="variable">watch</span> = <span class="variable">true</span>;
<span class="keyword">break</span>;
<span class="keyword">case</span> <span class="string">'--g'</span>:
<span class="keyword">case</span> <span class="string">'--growl'</span>:
<span class="variable">growl</span> = <span class="variable">true</span>;
<span class="keyword">break</span>;
<span class="keyword">default</span>:
<span class="keyword">if</span> (<span class="regexp">/\.js$/</span>.<span class="variable">test</span>(<span class="variable">arg</span>)) {
<span class="variable">files</span>.<span class="variable">push</span>(<span class="variable">arg</span>);
}
<span class="keyword">break</span>;
}
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Colorized sys.error().</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>String</em> str</p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">print</span>(<span class="variable">str</span>){
<span class="variable">sys</span>.<span class="variable">error</span>(<span class="variable">colorize</span>(<span class="variable">str</span>));
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Colorize the given string using ansi-escape sequences.
Disabled when --boring is set.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>String</em> str</p></li><li><p><strong>return</strong>: <em>String</em> </p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">colorize</span>(<span class="variable">str</span>){
<span class="keyword">var</span> <span class="variable">colors</span> = { <span class="variable">bold</span>: <span class="number integer">1</span>, <span class="variable">red</span>: <span class="number integer">31</span>, <span class="variable">green</span>: <span class="number integer">32</span>, <span class="variable">yellow</span>: <span class="number integer">33</span> };
<span class="keyword">return</span> <span class="variable">str</span>.<span class="variable">replace</span>(<span class="regexp">/\[(\w+)\]\{([^]*?)\}/g</span>, <span class="keyword">function</span>(<span class="variable">_</span>, <span class="variable">color</span>, <span class="variable">str</span>){
<span class="keyword">return</span> <span class="variable">boring</span>
? <span class="variable">str</span>
: <span class="string">'\x1B['</span> + <span class="variable">colors</span>[<span class="variable">color</span>] + <span class="string">'m'</span> + <span class="variable">str</span> + <span class="string">'\x1B[0m'</span>;
});
}
<span class="comment">// Alias deepEqual as eql for complex equality</span>
<span class="variable">assert</span>.<span class="variable">eql</span> = <span class="variable">assert</span>.<span class="variable">deepEqual</span>;</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Assert that <code>val</code> is null.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Mixed</em> val</p></li><li><p><strong>param</strong>: <em>String</em> msg</p></li></ul>
</td>
<td class="code">
<pre><code><span class="variable">assert</span>.<span class="variable">isNull</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">msg</span>) {
<span class="variable">assert</span>.<span class="variable">strictEqual</span>(<span class="keyword">null</span>, <span class="variable">val</span>, <span class="variable">msg</span>);
};</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Assert that <code>val</code> is not null.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Mixed</em> val</p></li><li><p><strong>param</strong>: <em>String</em> msg</p></li></ul>
</td>
<td class="code">
<pre><code><span class="variable">assert</span>.<span class="variable">isNotNull</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">msg</span>) {
<span class="variable">assert</span>.<span class="variable">notStrictEqual</span>(<span class="keyword">null</span>, <span class="variable">val</span>, <span class="variable">msg</span>);
};</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Assert that <code>val</code> is undefined.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Mixed</em> val</p></li><li><p><strong>param</strong>: <em>String</em> msg</p></li></ul>
</td>
<td class="code">
<pre><code><span class="variable">assert</span>.<span class="variable">isUndefined</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">msg</span>) {
<span class="variable">assert</span>.<span class="variable">strictEqual</span>(<span class="variable">undefined</span>, <span class="variable">val</span>, <span class="variable">msg</span>);
};</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Assert that <code>val</code> is not undefined.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Mixed</em> val</p></li><li><p><strong>param</strong>: <em>String</em> msg</p></li></ul>
</td>
<td class="code">
<pre><code><span class="variable">assert</span>.<span class="variable">isDefined</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">msg</span>) {
<span class="variable">assert</span>.<span class="variable">notStrictEqual</span>(<span class="variable">undefined</span>, <span class="variable">val</span>, <span class="variable">msg</span>);
};</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Assert that <code>obj</code> is <code>type</code>.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Mixed</em> obj</p></li><li><p><strong>param</strong>: <em>String</em> type</p></li><li><p><strong>api</strong>: <em>public</em></p></li></ul>
</td>
<td class="code">
<pre><code><span class="variable">assert</span>.<span class="variable">type</span> = <span class="keyword">function</span>(<span class="variable">obj</span>, <span class="variable">type</span>, <span class="variable">msg</span>){
<span class="keyword">var</span> <span class="variable">real</span> = <span class="keyword">typeof</span> <span class="variable">obj</span>;
<span class="variable">msg</span> = <span class="variable">msg</span> || <span class="string">'typeof '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">obj</span>) + <span class="string">' is '</span> + <span class="variable">real</span> + <span class="string">', expected '</span> + <span class="variable">type</span>;
<span class="variable">assert</span>.<span class="variable">ok</span>(<span class="variable">type</span> === <span class="variable">real</span>, <span class="variable">msg</span>);
};</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Assert that <code>str</code> matches <code>regexp</code>.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>String</em> str</p></li><li><p><strong>param</strong>: <em>RegExp</em> regexp</p></li><li><p><strong>param</strong>: <em>String</em> msg</p></li></ul>
</td>
<td class="code">
<pre><code><span class="variable">assert</span>.<span class="variable">match</span> = <span class="keyword">function</span>(<span class="variable">str</span>, <span class="variable">regexp</span>, <span class="variable">msg</span>) {
<span class="variable">msg</span> = <span class="variable">msg</span> || <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">str</span>) + <span class="string">' does not match '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">regexp</span>);
<span class="variable">assert</span>.<span class="variable">ok</span>(<span class="variable">regexp</span>.<span class="variable">test</span>(<span class="variable">str</span>), <span class="variable">msg</span>);
};</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Assert that <code>val</code> is within <code>obj</code>.</p>
<h2>Examples</h2>
<p> assert.includes('foobar', 'bar');
assert.includes(['foo', 'bar'], 'foo');</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>String | Array</em> obj</p></li><li><p><strong>param</strong>: <em>Mixed</em> val</p></li><li><p><strong>param</strong>: <em>String</em> msg</p></li></ul>
</td>
<td class="code">
<pre><code><span class="variable">assert</span>.<span class="variable">includes</span> = <span class="keyword">function</span>(<span class="variable">obj</span>, <span class="variable">val</span>, <span class="variable">msg</span>) {
<span class="variable">msg</span> = <span class="variable">msg</span> || <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">obj</span>) + <span class="string">' does not include '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">val</span>);
<span class="variable">assert</span>.<span class="variable">ok</span>(<span class="variable">obj</span>.<span class="variable">indexOf</span>(<span class="variable">val</span>) &<span class="variable">gt</span>;= <span class="number integer">0</span>, <span class="variable">msg</span>);
};</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Assert length of <code>val</code> is <code>n</code>.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Mixed</em> val</p></li><li><p><strong>param</strong>: <em>Number</em> n</p></li><li><p><strong>param</strong>: <em>String</em> msg</p></li></ul>
</td>
<td class="code">
<pre><code><span class="variable">assert</span>.<span class="variable">length</span> = <span class="keyword">function</span>(<span class="variable">val</span>, <span class="variable">n</span>, <span class="variable">msg</span>) {
<span class="variable">msg</span> = <span class="variable">msg</span> || <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">val</span>) + <span class="string">' has length of '</span> + <span class="variable">val</span>.<span class="variable">length</span> + <span class="string">', expected '</span> + <span class="variable">n</span>;
<span class="variable">assert</span>.<span class="variable">equal</span>(<span class="variable">n</span>, <span class="variable">val</span>.<span class="variable">length</span>, <span class="variable">msg</span>);
};</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Assert response from <code>server</code> with
the given <code>req</code> object and <code>res</code> assertions object.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Server</em> server</p></li><li><p><strong>param</strong>: <em>Object</em> req</p></li><li><p><strong>param</strong>: <em>Object | Function</em> res</p></li><li><p><strong>param</strong>: <em>String</em> msg</p></li></ul>
</td>
<td class="code">
<pre><code><span class="variable">assert</span>.<span class="variable">response</span> = <span class="keyword">function</span>(<span class="variable">server</span>, <span class="variable">req</span>, <span class="variable">res</span>, <span class="variable">msg</span>){
<span class="comment">// Callback as third or fourth arg</span>
<span class="keyword">var</span> <span class="variable">callback</span> = <span class="keyword">typeof</span> <span class="variable">res</span> === <span class="string">'function'</span>
? <span class="variable">res</span>
: <span class="keyword">typeof</span> <span class="variable">msg</span> === <span class="string">'function'</span>
? <span class="variable">msg</span>
: <span class="keyword">function</span>(){};
<span class="comment">// Default messate to test title</span>
<span class="variable">msg</span> = <span class="variable">msg</span> || <span class="variable">assert</span>.<span class="variable">testTitle</span>;
<span class="variable">msg</span> += <span class="string">'. '</span>;
<span class="comment">// Pending responses</span>
<span class="variable">server</span>.<span class="variable">__pending</span> = <span class="variable">server</span>.<span class="variable">__pending</span> || <span class="number integer">0</span>;
<span class="variable">server</span>.<span class="variable">__pending</span>++;
<span class="comment">// Create client</span>
<span class="keyword">if</span> (!<span class="variable">server</span>.<span class="variable">fd</span>) {
<span class="variable">server</span>.<span class="variable">listen</span>(<span class="variable">server</span>.<span class="variable">__port</span> = <span class="variable">port</span>++);
<span class="variable">server</span>.<span class="variable">client</span> = <span class="variable">http</span>.<span class="variable">createClient</span>(<span class="variable">server</span>.<span class="variable">__port</span>);
}
<span class="comment">// Issue request</span>
<span class="keyword">var</span> <span class="variable">timer</span>,
<span class="variable">client</span> = <span class="variable">server</span>.<span class="variable">client</span>,
<span class="variable">method</span> = <span class="variable">req</span>.<span class="variable">method</span> || <span class="string">'GET'</span>,
<span class="variable">status</span> = <span class="variable">res</span>.<span class="variable">status</span> || <span class="variable">res</span>.<span class="variable">statusCode</span>,
<span class="variable">data</span> = <span class="variable">req</span>.<span class="variable">data</span> || <span class="variable">req</span>.<span class="variable">body</span>,
<span class="variable">timeout</span> = <span class="variable">req</span>.<span class="variable">timeout</span> || <span class="number integer">0</span>;
<span class="keyword">var</span> <span class="variable">request</span> = <span class="variable">client</span>.<span class="variable">request</span>(<span class="variable">method</span>, <span class="variable">req</span>.<span class="variable">url</span>, <span class="variable">req</span>.<span class="variable">headers</span>);
<span class="comment">// Timeout</span>
<span class="keyword">if</span> (<span class="variable">timeout</span>) {
<span class="variable">timer</span> = <span class="variable">setTimeout</span>(<span class="keyword">function</span>(){
--<span class="variable">server</span>.<span class="variable">__pending</span> || <span class="variable">server</span>.<span class="variable">close</span>();
<span class="keyword">delete</span> <span class="variable">req</span>.<span class="variable">timeout</span>;
<span class="variable">assert</span>.<span class="variable">fail</span>(<span class="variable">msg</span> + <span class="string">'Request timed out after '</span> + <span class="variable">timeout</span> + <span class="string">'ms.'</span>);
}, <span class="variable">timeout</span>);
}
<span class="keyword">if</span> (<span class="variable">data</span>) <span class="variable">request</span>.<span class="variable">write</span>(<span class="variable">data</span>);
<span class="variable">request</span>.<span class="variable">addListener</span>(<span class="string">'response'</span>, <span class="keyword">function</span>(<span class="variable">response</span>){
<span class="variable">response</span>.<span class="variable">body</span> = <span class="string">''</span>;
<span class="variable">response</span>.<span class="variable">setEncoding</span>(<span class="string">'utf8'</span>);
<span class="variable">response</span>.<span class="variable">addListener</span>(<span class="string">'data'</span>, <span class="keyword">function</span>(<span class="variable">chunk</span>){ <span class="variable">response</span>.<span class="variable">body</span> += <span class="variable">chunk</span>; });
<span class="variable">response</span>.<span class="variable">addListener</span>(<span class="string">'end'</span>, <span class="keyword">function</span>(){
--<span class="variable">server</span>.<span class="variable">__pending</span> || <span class="variable">server</span>.<span class="variable">close</span>();
<span class="keyword">if</span> (<span class="variable">timer</span>) <span class="variable">clearTimeout</span>(<span class="variable">timer</span>);
<span class="comment">// Assert response body</span>
<span class="keyword">if</span> (<span class="variable">res</span>.<span class="variable">body</span> !== <span class="variable">undefined</span>) {
<span class="variable">assert</span>.<span class="variable">equal</span>(
<span class="variable">response</span>.<span class="variable">body</span>,
<span class="variable">res</span>.<span class="variable">body</span>,
<span class="variable">msg</span> + <span class="string">'Invalid response body.\n'</span>
+ <span class="string">' Expected: '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">res</span>.<span class="variable">body</span>) + <span class="string">'\n'</span>
+ <span class="string">' Got: '</span> + <span class="variable">sys</span>.<span class="variable">inspect</span>(<span class="variable">response</span>.<span class="variable">body</span>)
);
}
<span class="comment">// Assert response status</span>
<span class="keyword">if</span> (<span class="keyword">typeof</span> <span class="variable">status</span> === <span class="string">'number'</span>) {
<span class="variable">assert</span>.<span class="variable">equal</span>(
<span class="variable">response</span>.<span class="variable">statusCode</span>,
<span class="variable">status</span>,
<span class="variable">msg</span> + <span class="variable">colorize</span>(<span class="string">'Invalid response status code.\n'</span>
+ <span class="string">' Expected: [green]{'</span> + <span class="variable">status</span> + <span class="string">'}\n'</span>
+ <span class="string">' Got: [red]{'</span> + <span class="variable">response</span>.<span class="variable">statusCode</span> + <span class="string">'}'</span>)
);
}
<span class="comment">// Assert response headers</span>
<span class="keyword">if</span> (<span class="variable">res</span>.<span class="variable">headers</span>) {
<span class="keyword">var</span> <span class="variable">keys</span> = <span class="class">Object</span>.<span class="variable">keys</span>(<span class="variable">res</span>.<span class="variable">headers</span>);
<span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">i</span> = <span class="number integer">0</span>, <span class="variable">len</span> = <span class="variable">keys</span>.<span class="variable">length</span>; <span class="variable">i</span> &<span class="variable">lt</span>; <span class="variable">len</span>; ++<span class="variable">i</span>) {
<span class="keyword">var</span> <span class="variable">name</span> = <span class="variable">keys</span>[<span class="variable">i</span>],
<span class="variable">actual</span> = <span class="variable">response</span>.<span class="variable">headers</span>[<span class="variable">name</span>.<span class="variable">toLowerCase</span>()],
<span class="variable">expected</span> = <span class="variable">res</span>.<span class="variable">headers</span>[<span class="variable">name</span>];
<span class="variable">assert</span>.<span class="variable">equal</span>(
<span class="variable">actual</span>,
<span class="variable">expected</span>,
<span class="variable">msg</span> + <span class="variable">colorize</span>(<span class="string">'Invalid response header [bold]{'</span> + <span class="variable">name</span> + <span class="string">'}.\n'</span>
+ <span class="string">' Expected: [green]{'</span> + <span class="variable">expected</span> + <span class="string">'}\n'</span>
+ <span class="string">' Got: [red]{'</span> + <span class="variable">actual</span> + <span class="string">'}'</span>)
);
}
}
<span class="comment">// Callback</span>
<span class="variable">callback</span>(<span class="variable">response</span>);
});
});
<span class="variable">request</span>.<span class="variable">end</span>();
};</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Pad the given string to the maximum width provided.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>String</em> str</p></li><li><p><strong>param</strong>: <em>Number</em> width</p></li><li><p><strong>return</strong>: <em>String</em> </p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">lpad</span>(<span class="variable">str</span>, <span class="variable">width</span>) {
<span class="variable">str</span> = <span class="class">String</span>(<span class="variable">str</span>);
<span class="keyword">var</span> <span class="variable">n</span> = <span class="variable">width</span> - <span class="variable">str</span>.<span class="variable">length</span>;
<span class="keyword">if</span> (<span class="variable">n</span> &<span class="variable">lt</span>; <span class="number integer">1</span>) <span class="keyword">return</span> <span class="variable">str</span>;
<span class="keyword">while</span> (<span class="variable">n</span>--) <span class="variable">str</span> = <span class="string">' '</span> + <span class="variable">str</span>;
<span class="keyword">return</span> <span class="variable">str</span>;
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Pad the given string to the maximum width provided.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>String</em> str</p></li><li><p><strong>param</strong>: <em>Number</em> width</p></li><li><p><strong>return</strong>: <em>String</em> </p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">rpad</span>(<span class="variable">str</span>, <span class="variable">width</span>) {
<span class="variable">str</span> = <span class="class">String</span>(<span class="variable">str</span>);
<span class="keyword">var</span> <span class="variable">n</span> = <span class="variable">width</span> - <span class="variable">str</span>.<span class="variable">length</span>;
<span class="keyword">if</span> (<span class="variable">n</span> &<span class="variable">lt</span>; <span class="number integer">1</span>) <span class="keyword">return</span> <span class="variable">str</span>;
<span class="keyword">while</span> (<span class="variable">n</span>--) <span class="variable">str</span> = <span class="variable">str</span> + <span class="string">' '</span>;
<span class="keyword">return</span> <span class="variable">str</span>;
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Report test coverage.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Object</em> cov</p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">reportCoverage</span>(<span class="variable">cov</span>) {
<span class="variable">populateCoverage</span>(<span class="variable">cov</span>);
<span class="comment">// Stats</span>
<span class="variable">print</span>(<span class="string">'\n [bold]{Test Coverage}\n'</span>);
<span class="keyword">var</span> <span class="variable">sep</span> = <span class="string">' +------------------------------------------+----------+------+------+--------+'</span>,
<span class="variable">lastSep</span> = <span class="string">' +----------+------+------+--------+'</span>;
<span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">sep</span>);
<span class="variable">sys</span>.<span class="variable">puts</span>(<span class="string">' | filename | coverage | LOC | SLOC | missed |'</span>);
<span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">sep</span>);
<span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">name</span> <span class="keyword">in</span> <span class="variable">cov</span>) {
<span class="keyword">var</span> <span class="variable">file</span> = <span class="variable">cov</span>[<span class="variable">name</span>];
<span class="keyword">if</span> (<span class="class">Array</span>.<span class="variable">isArray</span>(<span class="variable">file</span>)) {
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">rpad</span>(<span class="variable">name</span>, <span class="number integer">40</span>));
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">file</span>.<span class="variable">coverage</span>.<span class="variable">toFixed</span>(<span class="number integer">2</span>), <span class="number integer">8</span>));
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">file</span>.<span class="class">LOC</span>, <span class="number integer">4</span>));
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">file</span>.<span class="class">SLOC</span>, <span class="number integer">4</span>));
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">file</span>.<span class="variable">totalMisses</span>, <span class="number integer">6</span>));
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' |\n'</span>);
}
}
<span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">sep</span>);
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' '</span> + <span class="variable">rpad</span>(<span class="string">''</span>, <span class="number integer">40</span>));
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">cov</span>.<span class="variable">coverage</span>.<span class="variable">toFixed</span>(<span class="number integer">2</span>), <span class="number integer">8</span>));
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">cov</span>.<span class="class">LOC</span>, <span class="number integer">4</span>));
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">cov</span>.<span class="class">SLOC</span>, <span class="number integer">4</span>));
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' | '</span> + <span class="variable">lpad</span>(<span class="variable">cov</span>.<span class="variable">totalMisses</span>, <span class="number integer">6</span>));
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">' |\n'</span>);
<span class="variable">sys</span>.<span class="variable">puts</span>(<span class="variable">lastSep</span>);
<span class="comment">// Source</span>
<span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">name</span> <span class="keyword">in</span> <span class="variable">cov</span>) {
<span class="keyword">if</span> (<span class="variable">name</span>.<span class="variable">match</span>(<span class="regexp">/\.js$/</span>)) {
<span class="keyword">var</span> <span class="variable">file</span> = <span class="variable">cov</span>[<span class="variable">name</span>];
<span class="variable">print</span>(<span class="string">'\n [bold]{'</span> + <span class="variable">name</span> + <span class="string">'}:'</span>);
<span class="variable">print</span>(<span class="variable">file</span>.<span class="variable">source</span>);
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'\n'</span>);
}
}
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Populate code coverage data.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Object</em> cov</p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">populateCoverage</span>(<span class="variable">cov</span>) {
<span class="variable">cov</span>.<span class="class">LOC</span> =
<span class="variable">cov</span>.<span class="class">SLOC</span> =
<span class="variable">cov</span>.<span class="variable">totalFiles</span> =
<span class="variable">cov</span>.<span class="variable">totalHits</span> =
<span class="variable">cov</span>.<span class="variable">totalMisses</span> =
<span class="variable">cov</span>.<span class="variable">coverage</span> = <span class="number integer">0</span>;
<span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">name</span> <span class="keyword">in</span> <span class="variable">cov</span>) {
<span class="keyword">var</span> <span class="variable">file</span> = <span class="variable">cov</span>[<span class="variable">name</span>];
<span class="keyword">if</span> (<span class="class">Array</span>.<span class="variable">isArray</span>(<span class="variable">file</span>)) {
<span class="comment">// Stats</span>
++<span class="variable">cov</span>.<span class="variable">totalFiles</span>;
<span class="variable">cov</span>.<span class="variable">totalHits</span> += <span class="variable">file</span>.<span class="variable">totalHits</span> = <span class="variable">coverage</span>(<span class="variable">file</span>, <span class="variable">true</span>);
<span class="variable">cov</span>.<span class="variable">totalMisses</span> += <span class="variable">file</span>.<span class="variable">totalMisses</span> = <span class="variable">coverage</span>(<span class="variable">file</span>, <span class="variable">false</span>);
<span class="variable">file</span>.<span class="variable">totalLines</span> = <span class="variable">file</span>.<span class="variable">totalHits</span> + <span class="variable">file</span>.<span class="variable">totalMisses</span>;
<span class="variable">cov</span>.<span class="class">SLOC</span> += <span class="variable">file</span>.<span class="class">SLOC</span> = <span class="variable">file</span>.<span class="variable">totalLines</span>;
<span class="variable">cov</span>.<span class="class">LOC</span> += <span class="variable">file</span>.<span class="class">LOC</span> = <span class="variable">file</span>.<span class="variable">source</span>.<span class="variable">length</span>;
<span class="variable">file</span>.<span class="variable">coverage</span> = (<span class="variable">file</span>.<span class="variable">totalHits</span> / <span class="variable">file</span>.<span class="variable">totalLines</span>) * <span class="number integer">100</span>;
<span class="comment">// Source</span>
<span class="keyword">var</span> <span class="variable">width</span> = <span class="variable">file</span>.<span class="variable">source</span>.<span class="variable">length</span>.<span class="variable">toString</span>().<span class="variable">length</span>;
<span class="variable">file</span>.<span class="variable">source</span> = <span class="variable">file</span>.<span class="variable">source</span>.<span class="variable">map</span>(<span class="keyword">function</span>(<span class="variable">line</span>, <span class="variable">i</span>){
++<span class="variable">i</span>;
<span class="keyword">var</span> <span class="variable">hits</span> = <span class="variable">file</span>[<span class="variable">i</span>] === <span class="number integer">0</span> ? <span class="number integer">0</span> : (<span class="variable">file</span>[<span class="variable">i</span>] || <span class="string">' '</span>);
<span class="keyword">if</span> (!<span class="variable">boring</span>) {
<span class="keyword">if</span> (<span class="variable">hits</span> === <span class="number integer">0</span>) {
<span class="variable">hits</span> = <span class="string">'\x1b[31m'</span> + <span class="variable">hits</span> + <span class="string">'\x1b[0m'</span>;
<span class="variable">line</span> = <span class="string">'\x1b[41m'</span> + <span class="variable">line</span> + <span class="string">'\x1b[0m'</span>;
} <span class="keyword">else</span> {
<span class="variable">hits</span> = <span class="string">'\x1b[32m'</span> + <span class="variable">hits</span> + <span class="string">'\x1b[0m'</span>;
}
}
<span class="keyword">return</span> <span class="string">'\n '</span> + <span class="variable">lpad</span>(<span class="variable">i</span>, <span class="variable">width</span>) + <span class="string">' | '</span> + <span class="variable">hits</span> + <span class="string">' | '</span> + <span class="variable">line</span>;
}).<span class="variable">join</span>(<span class="string">''</span>);
}
}
<span class="variable">cov</span>.<span class="variable">coverage</span> = (<span class="variable">cov</span>.<span class="variable">totalHits</span> / <span class="variable">cov</span>.<span class="class">SLOC</span>) * <span class="number integer">100</span>;
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Total coverage for the given file data.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Array</em> data</p></li><li><p><strong>return</strong>: <em>Type</em> </p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">coverage</span>(<span class="variable">data</span>, <span class="variable">val</span>) {
<span class="keyword">var</span> <span class="variable">n</span> = <span class="number integer">0</span>;
<span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">i</span> = <span class="number integer">0</span>, <span class="variable">len</span> = <span class="variable">data</span>.<span class="variable">length</span>; <span class="variable">i</span> &<span class="variable">lt</span>; <span class="variable">len</span>; ++<span class="variable">i</span>) {
<span class="keyword">if</span> (<span class="variable">data</span>[<span class="variable">i</span>] !== <span class="variable">undefined</span> &<span class="variable">amp</span>;&<span class="variable">amp</span>; <span class="variable">data</span>[<span class="variable">i</span>] == <span class="variable">val</span>) ++<span class="variable">n</span>;
}
<span class="keyword">return</span> <span class="variable">n</span>;
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Run the given test <code>files</code>, or try <em>test/*</em>.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Array</em> files</p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">run</span>(<span class="variable">files</span>) {
<span class="keyword">if</span> (!<span class="variable">files</span>.<span class="variable">length</span>) {
<span class="keyword">try</span> {
<span class="variable">files</span> = <span class="variable">fs</span>.<span class="variable">readdirSync</span>(<span class="string">'test'</span>).<span class="variable">map</span>(<span class="keyword">function</span>(<span class="variable">file</span>){
<span class="keyword">return</span> <span class="string">'test/'</span> + <span class="variable">file</span>;
});
} <span class="keyword">catch</span> (<span class="variable">err</span>) {
<span class="variable">print</span>(<span class="string">'\n failed to load tests in [bold]{./test}\n'</span>);
++<span class="variable">failures</span>;
<span class="variable">process</span>.<span class="variable">exit</span>(<span class="number integer">1</span>);
}
}
<span class="keyword">if</span> (<span class="variable">watch</span>) <span class="variable">watchFiles</span>(<span class="variable">files</span>);
<span class="variable">runFiles</span>(<span class="variable">files</span>);
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Show the cursor when <code>show</code> is true, otherwise hide it.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Boolean</em> show</p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">cursor</span>(<span class="variable">show</span>) {
<span class="keyword">if</span> (<span class="variable">show</span>) {
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'\x1b[?25h'</span>);
} <span class="keyword">else</span> {
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="string">'\x1b[?25l'</span>);
}
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Run the given test <code>files</code>.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Array</em> files</p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">runFiles</span>(<span class="variable">files</span>) {
<span class="variable">files</span>.<span class="variable">forEach</span>(<span class="variable">runFile</span>);
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Run tests for the given <code>file</code>.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>String</em> file</p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">runFile</span>(<span class="variable">file</span>) {
<span class="keyword">if</span> (<span class="variable">file</span>.<span class="variable">match</span>(<span class="regexp">/\.js$/</span>)) {
<span class="keyword">var</span> <span class="variable">title</span> = <span class="variable">path</span>.<span class="variable">basename</span>(<span class="variable">file</span>),
<span class="variable">file</span> = <span class="variable">path</span>.<span class="variable">join</span>(<span class="variable">cwd</span>, <span class="variable">file</span>),
<span class="variable">mod</span> = <span class="variable">require</span>(<span class="variable">file</span>.<span class="variable">replace</span>(<span class="regexp">/\.js$/</span>, <span class="string">''</span>));
(<span class="keyword">function</span> <span class="variable">check</span>(){
<span class="keyword">var</span> <span class="variable">len</span> = <span class="class">Object</span>.<span class="variable">keys</span>(<span class="variable">mod</span>).<span class="variable">length</span>;
<span class="keyword">if</span> (<span class="variable">len</span>) {
<span class="variable">runSuite</span>(<span class="variable">title</span>, <span class="variable">mod</span>);
} <span class="keyword">else</span> {
<span class="variable">setTimeout</span>(<span class="variable">check</span>, <span class="number integer">20</span>);
}
})();
}
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Clear the module cache for the given <code>file</code>.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>String</em> file</p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">clearCache</span>(<span class="variable">file</span>) {
<span class="keyword">var</span> <span class="variable">keys</span> = <span class="class">Object</span>.<span class="variable">keys</span>(<span class="variable">module</span>.<span class="variable">moduleCache</span>);
<span class="keyword">for</span> (<span class="keyword">var</span> <span class="variable">i</span> = <span class="number integer">0</span>, <span class="variable">len</span> = <span class="variable">keys</span>.<span class="variable">length</span>; <span class="variable">i</span> &<span class="variable">lt</span>; <span class="variable">len</span>; ++<span class="variable">i</span>) {
<span class="keyword">var</span> <span class="variable">key</span> = <span class="variable">keys</span>[<span class="variable">i</span>];
<span class="keyword">if</span> (<span class="variable">key</span>.<span class="variable">indexOf</span>(<span class="variable">file</span>) === <span class="variable">key</span>.<span class="variable">length</span> - <span class="variable">file</span>.<span class="variable">length</span>) {
<span class="keyword">delete</span> <span class="variable">module</span>.<span class="variable">moduleCache</span>[<span class="variable">key</span>];
}
}
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Watch the given <code>files</code> for changes.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>Array</em> files</p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">watchFiles</span>(<span class="variable">files</span>) {
<span class="keyword">var</span> <span class="variable">p</span> = <span class="number integer">0</span>,
<span class="variable">c</span> = [<span class="string">'▫ '</span>, <span class="string">'▫▫ '</span>, <span class="string">'▫▫▫ '</span>, <span class="string">' ▫▫▫'</span>,
<span class="string">' ▫▫'</span>, <span class="string">' ▫'</span>, <span class="string">' ▫'</span>, <span class="string">' ▫▫'</span>,
<span class="string">'▫▫▫ '</span>, <span class="string">'▫▫ '</span>, <span class="string">'▫ '</span>],
<span class="variable">l</span> = <span class="variable">c</span>.<span class="variable">length</span>;
<span class="variable">cursor</span>(<span class="variable">false</span>);
<span class="variable">setInterval</span>(<span class="keyword">function</span>(){
<span class="variable">sys</span>.<span class="variable">print</span>(<span class="variable">colorize</span>(<span class="string">' [green]{'</span> + <span class="variable">c</span>[<span class="variable">p</span>++ % <span class="variable">l</span>] + <span class="string">'} watching\r'</span>));
}, <span class="number integer">100</span>);
<span class="variable">files</span>.<span class="variable">forEach</span>(<span class="keyword">function</span>(<span class="variable">file</span>){
<span class="variable">fs</span>.<span class="variable">watchFile</span>(<span class="variable">file</span>, { <span class="variable">interval</span>: <span class="number integer">100</span> }, <span class="keyword">function</span>(<span class="variable">curr</span>, <span class="variable">prev</span>){
<span class="keyword">if</span> (<span class="variable">curr</span>.<span class="variable">mtime</span> &<span class="variable">gt</span>; <span class="variable">prev</span>.<span class="variable">mtime</span>) {
<span class="variable">print</span>(<span class="string">' [yellow]{◦} '</span> + <span class="variable">file</span>);
<span class="variable">clearCache</span>(<span class="variable">file</span>);
<span class="variable">runFile</span>(<span class="variable">file</span>);
}
});
});
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Report <code>err</code> for the given <code>test</code> and <code>suite</code>.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>String</em> suite</p></li><li><p><strong>param</strong>: <em>String</em> test</p></li><li><p><strong>param</strong>: <em>Error</em> err</p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">error</span>(<span class="variable">suite</span>, <span class="variable">test</span>, <span class="variable">err</span>) {
++<span class="variable">failures</span>;
<span class="keyword">var</span> <span class="variable">name</span> = <span class="variable">err</span>.<span class="variable">name</span>,
<span class="variable">stack</span> = <span class="variable">err</span>.<span class="variable">stack</span>.<span class="variable">replace</span>(<span class="variable">err</span>.<span class="variable">name</span>, <span class="string">''</span>),
<span class="keyword">label</span> = <span class="variable">test</span> === <span class="string">'uncaught'</span>
? <span class="variable">test</span>
: <span class="variable">suite</span> + <span class="string">' '</span> + <span class="variable">test</span>;
<span class="variable">print</span>(<span class="string">'\n [bold]{'</span> + <span class="keyword">label</span> + <span class="string">'}: [red]{'</span> + <span class="variable">name</span> + <span class="string">'}'</span> + <span class="variable">stack</span> + <span class="string">'\n'</span>);
<span class="keyword">if</span> (<span class="variable">watch</span>) <span class="variable">notify</span>(<span class="keyword">label</span> + <span class="string">' failed'</span>);
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Run the given tests.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>String</em> title</p></li><li><p><strong>param</strong>: <em>Object</em> tests</p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">runSuite</span>(<span class="variable">title</span>, <span class="variable">tests</span>) {
<span class="keyword">var</span> <span class="variable">keys</span> = <span class="variable">only</span>.<span class="variable">length</span>
? <span class="variable">only</span>.<span class="variable">slice</span>(<span class="number integer">0</span>)
: <span class="class">Object</span>.<span class="variable">keys</span>(<span class="variable">tests</span>);
(<span class="keyword">function</span> <span class="variable">next</span>(){
<span class="keyword">if</span> (<span class="variable">keys</span>.<span class="variable">length</span>) {
<span class="keyword">var</span> <span class="variable">key</span>,
<span class="variable">test</span> = <span class="variable">tests</span>[<span class="variable">key</span> = <span class="variable">keys</span>.<span class="variable">shift</span>()];
<span class="keyword">if</span> (<span class="variable">test</span>) {
<span class="keyword">try</span> {
<span class="variable">assert</span>.<span class="variable">testTitle</span> = <span class="variable">key</span>;
<span class="variable">test</span>(<span class="variable">assert</span>, <span class="keyword">function</span>(<span class="variable">fn</span>){
<span class="variable">process</span>.<span class="variable">addListener</span>(<span class="string">'beforeExit'</span>, <span class="keyword">function</span>(){
<span class="keyword">try</span> {
<span class="variable">fn</span>();
} <span class="keyword">catch</span> (<span class="variable">err</span>) {
<span class="variable">error</span>(<span class="variable">title</span>, <span class="variable">key</span>, <span class="variable">err</span>);
}
});
});
} <span class="keyword">catch</span> (<span class="variable">err</span>) {
<span class="variable">error</span>(<span class="variable">title</span>, <span class="variable">key</span>, <span class="variable">err</span>);
}
}
<span class="variable">next</span>();
}
})();
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Report exceptions.
</p>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">report</span>() {
<span class="variable">process</span>.<span class="variable">emit</span>(<span class="string">'beforeExit'</span>);
<span class="keyword">if</span> (<span class="variable">failures</span>) {
<span class="variable">print</span>(<span class="string">'\n [bold]{Failures}: [red]{'</span> + <span class="variable">failures</span> + <span class="string">'}\n\n'</span>);
<span class="variable">notify</span>(<span class="string">'Failures: '</span> + <span class="variable">failures</span>);
} <span class="keyword">else</span> {
<span class="variable">print</span>(<span class="string">'\n [green]{100%} ok\n'</span>);
<span class="variable">notify</span>(<span class="string">'100% ok'</span>);
}
<span class="keyword">if</span> (<span class="keyword">typeof</span> <span class="variable">_</span>$<span class="variable">jscoverage</span> === <span class="string">'object'</span>) {
<span class="variable">reportCoverage</span>(<span class="variable">_</span>$<span class="variable">jscoverage</span>);
}
}</code></pre>
</td>
</tr>
<tr class="code">
<td class="docs">
<p>Growl notify the given <code>msg</code>.</p>
<h2></h2>
<ul><li><p><strong>param</strong>: <em>String</em> msg</p></li></ul>
</td>
<td class="code">
<pre><code><span class="keyword">function</span> <span class="variable">notify</span>(<span class="variable">msg</span>) {
<span class="keyword">if</span> (<span class="variable">growl</span>) {
<span class="variable">childProcess</span>.<span class="variable">exec</span>(<span class="string">'growlnotify -name Expresso -m &quot;'</span> + <span class="variable">msg</span> + <span class="string">'&quot;'</span>);
}
}
<span class="comment">// Report uncaught exceptions</span>
<span class="variable">process</span>.<span class="variable">addListener</span>(<span class="string">'uncaughtException'</span>, <span class="keyword">function</span>(<span class="variable">err</span>){
<span class="variable">error</span>(<span class="string">'uncaught'</span>, <span class="string">'uncaught'</span>, <span class="variable">err</span>);
});
<span class="comment">// Show cursor</span>
[<span class="string">'INT'</span>, <span class="string">'TERM'</span>, <span class="string">'QUIT'</span>].<span class="variable">forEach</span>(<span class="keyword">function</span>(<span class="variable">sig</span>){
<span class="variable">process</span>.<span class="variable">addListener</span>(<span class="string">'SIG'</span> + <span class="variable">sig</span>, <span class="keyword">function</span>(){
<span class="variable">cursor</span>(<span class="variable">true</span>);
<span class="variable">process</span>.<span class="variable">exit</span>(<span class="number integer">1</span>);
});
});
<span class="comment">// Report test coverage when available</span>
<span class="comment">// and emit &quot;beforeExit&quot; event to perform</span>
<span class="comment">// final assertions</span>
<span class="keyword">var</span> <span class="variable">orig</span> = <span class="variable">process</span>.<span class="variable">emit</span>;
<span class="variable">process</span>.<span class="variable">emit</span> = <span class="keyword">function</span>(<span class="variable">event</span>){
<span class="keyword">if</span> (<span class="variable">event</span> === <span class="string">'exit'</span>) {
<span class="variable">report</span>();
<span class="variable">process</span>.<span class="variable">reallyExit</span>(<span class="variable">failures</span>);
}
<span class="variable">orig</span>.<span class="variable">apply</span>(<span class="this">this</span>, <span class="variable">arguments</span>);
};
<span class="comment">// Run test files</span>
<span class="keyword">if</span> (!<span class="variable">defer</span>) <span class="variable">run</span>(<span class="variable">files</span>);
</code></pre>
</td>
</tr> </body>
</html></tbody></table>

380
node_modules/ejs/support/expresso/docs/index.html generated vendored Normal file
View File

@ -0,0 +1,380 @@
<html>
<head>
<title>Expresso - TDD Framework For Node</title>
<style>
body {
font: 13px/1.4 "Helvetica", "Lucida Grande", Arial, sans-serif;
}
#header {
position: absolute;
top: 10px;
left: 0;
padding: 14px 0 12px 0;
text-indent: 40px;
font-family: "Helvetica";
width: 100%;
border-top: 1px solid rgba(0,0,0,0.2);
border-bottom: 1px solid rgba(0,0,0,0.2);
background: rgba(255,255,255,0.6) url(http://www.sencha.com/favicon.ico) no-repeat 15px 50%;
text-align: left;
color: #888;
}
#ribbon {
position: absolute;
top: 0;
right: 0;
z-index: 10;
}
#wrapper {
padding: 80px;
}
h1, h2, h3 {
margin: 25px 0 15px 0;
}
pre {
margin: 0 5px;
padding: 10px;
border: 1px solid #eee;
}
</style>
</head>
<body>
<a href="http://github.com/visionmedia/expresso">
<img alt="Fork me on GitHub" id="ribbon" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" />
</a>
<div id="header"><strong>Sencha</strong> labs</div>
<div id="wrapper">
<h1>Expresso</h1>
<div class='mp'>
<p><a href="http://github.com/visionmedia/expresso">Expresso</a> is a JavaScript <a href="http://en.wikipedia.org/wiki/Test-driven_development">TDD</a> framework written for <a href="http://nodejs.org">nodejs</a>. Expresso is extremely fast, and is packed with features such as additional assertion methods, code coverage reporting, CI support, and more.</p>
<h2 id="Features">Features</h2>
<ul>
<li>light-weight</li>
<li>intuitive async support</li>
<li>intuitive test runner executable</li>
<li>test coverage support and reporting via <a href="http://github.com/visionmedia/node-jscoverage">node-jscoverage</a></li>
<li>uses and extends the core <em>assert</em> module</li>
<li><code>assert.eql()</code> alias of <code>assert.deepEqual()</code></li>
<li><code>assert.response()</code> http response utility</li>
<li><code>assert.includes()</code></li>
<li><code>assert.isNull()</code></li>
<li><code>assert.isUndefined()</code></li>
<li><code>assert.isNotNull()</code></li>
<li><code>assert.isDefined()</code></li>
<li><code>assert.match()</code></li>
<li><code>assert.length()</code></li>
</ul>
<h2 id="Installation">Installation</h2>
<p>To install both expresso <em>and</em> node-jscoverage run
the command below, which will first compile node-jscoverage:</p>
<pre><code>$ make install
</code></pre>
<p>To install expresso alone without coverage reporting run:</p>
<pre><code>$ make install-expresso
</code></pre>
<p>Install via npm:</p>
<pre><code>$ npm install expresso
</code></pre>
<h2 id="Examples">Examples</h2>
<h2 id="Examples">Examples</h2>
<p>To define tests we simply export several functions:</p>
<pre><code>exports['test String#length'] = function(assert){
assert.equal(6, 'foobar'.length);
};
</code></pre>
<p>Alternatively for large numbers of tests you may want to
export your own object containing the tests, however this
is essentially the as above:</p>
<pre><code>module.exports = {
'test String#length': function(assert){
assert.equal(6, 'foobar'.length);
}
};
</code></pre>
<p>If you prefer not to use quoted keys:</p>
<pre><code>exports.testsStringLength = function(assert){
assert.equal(6, 'foobar'.length);
};
</code></pre>
<p>The second argument passed to each callback is <em>beforeExit</em>,
which is typically used to assert that callbacks have been
invoked.</p>
<pre><code>exports.testAsync = function(assert, beforeExit){
var n = 0;
setTimeout(function(){
++n;
assert.ok(true);
}, 200);
setTimeout(function(){
++n;
assert.ok(true);
}, 200);
beforeExit(function(){
assert.equal(2, n, 'Ensure both timeouts are called');
});
};
</code></pre>
<h2 id="Assert-Utilities">Assert Utilities</h2>
<h3 id="assert-isNull-val-msg-">assert.isNull(val[, msg])</h3>
<p>Asserts that the given <em>val</em> is <em>null</em>.</p>
<pre><code>assert.isNull(null);
</code></pre>
<h3 id="assert-isNotNull-val-msg-">assert.isNotNull(val[, msg])</h3>
<p>Asserts that the given <em>val</em> is not <em>null</em>.</p>
<pre><code>assert.isNotNull(undefined);
assert.isNotNull(false);
</code></pre>
<h3 id="assert-isUndefined-val-msg-">assert.isUndefined(val[, msg])</h3>
<p>Asserts that the given <em>val</em> is <em>undefined</em>.</p>
<pre><code>assert.isUndefined(undefined);
</code></pre>
<h3 id="assert-isDefined-val-msg-">assert.isDefined(val[, msg])</h3>
<p>Asserts that the given <em>val</em> is not <em>undefined</em>.</p>
<pre><code>assert.isDefined(null);
assert.isDefined(false);
</code></pre>
<h3 id="assert-match-str-regexp-msg-">assert.match(str, regexp[, msg])</h3>
<p>Asserts that the given <em>str</em> matches <em>regexp</em>.</p>
<pre><code>assert.match('foobar', /^foo(bar)?/);
assert.match('foo', /^foo(bar)?/);
</code></pre>
<h3 id="assert-length-val-n-msg-">assert.length(val, n[, msg])</h3>
<p>Assert that the given <em>val</em> has a length of <em>n</em>.</p>
<pre><code>assert.length([1,2,3], 3);
assert.length('foo', 3);
</code></pre>
<h3 id="assert-type-obj-type-msg-">assert.type(obj, type[, msg])</h3>
<p>Assert that the given <em>obj</em> is typeof <em>type</em>.</p>
<pre><code>assert.type(3, 'number');
</code></pre>
<h3 id="assert-eql-a-b-msg-">assert.eql(a, b[, msg])</h3>
<p>Assert that object <em>b</em> is equal to object <em>a</em>. This is an
alias for the core <em>assert.deepEqual()</em> method which does complex
comparisons, opposed to <em>assert.equal()</em> which uses <em>==</em>.</p>
<pre><code>assert.eql('foo', 'foo');
assert.eql([1,2], [1,2]);
assert.eql({ foo: 'bar' }, { foo: 'bar' });
</code></pre>
<h3 id="assert-includes-obj-val-msg-">assert.includes(obj, val[, msg])</h3>
<p>Assert that <em>obj</em> is within <em>val</em>. This method supports <em>Array_s
and </em>Strings_s.</p>
<pre><code>assert.includes([1,2,3], 3);
assert.includes('foobar', 'foo');
assert.includes('foobar', 'bar');
</code></pre>
<h3 id="assert-response-server-req-res-fn-msg-fn-">assert.response(server, req, res|fn[, msg|fn])</h3>
<p>Performs assertions on the given <em>server</em>, which should <em>not</em> call
listen(), as this is handled internally by expresso and the server
is killed after all responses have completed. This method works with
any <em>http.Server</em> instance, so <em>Connect</em> and <em>Express</em> servers will work
as well.</p>
<p>The <em>req</em> object may contain:</p>
<ul>
<li><em>url</em> request url</li>
<li><em>timeout</em> timeout in milliseconds</li>
<li><em>method</em> HTTP method</li>
<li><em>data</em> request body</li>
<li><em>headers</em> headers object</li>
</ul>
<p>The <em>res</em> object may be a callback function which
receives the response for assertions, or an object
which is then used to perform several assertions
on the response with the following properties:</p>
<ul>
<li><em>body</em> assert response body</li>
<li><em>status</em> assert response status code</li>
<li><em>header</em> assert that all given headers match (unspecified are ignored)</li>
</ul>
<p>When providing <em>res</em> you may then also pass a callback function
as the fourth argument for additional assertions.</p>
<p>Below are some examples:</p>
<pre><code>assert.response(server, {
url: '/', timeout: 500
}, {
body: 'foobar'
});
assert.response(server, {
url: '/',
method: 'GET'
},{
body: '{"name":"tj"}',
status: 200,
headers: {
'Content-Type': 'application/json; charset=utf8',
'X-Foo': 'bar'
}
});
assert.response(server, {
url: '/foo',
method: 'POST',
data: 'bar baz'
},{
body: '/foo bar baz',
status: 200
}, 'Test POST');
assert.response(server, {
url: '/foo',
method: 'POST',
data: 'bar baz'
},{
body: '/foo bar baz',
status: 200
}, function(res){
// All done, do some more tests if needed
});
assert.response(server, {
url: '/'
}, function(res){
assert.ok(res.body.indexOf('tj') &gt;= 0, 'Test assert.response() callback');
});
</code></pre>
<h2 id="expresso-1-">expresso(1)</h2>
<p>To run a single test suite (file) run:</p>
<pre><code>$ expresso test/a.test.js
</code></pre>
<p>To run several suites we may simply append another:</p>
<pre><code>$ expresso test/a.test.js test/b.test.js
</code></pre>
<p>We can also pass a whitelist of tests to run within all suites:</p>
<pre><code>$ expresso --only "foo()" --only "bar()"
</code></pre>
<p>Or several with one call:</p>
<pre><code>$ expresso --only "foo(), bar()"
</code></pre>
<p>Globbing is of course possible as well:</p>
<pre><code>$ expresso test/*
</code></pre>
<p>When expresso is called without any files, <em>test/*</em> is the default,
so the following is equivalent to the command above:</p>
<pre><code>$ expresso
</code></pre>
<p>If you wish to unshift a path to <code>require.paths</code> before
running tests, you may use the <code>-I</code> or <code>--include</code> flag.</p>
<pre><code>$ expresso --include lib test/*
</code></pre>
<p>The previous example is typically what I would recommend, since expresso
supports test coverage via <a href="http://github.com/visionmedia/node-jscoverage">node-jscoverage</a> (bundled with expresso),
so you will need to expose an instrumented version of you library.</p>
<p>To instrument your library, simply run <a href="http://github.com/visionmedia/node-jscoverage">node-jscoverage</a>,
passing the <em>src</em> and <em>dest</em> directories:</p>
<pre><code>$ node-jscoverage lib lib-cov
</code></pre>
<p>Now we can run our tests again, using the <em>lib-cov</em> directory that has been
instrumented with coverage statements:</p>
<pre><code>$ expresso -I lib-cov test/*
</code></pre>
<p>The output will look similar to below, depending on your test coverage of course :)</p>
<p><img src="http://dl.dropbox.com/u/6396913/cov.png" alt="node coverage" /></p>
<p>To make this process easier expresso has the <em>-c</em> or <em>--cov</em> which essentially
does the same as the two commands above. The following two commands will
run the same tests, however one will auto-instrument, and unshift <em>lib-cov</em>,
and the other will run tests normally:</p>
<pre><code>$ expresso -I lib test/*
$ expresso -I lib --cov test/*
</code></pre>
<p>Currently coverage is bound to the <em>lib</em> directory, however in the
future <code>--cov</code> will most likely accept a path.</p>
<h2 id="Async-Exports">Async Exports</h2>
<p>Sometimes it is useful to postpone running of tests until a callback or event has fired, currently the <em>exports.foo = function(){};</em> syntax is supported for this:</p>
<pre><code>setTimeout(function(){
exports['test async exports'] = function(assert){
assert.ok('wahoo');
};
}, 100);
</code></pre>
</div>
</div>
</body>
</html>

292
node_modules/ejs/support/expresso/docs/index.md generated vendored Normal file
View File

@ -0,0 +1,292 @@
[Expresso](http://github.com/visionmedia/expresso) is a JavaScript [TDD](http://en.wikipedia.org/wiki/Test-driven_development) framework written for [nodejs](http://nodejs.org). Expresso is extremely fast, and is packed with features such as additional assertion methods, code coverage reporting, CI support, and more.
## Features
- light-weight
- intuitive async support
- intuitive test runner executable
- test coverage support and reporting via [node-jscoverage](http://github.com/visionmedia/node-jscoverage)
- uses and extends the core _assert_ module
- `assert.eql()` alias of `assert.deepEqual()`
- `assert.response()` http response utility
- `assert.includes()`
- `assert.isNull()`
- `assert.isUndefined()`
- `assert.isNotNull()`
- `assert.isDefined()`
- `assert.match()`
- `assert.length()`
## Installation
To install both expresso _and_ node-jscoverage run
the command below, which will first compile node-jscoverage:
$ make install
To install expresso alone without coverage reporting run:
$ make install-expresso
Install via npm:
$ npm install expresso
## Examples
## Examples
To define tests we simply export several functions:
exports['test String#length'] = function(assert){
assert.equal(6, 'foobar'.length);
};
Alternatively for large numbers of tests you may want to
export your own object containing the tests, however this
is essentially the as above:
module.exports = {
'test String#length': function(assert){
assert.equal(6, 'foobar'.length);
}
};
If you prefer not to use quoted keys:
exports.testsStringLength = function(assert){
assert.equal(6, 'foobar'.length);
};
The second argument passed to each callback is _beforeExit_,
which is typically used to assert that callbacks have been
invoked.
exports.testAsync = function(assert, beforeExit){
var n = 0;
setTimeout(function(){
++n;
assert.ok(true);
}, 200);
setTimeout(function(){
++n;
assert.ok(true);
}, 200);
beforeExit(function(){
assert.equal(2, n, 'Ensure both timeouts are called');
});
};
## Assert Utilities
### assert.isNull(val[, msg])
Asserts that the given _val_ is _null_.
assert.isNull(null);
### assert.isNotNull(val[, msg])
Asserts that the given _val_ is not _null_.
assert.isNotNull(undefined);
assert.isNotNull(false);
### assert.isUndefined(val[, msg])
Asserts that the given _val_ is _undefined_.
assert.isUndefined(undefined);
### assert.isDefined(val[, msg])
Asserts that the given _val_ is not _undefined_.
assert.isDefined(null);
assert.isDefined(false);
### assert.match(str, regexp[, msg])
Asserts that the given _str_ matches _regexp_.
assert.match('foobar', /^foo(bar)?/);
assert.match('foo', /^foo(bar)?/);
### assert.length(val, n[, msg])
Assert that the given _val_ has a length of _n_.
assert.length([1,2,3], 3);
assert.length('foo', 3);
### assert.type(obj, type[, msg])
Assert that the given _obj_ is typeof _type_.
assert.type(3, 'number');
### assert.eql(a, b[, msg])
Assert that object _b_ is equal to object _a_. This is an
alias for the core _assert.deepEqual()_ method which does complex
comparisons, opposed to _assert.equal()_ which uses _==_.
assert.eql('foo', 'foo');
assert.eql([1,2], [1,2]);
assert.eql({ foo: 'bar' }, { foo: 'bar' });
### assert.includes(obj, val[, msg])
Assert that _obj_ is within _val_. This method supports _Array_s
and _Strings_s.
assert.includes([1,2,3], 3);
assert.includes('foobar', 'foo');
assert.includes('foobar', 'bar');
### assert.response(server, req, res|fn[, msg|fn])
Performs assertions on the given _server_, which should _not_ call
listen(), as this is handled internally by expresso and the server
is killed after all responses have completed. This method works with
any _http.Server_ instance, so _Connect_ and _Express_ servers will work
as well.
The _req_ object may contain:
- _url_ request url
- _timeout_ timeout in milliseconds
- _method_ HTTP method
- _data_ request body
- _headers_ headers object
The _res_ object may be a callback function which
receives the response for assertions, or an object
which is then used to perform several assertions
on the response with the following properties:
- _body_ assert response body
- _status_ assert response status code
- _header_ assert that all given headers match (unspecified are ignored)
When providing _res_ you may then also pass a callback function
as the fourth argument for additional assertions.
Below are some examples:
assert.response(server, {
url: '/', timeout: 500
}, {
body: 'foobar'
});
assert.response(server, {
url: '/',
method: 'GET'
},{
body: '{"name":"tj"}',
status: 200,
headers: {
'Content-Type': 'application/json; charset=utf8',
'X-Foo': 'bar'
}
});
assert.response(server, {
url: '/foo',
method: 'POST',
data: 'bar baz'
},{
body: '/foo bar baz',
status: 200
}, 'Test POST');
assert.response(server, {
url: '/foo',
method: 'POST',
data: 'bar baz'
},{
body: '/foo bar baz',
status: 200
}, function(res){
// All done, do some more tests if needed
});
assert.response(server, {
url: '/'
}, function(res){
assert.ok(res.body.indexOf('tj') >= 0, 'Test assert.response() callback');
});
## expresso(1)
To run a single test suite (file) run:
$ expresso test/a.test.js
To run several suites we may simply append another:
$ expresso test/a.test.js test/b.test.js
We can also pass a whitelist of tests to run within all suites:
$ expresso --only "foo()" --only "bar()"
Or several with one call:
$ expresso --only "foo(), bar()"
Globbing is of course possible as well:
$ expresso test/*
When expresso is called without any files, _test/*_ is the default,
so the following is equivalent to the command above:
$ expresso
If you wish to unshift a path to `require.paths` before
running tests, you may use the `-I` or `--include` flag.
$ expresso --include lib test/*
The previous example is typically what I would recommend, since expresso
supports test coverage via [node-jscoverage](http://github.com/visionmedia/node-jscoverage) (bundled with expresso),
so you will need to expose an instrumented version of you library.
To instrument your library, simply run [node-jscoverage](http://github.com/visionmedia/node-jscoverage),
passing the _src_ and _dest_ directories:
$ node-jscoverage lib lib-cov
Now we can run our tests again, using the _lib-cov_ directory that has been
instrumented with coverage statements:
$ expresso -I lib-cov test/*
The output will look similar to below, depending on your test coverage of course :)
![node coverage](http://dl.dropbox.com/u/6396913/cov.png)
To make this process easier expresso has the _-c_ or _--cov_ which essentially
does the same as the two commands above. The following two commands will
run the same tests, however one will auto-instrument, and unshift _lib-cov_,
and the other will run tests normally:
$ expresso -I lib test/*
$ expresso -I lib --cov test/*
Currently coverage is bound to the _lib_ directory, however in the
future `--cov` will most likely accept a path.
## Async Exports
Sometimes it is useful to postpone running of tests until a callback or event has fired, currently the _exports.foo = function(){};_ syntax is supported for this:
setTimeout(function(){
exports['test async exports'] = function(assert){
assert.ok('wahoo');
};
}, 100);

3
node_modules/ejs/support/expresso/docs/layout/foot.html generated vendored Normal file
View File

@ -0,0 +1,3 @@
</div>
</body>
</html>

47
node_modules/ejs/support/expresso/docs/layout/head.html generated vendored Normal file
View File

@ -0,0 +1,47 @@
<html>
<head>
<title>Expresso - TDD Framework For Node</title>
<style>
body {
font: 13px/1.4 "Helvetica", "Lucida Grande", Arial, sans-serif;
}
#header {
position: absolute;
top: 10px;
left: 0;
padding: 14px 0 12px 0;
text-indent: 40px;
font-family: "Helvetica";
width: 100%;
border-top: 1px solid rgba(0,0,0,0.2);
border-bottom: 1px solid rgba(0,0,0,0.2);
background: rgba(255,255,255,0.6) url(http://www.sencha.com/favicon.ico) no-repeat 15px 50%;
text-align: left;
color: #888;
}
#ribbon {
position: absolute;
top: 0;
right: 0;
z-index: 10;
}
#wrapper {
padding: 80px;
}
h1, h2, h3 {
margin: 25px 0 15px 0;
}
pre {
margin: 0 5px;
padding: 10px;
border: 1px solid #eee;
}
</style>
</head>
<body>
<a href="http://github.com/visionmedia/expresso">
<img alt="Fork me on GitHub" id="ribbon" src="http://s3.amazonaws.com/github/ribbons/forkme_right_white_ffffff.png" />
</a>
<div id="header"><strong>Sencha</strong> labs</div>
<div id="wrapper">
<h1>Expresso</h1>

4
node_modules/ejs/support/expresso/lib/bar.js generated vendored Normal file
View File

@ -0,0 +1,4 @@
exports.bar = function(msg){
return msg || 'bar';
};

16
node_modules/ejs/support/expresso/lib/foo.js generated vendored Normal file
View File

@ -0,0 +1,16 @@
exports.foo = function(msg){
if (msg) {
return msg;
} else {
return generateFoo();
}
};
function generateFoo() {
return 'foo';
}
function Foo(msg){
this.msg = msg || 'foo';
}

9
node_modules/ejs/support/expresso/package.json generated vendored Normal file
View File

@ -0,0 +1,9 @@
{ "name": "expresso",
"version": "0.6.1",
"description": "TDD framework, light-weight, fast, CI-friendly",
"author": "TJ Holowaychuk <tj@vision-media.ca>",
"bin": { "expresso": "./bin/expresso" },
"scripts": {
"install": "make install-jscov"
}
}

84
node_modules/ejs/support/expresso/test/assert.test.js generated vendored Normal file
View File

@ -0,0 +1,84 @@
module.exports = {
'assert.eql()': function(assert){
assert.equal(assert.deepEqual, assert.eql);
},
'assert.type()': function(assert){
assert.type('foobar', 'string');
assert.type(2, 'number');
assert.throws(function(){
assert.type([1,2,3], 'string');
});
},
'assert.includes()': function(assert){
assert.includes('some random string', 'dom');
assert.throws(function(){
assert.include('some random string', 'foobar');
});
assert.includes(['foo', 'bar'], 'bar');
assert.includes(['foo', 'bar'], 'foo');
assert.includes([1,2,3], 3);
assert.includes([1,2,3], 2);
assert.includes([1,2,3], 1);
assert.throws(function(){
assert.includes(['foo', 'bar'], 'baz');
});
assert.throws(function(){
assert.includes({ wrong: 'type' }, 'foo');
});
},
'assert.isNull()': function(assert){
assert.isNull(null);
assert.throws(function(){
assert.isNull(undefined);
});
assert.throws(function(){
assert.isNull(false);
});
},
'assert.isUndefined()': function(assert){
assert.isUndefined(undefined);
assert.throws(function(){
assert.isUndefined(null);
});
assert.throws(function(){
assert.isUndefined(false);
});
},
'assert.isNotNull()': function(assert){
assert.isNotNull(false);
assert.isNotNull(undefined);
assert.throws(function(){
assert.isNotNull(null);
});
},
'assert.isDefined()': function(assert){
assert.isDefined(false);
assert.isDefined(null);
assert.throws(function(){
assert.isDefined(undefined);
});
},
'assert.match()': function(assert){
assert.match('foobar', /foo(bar)?/);
assert.throws(function(){
assert.match('something', /rawr/);
});
},
'assert.length()': function(assert){
assert.length('test', 4);
assert.length([1,2,3,4], 4);
assert.throws(function(){
assert.length([1,2,3], 4);
});
}
};

6
node_modules/ejs/support/expresso/test/async.test.js generated vendored Normal file
View File

@ -0,0 +1,6 @@
setTimeout(function(){
exports['test async exports'] = function(assert){
assert.ok('wahoo');
};
}, 100);

12
node_modules/ejs/support/expresso/test/bar.test.js generated vendored Normal file
View File

@ -0,0 +1,12 @@
/**
* Module dependencies.
*/
var bar = require('bar');
module.exports = {
'bar()': function(assert){
assert.equal('bar', bar.bar());
}
};

13
node_modules/ejs/support/expresso/test/foo.test.js generated vendored Normal file
View File

@ -0,0 +1,13 @@
/**
* Module dependencies.
*/
var foo = require('foo');
module.exports = {
'foo()': function(assert){
assert.equal('foo', foo.foo());
assert.equal('foo', foo.foo());
}
};

76
node_modules/ejs/support/expresso/test/http.test.js generated vendored Normal file
View File

@ -0,0 +1,76 @@
/**
* Module dependencies.
*/
var http = require('http');
var server = http.createServer(function(req, res){
if (req.method === 'GET') {
if (req.url === '/delay') {
setTimeout(function(){
res.writeHead(200, {});
res.end('delayed');
}, 200);
} else {
var body = JSON.stringify({ name: 'tj' });
res.writeHead(200, {
'Content-Type': 'application/json; charset=utf8',
'Content-Length': body.length
});
res.end(body);
}
} else {
var body = '';
req.setEncoding('utf8');
req.addListener('data', function(chunk){ body += chunk });
req.addListener('end', function(){
res.writeHead(200, {});
res.end(req.url + ' ' + body);
});
}
});
module.exports = {
'test assert.response()': function(assert, beforeExit){
var called = 0;
assert.response(server, {
url: '/',
method: 'GET'
},{
body: '{"name":"tj"}',
status: 200,
headers: {
'Content-Type': 'application/json; charset=utf8'
}
});
assert.response(server, {
url: '/foo',
method: 'POST',
data: 'bar baz'
},{
body: '/foo bar baz',
status: 200
}, function(res){
++called;
assert.ok(res);
});
assert.response(server, {
url: '/foo'
}, function(res){
++called;
assert.ok(res.body.indexOf('tj') >= 0, 'Test assert.response() callback');
});
assert.response(server,
{ url: '/delay', timeout: 300 },
{ body: 'delayed' });
beforeExit(function(){
assert.equal(2, called);
});
}
};

245
node_modules/ejs/test/ejs.test.js generated vendored Normal file
View File

@ -0,0 +1,245 @@
/**
* Module dependencies.
*/
var ejs = require('ejs');
module.exports = {
'test .version': function(assert){
assert.ok(/^\d+\.\d+\.\d+$/.test(ejs.version), 'Test .version format');
},
'test html': function(assert){
assert.equal('<p>yay</p>', ejs.render('<p>yay</p>'));
},
'test buffered code': function(assert){
var html = '<p>tj</p>',
str = '<p><%= name %></p>',
locals = { name: 'tj' };
assert.equal(html, ejs.render(str, { locals: locals }));
},
'test unbuffered code': function(assert){
var html = '<p>tj</p>',
str = '<% if (name) { %><p><%= name %></p><% } %>',
locals = { name: 'tj' };
assert.equal(html, ejs.render(str, { locals: locals }));
},
'test `scope` option': function(assert){
var html = '<p>tj</p>',
str = '<p><%= this %></p>';
assert.equal(html, ejs.render(str, { scope: 'tj' }));
},
'test escaping': function(assert){
assert.equal('&lt;script&gt;', ejs.render('<%= "<script>" %>'));
assert.equal('<script>', ejs.render('<%- "<script>" %>'));
},
'test newlines': function(assert){
var html = '\n<p>tj</p>\n<p>tj@sencha.com</p>',
str = '<% if (name) { %>\n<p><%= name %></p>\n<p><%= email %></p><% } %>',
locals = { name: 'tj', email: 'tj@sencha.com' };
assert.equal(html, ejs.render(str, { locals: locals }));
},
'test single quotes': function(assert){
var html = '<p>WAHOO</p>',
str = "<p><%= up('wahoo') %></p>",
locals = { up: function(str){ return str.toUpperCase(); }};
assert.equal(html, ejs.render(str, { locals: locals }));
},
'test single quotes in the html': function(assert){
var html = '<p>WAHOO that\'s cool</p>',
str = '<p><%= up(\'wahoo\') %> that\'s cool</p>',
locals = { up: function(str){ return str.toUpperCase(); }};
assert.equal(html, ejs.render(str, { locals: locals }));
},
'test multiple single quotes': function(assert) {
var html = "<p>couldn't shouldn't can't</p>",
str = "<p>couldn't shouldn't can't</p>";
assert.equal(html, ejs.render(str));
},
'test single quotes inside tags': function(assert) {
var html = '<p>string</p>',
str = "<p><%= 'string' %></p>";
assert.equal(html, ejs.render(str));
},
'test back-slashes in the document': function(assert) {
var html = "<p>backslash: '\\'</p>",
str = "<p>backslash: '\\'</p>";
assert.equal(html, ejs.render(str));
},
'test double quotes': function(assert){
var html = '<p>WAHOO</p>',
str = '<p><%= up("wahoo") %></p>',
locals = { up: function(str){ return str.toUpperCase(); }};
assert.equal(html, ejs.render(str, { locals: locals }));
},
'test multiple double quotes': function(assert) {
var html = '<p>just a "test" wahoo</p>',
str = '<p>just a "test" wahoo</p>';
assert.equal(html, ejs.render(str));
},
'test whitespace': function(assert){
var html = '<p>foo</p>',
str = '<p><%="foo"%></p>';
assert.equal(html, ejs.render(str));
var html = '<p>foo</p>',
str = '<p><%=bar%></p>';
assert.equal(html, ejs.render(str, { locals: { bar: 'foo' }}));
},
'test custom tags': function(assert){
var html = '<p>foo</p>',
str = '<p>{{= "foo" }}</p>';
assert.equal(html, ejs.render(str, {
open: '{{',
close: '}}'
}));
var html = '<p>foo</p>',
str = '<p><?= "foo" ?></p>';
assert.equal(html, ejs.render(str, {
open: '<?',
close: '?>'
}));
},
'test custom tags over 2 chars': function(assert){
var html = '<p>foo</p>',
str = '<p>{{{{= "foo" }>>}</p>';
assert.equal(html, ejs.render(str, {
open: '{{{{',
close: '}>>}'
}));
var html = '<p>foo</p>',
str = '<p><??= "foo" ??></p>';
assert.equal(html, ejs.render(str, {
open: '<??',
close: '??>'
}));
},
'test global custom tags': function(assert){
var html = '<p>foo</p>',
str = '<p>{{= "foo" }}</p>';
ejs.open = '{{';
ejs.close = '}}';
assert.equal(html, ejs.render(str));
delete ejs.open;
delete ejs.close;
},
'test iteration': function(assert){
var html = '<p>foo</p>',
str = '<% for (var key in items) { %>'
+ '<p><%= items[key] %></p>'
+ '<% } %>';
assert.equal(html, ejs.render(str, {
locals: {
items: ['foo']
}
}));
var html = '<p>foo</p>',
str = '<% items.forEach(function(item){ %>'
+ '<p><%= item %></p>'
+ '<% }) %>';
assert.equal(html, ejs.render(str, {
locals: {
items: ['foo']
}
}));
},
'test filter support': function(assert){
var html = 'Zab',
str = '<%=: items | reverse | first | reverse | capitalize %>';
assert.equal(html, ejs.render(str, {
locals: {
items: ['foo', 'bar', 'baz']
}
}));
},
'test filter argument support': function(assert){
var html = 'tj, guillermo',
str = '<%=: users | map:"name" | join:", " %>';
assert.equal(html, ejs.render(str, {
locals: {
users: [
{ name: 'tj' },
{ name: 'guillermo' }
]
}
}));
},
'test sort_by filter': function(assert){
var html = 'tj',
str = '<%=: users | sort_by:"name" | last | get:"name" %>';
assert.equal(html, ejs.render(str, {
locals: {
users: [
{ name: 'guillermo' },
{ name: 'tj' },
{ name: 'mape' }
]
}
}));
},
'test custom filters': function(assert){
var html = 'Welcome Tj Holowaychuk',
str = '<%=: users | first | greeting %>';
ejs.filters.greeting = function(user){
return 'Welcome ' + user.first + ' ' + user.last + '';
};
assert.equal(html, ejs.render(str, {
locals: {
users: [
{ first: 'Tj', last: 'Holowaychuk' }
]
}
}));
},
'test useful stack traces': function(assert){
var str = [
"A little somethin'",
"somethin'",
"<% if (name) { %>", // Failing line
" <p><%= name %></p>",
" <p><%= email %></p>",
"<% } %>"
].join("\n");
try {
ejs.render(str)
} catch( err ){
assert.includes(err.message,"name is not defined");
assert.eql(err.name,"ReferenceError");
var lineno = parseInt(err.toString().match(/ejs:(\d+)\n/)[1]);
assert.eql(lineno,3,"Error should been thrown on line 3, was thrown on line "+lineno);
}
}
};

18
templates/default/index.js Normal file
View File

@ -0,0 +1,18 @@
exports.publish = function(docDb) {
var ejs = require('ejs');
function find(spec) {
return docDb.get( docDb.find(spec) );
}
var functions = find({'kind': 'function'});
//console.log(functions);
var data = {title: 'All Functions', functions: functions};
var template = '<h1><%= title %></h1>\n<ul>\n<%for (var f in functions){%><li><%=functions[f].longname%></li>\n<%}%></ul>';
var output = ejs.render(template, {locals: data});
return 'Hello: '+output;
}

1427
templates/lib/taffy.js Normal file
View File

File diff suppressed because it is too large Load Diff

15
test-rhino.js Executable file
View File

@ -0,0 +1,15 @@
load('lib/rhino-shim.js');
load('lib/nodeunit.js');
var fs = require('fs'),
testFiles = fs.ls('./test/'),
testFile;
while ( testFile = testFiles.shift() ) {
var testName = testFile.replace(/\.js$/, '');
var test = {};
test[testName] = require(testName);
nodeunit.run(test);
}

8
test.js Normal file
View File

@ -0,0 +1,8 @@
#!/usr/bin/env node
if (typeof load !== 'undefined') {
load('lib/rhino-shim.js');
}
var reporter = require('nodeunit').reporters['default'];
reporter.run(['./test']);

2
test/examples/only_comments.js Normal file
View File

@ -0,0 +1,2 @@
/**@overview nothing but comments 1*/
/**@overview nothing but comments 2*/

13
test/jsdoc_parser.js Normal file
View File

@ -0,0 +1,13 @@
var parser = require('jsdoc/parser');
exports['The jsdoc parser should exist.'] = function(t) {
t.expect(1);
t.equal( typeof parser, 'object' );
t.done();
};
exports['The parser should have a parse function.'] = function(t) {
t.expect(1);
t.equal( typeof parser.parse, 'function' );
t.done();
};

38
test/jsdoc_parser_comments.js Normal file
View File

@ -0,0 +1,38 @@
var parser = require('jsdoc/parser');
var dumper = require('jsdoc/util/dumper');
exports['Parse a source containing only a jsdoc comment.'] = function(t) {
t.expect(1);
var docs = parser.parse('/**@doc*/');
t.equal( docs.length, 1, 'should result in docs that contain the comment' );
t.done();
};
exports['Parse a source ending with a jsdoc comment.'] = function(t) {
t.expect(1);
var docs = parser.parse(';/**@doc*/');
t.equal( docs.length, 1, 'should result in docs that contain the comment' );
t.done();
};
exports['Parse a source with a jsdoc comment preceding a jsdoc comment.'] = function(t) {
t.expect(1);
var docs = parser.parse('/**@doc1*/ /**@doc2*/ var x;');
t.equal( docs.length, 2, 'should result in docs containing both the comments' );
t.done();
};
exports['Parse a source with only single line comments.'] = function(t) {
t.expect(1);
var docs = parser.parse('// foo');
t.equal( docs.length, 0, 'should result in docs that are empty' );
t.done();
};
exports['Parse a source with only single non-jsdoc multi-line comments.'] = function(t) {
t.expect(1);
var docs = parser.parse('/*foo*/');
t.equal( docs.length, 0, 'should result in docs that are empty' );
t.done();
};

29
test/jsdoc_parser_function.js Normal file
View File

@ -0,0 +1,29 @@
var parser = require('jsdoc/parser');
exports['An undocumented named function.'] = function(t) {
t.expect(3);
var docs = parser.parse('function foo() {}');
t.equal( docs.length, 1, 'should result in 1 doc' );
t.equal( typeof docs[0].longname, 'string', 'should have a longname set' );
t.equal( docs[0].longname, 'foo', 'should have a longname equal to the function name' );
t.done();
};
exports['A documented named function.'] = function(t) {
t.expect(4);
var docs = parser.parse('/**@desc a function*/ function foo() {}');
t.equal( docs.length, 1, 'should result in 1 doc' );
t.equal( docs[0].longname, 'foo', 'should have a longname equal to the function name' );
t.equal( typeof docs[0].jsdoc, 'object', 'should have a jsdoc set' );
t.equal( docs[0].jsdoc.src, '@desc a function', 'should have a jsdoc equal to the preceding doc comment' );
t.done();
};
exports['A nested documented named function.'] = function(t) {
t.expect(2);
var docs = parser.parse('function foo() { /**@desc a function*/ function bar() {} }');
t.equal( docs.length, 2, 'should result in 2 docs' );
t.equal( docs[1].longname, 'foo~bar', 'the inner function should have a longname equal to <the outer function name>~<the inner function name>' );
t.done();
};

24
test/narcissus.js Normal file
View File

@ -0,0 +1,24 @@
var narcissus = require('narcissus');
exports['Narcissus should exist.'] = function(t) {
t.expect(2);
t.equal( typeof narcissus, 'object' );
t.equal( typeof narcissus.Narcissus, 'object' );
t.done();
};
exports['Narcissus parse should be a function.'] = function(t) {
t.expect(2);
t.equal( typeof narcissus.Narcissus.parser, 'object' );
t.equal( typeof narcissus.Narcissus.parser.parse, 'function' );
t.done();
};
exports['Narcissus parse should generate an AST from source.'] = function(t) {
t.expect(1);
var src = 'var foo = 1;',
ast = narcissus.Narcissus.parser.parse(src, 'filename', 1);
t.equal( typeof ast, 'object' );
t.done();
};