vulcan 0.0.1 → 0.0.2

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

@@ -0,0 +1,131 @@
+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

@@ -0,0 +1,55 @@
+
+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

@@ -0,0 +1,29 @@
+
+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

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

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

@@ -0,0 +1,61 @@
+<!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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,54 @@
+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;
+    }
+};

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

@@ -0,0 +1,38 @@
+var sys  = require('sys'),
+    file = require('./file');
+
+this.name = 'coverage-report-plain';
+
+function lpad(str, width) {
+    str = String(str);
+    var n = width - str.length;
+
+    if (n < 1) {
+        return str;
+    }
+    
+    while (n--) {
+        str = ' ' + str;
+    }
+
+    return str;
+}
+
+
+this.report = function (coverageMap) {
+    for (var filename in coverageMap) {
+        if (coverageMap.hasOwnProperty(filename)) {
+            var data = file.coverage(filename, coverageMap[filename]);
+            
+            sys.print(filename + ":\n");
+            sys.print("[ hits: " + data.hits + ", misses: " + data.misses);
+            sys.print(", sloc: " + data.sloc + ", coverage: " + data.coverage.toFixed(2) + "% ]\n");
+
+            for (var i = 0; i < data.source.length; i++) {
+                sys.print(lpad(data.source[i].coverage, 5) + " | " + data.source[i].line + "\n");
+            }
+            
+            sys.print("\n");
+        }
+    }
+};

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

@@ -0,0 +1,28 @@
+var events = require('events');
+//
+// Wrap a Node.js style async function into an EventEmmitter
+//
+this.prepare = function (obj, targets) {
+    targets.forEach(function (target) {
+        if (target in obj) {
+            obj[target] = (function (fun) {
+                return function () {
+                    var args = Array.prototype.slice.call(arguments);
+                    var ee = new(events.EventEmitter);
+
+                    args.push(function (err /* [, data] */) {
+                        var args = Array.prototype.slice.call(arguments, 1);
+
+                        if (err) { ee.emit.apply(ee, ['error', err].concat(args)) }
+                        else     { ee.emit.apply(ee, ['success'].concat(args)) }
+                    });
+                    fun.apply(obj, args);
+
+                    return ee;
+                };
+            })(obj[target]);
+        }
+    });
+    return obj;
+};
+