RubyGems - vulcan - Versions diffs - 0.3.0 → 0.4.0 - Mend

vulcan 0.3.0 → 0.4.0

Files changed (211) hide show

data/server/node_modules/express/node_modules/qs/support/expresso/docs/index.html DELETED Viewed

@@ -1,377 +0,0 @@
-<html>
-	<head>
-		<title>Expresso - TDD Framework For Node</title>
-		<style>
-			body {
-				font: 13px/1.4 "Helvetica", "Lucida Grande", Arial, sans-serif;
-				text-align: center;
-			}
-			#ribbon {
-				position: absolute;
-				top: 0;
-				right: 0;
-				z-index: 10;
-			}
-			#wrapper {
-			  margin: 0 auto;
-				padding: 50px 80px;
-				width: 700px;
-				text-align: left;
-			}
-			h1, h2, h3 {
-				margin: 25px 0 15px 0;
-			}
-			h1 {
-			  font-size: 35px;
-			}
-			pre {
-				margin: 0 5px;
-				padding: 15px;
-				border: 1px solid #eee;
-			}
-			a {
-			  color: #00aaff;
-			}
-		</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="wrapper">
-			<h1>Expresso</h1>
-<div class='mp'>
-<h2 id="NAME">NAME</h2>
-<p class="man-name">
-  <code>index</code>
-</p>
-<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>
-<p>To define tests we simply export several functions:</p>
-<pre><code>exports['test String#length'] = function(){
-    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.equal(6, 'foobar'.length);
-    }
-};
-</code></pre>
-<p>If you prefer not to use quoted keys:</p>
-<pre><code>exports.testsStringLength = function(){
-    assert.equal(6, 'foobar'.length);
-};
-</code></pre>
-<p>The 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(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 (regexp or string)</li>
-<li><em>status</em> assert response status code</li>
-<li><em>header</em> assert that all given headers match (unspecified are ignored, use a regexp or string)</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.ok('wahoo');
-    };
-}, 100);
-</code></pre>
-</div>
-		</div>
-	</body>
-</html>

data/server/node_modules/express/node_modules/qs/support/expresso/docs/index.md DELETED Viewed

@@ -1,290 +0,0 @@
-[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
-To define tests we simply export several functions:
-	exports['test String#length'] = function(){
-		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.equal(6, 'foobar'.length);
-      	}
-    };
-If you prefer not to use quoted keys:
-	exports.testsStringLength = function(){
-		assert.equal(6, 'foobar'.length);
-	};
-The argument passed to each callback is _beforeExit_,
-which is typically used to assert that callbacks have been
-invoked.
-    exports.testAsync = function(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 (regexp or string)
-  - _status_ assert response status code
-  - _header_ assert that all given headers match (unspecified are ignored, use a regexp or string)
-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.ok('wahoo');
-	    };
-	}, 100);

data/server/node_modules/express/node_modules/qs/support/expresso/docs/layout/foot.html DELETED Viewed

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