vulcan 0.3.0 → 0.4.0

data/server/node_modules/cradle/node_modules/vows/lib/assert/macros.js

@@ -1,215 +0,0 @@
-var assert = require('assert'),
-    utils = require('./utils');
-
-var messages = {
-    'equal'       : "expected {expected},\n\tgot\t {actual} ({operator})",
-    'notEqual'    : "didn't expect {actual} ({operator})"
-};
-messages['strictEqual']    = messages['deepEqual']    = messages['equal'];
-messages['notStrictEqual'] = messages['notDeepEqual'] = messages['notEqual'];
-
-for (var key in messages) {
-    assert[key] = (function (key, callback) {
-        return function (actual, expected, message) {
-            callback(actual, expected, message || messages[key]);
-        };
-    })(key, assert[key]);
-}
-
-assert.ok = (function (callback) {
-    return function (actual, message) {
-        callback(actual, message ||  "expected expression to evaluate to {expected}, but was {actual}");
-    };
-})(assert.ok);
-
-assert.match = function (actual, expected, message) {
-    if (! expected.test(actual)) {
-        assert.fail(actual, expected, message || "expected {actual} to match {expected}", "match", assert.match);
-    }
-};
-assert.matches = assert.match;
-
-assert.isTrue = function (actual, message) {
-    if (actual !== true) {
-        assert.fail(actual, true, message || "expected {expected}, got {actual}", "===", assert.isTrue);
-    }
-};
-assert.isFalse = function (actual, message) {
-    if (actual !== false) {
-        assert.fail(actual, false, message || "expected {expected}, got {actual}", "===", assert.isFalse);
-    }
-};
-assert.isZero = function (actual, message) {
-    if (actual !== 0) {
-        assert.fail(actual, 0, message || "expected {expected}, got {actual}", "===", assert.isZero);
-    }
-};
-assert.isNotZero = function (actual, message) {
-    if (actual === 0) {
-        assert.fail(actual, 0, message || "expected non-zero value, got {actual}", "===", assert.isNotZero);
-    }
-};
-
-assert.greater = function (actual, expected, message) {
-    if (actual <= expected) {
-        assert.fail(actual, expected, message || "expected {actual} to be greater than {expected}", ">", assert.greater);
-    }
-};
-assert.lesser = function (actual, expected, message) {
-    if (actual >= expected) {
-        assert.fail(actual, expected, message || "expected {actual} to be lesser than {expected}", "<", assert.lesser);
-    }
-};
-
-assert.inDelta = function (actual, expected, delta, message) {
-    var lower = expected - delta;
-    var upper = expected + delta;
-    if (actual < lower || actual > upper) {
-        assert.fail(actual, expected, message || "expected {actual} to be in within *" + delta.toString() + "* of {expected}", null, assert.inDelta);
-    }
-};
-
-//
-// Inclusion
-//
-assert.include = function (actual, expected, message) {
-    if ((function (obj) {
-        if (isArray(obj) || isString(obj)) {
-            return obj.indexOf(expected) === -1;
-        } else if (isObject(actual)) {
-            return ! obj.hasOwnProperty(expected);
-        }
-        return false;
-    })(actual)) {
-        assert.fail(actual, expected, message || "expected {actual} to include {expected}", "include", assert.include);
-    }
-};
-assert.includes = assert.include;
-
-assert.deepInclude = function (actual, expected, message) {
-    if (!isArray(actual)) {
-        return assert.include(actual, expected, message);
-    }
-    if (!actual.some(function (item) { return utils.deepEqual(item, expected) })) {
-        assert.fail(actual, expected, message || "expected {actual} to include {expected}", "include", assert.deepInclude);
-    }
-};
-assert.deepIncludes = assert.deepInclude;
-
-//
-// Length
-//
-assert.isEmpty = function (actual, message) {
-    if ((isObject(actual) && Object.keys(actual).length > 0) || actual.length > 0) {
-        assert.fail(actual, 0, message || "expected {actual} to be empty", "length", assert.isEmpty);
-    }
-};
-assert.isNotEmpty = function (actual, message) {
-    if ((isObject(actual) && Object.keys(actual).length === 0) || actual.length === 0) {
-        assert.fail(actual, 0, message || "expected {actual} to be not empty", "length", assert.isNotEmpty);
-    }
-};
-
-assert.length = function (actual, expected, message) {
-    if (actual.length !== expected) {
-        assert.fail(actual, expected, message || "expected {actual} to have {expected} element(s)", "length", assert.length);
-    }
-};
-
-//
-// Type
-//
-assert.isArray = function (actual, message) {
-    assertTypeOf(actual, 'array', message || "expected {actual} to be an Array", assert.isArray);
-};
-assert.isObject = function (actual, message) {
-    assertTypeOf(actual, 'object', message || "expected {actual} to be an Object", assert.isObject);
-};
-assert.isNumber = function (actual, message) {
-    if (isNaN(actual)) {
-        assert.fail(actual, 'number', message || "expected {actual} to be of type {expected}", "isNaN", assert.isNumber);
-    } else {
-        assertTypeOf(actual, 'number', message || "expected {actual} to be a Number", assert.isNumber);
-    }
-};
-assert.isBoolean = function (actual, message) {
-    if (actual !== true && actual !== false) {
-        assert.fail(actual, 'boolean', message || "expected {actual} to be a Boolean", "===", assert.isBoolean);
-    }
-};
-assert.isNaN = function (actual, message) {
-    if (actual === actual) {
-        assert.fail(actual, 'NaN', message || "expected {actual} to be NaN", "===", assert.isNaN);
-    }
-};
-assert.isNull = function (actual, message) {
-    if (actual !== null) {
-        assert.fail(actual, null, message || "expected {expected}, got {actual}", "===", assert.isNull);
-    }
-};
-assert.isNotNull = function (actual, message) {
-    if (actual === null) {
-        assert.fail(actual, null, message || "expected non-null value, got {actual}", "===", assert.isNotNull);
-    }
-};
-assert.isUndefined = function (actual, message) {
-    if (actual !== undefined) {
-        assert.fail(actual, undefined, message || "expected {actual} to be {expected}", "===", assert.isUndefined);
-    }
-};
-assert.isDefined = function (actual, message) {
-    if(actual === undefined) {
-        assert.fail(actual, 0, message || "expected {actual} to be defined", "===", assert.isDefined);
-    }
-};
-assert.isString = function (actual, message) {
-    assertTypeOf(actual, 'string', message || "expected {actual} to be a String", assert.isString);
-};
-assert.isFunction = function (actual, message) {
-    assertTypeOf(actual, 'function', message || "expected {actual} to be a Function", assert.isFunction);
-};
-assert.typeOf = function (actual, expected, message) {
-    assertTypeOf(actual, expected, message, assert.typeOf);
-};
-assert.instanceOf = function (actual, expected, message) {
-    if (! (actual instanceof expected)) {
-        assert.fail(actual, expected, message || "expected {actual} to be an instance of {expected}", "instanceof", assert.instanceOf);
-    }
-};
-
-//
-// Utility functions
-//
-
-function assertTypeOf(actual, expected, message, caller) {
-    if (typeOf(actual) !== expected) {
-        assert.fail(actual, expected, message || "expected {actual} to be of type {expected}", "typeOf", caller);
-    }
-};
-
-function isArray (obj) {
-    return Array.isArray(obj);
-}
-
-function isString (obj) {
-    return typeof(obj) === 'string' || obj instanceof String;
-}
-
-function isObject (obj) {
-    return typeof(obj) === 'object' && obj && !isArray(obj);
-}
-
-// A better `typeof`
-function typeOf(value) {
-    var s = typeof(value),
-        types = [Object, Array, String, RegExp, Number, Function, Boolean, Date];
-
-    if (s === 'object' || s === 'function') {
-        if (value) {
-            types.forEach(function (t) {
-                if (value instanceof t) { s = t.name.toLowerCase() }
-            });
-        } else { s = 'null' }
-    }
-    return s;
-}

data/server/node_modules/cradle/node_modules/vows/lib/assert/utils.js

@@ -1,77 +0,0 @@
-
-// Taken from node/lib/assert.js
-exports.deepEqual = function (actual, expected) {
-  if (actual === expected) {
-    return true;
-
-  } else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) {
-    if (actual.length != expected.length) return false;
-
-    for (var i = 0; i < actual.length; i++) {
-      if (actual[i] !== expected[i]) return false;
-    }
-    return true;
-
-  } else if (actual instanceof Date && expected instanceof Date) {
-    return actual.getTime() === expected.getTime();
-
-  } else if (typeof actual != 'object' && typeof expected != 'object') {
-    return actual == expected;
-
-  } else {
-    return objEquiv(actual, expected);
-  }
-}
-
-// Taken from node/lib/assert.js
-exports.notDeepEqual = function (actual, expected, message) {
-  if (exports.deepEqual(actual, expected)) {
-    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
-  }
-}
-
-// Taken from node/lib/assert.js
-function isUndefinedOrNull(value) {
-  return value === null || value === undefined;
-}
-
-// Taken from node/lib/assert.js
-function isArguments(object) {
-  return Object.prototype.toString.call(object) == '[object Arguments]';
-}
-
-// Taken from node/lib/assert.js
-function objEquiv(a, b) {
-  if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
-    return false;
-  if (a.prototype !== b.prototype) return false;
-  if (isArguments(a)) {
-    if (!isArguments(b)) {
-      return false;
-    }
-    a = pSlice.call(a);
-    b = pSlice.call(b);
-    return exports.deepEqual(a, b);
-  }
-  try {
-    var ka = Object.keys(a),
-        kb = Object.keys(b),
-        key, i;
-  } catch (e) {
-    return false;
-  }
-  if (ka.length != kb.length)
-    return false;
-  ka.sort();
-  kb.sort();
-  for (i = ka.length - 1; i >= 0; i--) {
-    if (ka[i] != kb[i])
-      return false;
-  }
-  for (i = ka.length - 1; i >= 0; i--) {
-    key = ka[i];
-    if (!exports.deepEqual(a[key], b[key])) return false;
-  }
-  return true;
-}
-

data/server/node_modules/cradle/node_modules/vows/lib/vows/console.js

@@ -1,131 +0,0 @@
-var eyes = require('eyes').inspector({ stream: null, styles: false });
-
-// Stylize a string
-this.stylize = function stylize(str, style) {
-    var styles = {
-        'bold'      : [1,  22],
-        'italic'    : [3,  23],
-        'underline' : [4,  24],
-        'cyan'      : [96, 39],
-        'yellow'    : [33, 39],
-        'green'     : [32, 39],
-        'red'       : [31, 39],
-        'grey'      : [90, 39],
-        'green-hi'  : [92, 32],
-    };
-    return '\033[' + styles[style][0] + 'm' + str +
-           '\033[' + styles[style][1] + 'm';
-};
-
-var $ = this.$ = function (str) {
-    str = new(String)(str);
-
-    ['bold', 'grey', 'yellow', 'red', 'green', 'white', 'cyan', 'italic'].forEach(function (style) {
-        Object.defineProperty(str, style, {
-            get: function () {
-                return exports.$(exports.stylize(this, style));
-            }
-        });
-    });
-    return str;
-};
-
-this.puts = function (options) {
-    var stylize = exports.stylize;
-    options.stream || (options.stream = process.stdout);
-    options.tail = options.tail || '';
-
-    return function (args) {
-        args = Array.prototype.slice.call(arguments);
-        if (!options.raw) {
-            args = args.map(function (a) {
-                return a.replace(/`([^`]+)`/g,   function (_, capture) { return stylize(capture, 'italic') })
-                        .replace(/\*([^*]+)\*/g, function (_, capture) { return stylize(capture, 'bold') });
-            });
-        }
-        return options.stream.write(args.join('\n') + options.tail);
-    };
-};
-
-this.result = function (event) {
-    var result = [], buffer = [], time = '', header;
-    var complete = event.honored + event.pending + event.errored + event.broken;
-    var status = (event.errored && 'errored') || (event.broken && 'broken') ||
-                 (event.honored && 'honored') || (event.pending && 'pending');
-
-    if (event.total === 0) {
-        return [$("Could not find any tests to run.").bold.red];
-    }
-
-    event.honored && result.push($(event.honored).bold + " honored");
-    event.broken  && result.push($(event.broken).bold  + " broken");
-    event.errored && result.push($(event.errored).bold + " errored");
-    event.pending && result.push($(event.pending).bold + " pending");
-
-    if (complete < event.total) {
-        result.push($(event.total - complete).bold + " dropped");
-    }
-
-    result = result.join(' ∙ ');
-
-    header = {
-        honored: '✓ ' + $('OK').bold.green,
-        broken:  '✗ ' + $('Broken').bold.yellow,
-        errored: '✗ ' + $('Errored').bold.red,
-        pending: '- ' + $('Pending').bold.cyan
-    }[status] + ' » ';
-
-    if (typeof(event.time) === 'number') {
-        time = ' (' + event.time.toFixed(3) + 's)';
-        time = this.stylize(time, 'grey');
-    }
-    buffer.push(header + result + time + '\n');
-
-    return buffer;
-};
-
-this.inspect = function inspect(val) {
-    return '\033[1m' + eyes(val) + '\033[22m';
-};
-
-this.error = function (obj) {
-    var string  = '✗ ' + $('Errored ').red + '» ';
-        string += $(obj.error).red.bold                         + '\n';
-        string += (obj.context ? '    in ' + $(obj.context).red + '\n': '');
-        string += '    in ' + $(obj.suite.subject).red          + '\n';
-        string += '    in ' + $(obj.suite._filename).red;
-
-    return string;
-};
-
-this.contextText = function (event) {
-    return '  ' + event;
-};
-
-this.vowText = function (event) {
-    var buffer = [];
-
-    buffer.push('   ' + {
-        honored: ' ✓ ',
-        broken:  ' ✗ ',
-        errored: ' ✗ ',
-        pending: ' - '
-    }[event.status] + this.stylize(event.title, ({
-        honored: 'green',
-        broken:  'yellow',
-        errored: 'red',
-        pending: 'cyan'
-    })[event.status]));
-
-    if (event.status === 'broken') {
-        buffer.push('      » ' + event.exception);
-    } else if (event.status === 'errored') {
-        if (event.exception.type === 'promise') {
-            buffer.push('      » ' + this.stylize("An unexpected error was caught: " +
-                           this.stylize(event.exception.error, 'bold'), 'red'));
-        } else {
-            buffer.push('    ' + this.stylize(event.exception, 'red'));
-        }
-    }
-    return buffer.join('\n');
-};

data/server/node_modules/cradle/node_modules/vows/lib/vows/context.js

@@ -1,55 +0,0 @@
-
-this.Context = function (vow, ctx, env) {
-    var that = this;
-
-    this.tests = vow.callback;
-    this.topics = (ctx.topics || []).slice(0);
-    this.emitter = null;
-    this.env = env || {};
-    this.env.context = this;
-
-    this.env.callback = function (/* arguments */) {
-        var ctx = this;
-        var args = Array.prototype.slice.call(arguments);
-
-        var emit = (function (args) {
-            //
-            // Convert callback-style results into events.
-            //
-            if (vow.batch.suite.options.error) {
-                return function () {
-                    var e = args.shift();
-                    that.emitter.ctx = ctx;
-                    // We handle a special case, where the first argument is a
-                    // boolean, in which case we treat it as a result, and not
-                    // an error. This is useful for `path.exists` and other
-                    // functions like it, which only pass a single boolean
-                    // parameter instead of the more common (error, result) pair.
-                    if (typeof(e) === 'boolean' && args.length === 0) {
-                        that.emitter.emit.call(that.emitter, 'success', e);
-                    } else {
-                        if (e) { that.emitter.emit.apply(that.emitter, ['error', e].concat(args)) }
-                        else   { that.emitter.emit.apply(that.emitter, ['success'].concat(args)) }
-                    }
-                };
-            } else {
-                return function () {
-                    that.emitter.ctx = ctx;
-                    that.emitter.emit.apply(that.emitter, ['success'].concat(args));
-                };
-            }
-        })(args.slice(0));
-        // If `this.callback` is called synchronously,
-        // the emitter will not have been set yet,
-        // so we defer the emition, that way it'll behave
-        // asynchronously.
-        if (that.emitter) { emit() }
-        else              { process.nextTick(emit) }
-    };
-    this.name = vow.description;
-    this.title = [
-        ctx.title || '',
-        vow.description || ''
-    ].join(/^[#.:]/.test(vow.description) ? '' : ' ').trim();
-};
-

data/server/node_modules/cradle/node_modules/vows/lib/vows/coverage/file.js

@@ -1,29 +0,0 @@
-
-exports.coverage = function (filename, data) {
-    var ret = {
-        filename: filename,
-        coverage: 0,
-        hits:     0,
-        misses:   0,
-        sloc  :   0
-    };
-
-    var source = data.source;
-    ret.source = source.map(function (line, num) {
-        num++;
-        
-        if (data[num] === 0) {
-            ret.misses++;
-            ret.sloc++;
-        } else if (data[num] !== undefined) {
-            ret.hits++;
-            ret.sloc++;
-        }
-        
-        return { line: line, coverage: (data[num] === undefined ? '' : data[num]) };
-    });
-
-    ret.coverage = (ret.hits / ret.sloc) * 100;
-    
-    return ret;
-};

data/server/node_modules/cradle/node_modules/vows/lib/vows/coverage/fragments/coverage-foot.html

@@ -1,2 +0,0 @@
-</body>
-</html>

data/server/node_modules/cradle/node_modules/vows/lib/vows/coverage/fragments/coverage-head.html

@@ -1,61 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <style type="text/css">
-  .covered {
-    background-color: green;
-  }
-  .uncovered {
-    background-color: red;
-  }
-  .coverage {
-    font-size: 0.8em;
-    color: #333;
-  }
-  .coverage.fullCoverage {
-    background-color:#0f0;
-    color: #111;
-  }
-  .coverage.okCoverage {
-    background-color: orange;
-  }
-  .coverage.poorCoverage {
-    background-color: red;
-  }
-  .code {
-    font-family: "Consolas", "Courier New", Courier, mono;
-    white-space: pre;
-    line-height: 16px;
-  }
-  .collapsed {
-    display: none;
-  }
-  body {
-    margin-left: 20px;
-    margin-top: 8px;
-    background-color: white;
-    color: black;
-    font-size: 16px;
-  }
-  ol {
-    margin-left: 20px;
-    margin-bottom: 40px;
-    width: 800px;
-    line-height: 18px;
-    -moz-box-shadow: 10px 10px 5px #888;
-    -webkit-box-shadow: 10px 10px 5px #888;
-    box-shadow: 10px 10px 5px #888;
-  }
-  </style>
-  <script type="text/javascript">
-    function expando(elem) {
-      // We're skipping the '/n' text element sibling.
-      var olElement= elem.nextSibling.nextSibling;
-      var currentState= olElement.className;
-      if( currentState == "collapsed" ) currentState= "";
-      else currentState= "collapsed";
-      olElement.className= currentState;
-    }
-  </script>
-</head>
-<body>

data/server/node_modules/cradle/node_modules/vows/lib/vows/coverage/report-html.js

@@ -1,54 +0,0 @@
-var sys  = require('sys'),
-    fs   = require('fs'),
-    file = require('./file');
-
-this.name = 'coverage-report-html';
-
-function getCoverageClass( data ) {
-  var fullCoverage= (data.coverage == 100);
-  var okCoverage= (!fullCoverage && data.coverage >=60);
-  var coverageClass= '';
-  if( fullCoverage ) coverageClass= 'fullCoverage';
-  else if( okCoverage) coverageClass= 'okCoverage';
-  else coverageClass= 'poorCoverage';
-  return coverageClass;
-}
-this.report = function (coverageMap) {
-    var out, head, foot;
-    
-    try {
-        out  = fs.openSync("coverage.html", "w");
-        head = fs.readFileSync(__dirname + "/fragments/coverage-head.html", "utf8");
-        foot = fs.readFileSync(__dirname + "/fragments/coverage-foot.html", "utf8");
-    } catch (error) {
-        sys.print("Error: Unable to write to file coverage.html\n");
-        return;
-    }
-
-    fs.writeSync(out, head);
-
-    for (var filename in coverageMap) {
-        if (coverageMap.hasOwnProperty(filename)) {
-            var data = file.coverage(filename, coverageMap[filename]);
-            var coverageClass= getCoverageClass( data );
-            fs.writeSync(out, "<h2>" + filename + "</h2>\n");
-            fs.writeSync(out, '<span class="coverage '+ coverageClass+'">' + "[ hits: " + data.hits);
-            fs.writeSync(out, ", misses: " + data.misses + ", sloc: " + data.sloc);
-            fs.writeSync(out, ", coverage: " + data.coverage.toFixed(2) + "% ]" + "</span> <a href='#' onclick='expando(this)'>[+]</a>\n");
-            fs.writeSync(out, "<ol class='collapsed'>\n");
-
-            for (var i = 0; i < data.source.length; i++) {
-                fs.writeSync(out, '  <li class="code ');
-                fs.writeSync(out, (data.source[i].coverage === 0 ? 'uncovered' : 'covered'));
-                fs.writeSync(out, '" coverage="' + data.source[i].coverage + '">');
-                fs.writeSync(out, data.source[i].line + "</li>\n");
-            }
-            
-            fs.writeSync(out, "</ol>\n");
-            fs.writeSync(out, "<hr/>\n");
-        }
-    }
-    
-    fs.writeSync(out, foot);
-    fs.close(out);
-};

data/server/node_modules/cradle/node_modules/vows/lib/vows/coverage/report-json.js

@@ -1,54 +0,0 @@
-var sys  = require('sys'),
-    fs   = require('fs'),
-    file = require('./file');
-
-this.name = 'coverage-report-json';
-
-this.report = function (coverageMap) {
-    var output = {
-        meta: {
-            "generator":        "vowsjs",
-            "generated":        new Date().toString(),
-            "instrumentation":  "node-jscoverage",
-            "file-version":     "1.0"
-        },
-        files:     [ ],
-        coverage:  [ ]
-    };
-    
-    
-    for (var filename in coverageMap) {
-        if (coverageMap.hasOwnProperty(filename)) {
-            var data = file.coverage(filename, coverageMap[filename]);
-            
-            var coverage = {
-                file:      filename,
-                coverage:  data.coverage.toFixed(2),
-                hits:      data.hits,
-                misses:    data.misses,
-                sloc:      data.sloc,
-                source:    { }
-            };
-
-            for (var i = 0; i < data.source.length; i++) {
-                coverage.source[i + 1] = {
-                    line:     data.source[i].line,
-                    coverage: data.source[i].coverage
-                };
-            }
-
-            output.coverage.push(coverage);
-
-            output.files.push(filename);
-        }
-    }
-
-    try {
-        out  = fs.openSync("coverage.json", "w");
-        fs.writeSync(out, JSON.stringify(output));
-        fs.close(out);
-    } catch (error) {
-        sys.print("Error: Unable to write to file coverage.json\n");
-        return;
-    }
-};