452 lines
13 KiB
JavaScript
452 lines
13 KiB
JavaScript
import path from 'path'
|
|
import fs from 'fs'
|
|
import fsPromise from 'fs/promises'
|
|
import cluster from 'cluster'
|
|
import child_process from 'child_process'
|
|
import kill from './kill.mjs'
|
|
import Watcher, { EVENT_REMOVE, EVENT_UPDATE } from './watch/index.mjs'
|
|
|
|
export const MESSAGE_FILES_REQUEST = 'message_files_request'
|
|
export const MESSAGE_FILES_PAYLOAD = 'message_files_payload'
|
|
export const MESSAGE_RUN_FINISHED = 'message_run_finished'
|
|
|
|
export function createMessage(type, data = null) {
|
|
return {
|
|
messageType: type,
|
|
data: data,
|
|
}
|
|
}
|
|
|
|
const RegexCache = new Map()
|
|
|
|
function targetToRegex(target) {
|
|
let regex = RegexCache.get(target)
|
|
if (!regex) {
|
|
let parsed = target.startsWith('./') ? target.slice(2) : target
|
|
parsed = parsed.endsWith('/') ? parsed + '*' : parsed
|
|
RegexCache.set(target, regex = new RegExp('^' +
|
|
parsed.replace(/\./g, '\\.')
|
|
.replace(/\*\*\/?/g, '&&&&&&&&&&&&&')
|
|
.replace(/\*/g, '[^/]+')
|
|
.replace(/&&&&&&&&&&&&&/g, '.*')
|
|
+ '$'
|
|
))
|
|
}
|
|
return regex
|
|
}
|
|
|
|
export function CLI(e, overrides = {}) {
|
|
this.e = e
|
|
this.ac = new AbortController()
|
|
this.cluster = overrides.cluster || cluster
|
|
this.logger = overrides.logger || console
|
|
this.child_process = overrides.child_process || child_process
|
|
this.process = overrides.process || process
|
|
this.kill = overrides.kill || kill
|
|
this.importer = overrides.importer
|
|
this.loadDefaults()
|
|
}
|
|
|
|
CLI.prototype.loadDefaults = function() {
|
|
// Eltro specific options
|
|
this.reporter = 'list'
|
|
this.ignoreOnly = false
|
|
this.timeout = 2000
|
|
|
|
// Cli specific options
|
|
this.watch = null
|
|
this.watcher = null
|
|
this.worker = null
|
|
this.run = 'test'
|
|
this.isSlave = this.cluster.isWorker || false
|
|
this.targets = ['test/**']
|
|
this.files = []
|
|
}
|
|
|
|
CLI.prototype.fileMatchesTarget = function(path) {
|
|
for (let target of this.targets) {
|
|
if (targetToRegex(target).test(path)) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
CLI.prototype.parseOptions = function(args) {
|
|
if (!args || !args.length) {
|
|
this.targets.push('test/**')
|
|
return Promise.resolve()
|
|
}
|
|
|
|
this.targets.splice(0, this.targets.length)
|
|
|
|
|
|
for (let i = 0; i < args.length; i++) {
|
|
if (args[i] === '-r' || args[i] === '--reporter') {
|
|
if (!args[i + 1] || (args[i + 1] !== 'list' && args[i + 1] !== 'dot')) {
|
|
return Promise.reject(new Error('Reporter was missing or invalid. Only "list" and "dot" are supported.'))
|
|
}
|
|
this.reporter = args[i + 1]
|
|
i++
|
|
} else if (args[i] === '-t' || args[i] === '--timeout') {
|
|
if (!args[i + 1] || isNaN(Number(args[i + 1]))) {
|
|
return Promise.reject(new Error('Timeout was missing or invalid'))
|
|
}
|
|
this.timeout = Number(args[i + 1])
|
|
i++
|
|
} else if (args[i] === '-w' || args[i] === '--watch') {
|
|
if (!args[i + 1] || args[i + 1][0] === '-') {
|
|
return Promise.reject(new Error('Watch was missing or invalid'))
|
|
}
|
|
this.watch = args[i + 1]
|
|
i++
|
|
} else if (args[i] === '-n' || args[i] === '--npm') {
|
|
if (!args[i + 1] || args[i + 1][0] === '-') {
|
|
return Promise.reject(new Error('Npm was missing or invalid'))
|
|
}
|
|
this.run = args[i + 1]
|
|
i++
|
|
} else if (args[i] === '--ignore-only') {
|
|
this.ignoreOnly = true
|
|
} else if (args[i][0] === '-') {
|
|
return Promise.reject(new Error(`Unknown option ${args[i]}`))
|
|
} else {
|
|
this.targets.push(args[i])
|
|
}
|
|
}
|
|
|
|
if (!this.targets.length && this.run === 'test') {
|
|
this.targets.push('test/**')
|
|
}
|
|
|
|
return Promise.resolve()
|
|
}
|
|
|
|
CLI.prototype.startWatcher = async function() {
|
|
if (!this.watch || this.isSlave) {
|
|
return Promise.resolve()
|
|
}
|
|
|
|
let packageJson
|
|
try {
|
|
packageJson = JSON.parse(await fsPromise.readFile('package.json'))
|
|
} catch (err) {
|
|
throw new Error(`package.json was missing or invalid JSON: ${err.message}`)
|
|
}
|
|
|
|
let currentGroup = packageJson.watch && packageJson.watch[this.watch]
|
|
|
|
if (!currentGroup || !currentGroup.patterns) {
|
|
throw new Error(`package.json was missing watch property or missing ${this.watch} in watch or missing pattern`)
|
|
}
|
|
|
|
if (!currentGroup.extensions) {
|
|
currentGroup.extensions = 'js,mjs'
|
|
} else if (!currentGroup.extensions.match(/^([a-zA-Z]{2,3})(,[a-zA-Z]{2,3})*$/)) {
|
|
throw new Error(`package.json watch ${this.watch} extension "${currentGroup.extensions}" was invalid`)
|
|
}
|
|
|
|
return new Promise((res, rej) => {
|
|
this.watcher = new Watcher(currentGroup.patterns, {
|
|
quickNativeCheck: true,
|
|
delay: currentGroup.delay || 200,
|
|
skip: function(name) {
|
|
return name.indexOf('node_modules') >= 0
|
|
},
|
|
filter: new RegExp(currentGroup.extensions.split(',').map(x => `(\\.${x}$)`).join('|'))
|
|
})
|
|
this.watcher.once('error', rej)
|
|
this.watcher.once('ready', () => {
|
|
this.watcher.off('error', rej)
|
|
res()
|
|
})
|
|
})
|
|
}
|
|
|
|
CLI.prototype.getFiles = function() {
|
|
if (this.isSlave) {
|
|
return this._askMasterForFiles()
|
|
} else {
|
|
return this._processTargets()
|
|
}
|
|
}
|
|
|
|
CLI.prototype._askMasterForFiles = function() {
|
|
return new Promise(res => {
|
|
const handler = (payload) => {
|
|
if (isMessageInvalid(payload, MESSAGE_FILES_PAYLOAD)) return
|
|
this.process.off('message', handler)
|
|
res(this.files = payload.data)
|
|
}
|
|
this.process.on('message', handler)
|
|
this.process.send(createMessage(MESSAGE_FILES_REQUEST))
|
|
})
|
|
}
|
|
|
|
CLI.prototype._processTargets = function() {
|
|
this.files.splice(0, this.files.length)
|
|
|
|
if (!this.targets.length) {
|
|
return Promise.resolve()
|
|
}
|
|
|
|
return Promise.all(this.targets.map((target) => {
|
|
return getFilesFromTarget(this.files, target)
|
|
})).then(() => {
|
|
if (!this.files.length) {
|
|
this.errored = 'empty'
|
|
}
|
|
return this.files
|
|
})
|
|
}
|
|
|
|
CLI.prototype.loadFiles = async function() {
|
|
if (!this.isSlave && this.watch) {
|
|
return Promise.resolve()
|
|
}
|
|
this.e.begin()
|
|
|
|
let cwd = this.process.cwd()
|
|
|
|
for (let i = 0; i < this.files.length; i++) {
|
|
if (this.files[i].endsWith('.mjs') || this.files[i].endsWith('.js')) {
|
|
try {
|
|
this.e.setFilename(this.files[i])
|
|
await this.import('file:///' + path.join(cwd, this.files[i]))
|
|
this.e.resetFilename()
|
|
} catch (e) {
|
|
let newError = new Error(`Error while loading ${this.files[i]}`)
|
|
newError.inner = e
|
|
throw newError
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CLI.prototype.beginRun = async function() {
|
|
if (this.watcher) {
|
|
return this._runWorker()
|
|
} else {
|
|
return this._runTests()
|
|
}
|
|
}
|
|
|
|
CLI.prototype._runTests = function() {
|
|
this.e.reporter = this.reporter
|
|
this.e.ignoreOnly = this.ignoreOnly
|
|
this.e.__timeout = this.timeout
|
|
|
|
return this.e.run().then((stats) => {
|
|
if (this.isSlave) {
|
|
this.process.send(createMessage(MESSAGE_RUN_FINISHED, { stats: stats }))
|
|
}
|
|
return stats
|
|
})
|
|
}
|
|
|
|
CLI.prototype._runWorker = function() {
|
|
let lastStats = null
|
|
|
|
const messageHandler = (payload) => {
|
|
if (isMessageInvalid(payload, MESSAGE_RUN_FINISHED)) return
|
|
lastStats = payload.data.stats
|
|
}
|
|
const changeHandler = (evt, name) => {
|
|
if (evt === EVENT_UPDATE && !this.files.includes(name) && this.fileMatchesTarget(name)) {
|
|
this.files.push(name)
|
|
} else if (evt === EVENT_REMOVE) {
|
|
let index = this.files.indexOf(name)
|
|
if (index >= 0) {
|
|
this.files.splice(index, 1)
|
|
}
|
|
}
|
|
}
|
|
const changedHandler = () => {
|
|
this.runProgram()
|
|
}
|
|
|
|
return new Promise(res => {
|
|
const cleanup = () => {
|
|
this.process.off('message', messageHandler)
|
|
this.watcher.off('change', changeHandler)
|
|
this.watcher.off('changed', changedHandler)
|
|
res(lastStats)
|
|
}
|
|
|
|
this.process.on('message', messageHandler)
|
|
this.watcher.on('change', changeHandler)
|
|
this.watcher.on('changed', changedHandler)
|
|
|
|
this.ac.signal.addEventListener('abort', cleanup, { once: true });
|
|
changedHandler()
|
|
})
|
|
}
|
|
|
|
CLI.prototype.runProgram = function() {
|
|
let runningTest = this.run === 'test'
|
|
|
|
if (this.worker) {
|
|
if (runningTest) {
|
|
return
|
|
} else {
|
|
this.kill(this.worker.pid)
|
|
}
|
|
}
|
|
|
|
let worker
|
|
if (runningTest) {
|
|
worker = this.worker = this.cluster.fork()
|
|
} else {
|
|
worker = this.worker = this.child_process.spawn('npm', ['run', this.run])
|
|
}
|
|
|
|
worker.once('exit', (exitCode) => {
|
|
if (this.worker !== worker) return
|
|
|
|
let currentTime = new Date().toISOString().split('T')[1].split('.')[0]
|
|
if (!runningTest) {
|
|
console.log()
|
|
}
|
|
if (exitCode > 0) {
|
|
console.error(`\x1b[31m[${this.watch}] ${currentTime}: Exited with error code ${exitCode}. Waiting for file changes before running again...\x1b[0m`)
|
|
} else {
|
|
console.error(`\x1b[32m[${this.watch}] ${currentTime}: Ran successfully. Waiting for file changes before running again...\x1b[0m`)
|
|
}
|
|
this.worker = null
|
|
})
|
|
if (runningTest) {
|
|
worker.on('message', (msg) => {
|
|
if (isMessageValid(msg, MESSAGE_FILES_REQUEST)) {
|
|
worker.send(createMessage(MESSAGE_FILES_PAYLOAD, this.files))
|
|
}
|
|
})
|
|
} else {
|
|
worker.stdout.on('data', (d) => { this.process.stdout.write(d.toString()) })
|
|
worker.stderr.on('data', (d) => { this.process.stderr.write(d.toString()) })
|
|
}
|
|
}
|
|
|
|
CLI.prototype.import = function(path) {
|
|
if (this.importer) {
|
|
return this.importer(path)
|
|
}
|
|
return import(path)
|
|
}
|
|
|
|
function isMessageInvalid(payload, messageType) {
|
|
if (!payload
|
|
|| typeof(payload) !== 'object'
|
|
|| typeof(payload.messageType) !== 'string'
|
|
|| payload.messageType !== messageType
|
|
|| (payload.data != null && typeof(payload.data) !== 'object')) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
function isMessageValid(payload, messageType) {
|
|
return !isMessageInvalid(payload, messageType)
|
|
}
|
|
|
|
function traverseFolder(files, curr, match, insidePath, grabAll, insideStar, includeFiles) {
|
|
return new Promise(function(resolve, reject) {
|
|
return fs.readdir(curr, function(err, data) {
|
|
if (err) return reject(new Error('unable to read directory ' + curr + ': ' + err.message))
|
|
|
|
resolve(Promise.all(data.map(function(file) {
|
|
return new Promise(function(res, rej) {
|
|
fs.lstat(path.join(curr, file), function(err, stat) {
|
|
if (err) return rej(new Error('unable to read file or directory ' + path.join(curr, file) + ': ' + err.message))
|
|
|
|
if ((includeFiles || grabAll) && stat.isFile()) {
|
|
if (!match || fileMatches(file, match)) {
|
|
files.push(path.join(insidePath, file).replace(/\\/g, '/'))
|
|
return res(files)
|
|
}
|
|
}
|
|
if (stat.isDirectory() && grabAll) {
|
|
return res(traverseFolder(files, path.join(curr, file), match, path.join(insidePath, file), grabAll, insideStar, includeFiles))
|
|
} else if (stat.isDirectory() && match) {
|
|
return res(getFilesFromTarget(files, match, path.join(insidePath, file), grabAll, insideStar))
|
|
}
|
|
res(null)
|
|
})
|
|
})
|
|
})).then(function() { return files }))
|
|
})
|
|
})
|
|
}
|
|
|
|
export function fileMatches(filename, match) {
|
|
return Boolean(filename.match(new RegExp(match.replace(/\./, '\\.').replace(/\*/, '.*'))))
|
|
}
|
|
|
|
export function getFilesFromTarget(files, match, insidePath, grabAll, insideStar) {
|
|
let isGrabbingAll = grabAll || false
|
|
let isStarred = insideStar || false
|
|
let cwd = process.cwd()
|
|
let currPath = insidePath || ''
|
|
let curr = path.join(cwd, currPath || '')
|
|
|
|
return new Promise(function(res, rej) {
|
|
let start = 0
|
|
let splitted = match.split('/')
|
|
if (splitted[start] === '.') {
|
|
start++
|
|
}
|
|
if (splitted[splitted.length - 1] === '') {
|
|
splitted[splitted.length - 1] === '*'
|
|
}
|
|
|
|
let first = splitted[start]
|
|
|
|
if (splitted.length > start + 1) {
|
|
if (first === '**') {
|
|
isGrabbingAll = isStarred = true
|
|
return traverseFolder(files, curr, splitted.slice(start + 1).join('/'), currPath, isGrabbingAll, isStarred, false)
|
|
.then(res, rej)
|
|
} else if (first === '*') {
|
|
isStarred = true
|
|
return traverseFolder(files, curr, splitted.slice(start + 1).join('/'), currPath, isGrabbingAll, isStarred, false)
|
|
.then(res, rej)
|
|
}
|
|
return getFilesFromTarget(files, splitted.slice(start + 1).join('/'), path.join(currPath, first), grabAll, isStarred)
|
|
.then(res, rej)
|
|
} else if (first.indexOf('*') >= 0) {
|
|
if (first === '**') {
|
|
isGrabbingAll = isStarred = true
|
|
}
|
|
return traverseFolder(files, curr, first === '*' || first === '**'? '' : first, currPath, isGrabbingAll, isStarred, true)
|
|
.then(res, rej)
|
|
}
|
|
|
|
fs.lstat(path.join(curr, first), function(err, stat) {
|
|
if (err) {
|
|
// If we're inside a star, we ignore files we cannot find
|
|
if (isStarred) {
|
|
return res(files)
|
|
}
|
|
return rej(new Error('file ' + path.join(insidePath, first) + ' could not be found: ' + err.message))
|
|
}
|
|
|
|
if (stat.isDirectory()) {
|
|
return traverseFolder(files, path.join(curr, first), '', path.join(currPath, first), true, true, true)
|
|
.then(res, rej)
|
|
}
|
|
|
|
files.push(path.join(currPath, match).replace(/\\/g, '/'))
|
|
return res(files)
|
|
})
|
|
})
|
|
}
|
|
|
|
export function printError(err, msg, clean = false) {
|
|
let before = msg || ''
|
|
if (!clean) console.error('')
|
|
console.error('\x1b[31m '
|
|
+ before + err.toString()
|
|
+ '\x1b[0m\n \x1b[90m'
|
|
+ (err.stack || '').replace(err.toString(), ''))
|
|
console.error('\x1b[0m')
|
|
}
|