@plugjs/plug 0.3.5 → 0.4.0

package/src/logging/logger.ts

@@ -1,13 +1,17 @@
-import { BuildFailure, isBuildFailure } from '../asserts'
+import { formatWithOptions } from 'node:util'
+
+import { BuildFailure } from '../asserts'
 import { emitColor, emitPlain } from './emit'
 import { DEBUG, ERROR, INFO, NOTICE, TRACE, WARN } from './levels'
 import { logOptions } from './options'
 import { ReportImpl } from './report'
+import { $gry } from './colors'
 
-import type { LogEmitter } from './emit'
+import type { LogEmitter, LogEmitterOptions } from './emit'
 import type { LogLevel } from './levels'
 import type { Report } from './report'
 
+
 /* ========================================================================== */
 
 /* Initial value of log colors, and subscribe to changes */
@@ -26,8 +30,6 @@ logOptions.on('changed', ({ defaultTaskName, colors, level }) => {
 
 /** The basic interface giving access to log facilities. */
 export interface Log {
-  /** The current {@link Logger} */
-  readonly logger: Logger
   /** Log a `TRACE` message */
   trace(...args: [ any, ...any ]): void
   /** Log a `DEBUG` message */
@@ -45,7 +47,7 @@ export interface Log {
 }
 
 /** A {@link Logger} extends the basic {@link Log} adding some state. */
-export interface Logger extends Omit<Log, 'logger'> {
+export interface Logger extends Log {
   /** The current level for logging. */
   level: LogLevel,
 
@@ -95,7 +97,7 @@ class LoggerImpl implements Logger {
 
     // The `BuildFailure` is a bit special case
     const params = args.filter((arg) => {
-      if (isBuildFailure(arg)) {
+      if (arg instanceof BuildFailure) {
         // Filter out any previously logged build failure and mark
         if (_loggedFailures.has(arg)) return false
         _loggedFailures.add(arg)
@@ -198,6 +200,57 @@ class LoggerImpl implements Logger {
   }
 
   report(title: string): Report {
-    return new ReportImpl(title, this._task, this._emitter)
+    const emitter: LogEmitter = (options: LogEmitterOptions, args: any) => {
+      if (this._stack.length) {
+        for (const { message, ...extras } of this._stack) {
+          this._emitter({ ...options, ...extras }, [ message ])
+        }
+        this._stack.splice(0)
+      }
+
+      let { indent = 0, prefix = '' } = options
+      prefix = this._indent ? $gry('| ') + prefix : prefix
+      indent += this._indent
+      this._emitter({ ...options, indent, prefix }, args)
+    }
+    return new ReportImpl(title, this._task, emitter)
+  }
+}
+
+/* ========================================================================== */
+
+/** Pattern to match ANSI expressions */
+const ansiPattern = '[\\u001b\\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]'
+/** Regular expression matching ANSI */
+const ansiRegExp = new RegExp(ansiPattern, 'g')
+
+/** A test logger, writing to a buffer always _without_ colors */
+export class TestLogger extends LoggerImpl {
+  private _lines: string[] = []
+
+  constructor() {
+    super('', (options: LogEmitterOptions, args: any[]): void => {
+      const { prefix = '', indent = 0 } = options
+      const linePrefix = ''.padStart(indent * 2) + prefix
+
+      /* Now for the normal logging of all our parameters */
+      formatWithOptions({ colors: false, breakLength: 120 }, ...args)
+          .split('\n').forEach((line) => {
+            const stripped = line.replaceAll(ansiRegExp, '')
+            this._lines.push(`${linePrefix}${stripped}`)
+          })
+    })
+  }
+
+  /** Return the _current_ buffer for this instance */
+  get buffer(): string {
+    return this._lines.join('\n')
+  }
+
+  /** Reset the buffer and return any previously buffered text */
+  reset(): string {
+    const buffer = this.buffer
+    this._lines = []
+    return buffer
   }
 }

package/src/logging/options.ts

@@ -96,7 +96,11 @@ class LogOptionsImpl extends EventEmitter implements LogOptions {
      * and consumed by the `Exec` plug (which has no other way of communicating)
      */
     const { fd, ...options } = JSON.parse(process.env.__LOG_OPTIONS || '{}')
-    if (fd) this._output = new Socket({ fd, readable: false, writable: true }).unref()
+    if (fd) {
+      const output = new Socket({ fd, readable: false, writable: true }).unref()
+      process.on('beforeExit', () => this._output.end())
+      this._output = output
+    }
     Object.assign(this, options)
   }
 

package/src/logging.ts

@@ -1,8 +1,9 @@
 import { currentContext } from './async'
+import { $gry, $wht } from './logging/colors'
 import { getLogger } from './logging/logger'
 import { setupSpinner } from './logging/spinner'
 
-import type { Logger, Log } from './logging/logger'
+import type { Log, Logger } from './logging/logger'
 
 export * from './logging/colors'
 export * from './logging/github'
@@ -32,10 +33,6 @@ export const log: LogFunction = ((): LogFunction => {
 
   /* Create a Logger wrapping the current logger */
   const wrapper: Log = {
-    get logger() {
-      return logger()
-    },
-
     trace(...args: [ any, ...any ]): void {
       logger().trace(...args)
     },
@@ -71,3 +68,21 @@ export const log: LogFunction = ((): LogFunction => {
   /* Return our function, with added Logger implementation */
   return Object.assign(log, wrapper)
 })()
+
+/* ========================================================================== *
+ * BANNER                                                                     *
+ * ========================================================================== */
+
+/** Print a nice _banner_ message on the log */
+export function banner(message: string): void {
+  const padMessage = message.length > 60 ? message.length : 60
+  const padLines = padMessage + 2
+
+  log.notice([
+    '',
+    $gry(`\u2554${''.padStart(padLines, '\u2550')}\u2557`),
+    `${$gry('\u2551')} ${$wht(message.padEnd(padMessage, ' '))} ${$gry('\u2551')}`,
+    $gry(`\u255A${''.padStart(padLines, '\u2550')}\u255D`),
+    '',
+  ].join('\n'))
+}

package/src/plugs/build.ts

@@ -0,0 +1,58 @@
+import { $p } from '../logging/colors'
+import { ForkingPlug, type ForkOptions } from '../fork'
+import { requireFilename } from '../paths'
+
+import type { Files } from '../files'
+import type { Context, Plug } from '../pipe'
+import type { Build } from '../types'
+
+/** Writes some info about the current {@link Files} being passed around. */
+export class RunBuildInternal implements Plug<void> {
+  constructor(
+      private readonly _tasks: readonly string[],
+      private readonly _props: Readonly<Record<string, string>>,
+  ) {}
+
+  async pipe(files: Files, context: Context): Promise<void> {
+    const tasks = this._tasks.length === 0 ? [ 'default' ] : this._tasks
+
+    for (const file of files.absolutePaths()) {
+      // Import and check build file
+      let maybeBuild = await import(file)
+      while (maybeBuild) {
+        if (isBuild(maybeBuild)) break
+        maybeBuild = maybeBuild.default
+      }
+
+      // We _need_ a build
+      if (! isBuild(maybeBuild)) {
+        context.log.fail(`File ${$p(file)} did not export a proper build`)
+      } else {
+        await maybeBuild[buildMarker](tasks, this._props)
+      }
+    }
+  }
+}
+
+/** Symbol indicating that an object is a {@link Build}. */
+const buildMarker = Symbol.for('plugjs:isBuild')
+
+/** Check if the specified build is actually a {@link Build} */
+function isBuild(build: any): build is Build<Record<string, any>> & {
+  [buildMarker]: (
+    tasks: readonly string[],
+    props?: Record<string, string | undefined>,
+  ) => Promise<void>
+} {
+  return build && typeof build[buildMarker] === 'function'
+}
+
+export class RunBuild extends ForkingPlug {
+  constructor(
+      tasks: readonly string[],
+      props: Readonly<Record<string, string>>,
+      options: ForkOptions,
+  ) {
+    super(requireFilename(__fileurl), [ tasks, props, options ], RunBuildInternal.name)
+  }
+}

package/src/types.ts

@@ -26,6 +26,8 @@ export interface State {
   readonly tasks: Tasks
   /** All _properties_ available in this {@link State} */
   readonly props: Props
+  /** All _tasks_ that have failed in this {@link State} */
+  readonly fails: Set<Task>
 }
 
 /* ========================================================================== *

package/src/utils/exec.ts

@@ -1,9 +1,9 @@
+import { spawn } from 'node:child_process'
 import path from 'node:path'
 import readline from 'node:readline'
-import { fork as forkProcess, spawn as spawnProcess } from 'node:child_process'
 
 import { assert, BuildFailure } from '../asserts'
-import { $p, logOptions } from '../logging'
+import { $p } from '../logging'
 import { getCurrentWorkingDirectory, resolveDirectory } from '../paths'
 
 import type { SpawnOptions } from 'node:child_process'
@@ -16,8 +16,6 @@ export interface ExecChildOptions {
   coverageDir?: string,
   /** Extra environment variables, or overrides for existing ones */
   env?: Record<string, any>,
-  /** Whether to _fork_ the process (argument is a javascript file) or not */
-  fork?: boolean,
   /** Whether to run the command in a shell (optionally name the shell) */
   shell?: string | boolean,
   /** The current working directory of the process to execute. */
@@ -32,7 +30,6 @@ export async function execChild(
 ): Promise<void> {
   const {
     env = {}, // default empty environment
-    fork = false, // by default do not fork
     shell = false, // by default do not use a shell
     cwd = undefined, // by default use "process.cwd()"
     coverageDir, // default "undefined" (pass throug from env)
@@ -42,9 +39,6 @@ export async function execChild(
   const childCwd = cwd ? context.resolve(cwd) : getCurrentWorkingDirectory()
   assert(resolveDirectory(childCwd), `Current working directory ${$p(childCwd)} does not exist`)
 
-  // Check for wrong fork/shell combination
-  assert(!(fork && shell), 'Options "fork" and "shell" can not coexist')
-
   // Figure out the PATH environment variable
   const childPaths: AbsolutePath[] = []
 
@@ -62,8 +56,7 @@ export async function execChild(
 
   // Build our environment variables record
   const PATH = childPaths.join(path.delimiter)
-  const logForkEnv = logOptions.forkEnv(context.taskName, 4)
-  const childEnv: Record<string, string> = { ...process.env, ...env, ...logForkEnv, PATH }
+  const childEnv: Record<string, string> = { ...process.env, ...env, PATH }
 
   // Instrument coverage directory if needed
   if (coverageDir) childEnv.NODE_V8_COVERAGE = context.resolve(coverageDir)
@@ -71,19 +64,17 @@ export async function execChild(
   // Prepare the options for calling `spawn`
   const childOptions: SpawnOptions = {
     ...extraOptions,
-    stdio: [ 'ignore', 'pipe', 'pipe', 'ipc', 'pipe' ],
+    stdio: [ 'ignore', 'pipe', 'pipe' ],
     cwd: childCwd,
     env: childEnv,
     shell,
   }
 
   // Spawn our subprocess and monitor its stdout/stderr
-  context.log.info(fork ? 'Forking' : 'Executing', [ cmd, ...args ])
+  context.log.info('Executing', [ cmd, ...args ])
   context.log.debug('Child process options', childOptions)
 
-  const child = fork ?
-    forkProcess(cmd, args, childOptions) :
-    spawnProcess(cmd, args, childOptions)
+  const child = spawn(cmd, args, childOptions)
 
   try {
     context.log.info('Child process PID', child.pid)
@@ -99,11 +90,6 @@ export async function execChild(
       const err = readline.createInterface(child.stderr)
       err.on('line', (line) => context.log.warn(line ||'\u00a0'))
     }
-
-    // Log output bypass
-    if (child.stdio[4]) {
-      child.stdio[4].on('data', (data) => logOptions.output.write(data))
-    }
   } catch (error) {
     // If something happens before returning our promise, kill the child...
     child.kill()