forked from enviPath/enviPy
161 lines
4.1 KiB
JavaScript
Executable File
161 lines
4.1 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
|
|
|
var Parser = require('../')
|
|
var etoa = require('events-to-array')
|
|
var util = require('util')
|
|
|
|
var args = process.argv.slice(2)
|
|
var json = null
|
|
var bail = false
|
|
var preserveWhitespace = true
|
|
var omitVersion = false
|
|
|
|
function version () {
|
|
console.log(require('../package.json').version)
|
|
process.exit(0)
|
|
}
|
|
|
|
args.forEach(function (arg, i) {
|
|
if (arg === '-j') {
|
|
json = args[i + 1] || 2
|
|
} else {
|
|
var m = arg.match(/^--json(?:=([0-9]+))$/)
|
|
if (m)
|
|
json = +m[1] || args[i + 1] || 2
|
|
}
|
|
|
|
if (arg === '-v' || arg === '--version')
|
|
version()
|
|
else if (arg === '-o' || arg === '--omit-version')
|
|
omitVersion = true
|
|
else if (arg === '-w' || arg === '--ignore-all-whitespace')
|
|
preserveWhitespace = false
|
|
else if (arg === '-b' || arg === '--bail')
|
|
bail = true
|
|
else if (arg === '-t' || arg === '--tap')
|
|
json = 'tap'
|
|
else if (arg === '-l' || arg === '--lines')
|
|
json = 'lines'
|
|
else if (arg === '-h' || arg === '--help')
|
|
usage()
|
|
else
|
|
console.error('Unrecognized arg: %j', arg)
|
|
|
|
if (arg === '-v' || arg === '--version')
|
|
console.log(require('../package.json').version)
|
|
})
|
|
|
|
function usage () {
|
|
console.log(function () {/*
|
|
Usage:
|
|
tap-parser <options>
|
|
|
|
Parses TAP data from stdin, and outputs the parsed result
|
|
in the format specified by the options. Default output is
|
|
uses node's `util.format()` method.
|
|
|
|
Options:
|
|
|
|
-j [<indent>] | --json[=indent]
|
|
Output event data as JSON with the specified indentation (default=2)
|
|
|
|
-t | --tap
|
|
Output data as reconstituted TAP based on parsed results
|
|
|
|
-l | --lines
|
|
Output each parsed line as it is recognized by the parser
|
|
|
|
-b | --bail
|
|
Emit a `Bail out!` at the first failed test point encountered
|
|
|
|
-w | --ignore-all-whitespace
|
|
Skip over blank lines outside of YAML blocks
|
|
|
|
-o | --omit-version
|
|
Ignore the `TAP version 13` line at the start of tests
|
|
*/}.toString().split('\n').slice(1, -1).join('\n'))
|
|
|
|
if (!process.stdin.isTTY)
|
|
process.stdin.resume()
|
|
|
|
process.exit()
|
|
}
|
|
|
|
var yaml = require('js-yaml')
|
|
function tapFormat (msg, indent) {
|
|
return indent + msg.map(function (item) {
|
|
switch (item[0]) {
|
|
case 'child':
|
|
var comment = item[1][0]
|
|
var child = item[1].slice(1)
|
|
return tapFormat([comment], '') + tapFormat(child, ' ')
|
|
|
|
case 'version':
|
|
return 'TAP version ' + item[1] + '\n'
|
|
|
|
case 'plan':
|
|
var p = item[1].start + '..' + item[1].end
|
|
if (item[1].comment)
|
|
p += ' # ' + item[1].comment
|
|
return p + '\n'
|
|
|
|
case 'pragma':
|
|
return 'pragma ' + (item[2] ? '+' : '-') + item[1] + '\n'
|
|
|
|
case 'bailout':
|
|
var r = item[1] === true ? '' : (' ' + item[1])
|
|
return 'Bail out!' + r + '\n'
|
|
|
|
case 'assert':
|
|
var res = item[1]
|
|
return (res.ok ? '' : 'not ') + 'ok ' + res.id +
|
|
(res.name ? ' - ' + res.name.replace(/ \{$/, '') : '') +
|
|
(res.skip ? ' # SKIP' +
|
|
(res.skip === true ? '' : ' ' + res.skip) : '') +
|
|
(res.todo ? ' # TODO' +
|
|
(res.todo === true ? '' : ' ' + res.todo) : '') +
|
|
(res.time ? ' # time=' + res.time + 'ms' : '') +
|
|
'\n' +
|
|
(res.diag ?
|
|
' ---\n ' +
|
|
yaml.safeDump(res.diag).split('\n').join('\n ').trim() +
|
|
'\n ...\n'
|
|
: '')
|
|
|
|
case 'extra':
|
|
case 'comment':
|
|
return item[1]
|
|
}
|
|
}).join('').split('\n').join('\n' + indent).trim() + '\n'
|
|
}
|
|
|
|
function format (msg) {
|
|
if (json === 'tap')
|
|
return tapFormat(msg, '')
|
|
else if (json !== null)
|
|
return JSON.stringify(msg, null, +json)
|
|
else
|
|
return util.inspect(events, null, Infinity)
|
|
}
|
|
|
|
var options = {
|
|
bail: bail,
|
|
preserveWhitespace: preserveWhitespace,
|
|
omitVersion: omitVersion
|
|
}
|
|
|
|
var parser = new Parser(options)
|
|
var events = etoa(parser, [ 'pipe', 'unpipe', 'prefinish', 'finish', 'line' ])
|
|
|
|
process.stdin.pipe(parser)
|
|
if (json === 'lines')
|
|
parser.on('line', function (l) {
|
|
process.stdout.write(l)
|
|
})
|
|
else
|
|
process.on('exit', function () {
|
|
console.log(format(events))
|
|
if (!parser.ok)
|
|
process.exit(1)
|
|
})
|