hereby 1.0.6 → 1.2.0

package/dist/cli/index.js

@@ -5,7 +5,7 @@ import { formatTasks } from "./formatTasks.js";
 import { findHerebyfile, loadHerebyfile } from "./loadHerebyfile.js";
 import { getUsage, parseArgs } from "./parseArgs.js";
 import { reexec } from "./reexec.js";
-import { CLIRunner } from "./runner.js";
+import { Runner } from "./runner.js";
 import { ExitCodeError, simplifyPath, UserError } from "./utils.js";
 export async function main(d) {
     try {
@@ -35,6 +35,10 @@ async function mainWorker(d) {
     if (await reexec(d, herebyfilePath)) {
         return;
     }
+    if (args.version) {
+        d.log(`hereby ${d.version}`);
+        return;
+    }
     d.chdir(path.dirname(herebyfilePath));
     d.log(`Using ${simplifyPath(herebyfilePath)}`);
     const herebyfile = await loadHerebyfile(herebyfilePath);
@@ -44,7 +48,7 @@ async function mainWorker(d) {
     }
     const tasks = selectTasks(herebyfile, args.run);
     try {
-        const runner = new CLIRunner(d);
+        const runner = new Runner(d);
         await runner.runTasks(...tasks);
     }
     catch (e) {
@@ -66,7 +70,7 @@ export function selectTasks(herebyfile, taskNames) {
                 let message = `Task "${name}" does not exist or is not exported in the Herebyfile.`;
                 const candidate = closest(name, Array.from(allTasks.keys()));
                 if (distance(name, candidate) < name.length * 0.4) {
-                    message += ` Did you mean "${candidate}?"`;
+                    message += ` Did you mean "${candidate}"?`;
                 }
                 throw new UserError(message);
             }

package/dist/cli/parseArgs.js

@@ -10,6 +10,7 @@ export function parseArgs(argv) {
         { name: "herebyfile", type: String },
         { name: "tasks", alias: "T", type: Boolean },
         { name: "help", alias: "h", type: Boolean },
+        { name: "version", type: Boolean },
     ], {
         argv,
         stopAtFirstUnknown: true,
@@ -19,6 +20,7 @@ export function parseArgs(argv) {
         run: options["run"],
         herebyfile: options["herebyfile"],
         printTasks: options["tasks"],
+        version: options["version"],
     };
 }
 export function getUsage() {
@@ -53,6 +55,11 @@ export function getUsage() {
                     alias: "T",
                     type: Boolean,
                 },
+                {
+                    name: "version",
+                    description: "Print the current hereby version.",
+                    type: Boolean,
+                },
             ],
         },
         {

package/dist/cli/runner.js

@@ -1,13 +1,45 @@
 import assert from "assert";
 import chalk from "chalk";
-import { Runner } from "../runner.js";
-export class CLIRunner extends Runner {
-    constructor(d) {
-        super({ concurrency: d.numCPUs });
+import pLimit from "p-limit";
+export class Runner {
+    constructor(d, limiter) {
+        this._addedTasks = new WeakMap();
         this._errored = false;
         this._startTimes = new WeakMap();
+        this._limiter = limiter ?? pLimit(d.numCPUs);
         this._d = d;
     }
+    async runTasks(...tasks) {
+        await Promise.all(tasks.map((task) => {
+            const cached = this._addedTasks.get(task);
+            if (cached) {
+                return cached;
+            }
+            const promise = this._runTask(task);
+            this._addedTasks.set(task, promise);
+            return promise;
+        }));
+    }
+    async _runTask(task) {
+        const { dependencies, run } = task.options;
+        if (dependencies) {
+            await this.runTasks(...dependencies);
+        }
+        if (!run) {
+            return;
+        }
+        return this._limiter(async () => {
+            try {
+                this.onTaskStart(task);
+                await run();
+                this.onTaskFinish(task);
+            }
+            catch (e) {
+                this.onTaskError(task, e);
+                throw e;
+            }
+        });
+    }
     onTaskStart(task) {
         this._startTimes.set(task, Date.now());
         if (this._errored) {
@@ -27,7 +59,8 @@ export class CLIRunner extends Runner {
             return; // Skip logging.
         }
         this._errored = true;
-        this._d.error(`Error in ${chalk.red(task.options.name)}\n${e}`);
+        const took = Date.now() - checkDefined(this._startTimes.get(task));
+        this._d.error(`Error in ${chalk.red(task.options.name)} in ${this._d.prettyMilliseconds(took)}\n${e}`);
     }
 }
 function checkDefined(value) {

package/dist/cli/utils.js

@@ -1,5 +1,7 @@
+import fs from "fs/promises";
 import os from "os";
 import path from "path";
+import { fileURLToPath } from "url";
 export function taskSorter(a, b) {
     return stringSorter(a.options.name, b.options.name);
 }
@@ -40,6 +42,9 @@ export async function real() {
     const { default: foregroundChild } = await import("foreground-child");
     const { resolve } = await import("import-meta-resolve");
     const { default: prettyMilliseconds } = await import("pretty-ms");
+    const packageJsonPath = fileURLToPath(await resolve("hereby/package.json", import.meta.url));
+    const packageJson = await fs.readFile(packageJsonPath, "utf-8");
+    const { version } = JSON.parse(packageJson);
     /* eslint-disable no-restricted-globals */
     return {
         log: console.log,
@@ -55,6 +60,7 @@ export async function real() {
             process.exitCode = code;
         },
         numCPUs: os.cpus().length,
+        version,
         foregroundChild,
         resolve,
         prettyMilliseconds,

package/dist/index.d.ts

@@ -14,11 +14,13 @@ export interface TaskOptions {
      * A list of tasks that must has been run to completion before
      * this task can execute.
      */
-    dependencies?: Task[] | undefined;
+    dependencies?: readonly Task[] | undefined;
     /**
-     * A function to execute when this task is run.
+     * A function to execute when this task is run. If this function
+     * returns a promise, the task will not be marked as finished until
+     * that promise resolves.
      */
-    run?: (() => void | Promise<void>) | undefined;
+    run?: (() => void) | (() => PromiseLike<void>) | undefined;
 }
 /**
  * A hereby Task. To get an instance, call `test`.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hereby",
-    "version": "1.0.6",
+    "version": "1.2.0",
     "description": "A simple task runner",
     "repository": "github:jakebailey/hereby",
     "type": "module",
@@ -52,19 +52,19 @@
         "@tsconfig/node14": "^1.0.3",
         "@types/command-line-args": "^5.2.0",
         "@types/command-line-usage": "^5.0.2",
-        "@types/node": "^14.18.28",
-        "@typescript-eslint/eslint-plugin": "^5.36.2",
-        "@typescript-eslint/parser": "^5.36.2",
+        "@types/node": "^14.18.30",
+        "@typescript-eslint/eslint-plugin": "^5.38.0",
+        "@typescript-eslint/parser": "^5.38.0",
         "ava": "^4.3.3",
         "c8": "^7.12.0",
-        "eslint": "^8.23.0",
+        "eslint": "^8.24.0",
         "eslint-config-prettier": "^8.5.0",
         "eslint-plugin-ava": "^13.2.0",
         "eslint-plugin-simple-import-sort": "^8.0.0",
         "execa": "^6.1.0",
         "moq.ts": "^9.0.2",
         "prettier": "^2.7.1",
-        "release-it": "^15.4.1",
+        "release-it": "^15.4.2",
         "rimraf": "^3.0.2",
         "tempy": "^3.0.0",
         "typescript": "~4.8.3"
@@ -107,7 +107,7 @@
             "tagName": "v${version}"
         },
         "hooks": {
-            "before:init": "npm run test"
+            "before:init": "npm run build && npm run test"
         }
     }
 }

package/dist/runner.js

@@ -1,44 +0,0 @@
-import pLimit from "p-limit";
-export class Runner {
-    constructor(options) {
-        this._addedTasks = new WeakMap();
-        this._limiter = (fn) => fn();
-        const concurrency = options?.concurrency;
-        if (concurrency !== undefined) {
-            this._limiter = pLimit(concurrency);
-        }
-    }
-    async runTasks(...tasks) {
-        await Promise.all(tasks.map((task) => {
-            const cached = this._addedTasks.get(task);
-            if (cached) {
-                return cached;
-            }
-            const promise = this._runTask(task);
-            this._addedTasks.set(task, promise);
-            return promise;
-        }));
-    }
-    async _runTask(task) {
-        this.onTaskAdd?.(task);
-        const { dependencies, run } = task.options;
-        if (dependencies) {
-            await this.runTasks(...dependencies);
-        }
-        if (!run) {
-            return;
-        }
-        return this._limiter(async () => {
-            try {
-                this.onTaskStart?.(task);
-                await run();
-                this.onTaskFinish?.(task);
-            }
-            catch (e) {
-                this.onTaskError?.(task, e);
-                throw e;
-            }
-        });
-    }
-}
-//# sourceMappingURL=runner.js.map