zarro 1.92.0

package/gulp-tasks/update-git-submodules.js

@@ -0,0 +1,11 @@
+"use strict";
+(function () {
+    const gulp = requireModule("gulp"), status = requireModule("status"), Git = require("simple-git/promise"), env = requireModule("env");
+    env.associate("UPDATE_SUBMODULES_TO_LATEST", "update-git-submodules");
+    gulp.task("update-git-submodules", "Updates all git submodules to latest commit on master branch", async () => {
+        const git = new Git(".");
+        await status.run("Ensure submodules are initialized...", async () => await git.subModule(["update", "--init"]));
+        await status.run("Check out master on all submodules...", async () => await git.subModule(["foreach", "git", "checkout", "master"]));
+        await status.run("Update to latest commit on each submodule...", async () => await git.subModule(["foreach", "git", "pull", "--rebase"]));
+    });
+})();

package/gulp-tasks/update-git-submodules.ts

@@ -0,0 +1,29 @@
+(function() {
+  const gulp = requireModule<Gulp>("gulp"),
+    status = requireModule<Status>("status"),
+    Git = require("simple-git/promise"),
+    env = requireModule<Env>("env");
+
+  env.associate("UPDATE_SUBMODULES_TO_LATEST", "update-git-submodules");
+
+  gulp.task(
+    "update-git-submodules",
+    "Updates all git submodules to latest commit on master branch",
+    async () => {
+      const git = new Git(".");
+      await status.run(
+        "Ensure submodules are initialized...",
+        async () => await git.subModule(["update", "--init"])
+      );
+      await status.run(
+        "Check out master on all submodules...",
+        async () => await git.subModule(["foreach", "git", "checkout", "master"])
+      );
+      await status.run(
+        "Update to latest commit on each submodule...",
+        async () => await git.subModule(["foreach", "git", "pull", "--rebase"])
+      );
+    }
+  );
+})();
+

package/gulp-tasks/update-self.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const spawn = requireModule("spawn"), gulp = requireModule("gulp"), env = requireModule("env"), chalk = require("ansi-colors"), resolveMasks = requireModule("resolve-masks"), debug = require("debug")("update-self"), es = require("event-stream");
+env.associate([
+    env.DRY_RUN,
+    env.INCLUDE_PACKAGE_JSON,
+    env.EXCLUDE_PACKAGE_JSON
+], "update-self");
+gulp.task("update-self", "Updates zarro throughout your current project", () => {
+    const glob = resolveMasks(env.INCLUDE_PACKAGE_JSON, env.EXCLUDE_PACKAGE_JSON);
+    debug({
+        glob
+    });
+    return gulp.src(glob)
+        .pipe(updateZarroPipe(env.resolveFlag(env.BETA)));
+});
+function updateZarroPipe(beta) {
+    const promises = [];
+    const stream = es.through(function input(file) {
+        let save = false, saveDev = false;
+        const json = file.contents.toString();
+        try {
+            const search = "zarro", packageIndex = JSON.parse(json), deps = packageIndex.dependencies || {}, devDeps = packageIndex.devDependencies || {};
+            save = Object.keys(deps).includes(search);
+            saveDev = Object.keys(devDeps).includes(search);
+            if (!save && !saveDev) {
+                debug(`${search} not installed in ${file.path}`);
+                return;
+            }
+        }
+        catch (e) {
+            debug(`${file.path} is not valid JSON`);
+            return;
+        }
+        console.log(chalk.yellow(`update zarro in: ${file.dirname}`));
+        const proc = "npm", tag = beta ? "beta" : "latest", args = ["install", save ? "--save" : "--save-dev", `zarro@${tag}`, "--no-progress", "--silent"], opts = {
+            cwd: file.dirname
+        };
+        if (env.resolveFlag(env.DRY_RUN)) {
+            console.log({
+                label: "would run spawn with",
+                proc,
+                args,
+                opts
+            });
+        }
+        else {
+            promises.push(spawn.call(null, proc, args, opts));
+        }
+    }, async function end() {
+        try {
+            await Promise.all(promises);
+            stream.emit("end");
+        }
+        catch (err) {
+            console.error(chalk.redBright(`
+ ==================================================
+| WARNING: Unable to update zarro, error(s) follow |
+ ==================================================
+`));
+            stream.emit("error", err);
+        }
+    });
+    return stream;
+}

package/gulp-tasks/update-self.ts

@@ -0,0 +1,88 @@
+export {}
+import * as vinyl from "vinyl";
+
+const
+  spawn = requireModule<Spawn>("spawn"),
+  gulp = requireModule<GulpWithHelp>("gulp"),
+  env = requireModule<Env>("env"),
+  chalk = require("ansi-colors"),
+  resolveMasks = requireModule<ResolveMasks>("resolve-masks"),
+  debug = require("debug")("update-self"),
+  es = require("event-stream");
+
+env.associate([
+  env.DRY_RUN,
+  env.INCLUDE_PACKAGE_JSON,
+  env.EXCLUDE_PACKAGE_JSON
+], "update-self");
+
+gulp.task(
+  "update-self",
+  "Updates zarro throughout your current project",
+  () => {
+    const
+      glob = resolveMasks(env.INCLUDE_PACKAGE_JSON, env.EXCLUDE_PACKAGE_JSON);
+    debug({
+      glob
+    });
+    return gulp.src(glob)
+      .pipe(updateZarroPipe(env.resolveFlag(env.BETA)));
+  });
+
+function updateZarroPipe(beta: boolean) {
+  const
+    promises: Promise<any>[] = [];
+  const stream = es.through(function input(file: vinyl.BufferFile) {
+    let
+      save = false,
+      saveDev = false;
+    const json = file.contents.toString();
+    try {
+      const
+        search = "zarro",
+        packageIndex = JSON.parse(json) as PackageIndex,
+        deps = packageIndex.dependencies || {},
+        devDeps = packageIndex.devDependencies || {};
+      save = Object.keys(deps).includes(search);
+      saveDev = Object.keys(devDeps).includes(search);
+      if (!save && !saveDev) {
+        debug(`${ search } not installed in ${ file.path }`);
+        return;
+      }
+    } catch (e) {
+      debug(`${ file.path } is not valid JSON`);
+      return;
+    }
+    console.log(chalk.yellow(`update zarro in: ${ file.dirname }`));
+    const
+      proc = "npm",
+      tag = beta ? "beta" : "latest",
+      args = ["install", save ? "--save" : "--save-dev", `zarro@${tag}`, "--no-progress", "--silent"],
+      opts = {
+        cwd: file.dirname
+      }
+    if (env.resolveFlag(env.DRY_RUN)) {
+      console.log({
+        label: "would run spawn with",
+        proc,
+        args,
+        opts
+      });
+    } else {
+      promises.push(spawn.call(null, proc, args, opts))
+    }
+  }, async function end() {
+    try {
+      await Promise.all(promises)
+      stream.emit("end");
+    } catch (err) {
+      console.error(chalk.redBright(`
+ ==================================================
+| WARNING: Unable to update zarro, error(s) follow |
+ ==================================================
+`));
+      stream.emit("error", err);
+    }
+  });
+  return stream;
+}

package/gulp-tasks/verify-up-to-date.js

@@ -0,0 +1,77 @@
+"use strict";
+(function () {
+    const os = require("os"), chalk = require("ansi-colors"), log = requireModule("log"), env = requireModule("env"), Git = require("simple-git/promise"), failAfter = requireModule("fail-after"), readMainBranchName = requireModule("read-main-branch-name"), readAllGitRemotes = requireModule("read-all-git-remotes"), readCurrentBranch = requireModule("read-current-git-branch"), readGitCommitDeltaCount = requireModule("read-git-commit-delta-count"), readLastFetchTime = requireModule("read-last-fetch-time"), gulp = requireModule("gulp"), { ZarroError } = requireModule("zarro-error"), taskName = "verify-up-to-date";
+    env.associate([
+        "SKIP_FETCH_ON_VERIFY",
+        "ENFORCE_VERIFICATION",
+        "INTERACTIVE"
+    ], taskName);
+    gulp.task(taskName, async () => {
+        // git on OSX is still inserting a pager somewhere, breaking this, so temporarily
+        // disable this test
+        if (os.platform() === "darwin") {
+            console.warn(chalk.redBright(`up-to-date verification is experimental on OSX! Please report errors to davydm@gmail.com`));
+        }
+        const remoteInfos = (await readAllGitRemotes()) || [], remotes = remoteInfos.map(r => r.name), mainBranch = env.resolve("GIT_MAIN_BRANCH") || await resolveDefaultVerifyTarget(remotes), verifyBranch = env.resolve("GIT_VERIFY_BRANCH") || await readCurrentBranch();
+        if (!mainBranch) {
+            throw new ZarroError(`Can't determine main branch (try setting env: GIT_MAIN_BRANCH)`);
+        }
+        if (!verifyBranch) {
+            throw new ZarroError(`Can't determine branch to verify (try setting env: GIT_VERIFY_BRANCH)`);
+        }
+        if (remotes.length && !env.resolveFlag("SKIP_FETCH_ON_VERIFY")) {
+            const lastFetch = await readLastFetchTime(), fetchRecentPeriod = env.resolveNumber("FETCH_RECENT_TIME") * 1000, now = Date.now();
+            let recentEnough = false;
+            if (lastFetch) {
+                recentEnough = (now - fetchRecentPeriod) < lastFetch.getTime();
+            }
+            if (!recentEnough) {
+                log.info(`${taskName} :: fetching all remotes...`);
+                const git = new Git(), timeout = env.resolveNumber("GIT_FETCH_TIMEOUT");
+                try {
+                    const fail = failAfter(timeout);
+                    await Promise.race([
+                        git.fetch(["--all"]),
+                        fail.promise
+                    ]);
+                    fail.cancel();
+                }
+                catch (e) {
+                    const msg = e.message || e;
+                    if (msg === "operation timed out") {
+                        log.error(chalk.redBright(`fetch operation timed out:
+ - check that the current account can fetch from all remotes
+ - optionally disable fetch with SKIP_FETCH_ON_VERIFY=1
+ - optionally increase GIT_FETCH_TIMEOUT from current value: ${timeout}`));
+                    }
+                }
+            }
+            else {
+                log.info(`${taskName} :: skipping fetch: was last done at ${lastFetch}`);
+            }
+        }
+        const verifyResult = await readGitCommitDeltaCount(mainBranch || "master", verifyBranch);
+        // TODO: get the delta count & chuck if behind
+        const aheadS = verifyResult.ahead === 1 ? "" : "s", behindS = verifyResult.behind === 1 ? "" : "s", message = `${chalk.yellow(verifyBranch)} is ${chalk.green(verifyResult.ahead)} commit${aheadS} ahead and ${chalk.red(verifyResult.behind)} commit${behindS} behind ${chalk.cyanBright(mainBranch)}`;
+        log.info(`${taskName} :: ${message}`);
+        if (verifyResult.behind > 0) {
+            if (env.resolveFlag("ENFORCE_VERIFICATION")) {
+                throw new ZarroError(message);
+            }
+            if (env.resolveFlag("INTERACTIVE")) {
+                console.error(`interactive mode for verify-up-to-date is not yet implemented`);
+                // TODO: ask if the user would like to merge in master & proceed if ok
+            }
+        }
+    });
+    async function resolveDefaultVerifyTarget(remotes) {
+        remotes = remotes !== null && remotes !== void 0 ? remotes : [];
+        const mainBranchName = await readMainBranchName(), remote = remotes[0];
+        if (mainBranchName === null || mainBranchName === void 0 ? void 0 : mainBranchName.startsWith(`${remote}/`)) {
+            return mainBranchName;
+        }
+        return remote
+            ? `${remote}/${mainBranchName}`
+            : mainBranchName;
+    }
+})();

package/gulp-tasks/verify-up-to-date.ts

@@ -0,0 +1,119 @@
+(function() {
+  const
+    os = require("os"),
+    chalk = require("ansi-colors"),
+    log = requireModule<Log>("log"),
+    env = requireModule<Env>("env"),
+    Git = require("simple-git/promise"),
+    failAfter = requireModule<FailAfter>("fail-after"),
+    readMainBranchName = requireModule<ReadMainBranchName>("read-main-branch-name"),
+    readAllGitRemotes = requireModule<ReadAllGitRemotes>("read-all-git-remotes"),
+    readCurrentBranch = requireModule<ReadCurrentGitBranch>("read-current-git-branch"),
+    readGitCommitDeltaCount = requireModule<ReadGitCommitDeltaCount>("read-git-commit-delta-count"),
+    readLastFetchTime = requireModule<ReadLastFetchTime>("read-last-fetch-time"),
+    gulp = requireModule<GulpWithHelp>("gulp"),
+    { ZarroError } = requireModule("zarro-error"),
+    taskName = "verify-up-to-date";
+
+  env.associate([
+    "SKIP_FETCH_ON_VERIFY",
+    "ENFORCE_VERIFICATION",
+    "INTERACTIVE"
+  ], taskName);
+
+  gulp.task(taskName, async () => {
+    // git on OSX is still inserting a pager somewhere, breaking this, so temporarily
+    // disable this test
+    if (os.platform() === "darwin") {
+      console.warn(
+        chalk.redBright(
+          `up-to-date verification is experimental on OSX! Please report errors to davydm@gmail.com`
+        )
+      );
+    }
+    const
+      remoteInfos = (await readAllGitRemotes()) || [],
+      remotes = remoteInfos.map(r => r.name),
+      mainBranch = env.resolve("GIT_MAIN_BRANCH") || await resolveDefaultVerifyTarget(remotes),
+      verifyBranch = env.resolve("GIT_VERIFY_BRANCH") || await readCurrentBranch();
+    if (!mainBranch) {
+      throw new ZarroError(`Can't determine main branch (try setting env: GIT_MAIN_BRANCH)`);
+    }
+    if (!verifyBranch) {
+      throw new ZarroError(`Can't determine branch to verify (try setting env: GIT_VERIFY_BRANCH)`);
+    }
+    if (remotes.length && !env.resolveFlag("SKIP_FETCH_ON_VERIFY")) {
+      const
+        lastFetch = await readLastFetchTime(),
+        fetchRecentPeriod = env.resolveNumber("FETCH_RECENT_TIME") * 1000,
+        now = Date.now();
+      let recentEnough = false;
+      if (lastFetch) {
+        recentEnough = (now - fetchRecentPeriod) < lastFetch.getTime();
+      }
+      if (!recentEnough) {
+        log.info(`${ taskName } :: fetching all remotes...`);
+        const
+          git = new Git(),
+          timeout = env.resolveNumber("GIT_FETCH_TIMEOUT");
+        try {
+          const fail = failAfter(timeout);
+          await Promise.race([
+            git.fetch(["--all"]),
+            fail.promise
+          ]);
+          fail.cancel();
+        } catch (e) {
+          const msg = e.message || e;
+          if (msg === "operation timed out") {
+            log.error(chalk.redBright(`fetch operation timed out:
+ - check that the current account can fetch from all remotes
+ - optionally disable fetch with SKIP_FETCH_ON_VERIFY=1
+ - optionally increase GIT_FETCH_TIMEOUT from current value: ${timeout}`))
+          }
+        }
+      } else {
+        log.info(`${ taskName } :: skipping fetch: was last done at ${ lastFetch }`);
+      }
+    }
+    const verifyResult = await readGitCommitDeltaCount(
+      mainBranch || "master", verifyBranch);
+    // TODO: get the delta count & chuck if behind
+    const
+      aheadS = verifyResult.ahead === 1 ? "" : "s",
+      behindS = verifyResult.behind === 1 ? "" : "s",
+      message = `${
+        chalk.yellow(verifyBranch)
+      } is ${
+        chalk.green(verifyResult.ahead)
+      } commit${ aheadS } ahead and ${
+        chalk.red(verifyResult.behind)
+      } commit${ behindS } behind ${
+        chalk.cyanBright(mainBranch)
+      }`;
+    log.info(`${ taskName } :: ${ message }`);
+
+    if (verifyResult.behind > 0) {
+      if (env.resolveFlag("ENFORCE_VERIFICATION")) {
+        throw new ZarroError(message);
+      }
+      if (env.resolveFlag("INTERACTIVE")) {
+        console.error(`interactive mode for verify-up-to-date is not yet implemented`);
+        // TODO: ask if the user would like to merge in master & proceed if ok
+      }
+    }
+  });
+
+  async function resolveDefaultVerifyTarget(remotes?: string[]) {
+    remotes = remotes ?? [];
+    const
+      mainBranchName = await readMainBranchName(),
+      remote = remotes[0];
+    if (mainBranchName?.startsWith(`${ remote }/`)) {
+      return mainBranchName;
+    }
+    return remote
+      ? `${ remote }/${ mainBranchName }`
+      : mainBranchName
+  }
+})();

package/index-modules/contains-any.js

@@ -0,0 +1,31 @@
+(function () {
+  module.exports = function containsAny() {
+    // should be invoked with an args array followed by a list of things to look for
+    let
+      args = Array.from(arguments),
+      array = args[0] || [];
+    if (!Array.isArray(array)) {
+      array = [ array ]
+    }
+    if (array.length === 0) {
+      return false;
+    }
+
+    const values = args.slice(1);
+    if (values.length === 0) {
+      return true;
+    }
+
+    return array.reduce(
+      (acc, cur) => {
+        if (acc) {
+          return acc;
+        }
+        if (cur === values[0]) {
+          return true;
+        }
+        return containsAny(values.slice(1), cur);
+      },
+      false);
+  };
+})();

package/index-modules/gather-args.js

@@ -0,0 +1,21 @@
+module.exports = async function gatherArgs(
+  potentialEntryPoints,
+  overrideArgv // for testing only
+) {
+  const argv = overrideArgv || process.argv;
+  if (!Array.isArray(potentialEntryPoints)) {
+    potentialEntryPoints = [potentialEntryPoints];
+  }
+  for (let entryPoint of potentialEntryPoints) {
+    const entryPointIndex = argv.indexOf(entryPoint);
+    if (entryPointIndex > -1) {
+      return argv.slice(entryPointIndex + 1);
+    }
+    continue;
+  }
+  throw new Error(`Can't figure out args: unable to find entry point in args list:\n${JSON.stringify({
+    potentialEntryPoints,
+    overrideArgv,
+    argv: process.argv
+  }, null, 2)}`);
+};