@plugjs/plug 0.0.18 → 0.0.20

package/src/fork.ts

@@ -89,7 +89,7 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
 
       child.on('error', (error) => {
         context.log.error('Child process error', error)
-        return done || reject(new BuildFailure({ logged: true }))
+        return done || reject(BuildFailure.fail())
       })
 
       child.on('message', (message: ForkResult) => {
@@ -100,16 +100,16 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
       child.on('exit', (code, signal) => {
         if (signal) {
           context.log.error(`Child process exited with signal ${signal}`, $gry(`(pid=${child.pid})`))
-          return done || reject(new BuildFailure({ logged: true }))
+          return done || reject(BuildFailure.fail())
         } else if (code !== 0) {
           context.log.error(`Child process exited with code ${code}`, $gry(`(pid=${child.pid})`))
-          return done || reject(new BuildFailure({ logged: true }))
+          return done || reject(BuildFailure.fail())
         } else if (! result) {
           context.log.error('Child process exited with no result', $gry(`(pid=${child.pid})`))
-          return done || reject(new BuildFailure({ logged: true }))
+          return done || reject(BuildFailure.fail())
         } else if (result.failed) {
           // definitely logged on the child side
-          return done || reject(new BuildFailure({ logged: true }))
+          return done || reject(BuildFailure.fail())
         }
 
         /* We definitely have a successful result! */
@@ -123,16 +123,16 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
         const result = child.send(message, (error) => {
           if (error) {
             context.log.error('Error sending message to child process (callback failure)', error)
-            reject(new BuildFailure({ logged: true }))
+            reject(BuildFailure.fail())
           }
         })
         if (! result) {
           context.log.error('Error sending message to child process (send returned false)')
-          reject(new BuildFailure({ logged: true }))
+          reject(BuildFailure.fail())
         }
       } catch (error) {
         context.log.error('Error sending message to child process (exception caught)', error)
-        reject(new BuildFailure({ logged: true }))
+        reject(BuildFailure.fail())
       }
     }).finally(() => done = true)
   }
@@ -152,7 +152,7 @@ if ((process.argv[1] === requireFilename(__fileurl)) && (process.send)) {
   /* If we haven't processed our message in 5 seconds, fail _badly_ */
   const timeout = setTimeout(() => {
     // eslint-disable-next-line no-console
-    console.error('Mocha not initialized in 5 seconds')
+    console.error('Fork not initialized in 5 seconds')
     process.exit(2)
   }, 5000)
 

package/src/log/logger.ts

@@ -85,11 +85,18 @@ class LoggerImpl implements Logger {
   private _emit(level: LogLevel, args: [ any, ...any ]): this {
     if (this._level > level) return this
 
-    // Filter out build failures that were already logged
+    // The `BuildFailure` is a bit special case
     const params = args.filter((arg) => {
       if (isBuildFailure(arg)) {
-        if (arg.logged) return false // already logged? skip!
-        return arg.logged = true // set logged to true and log!
+        // Filter out any previously logged build failure and mark
+        if (arg.logged) return false
+        arg.logged = true
+
+        // If the build failure has any root cause, log those
+        arg.errors.forEach((error) => this._emit(level, [ error ]))
+
+        // Log this only if it has a message
+        return !! arg.message
       } else {
         return true
       }
@@ -148,7 +155,7 @@ class LoggerImpl implements Logger {
 
   fail(...args: [ any, ...any ]): never {
     this._emit(ERROR, args)
-    throw new BuildFailure({ logged: true })
+    throw BuildFailure.fail()
   }
 
   enter(): this

package/src/log/report.ts

@@ -194,7 +194,7 @@ export class ReportImpl implements Report {
       if (! messages.length) {
         const options = { taskName: this._task, level: ERROR }
         this._emitter(options, [ 'No message for report record' ])
-        throw new BuildFailure({ logged: true })
+        throw BuildFailure.fail()
       }
 
       const level = record.level
@@ -267,7 +267,7 @@ export class ReportImpl implements Report {
   done(showSources?: boolean | undefined): void {
     if (showSources == null) showSources = logOptions.showSources
     if (! this.empty) this._emit(showSources)
-    if (this.errors) throw new BuildFailure({ logged: true })
+    if (this.errors) throw BuildFailure.fail()
   }
 
   private _emit(showSources: boolean): this {

package/src/pipe.ts

@@ -87,22 +87,59 @@ export class Context {
  * ========================================================================== */
 
 /**
- * In pipe chains, we want to keep track of the _leaf_ `Files` promises (that
+ * In pipe chains, we want to keep track of the _leaf_ promises (that
  * is, when a derived pipe is created calling `plug` we want to track only the
  * new, derived, promise).
  *
  * We key these _leaf_ promises by _context_ (with a WeakMap), and those will
  * be awaited at the end of the task.
  */
-const contextPromises = new WeakMap<Context, Set<Promise<Result>>>()
+const contextPromises = new WeakMap<Context, ContextPromises>()
 
-export function getContextPromises(context: Context): Set<Promise<Result>> {
-  let promises = contextPromises.get(context)
-  if (! promises) {
-    promises = new Set<Promise<Files>>()
-    contextPromises.set(context, promises)
+/**
+ * An internal class recording _hot_ (failure will fail the task) and _cold_
+ * (failure will be ignored) {@link Promise}s for a task's {@link Context}.
+ */
+export class ContextPromises {
+  private readonly _cold = new Set<Promise<Result>>()
+  private readonly _hot = new Set<Promise<Result>>()
+
+  /* Private constructor */
+  private constructor(readonly context: Context) {}
+
+  /** Track a {@link Promise} _hot_ (failure will fail the task) */
+  hot(promise: Promise<Result>): void {
+    this._cold.delete(promise)
+    this._hot.add(promise)
+  }
+
+  /** Track a {@link Promise} _cold_ (failure will be ignored) */
+  cold(promise: Promise<Result>): void {
+    this._hot.delete(promise)
+    this._cold.add(promise)
+  }
+
+  /**
+   * Await all tracked {@link Promise}s, triggering a build failure if any of
+   * the _hot_ ones is rejected.
+   */
+  static async wait(context: Context): Promise<void> {
+    const instance = contextPromises.get(context)
+    if (! instance) return
+
+    await Promise.allSettled([ ...instance._cold ])
+    await assertPromises([ ...instance._hot ])
+  }
+
+  /** Get a {@link ContextPromises} instance for the given {@link Context} */
+  static get(context: Context): ContextPromises {
+    let promises = contextPromises.get(context)
+    if (! promises) {
+      promises = new ContextPromises(context)
+      contextPromises.set(context, promises)
+    }
+    return promises
   }
-  return promises
 }
 
 /**
@@ -127,7 +164,7 @@ export class Pipe extends PipeProto implements Promise<Files> {
     super()
 
     // New "Pipe", remember the promise!
-    getContextPromises(_context).add(_promise)
+    ContextPromises.get(_context).hot(_promise)
   }
 
   /* ------------------------------------------------------------------------ *
@@ -152,7 +189,7 @@ export class Pipe extends PipeProto implements Promise<Files> {
       onrejected?: ((reason: any) => R2 | PromiseLike<R2>) | null | undefined,
   ): Promise<R1 | R2> {
     // We are delegating the handling of this promise to the caller
-    getContextPromises(this._context).delete(this._promise)
+    ContextPromises.get(this._context).cold(this._promise)
     return this._promise.then(onfulfilled as (value: Result) => R1 | PromiseLike<R1>, onrejected)
   }
 
@@ -160,13 +197,13 @@ export class Pipe extends PipeProto implements Promise<Files> {
       onrejected?: ((reason: any) => R | PromiseLike<R>) | null | undefined,
   ): Promise<Files | R> {
     // We are delegating the handling of this promise to the caller
-    getContextPromises(this._context).delete(this._promise)
+    ContextPromises.get(this._context).cold(this._promise)
     return this._promise.catch(onrejected) as Promise<Files | R>
   }
 
   finally(onfinally?: (() => void) | null | undefined): Promise<Files> {
     // We are delegating the handling of this promise to the caller
-    getContextPromises(this._context).delete(this._promise)
+    ContextPromises.get(this._context).cold(this._promise)
     return this._promise.finally(onfinally) as Promise<Files>
   }
 
@@ -182,7 +219,7 @@ export class Pipe extends PipeProto implements Promise<Files> {
     const plug = typeof arg === 'function' ? { pipe: arg } : arg
 
     // We are creating a new "leaf" Pipe, we can forget our promise
-    getContextPromises(this._context).delete(this._promise)
+    ContextPromises.get(this._context).cold(this._promise)
 
     // Create and return the new Pipe
     return new Pipe(this._context, this._promise.then(async (result) => {
@@ -214,7 +251,7 @@ export class Pipe extends PipeProto implements Promise<Files> {
       if (pipes.length === 0) return Files.builder(getCurrentWorkingDirectory()).build()
 
       // Await for all pipes / files / files promises
-      const results = await assertPromises<Files>(pipes, 'Error in pipe while merging')
+      const results = await assertPromises<Files>(pipes)
 
       // Find the common directory between all the Files instances
       const [ firstDir, ...otherDirs ] = results.map((f) => f.directory)

package/src/plugs/eslint/runner.ts

@@ -60,7 +60,7 @@ export default class ESLint implements Plug<void> {
 
     /* In case of failures from promises, fail! */
     const { results, failures } = summary
-    if (failures) throw new BuildFailure({ logged: true })
+    if (failures) throw BuildFailure.fail()
 
     /* Create our report */
     const report = context.log.report('ESLint Report')

package/src/plugs/mocha/runner.ts

@@ -40,7 +40,7 @@ export default class Mocha implements Plug<void> {
     return new Promise((resolve, reject) => {
       try {
         mocha.run((failures) => {
-          if (failures) reject(new BuildFailure({ logged: true }))
+          if (failures) reject(BuildFailure.fail())
           resolve(undefined)
         })
       } catch (error) {

package/src/plugs/tsc/runner.ts

@@ -4,7 +4,7 @@ import { assertPromises } from '../../assert'
 import { BuildFailure } from '../../failure'
 import { Files } from '../../files'
 import { $p, log } from '../../log'
-import { AbsolutePath, resolveFile } from '../../paths'
+import { AbsolutePath, resolveAbsolutePath, resolveFile } from '../../paths'
 import { Context, PipeParameters, Plug } from '../../pipe'
 import { parseOptions } from '../../utils/options'
 import { TypeScriptHost } from './compiler'
@@ -96,12 +96,14 @@ export default class Tsc implements Plug<Files> {
       promises.push(builder.write(fileName, code).then((file) => {
         log.trace('Written', $p(file))
       }).catch((error) => {
-        throw new BuildFailure(`Error writing to ${fileName}`, [ error ])
+        const outFile = resolveAbsolutePath(outDir, fileName)
+        log.error('Error writing to', $p(outFile), error)
+        throw BuildFailure.fail()
       }))
     })
 
     /* Await for all files to be written and check */
-    await assertPromises(promises, 'Error writing files')
+    await assertPromises(promises)
 
     /* Update report and fail on errors */
     updateReport(report, result.diagnostics, rootDir)