@plugjs/plug 0.0.14 → 0.0.16

package/src/plugs/exec.ts

@@ -2,14 +2,13 @@ import path from 'node:path'
 import reaadline from 'node:readline'
 
 import { spawn, SpawnOptions } from 'node:child_process'
-import { assert } from '../assert.js'
-import { currentRun } from '../async.js'
-import { Files } from '../files.js'
-import { $p, logOptions } from '../log.js'
-import { AbsolutePath, getCurrentWorkingDirectory, resolveDirectory } from '../paths.js'
-import { install, Plug } from '../pipe.js'
-import { Run } from '../run.js'
-import { parseOptions, ParseOptions } from '../utils/options.js'
+import { assert } from '../assert'
+import { Files } from '../files'
+import { $p, logOptions } from '../log'
+import { AbsolutePath, getCurrentWorkingDirectory, resolveDirectory } from '../paths'
+import { Context, install, PipeParameters, Plug } from '../pipe'
+import { parseOptions } from '../utils/options'
+import { requireContext } from '../async'
 
 /** Options for executing scripts */
 export interface ExecOptions {
@@ -31,40 +30,75 @@ export interface ExecOptions {
   relativePaths?: boolean
 }
 
-/**
- * Execute a shell command, adding to its _arguments_ the list of files from
- * the current pipe (much like `xargs` does on Unix systems).
- *
- * This {@link Plug} returns the same {@link Files} it was given, so that
- * executing a shell command doesn't interrupt a {@link Pipe}.
- *
- * For example:
- *
- * ```
- * import { find, exec } from '@plugjs/plugjs'
- *
- * export default build({
- *   async runme() {
- *     find('*.ts', { directory: 'src' })
- *       .plug(new Exec('chmod', '755' }))
- *       .plug(new Exec('chown root:root', { shell: true }))
- *   },
- * })
- * ```
- */
-export class Exec implements Plug<Files> {
+declare module '../pipe' {
+  export interface Pipe {
+    /**
+     * Execute a shell command, adding to its _arguments_ the list of files
+     * from the current pipe (much like `xargs` does on Unix systems).
+     *
+     * For example:
+     *
+     * ```
+     * import { build } from '@plugjs/plugjs'
+     *
+     * export default build({
+     *   runme() {
+     *     this.find('*.ts', { directory: 'src' })
+     *       .exec('chmod', '755' })
+     *       .exec('chown root:root', { shell: true })
+     *   },
+     * })
+     * ```
+     *
+     * @param cmd The command to execute
+     * @param args Any additional argument for the command to execute
+     */
+    exec(cmd: string, ...args: string[]): Pipe
+
+    /**
+     * Execute a shell command, adding to its _arguments_ the list of files
+     * from the current pipe (much like `xargs` does on Unix systems).
+     *
+     * For example:
+     *
+     * ```
+     * import { build } from '@plugjs/plugjs'
+     *
+     * export default build({
+     *   runme() {
+     *     this.find('*.ts', { directory: 'src' })
+     *       .exec('chmod', '755' })
+     *       .exec('chown root:root', { shell: true })
+     *   },
+     * })
+     * ```
+     *
+     * @param cmd The command to execute
+     * @param args Any additional argument for the command to execute
+     * @param options Extra {@link ExecOptions | options} for process execution
+     */
+    exec(cmd: string, ...extra: [ ...args: string[], options: ExecOptions ]): Pipe
+  }
+}
+
+/* ========================================================================== *
+ * INSTALLATION / IMPLEMENTATION                                              *
+ * ========================================================================== */
+
+install('exec', class Exec implements Plug<Files> {
   private readonly _cmd: string
   private readonly _args: readonly string[]
   private readonly _options: ExecOptions
 
-  constructor(cmd: string, ...args: ParseOptions<ExecOptions>) {
+  constructor(...args: PipeParameters<'exec'>) {
     const { params, options } = parseOptions(args, {})
-    this._cmd = cmd
-    this._args = params
+    const [ _cmd, ..._args ] = params
+    this._cmd = _cmd
+    this._args = _args
     this._options = options
   }
 
-  async pipe(files: Files, run: Run): Promise<Files> {
+  async pipe(files: Files, context: Context): Promise<Files> {
     const { relativePaths = true, ...options } = this._options
 
     if (! options.cwd) options.cwd = files.directory
@@ -76,12 +110,12 @@ export class Exec implements Plug<Files> {
     if (options.shell) params.forEach((s, i, a) => a[i] = JSON.stringify(s))
 
     // Run our child
-    await spawnChild(this._cmd, [ ...this._args, ...params ], options, run)
+    await spawnChild(this._cmd, [ ...this._args, ...params ], options, context)
 
     // Return our files
     return files
   }
-}
+})
 
 /**
  * Execute a command and await for its result from within a task.
@@ -94,50 +128,27 @@ export class Exec implements Plug<Files> {
  * export default build({
  *   async runme() {
  *     await exec('ls', '-la', '/')
+ *     // or similarly letting the shell interpret the command
+ *     await exec('ls -la /', { shell: true })
  *   },
  * })
  * ```
+ *
+ * @param cmd The command to execute
+ * @param args Any additional argument for the command to execute
+ * @param options Extra {@link ExecOptions | options} for process execution
  */
-
-export function exec(cmd: string, ...args: ParseOptions<ExecOptions>): Promise<void> {
-  const run = currentRun()
-  assert(run, 'Unable to execute commands outside a running task')
-
-  const { params, options } = parseOptions(args, {})
-  return spawnChild(cmd, params, options, run)
+export function exec(
+    cmd: string,
+    ...args:
+    | [ ...args: string[] ]
+    | [ ...args: string[], options: ExecOptions ]
+): Promise<void> {
+  const { params, options } = parseOptions(args)
+  return spawnChild(cmd, params, options, requireContext())
 }
 
 
-/* ========================================================================== *
- * INSTALLATION                                                               *
- * ========================================================================== */
-
-install('exec', Exec)
-
-declare module '../pipe.js' {
-  export interface Pipe {
-    /**
-     * Execute a shell command, adding to its _arguments_ the list of files
-     * from the current pipe (much like `xargs` does on Unix systems).
-     *
-     * For example:
-     *
-     * ```
-     * import { find, exec } from '@plugjs/plugjs'
-     *
-     * export default build({
-     *   async runme() {
-     *     find('*.ts', { directory: 'src' })
-     *       .exec('chmod', '755' })
-     *       .exec('chown root:root', { shell: true })
-     *   },
-     * })
-     * ```
-     */
-    exec: PipeExtension<typeof Exec>
-  }
-}
-
 /* ========================================================================== *
  * INTERNALS                                                                  *
  * ========================================================================== */
@@ -146,7 +157,7 @@ async function spawnChild(
     cmd: string,
     args: readonly string[],
     options: ExecOptions = {},
-    run: Run,
+    context: Context,
 ): Promise<void> {
   const {
     env = {}, // default empty environment
@@ -155,18 +166,18 @@ async function spawnChild(
     ...extraOptions
   } = options
 
-  const childCwd = cwd ? run.resolve(cwd) : getCurrentWorkingDirectory()
+  const childCwd = cwd ? context.resolve(cwd) : getCurrentWorkingDirectory()
   assert(resolveDirectory(childCwd), `Current working directory ${$p(childCwd)} does not exist`)
 
   // Figure out the PATH environment variable
   const childPaths: AbsolutePath[] = []
 
   // The `.../node_modules/.bin` path relative to the current working dir */
-  const baseNodePath = run.resolve('@node_modules', '.bin')
+  const baseNodePath = context.resolve('@node_modules', '.bin')
   if (resolveDirectory(baseNodePath)) childPaths.push(baseNodePath)
 
   // The `.../node_bodules/.bin` path relative to the buildDir */
-  const buildNodePath = run.resolve('./node_modules', '.bin')
+  const buildNodePath = context.resolve('./node_modules', '.bin')
   if (resolveDirectory(buildNodePath)) childPaths.push(buildNodePath)
 
   // Any other paths either from `process.env` or `env` (which overrides it)
@@ -175,7 +186,7 @@ async function spawnChild(
 
   // Build our environment variables record
   const PATH = childPaths.join(path.delimiter)
-  const __LOG_OPTIONS = JSON.stringify(logOptions.fork(run.taskName))
+  const __LOG_OPTIONS = JSON.stringify(logOptions.fork(context.taskName))
   const childEnv = { ...process.env, ...env, PATH, __LOG_OPTIONS }
 
   // Prepare the options for calling `spawn`
@@ -188,18 +199,18 @@ async function spawnChild(
   }
 
   // Spawn our subprocess and monitor its stdout/stderr
-  run.log.info('Executing', [ cmd, ...args ])
-  run.log.info('Execution options', childOptions)
+  context.log.info('Executing', [ cmd, ...args ])
+  context.log.info('Execution options', childOptions)
   const child = spawn(cmd, args, childOptions)
 
   if (child.stdout) {
     const out = reaadline.createInterface(child.stdout)
-    out.on('line', (line) => line ? run.log.notice(line) : run.log.notice('\u00a0'))
+    out.on('line', (line) => line ? context.log.notice(line) : context.log.notice('\u00a0'))
   }
 
   if (child.stderr) {
     const err = reaadline.createInterface(child.stderr)
-    err.on('line', (line) => line ? run.log.warn(line) : run.log.warn('\u00a0'))
+    err.on('line', (line) => line ? context.log.warn(line) : context.log.warn('\u00a0'))
   }
 
   // Return our promise from the spawn events

package/src/plugs/filter.ts

@@ -1,9 +1,8 @@
-import { Files } from '../files.js'
-import { resolveRelativeChildPath } from '../paths.js'
-import { install, Plug } from '../pipe.js'
-import { Run } from '../run.js'
-import { match, MatchOptions } from '../utils/match.js'
-import { ParseOptions, parseOptions } from '../utils/options.js'
+import { Files } from '../files'
+import { resolveRelativeChildPath } from '../paths'
+import { Context, install, PipeParameters, Plug } from '../pipe'
+import { match, MatchOptions } from '../utils/match'
+import { parseOptions } from '../utils/options'
 
 /** Options for filtering {@link Files}. */
 export interface FilterOptions extends MatchOptions {
@@ -11,45 +10,61 @@ export interface FilterOptions extends MatchOptions {
   directory?: string
 }
 
+declare module '../pipe' {
+  export interface Pipe {
+    /**
+     * Filter the current {@link Files} using globs.
+     *
+     * @param glob The glob to use for filtering files
+     */
+    filter(glob: string): Pipe
+    /**
+     * Filter the current {@link Files} using globs.
+     *
+     * @param globs The globs to use for filtering files (at least one)
+     */
+    filter(...globs: [ string, ...string[] ]): Pipe
+    /**
+     * Filter the current {@link Files} using globs.
+     *
+     * @param globs The globs to use for filtering files (at least one)
+     * @param options Additional {@link FilterOptions | options} for filtering
+     */
+    filter(...args: [ ...globs: [ string, ...string[] ], options: FilterOptions ]): Pipe
+  }
+}
+
+/* ========================================================================== *
+ * INSTALLATION / IMPLEMENTATION                                              *
+ * ========================================================================== */
+
 /** Filter the current {@link Files} using globs. */
-export class Filter implements Plug<Files> {
+install('filter', class Filter implements Plug<Files> {
   private readonly _globs: readonly [ string, ...readonly string[] ]
   private readonly _options: FilterOptions
 
-  constructor(glob: string, ...args: ParseOptions<FilterOptions>) {
+  constructor(...args: PipeParameters<'filter'>) {
     const { params, options } = parseOptions(args, {})
-    this._globs = [ glob, ...params ]
     this._options = options
+    this._globs = params
   }
 
-  pipe(files: Files, run: Run): Files {
+  pipe(files: Files, context: Context): Files {
     const { directory, ...options } = this._options
 
-    const builder = run.files(directory || files.directory)
+    const dir = directory ? context.resolve(directory) : files.directory
+    const builder = Files.builder(dir)
     const matcher = match(this._globs, options)
 
     for (const file of files.absolutePaths()) {
       const relative = resolveRelativeChildPath(builder.directory, file)
-      if (relative && matcher(relative)) builder.unchecked(relative)
+      if (relative && matcher(relative)) builder.add(relative)
     }
 
     const result = builder.build()
     const discarded = files.length - result.length
-    run.log.debug('Filtered', result.length, 'files (discarded', discarded, 'files)')
+    context.log.debug('Filtered', result.length, 'files (discarded', discarded, 'files)')
 
     return result
   }
-}
-
-/* ========================================================================== *
- * INSTALLATION                                                               *
- * ========================================================================== */
-
-install('filter', Filter)
-
-declare module '../pipe.js' {
-  export interface Pipe {
-    /** Filter the current {@link Files} using globs. */
-    filter: PipeExtension<typeof Filter>
-  }
-}
+})

package/src/plugs/mocha/reporter.ts

@@ -2,7 +2,7 @@ import RealMocha from 'mocha' // Mocha types pollute the global scope!
 
 import { AssertionError } from 'assert'
 import { diffJson } from 'diff'
-import { $blu, $grn, $gry, $ms, $red, $wht, $ylw, ERROR, Logger, NOTICE, WARN } from '../../log.js'
+import { $blu, $grn, $gry, $ms, $red, $wht, $ylw, ERROR, Logger, NOTICE, WARN } from '../../log'
 
 const _pending = '\u22EF' // middle ellipsis
 const _success = '\u2714' // heavy check mark
@@ -15,8 +15,6 @@ const _details = '\u21B3' // downwards arrow with tip rightwards
 
 /** Symbol to inject `Logger` in reporter options */
 export const logSymbol = Symbol()
-/** Symbol to inject `Run` in reporter options */
-export const runSymbol = Symbol()
 
 export class PlugReporter extends RealMocha.reporters.Base {
   constructor(runner: RealMocha.Runner, options: RealMocha.MochaOptions) {
@@ -26,6 +24,7 @@ export class PlugReporter extends RealMocha.reporters.Base {
     const log = options.reporterOptions[logSymbol] as Logger
     const failures: RealMocha.Test[] = []
     const rootSuite = runner.suite
+    let slow = 0
 
     // Enter a suite (increase indent)
     runner.on('suite', (suite) => {
@@ -55,9 +54,14 @@ export class PlugReporter extends RealMocha.reporters.Base {
 
     // Leave a test (handle warning/failures and decrease indent)
     runner.on('test end', (test) => {
-      // TODO: slow!!!
       if (test.isPassed()) {
-        log.leave(NOTICE, `${$grn(_success)} ${test.title}`)
+        const duration = test.duration || 0
+        if (duration < test.slow()) {
+          log.leave(NOTICE, `${$grn(_success)} ${test.title}`)
+        } else {
+          log.leave(WARN, `${$ylw(_success)} ${test.title} ${$ms(duration, 'slow')}`)
+          slow ++
+        }
       } else if (test.isPending()) {
         const tag = $gry('[') + $ylw('skipped') + $gry(']')
         log.leave(WARN, `${$ylw(_pending)} ${test.title} ${tag}`)
@@ -147,6 +151,7 @@ export class PlugReporter extends RealMocha.reporters.Base {
           const { passes, pending, failures, duration = 0 } = runner.stats
           const fmt = (n: number): string => n === 1 ? `${n} test` : `${n} tests`
           if (passes) log.notice($grn(fmt(passes)), 'passing', $ms(duration))
+          if (slow) log.warn($ylw(fmt(slow)), 'slow')
           if (pending) log.warn($ylw(fmt(pending)), 'pending')
           if (failures) log.error($red(fmt(failures)), 'pending')
         }

package/src/plugs/mocha/runner.ts

@@ -1,47 +1,22 @@
 import RealMocha from 'mocha' // Mocha types pollute the global scope!
 
-import { failure } from '../../assert.js'
-import { Files } from '../../files.js'
-import { $wht, NOTICE } from '../../log.js'
-import { Plug } from '../../pipe.js'
-import { Run } from '../../run.js'
-import { logSymbol, PlugReporter, runSymbol } from './reporter.js'
-
-/** Options to construct our {@link Mocha} plug. */
-export interface MochaOptions {
-  /** Specify the directory where coverage data will be saved */
-  coverageDir?: string,
-  /** Bail after first test failure? */
-  bail?: boolean,
-  /** Show diff on failure? */
-  diff?: boolean,
-  /** Report tests without running them? */
-  dryRun?: boolean,
-  /** Tests marked `only` fail the suite? */
-  forbidOnly?: boolean,
-  /** Pending tests fail the suite? */
-  forbidPending?: false,
-  /** Reporter name. */
-  reporter?: string
-  /** Options for the reporter */
-  reporterOptions?: Record<string, any>,
-  /** Number of times to retry failed tests. */
-  retries?: number,
-  /** Slow threshold value. */
-  slow?: number,
-  /** Timeout threshold value. */
-  timeout?: number,
-}
+import { failure } from '../../assert'
+import { Files } from '../../files'
+import { $wht, NOTICE } from '../../log'
+import { PipeParameters, Plug, Context } from '../../pipe'
+import { MochaOptions } from '../mocha'
+import { logSymbol, PlugReporter } from './reporter'
 
 /** Writes some info about the current {@link Files} being passed around. */
-export default class Mocha implements Plug<undefined> {
+export default class Mocha implements Plug<void> {
+  constructor(...args: PipeParameters<'mocha'>)
   constructor(private readonly _options: MochaOptions = {}) {}
 
-  async pipe(files: Files, run: Run): Promise<undefined> {
+  async pipe(files: Files, context: Context): Promise<void> {
     // Enter log here, so that log messages called when loading files get
     // properly indented by our logger
-    run.log.notice('') // empty line
-    run.log.enter(NOTICE, $wht('Starting Mocha'))
+    context.log.notice('') // empty line
+    context.log.enter(NOTICE, $wht('Starting Mocha'))
 
     // Create the mocha runner
     const mocha = new RealMocha({
@@ -50,8 +25,7 @@ export default class Mocha implements Plug<undefined> {
       ...this._options, // override defaults with all other options
       reporterOptions: {
         ...this._options.reporterOptions,
-        [logSymbol]: run.log, // always force a log
-        [runSymbol]: run, // always force a run
+        [logSymbol]: context.log, // always force a log
       },
       allowUncaught: false, // never allow uncaught exceptions
       delay: false, // never delay running

package/src/plugs/mocha.ts

@@ -0,0 +1,41 @@
+import { requireResolve } from '../paths'
+import { installForking } from '../pipe'
+
+/** Options to construct our {@link Mocha} plug. */
+export interface MochaOptions {
+  /** Specify the directory where coverage data will be saved */
+  coverageDir?: string,
+  /** Bail after first test failure? */
+  bail?: boolean,
+  /** Show diff on failure? */
+  diff?: boolean,
+  /** Report tests without running them? */
+  dryRun?: boolean,
+  /** Tests marked `only` fail the suite? */
+  forbidOnly?: boolean,
+  /** Pending tests fail the suite? */
+  forbidPending?: false,
+  /** Reporter name. */
+  reporter?: string
+  /** Options for the reporter */
+  reporterOptions?: Record<string, any>,
+  /** Number of times to retry failed tests. */
+  retries?: number,
+  /** Slow threshold value. */
+  slow?: number,
+  /** Timeout threshold value. */
+  timeout?: number,
+}
+
+declare module '../pipe' {
+  export interface Pipe {
+    /**
+     * Run tests using {@link https://mochajs.org/ _Mocha_}.
+     *
+     * @param options Optional {@link MochaOptions | options} for _Mocha_.
+     */
+    mocha(options?: MochaOptions): Promise<undefined>
+  }
+}
+
+installForking('mocha', requireResolve(__fileurl, './mocha/runner'))

package/src/plugs/rmf.ts

@@ -1,42 +1,38 @@
-import { Files } from '../files.js'
-import { $gry, $p } from '../log.js'
-import { install, Plug } from '../pipe.js'
-import { Run } from '../run.js'
-import { rm } from '../utils/asyncfs.js'
+import { Files } from '../files'
+import { $gry, $p } from '../log'
+import { install, PipeParameters, Plug, Context } from '../pipe'
+import { rm } from '../utils/asyncfs'
+
+declare module '../pipe' {
+  export interface Pipe {
+    /**
+     * Remove all {@link Files} piped in.
+     *
+     * @param dryRun If `true` only log what would be removed (default `false`)
+     */
+    rmf(dryRun?: boolean): Promise<undefined>
+  }
+}
 
 /** Remove some files using globs. */
-export class Rmf implements Plug<undefined> {
+install('rmf', class Rmf implements Plug<void> {
   private readonly _dryRun: boolean
 
+  constructor(...args: PipeParameters<'rmf'>)
   constructor(dryRun?: boolean) {
     this._dryRun = !! dryRun
   }
 
-  async pipe(files: Files, run: Run): Promise<undefined> {
+  async pipe(files: Files, context: Context): Promise<void> {
     if (this._dryRun) {
       for (const file of files.absolutePaths()) {
-        run.log.notice('Not removing file', $p(file), $gry('(dry-run)'))
+        context.log.notice('Not removing file', $p(file), $gry('(dry-run)'))
       }
     } else {
       for (const file of files.absolutePaths()) {
-        run.log.notice('Removing file', $p(file))
+        context.log.notice('Removing file', $p(file))
         await rm(file)
       }
     }
-
-    return undefined
-  }
-}
-
-/* ========================================================================== *
- * INSTALLATION                                                               *
- * ========================================================================== */
-
-install('rmf', Rmf)
-
-declare module '../pipe.js' {
-  export interface Pipe {
-    /** Remove all {@link Files} piped in. */
-    rmf: PipeExtension<typeof Rmf>
   }
-}
+})

package/src/plugs/tsc/compiler.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript' // TypeScript does NOT support ESM modules
 
-import { AbsolutePath, resolveAbsolutePath } from '../../paths.js'
+import { AbsolutePath, resolveAbsolutePath } from '../../paths'
 
 export class TypeScriptHost
 implements ts.CompilerHost {

package/src/plugs/tsc/options.ts

@@ -1,7 +1,7 @@
 import ts from 'typescript' // TypeScript does NOT support ESM modules
 
-import { AbsolutePath, getAbsoluteParent, resolveAbsolutePath } from '../../paths.js'
-import { readFile } from '../../utils/asyncfs.js'
+import { AbsolutePath, getAbsoluteParent, resolveAbsolutePath } from '../../paths'
+import { readFile } from '../../utils/asyncfs'
 
 /* ========================================================================== */
 

package/src/plugs/tsc/report.ts

@@ -1,7 +1,7 @@
 import ts from 'typescript' // TypeScript does NOT support ESM modules
 
-import { ERROR, NOTICE, Report, ReportLevel, ReportRecord, WARN } from '../../log.js'
-import { AbsolutePath, resolveAbsolutePath } from '../../paths.js'
+import { ERROR, NOTICE, Report, ReportLevel, ReportRecord, WARN } from '../../log'
+import { AbsolutePath, resolveAbsolutePath } from '../../paths'
 
 function convertMessageChain(chain: ts.DiagnosticMessageChain, indent = 0): string[] {
   const message = `${''.padStart(indent * 2)}${chain.messageText}`