zarro 1.92.0

package/gulp-tasks/modules/fail-after.js

@@ -0,0 +1,30 @@
+"use strict";
+(function () {
+    class Failer {
+        constructor(ms, message) {
+            this.ms = ms;
+            this._cancelled = false;
+            this.promise = new Promise((_, reject) => {
+                this._timer = setTimeout(() => {
+                    this._timer = undefined;
+                    message = message || "operation timed out";
+                    reject(new Error(message));
+                }, ms);
+            });
+        }
+        cancel() {
+            if (this._timer) {
+                clearTimeout(this._timer);
+                this._cancelled = true;
+                this._timer = undefined;
+            }
+            else if (!this._cancelled) {
+                // perhaps timer hasn't been set yet
+                setImmediate(() => this.cancel());
+            }
+        }
+    }
+    module.exports = function failAfter(ms, message) {
+        return new Failer(ms, message);
+    };
+})();

package/gulp-tasks/modules/fail-after.ts

@@ -0,0 +1,34 @@
+import Timeout = NodeJS.Timeout;
+
+(function() {
+  class Failer {
+    public promise: Promise<void>;
+
+    private _timer?: Timeout;
+    private _cancelled = false;
+
+    constructor(public ms: number, message?: string) {
+      this.promise = new Promise((_, reject) => {
+        this._timer = setTimeout(() => {
+          this._timer = undefined;
+          message = message || "operation timed out";
+          reject(new Error(message));
+        }, ms);
+      })
+    }
+
+    public cancel() {
+      if (this._timer) {
+        clearTimeout(this._timer);
+        this._cancelled = true;
+        this._timer = undefined;
+      } else if (!this._cancelled) {
+        // perhaps timer hasn't been set yet
+        setImmediate(() => this.cancel());
+      }
+    }
+  }
+  module.exports = function failAfter(ms: number, message?: string) {
+    return new Failer(ms, message);
+  };
+})();

package/gulp-tasks/modules/fallback.js

@@ -0,0 +1,6 @@
+module.exports = function fallback() {
+  const args = Array.from(arguments);
+  return args.reduce((acc, cur) => {
+    return acc === undefined ? cur : acc;
+  });
+}

package/gulp-tasks/modules/find-dirs.js

@@ -0,0 +1,39 @@
+var fs = require("fs"),
+  path = require("path"),
+  multiSplit = require("./multi-split");
+
+function isDir(p) {
+  return fs.existsSync(p) && fs.lstatSync(p).isDirectory();
+}
+
+function pushAll(array, items) {
+  Array.prototype.push.apply(array, items);
+}
+
+const cache = {};
+
+function findDirs(under, withName, neverTraverse) {
+  var result = [];
+  neverTraverse = neverTraverse || [];
+
+  var start = cache[under] || (cache[under] = fs.readdirSync(under));
+  var dirs = start.map(d => path.resolve(path.join(under, d))).filter(isDir);
+  var toAdd = dirs.filter(d => path.basename(d) === withName);
+  var toCheck = dirs
+    .filter(d => path.basename(d) !== withName)
+    .filter(d => {
+      const
+        parts = multiSplit(d, [ "/", "\\" ]),
+        include = neverTraverse.indexOf(parts[parts.length-1]) === -1;
+      return include;
+    });
+
+  pushAll(result, toAdd);
+  toCheck.forEach(d => {
+    result.push.apply(result, findDirs(d, withName, neverTraverse));
+  });
+
+  return result;
+}
+
+module.exports = findDirs;

package/gulp-tasks/modules/find-local-nuget.js

@@ -0,0 +1,42 @@
+const
+  fs = require("fs"),
+  path = require("path"),
+  resolveNuget = require("./resolve-nuget"),
+  pathUnquote = require("./path-unquote"),
+  downloadNuget = require("./download-nuget"),
+  env = require("./env");
+
+let startedDownload = false,
+  resolver = null,
+  lastResolution = new Promise(function (resolve) {
+    resolver = resolve;
+  });
+
+function findLocalNuget() {
+  const
+    targetFolder = env.resolve("BUILD_TOOLS_FOLDER"),
+    localNuget = resolveNuget(undefined, false) || path.join(targetFolder, 'nuget.exe');
+  return new Promise(function(resolve, reject) {
+    if (startedDownload && lastResolution) {
+      return resolve(lastResolution);
+    }
+    if (fs.existsSync(pathUnquote(localNuget))) {
+      return resolve(localNuget);
+    }
+    startedDownload = true;
+    downloadNuget(targetFolder).then(function(dl) {
+      resolver(dl); // = dl;
+      resolve(dl);
+    }).catch(function(err) {
+      if (fs.existsSync(localNuget)) {
+        log.info(err);
+        log.info('Falling back on last local nuget.exe');
+        lastResolution = localNuget;
+        return resolve(localNuget);
+      }
+      reject(err);
+    });
+  });
+}
+
+module.exports = findLocalNuget;

package/gulp-tasks/modules/find-npm-base.js

@@ -0,0 +1,42 @@
+const
+  { ZarroError } = requireModule("zarro-error"),
+  path = require("path"),
+  fs = requireModule("fs");
+let cached;
+
+function findClosestPackageJsonFolder() {
+  let current = __dirname;
+  while (inNodeModulesFolder(current) || !hasPackageJson(current)) {
+    const next = path.dirname(current);
+    if (next === current) {
+      throw new ZarroError(`Can't find a package.json, traversing up from ${__dirname}`);
+    }
+    current = next;
+  }
+  return current;
+}
+
+function inNodeModulesFolder(folder) {
+  return !!folder.match(/node_modules/);
+}
+
+function hasPackageJson(folder) {
+  const test = path.join(folder, "package.json");
+  if (!fs.existsSync(test)) {
+    return false;
+  }
+  try {
+    const
+      contents = require(test),
+      repo = contents.repository || {},
+      url = repo.url || "",
+      isGulpTasks = url.match(/\/fluffynuts\/gulp-tasks$/);
+    return !isGulpTasks;
+  } catch (ignore) {
+    return false;
+  }
+}
+
+module.exports = function() {
+  return cached || (cached = findClosestPackageJsonFolder());
+};

package/gulp-tasks/modules/fs.js

@@ -0,0 +1,79 @@
+const
+  { ZarroError } = requireModule("zarro-error"),
+  promisify = require("./promisify-function"),
+  path = require("path"),
+  fs = require("fs");
+
+const
+  stat = promisify(fs.stat, fs),
+  readFile = promisify(fs.readFile, fs),
+  readdir = promisify(fs.readdir, fs),
+  mkdir = promisify(fs.mkdir, fs),
+  exists = promisify(fs.exists, fs, true);
+
+function isFile(p) {
+  return runStat(p, st => st.isFile());
+}
+
+function isFolder(p) {
+  return runStat(p, st => st.isDirectory());
+}
+
+function runStat(p, fn) {
+  return new Promise(resolve => {
+    fs.stat(p, (err, st) => {
+      if (err) {
+        return resolve(false);
+      }
+      try {
+        resolve(st && fn(st));
+      } catch (e) {
+        resolve(false);
+      }
+    });
+  });
+}
+
+const exported = {
+  ...fs.promises,  // if they exist
+  stat,
+  readFile,
+  readdir,
+  mkdir,
+  exists,
+  isFile,
+  isFolder,
+  fileExists: isFile,
+  folderExists: isFolder,
+
+  ensureDirectoryExists: async function(expectedPath) {
+    // forward-slashes can be valid (and mixed) on win32,
+    //  so split on both \ and / to make \o/
+    const
+      parts = expectedPath.split(/\\|\//),
+      current = [];
+    for (const part of parts) {
+      if (!part) {
+        continue;
+      }
+      current.push(part);
+      const
+        test = current.join(path.sep),
+        pathExists = await exists(test);
+      if (pathExists) {
+        const st = await stat(test);
+        if (!st.isDirectory()) {
+          throw new ZarroError(`${test} exists but is not a directory`);
+        }
+        continue;
+      }
+      await mkdir(test);
+    }
+  }
+};
+
+Object.keys(fs)
+  .filter(k => k.match(/Sync$/) && typeof fs[k] === "function")
+  .forEach(k => exported[k] = fs[k].bind(fs));
+
+module.exports = exported;

package/gulp-tasks/modules/gather-paths.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+(function () {
+    // resolves the file paths found by a globbing gulp.src
+    const collectFiles = require("./collect-files"), promisifyStream = require("./promisify-stream"), gulp = require("./gulp");
+    module.exports = async function (pathSpecs) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                if (!Array.isArray(pathSpecs)) {
+                    pathSpecs = [pathSpecs];
+                }
+                const target = [];
+                await promisifyStream(gulp.src(pathSpecs)
+                    .pipe(collectFiles(target)));
+                resolve(target.map(f => f.path));
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    };
+    module.exports;
+})();

package/gulp-tasks/modules/gather-paths.ts

@@ -0,0 +1,29 @@
+import * as vinyl from "vinyl";
+
+(function() {
+  // resolves the file paths found by a globbing gulp.src
+  const
+    collectFiles = require("./collect-files"),
+    promisifyStream = require("./promisify-stream"),
+    gulp = require("./gulp");
+
+  module.exports = async function(pathSpecs: string | string[]) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (!Array.isArray(pathSpecs)) {
+          pathSpecs = [pathSpecs];
+        }
+        const target = [] as vinyl.BufferFile[];
+        await promisifyStream(
+          gulp.src(pathSpecs)
+            .pipe(collectFiles(target))
+        );
+        resolve(target.map(f => f.path));
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  module.exports;
+})();

package/gulp-tasks/modules/generate-env-help-for.js

@@ -0,0 +1,30 @@
+const
+  fallback = require("./fallback"),
+  padRight = require("./pad-right");
+
+function makeHelpString(stringOrObject) {
+  if (typeof(stringOrObject === "string")) {
+    return stringOrObject;
+  }
+  let msg, defaultValue;
+  if (Array.isArray(stringOrObject)) {
+    msg = stringOrObject[0];
+    defaultValue = stringOrObject[1];
+  } else {
+    msg = fallback(stringOrObject.message, stringOrObject.msg);
+    defaultValue = fallback(stringOrObject.defaultValue, stringOrObject.default);
+  }
+  return `${msg} (default: ${defaultValue})`;
+}
+
+module.exports = function generateEnvHelpFor(dict) {
+  const
+    keys = Object.keys(dict),
+    longest = keys.reduce((acc, cur) => cur.length > acc ? cur.length : acc);
+
+  return [
+    "\tObserved environment variables:"
+  ].concat(Object.keys(dict).map(k =>
+    `${padRight(k, longest)}  ${makeHelpString(dict[k])}`
+  )).join("\n\t\t");
+}

package/gulp-tasks/modules/get-tools-folder.js

@@ -0,0 +1,12 @@
+let env;
+const debug = require("debug")("get-tools-folder");
+function getToolsFolder(overrideEnv) {
+  if (!overrideEnv) {
+    env = env || require("./env");
+  }
+  var result = (overrideEnv || env).resolve("BUILD_TOOLS_FOLDER");
+  debug("-> getting tools from: ", result);
+  return result;
+}
+
+module.exports = getToolsFolder;

package/gulp-tasks/modules/git-push-tags.js

@@ -0,0 +1,33 @@
+"use strict";
+(function () {
+    const Git = require("simple-git/promise"), gutil = requireModule("gulp-util"), resolveGitRemote = requireModule("resolve-git-remote");
+    async function gitPushTags(dryRun, where) {
+        if (dryRun === undefined) {
+            dryRun = {};
+        }
+        let quiet = false;
+        if (typeof dryRun === "object") {
+            where = dryRun.where || ".";
+            quiet = dryRun.quiet || false;
+            dryRun = dryRun.dryRun || false;
+        }
+        else if (where !== undefined) {
+            gutil.log.warn(gutil.colors.red("depreciation warning: options for git-push-tags should be sent via an object"));
+        }
+        where = where || ".";
+        const git = new Git(where), more = where && where !== "." ? ` (${where})` : "";
+        if (dryRun) {
+            if (!quiet) {
+                gutil.log(gutil.colors.green(`dry run: should push tags now${more}...`));
+            }
+            return;
+        }
+        const remote = await resolveGitRemote();
+        if (!remote) {
+            return;
+        }
+        gutil.log(gutil.colors.green(`pushing tags${more}...`));
+        await git.pushTags(remote);
+    }
+    module.exports = gitPushTags;
+})();

package/gulp-tasks/modules/git-push-tags.ts

@@ -0,0 +1,42 @@
+(function() {
+  const
+    Git = require("simple-git/promise"),
+    gutil = requireModule<GulpUtil>("gulp-util"),
+    resolveGitRemote = requireModule<ResolveGitRemote>("resolve-git-remote");
+
+  async function gitPushTags(dryRun?: boolean | GitPushOptions, where?: string): Promise<void> {
+    if (dryRun === undefined) {
+      dryRun = {};
+    }
+    let quiet = false;
+    if (typeof dryRun === "object") {
+      where = dryRun.where || ".";
+      quiet = dryRun.quiet || false;
+      dryRun = dryRun.dryRun || false;
+    } else if (where !== undefined) {
+      gutil.log.warn(
+        gutil.colors.red(
+          "depreciation warning: options for git-push-tags should be sent via an object"
+        )
+      );
+    }
+    where = where || ".";
+    const
+      git = new Git(where),
+      more = where && where !== "." ? ` (${ where })` : ""
+    if (dryRun) {
+      if (!quiet) {
+        gutil.log(gutil.colors.green(`dry run: should push tags now${ more }...`));
+      }
+      return;
+    }
+    const remote = await resolveGitRemote();
+    if (!remote) {
+      return;
+    }
+    gutil.log(gutil.colors.green(`pushing tags${ more }...`));
+    await git.pushTags(remote);
+  }
+
+  module.exports = gitPushTags;
+})();