zarro 1.92.0

package/gulp-tasks/modules/seed.js

@@ -0,0 +1,12 @@
+/**
+ * Generates an array with the required number of elements, all undefined
+ * -> unlike Array(N), this creates the elements, where Array(N) only allocates
+ *      the space for elements: attempting to forEach or map over Array(N)
+ *      won't accomplish much
+ * @param howMany
+ */
+module.exports = function seed(howMany) {
+  return Array.apply(null, Array.from({
+    length: howMany
+  }));
+}

package/gulp-tasks/modules/set-task-name.js

@@ -0,0 +1,9 @@
+module.exports = function setTaskName(task, name) {
+  task.displayName = name;
+  Object.defineProperty(task, "name", {
+    get() {
+      return name;
+    }
+  });
+  return task;
+};

package/gulp-tasks/modules/sleep.js

@@ -0,0 +1,5 @@
+module.exports = function(ms) {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });
+};

package/gulp-tasks/modules/spawn-nuget.js

@@ -0,0 +1,13 @@
+const
+  spawn = require("./spawn"),
+  debug = require("debug")("spawn-nuget"),
+  findLocalNuget = require("./find-local-nuget");
+
+module.exports = async function(args, opts) {
+  const nuget = await findLocalNuget();
+  debug(`spawn nuget: ${nuget} ${args.join(" ")}`);
+  if (opts && Object.keys(opts).length) {
+    debug(` nuget spawn options: ${JSON.stringify(opts)}`);
+  }
+  return await spawn(nuget, args, opts);
+};

package/gulp-tasks/modules/spawn.js

@@ -0,0 +1,103 @@
+// use for spawning actual processes.
+// You must use exec if you want to run batch files
+
+const tryLoadDebug = function () {
+    try {
+      return require("debug")("spawn");
+    } catch (e) {
+      return function () {
+      };
+    }
+  },
+  quoteIfRequired = require("./quote-if-required"),
+  debug = tryLoadDebug(),
+  child_process = require("child_process");
+
+const defaultOptions = {
+  stdio: [process.stdin, process.stdout, process.stderr],
+  cwd: process.cwd(),
+  shell: true
+};
+
+function spawn(executable, args, opts) {
+  args = args || [];
+  opts = Object.assign({}, defaultOptions, opts);
+
+  let stdOutWriter = null,
+    stdErrWriter = null;
+  if (typeof opts.stdout === "function") {
+    stdOutWriter = opts.stdout;
+    opts.stdio[1] = "pipe";
+  } else {
+    opts.stdio[1] = "inherit";
+  }
+  if (typeof opts.stderr === "function") {
+    stdErrWriter = opts.stderr;
+    opts.stdio[2] = "pipe";
+  } else {
+    opts.stdio[2] = "inherit";
+  }
+
+  const result = {
+    executable: executable,
+    args: args
+  };
+
+  executable = quoteIfRequired(executable);
+
+  debug(`spawning: ${ executable } ${ args.map(a => '"' + a + '"').join(" ") }`);
+  debug({ opts });
+
+  return new Promise((resolve, reject) => {
+    try {
+      const child = child_process.spawn(executable, args, opts);
+      const stdout = [];
+      const stderr = [];
+      child.on("error", function (err) {
+        debug(`child error: ${ err }`);
+        const e = new Error(
+          `"${ [executable].concat(args).join(" ") }" failed with "${ err }"`
+        );
+        e.exitCode = -1;
+        e.stderr = stderr;
+        e.stdout = stdout;
+        reject(e);
+      });
+      child.on("close", function (code) {
+        debug(`child exits: ${ code }`);
+        result.exitCode = code;
+        if (code === 0) {
+          resolve(result);
+        } else {
+          const err = new Error(
+            `"${ [executable]
+              .concat(args)
+              .join(" ") }" failed with exit code ${ code }`
+          );
+          err.exitCode = code;
+          err.stdout = stdout;
+          err.stderr = stderr;
+          return reject(err);
+        }
+      });
+      if (stdOutWriter) {
+        child.stdout.on("data", data => {
+          const str = data.toString();
+          stdout.push(str);
+          stdOutWriter(str);
+        });
+      }
+      if (stdErrWriter) {
+        child.stderr.on("data", data => {
+          const str = data.toString();
+          stderr.push(str);
+          stdErrWriter(str);
+        });
+      }
+    } catch (e) {
+      reject(`Unable to spawn process: ${ e }`);
+    }
+  });
+}
+
+module.exports = spawn;

package/gulp-tasks/modules/split-path.js

@@ -0,0 +1,3 @@
+module.exports = function splitPath(path) {
+  return (path || "").split(/\/|\\/);
+}

package/gulp-tasks/modules/stat.js

@@ -0,0 +1,8 @@
+const fs = require("fs").promises;
+module.exports = async function(path) {
+  try {
+    return await fs.stat(path);
+  } catch (e) {
+    return null;
+  }
+};

package/gulp-tasks/modules/status.js

@@ -0,0 +1,57 @@
+"use strict";
+(function () {
+    "use strict";
+    const env = requireModule("env"), chalk = require("ansi-colors"), noUnicode = env.resolveFlag("NO_UNICODE"), noColor = env.resolveFlag("NO_COLOR"), prefixSize = noUnicode ? 6 : 2, asciiOk = "[ OK ]", asciiFail = "[FAIL]", okMarker = noUnicode
+        ? (noColor ? asciiOk : chalk.green(asciiOk))
+        : chalk.greenBright("✓"), failMarker = noUnicode
+        ? (noColor ? asciiFail : chalk.redBright(asciiFail))
+        : chalk.redBright("❌"), spacedPrefix = " ".repeat(prefixSize);
+    function start(message, color) {
+        if (color && chalk[color]) {
+            message = chalk[color](message);
+        }
+        process.stdout.write(`${spacedPrefix} ${message}`);
+    }
+    function ok() {
+        process.stdout.write(`\r${okMarker}`);
+        process.stdout.write("\n");
+    }
+    function fail() {
+        process.stdout.write(`\r${failMarker}`);
+        process.stdout.write("\n");
+    }
+    function looksLikePromise(o) {
+        return isFunction(o.then);
+    }
+    function isFunction(o) {
+        return typeof (o) === "function";
+    }
+    async function run(message, action) {
+        start(message);
+        let result;
+        try {
+            result = action();
+        }
+        catch (e) {
+            fail();
+            throw e;
+        }
+        if (looksLikePromise(result)) {
+            try {
+                result = await result;
+            }
+            catch (e) {
+                fail();
+                throw e;
+            }
+        }
+        ok();
+        return result;
+    }
+    module.exports = {
+        start,
+        ok,
+        fail,
+        run
+    };
+})();

package/gulp-tasks/modules/status.ts

@@ -0,0 +1,71 @@
+(function () {
+  "use strict";
+  const
+    env = requireModule<Env>("env"),
+    chalk = require("ansi-colors"),
+    noUnicode = env.resolveFlag("NO_UNICODE"),
+    noColor = env.resolveFlag("NO_COLOR"),
+    prefixSize = noUnicode ? 6 : 2,
+    asciiOk = "[ OK ]",
+    asciiFail = "[FAIL]",
+    okMarker = noUnicode
+      ? (noColor ? asciiOk : chalk.green(asciiOk))
+      : chalk.greenBright("✓"),
+    failMarker = noUnicode
+      ? (noColor ? asciiFail : chalk.redBright(asciiFail))
+      : chalk.redBright("❌"),
+    spacedPrefix = " ".repeat(prefixSize);
+
+  function start(message: string, color?: Colors) {
+    if (color && chalk[color as string]) {
+      message = chalk[color](message);
+    }
+    process.stdout.write(`${spacedPrefix} ${message}`);
+  }
+
+  function ok() {
+    process.stdout.write(`\r${okMarker}`);
+    process.stdout.write("\n");
+  }
+
+  function fail() {
+    process.stdout.write(`\r${failMarker}`);
+    process.stdout.write("\n");
+  }
+
+  function looksLikePromise(o: any) {
+    return isFunction(o.then);
+  }
+
+  function isFunction(o: any) {
+    return typeof (o) === "function";
+  }
+
+  async function run<T>(message: string, action: (() => T | Promise<T>)) {
+    start(message);
+    let result;
+    try {
+      result = action();
+    } catch (e) {
+      fail();
+      throw e;
+    }
+    if (looksLikePromise(result)) {
+      try {
+        result = await result;
+      } catch (e) {
+        fail();
+        throw e;
+      }
+    }
+    ok()
+    return result;
+  }
+
+  module.exports = {
+    start,
+    ok,
+    fail,
+    run
+  };
+})();

package/gulp-tasks/modules/test-path.js

@@ -0,0 +1,3 @@
+var path = require('path');
+
+console.log(path.resolve(path.join(__dirname, '..', '..', 'nuget.exe')));

package/gulp-tasks/modules/testutil-finder.js

@@ -0,0 +1,176 @@
+"use strict";
+const
+  log = require("./log"),
+  fs = require("fs"),
+  path = require("path"),
+  debug = require("debug")("testutil-finder"),
+  lsR = require("./ls-r"),
+  whichLib = require("which"),
+  programFilesFolder = process.env["ProgramFiles(x86)"] || process.env["ProgramFiles"],
+  getToolsFolder = require("./get-tools-folder"),
+  { ZarroError } = requireModule("zarro-error"),
+  localAppDataFolder = process.env["LOCALAPPDATA"];
+
+function which(command) {
+  try {
+    return whichLib.sync(command, {});
+  } catch (e) {
+    return undefined;
+  }
+}
+
+function isUnstable(folderName) {
+  return folderName.indexOf("alpha") > -1 ||
+    folderName.indexOf("beta") > -1;
+}
+
+function finder(searchBaseFolders, searchBaseSubFolder, searchFolderPrefix, searchBin, options) {
+  const
+    ignoreBetas = options.ignoreBetas === undefined ? true : options.ignoreBetas,
+    lprefix = searchFolderPrefix.toLowerCase();
+  if (!Array.isArray(searchBaseFolders)) {
+    searchBaseFolders = [ searchBaseFolders ];
+  }
+  const runner = searchBaseFolders
+    .filter(f => !!f)
+    .map(f => {
+      return searchBaseSubFolder
+        ? path.join(f, searchBaseSubFolder)
+        : f;
+    })
+    .filter(checkExists)
+    .reduce((possibles, baseFolder) => {
+      debug("Searching: " + baseFolder);
+      return fs.readdirSync(baseFolder)
+        .reduce((acc, cur) => {
+          const folder = path.join(baseFolder, cur);
+          const lcur = cur.toLowerCase();
+          if (lcur.indexOf(lprefix) === 0) {
+            if (ignoreBetas && isUnstable(lcur)) {
+              log.notice("Ignoring unstable tool at: " + folder);
+              return acc;
+            }
+            const match = cur.match(/\d+/g);
+            if (!match) {
+              return acc;
+            }
+            const version = match.map(Number);
+            debug(`Adding possible: ${folder} = version ${version}`);
+            acc.push({
+              folder: folder,
+              version: version
+            });
+          }
+          return acc;
+        }, possibles);
+    }, [])
+    .sort((x,y) => -compareVersionArrays(x.version, y.version))
+    .map(possible => path.join(possible.folder, searchBin))
+    .find(checkExists);
+  if (runner) {
+    log.debug("Using " + runner);
+  }
+  return runner;
+}
+
+function compareVersionArrays(x, y) {
+  return x.reduce((acc, cur, i) => acc || cur - y[i] || 0, 0) || x.length - y.length;
+}
+
+function findWrapper(func, name) {
+  const found = func();
+  if (!found) {
+    debug(`Can't find any installed ${name}`);
+  }
+  return found;
+}
+
+function findInstalledNUnit3() {
+  if (!programFilesFolder) {
+    return null;
+  }
+  var search = path.join(programFilesFolder, "NUnit.org", "nunit-console", "nunit3-console.exe");
+  if (!search) {
+    return null;
+  }
+  return fs.existsSync(search) ? search : null;
+};
+
+function checkExists(somePath) {
+  debug(`Checking if file exists: ${somePath}`);
+  return fs.existsSync(somePath) ? somePath : undefined;
+}
+
+function tryToFindNUnit(options) {
+  return initialToolSearch("nunit3-console.exe", "NUNIT") ||
+    searchForNunit(options);
+}
+
+function latestNUnit(options) {
+  const result = tryToFindNUnit(options);
+  debug(`Using nunit runner: ${result || "NOT FOUND"}`);
+  return result;
+}
+
+function nunit2Finder(searchBin, options) {
+  if (!programFilesFolder) {
+    return null;
+  }
+  return finder([programFilesFolder], undefined, "NUnit", searchBin, options);
+}
+
+function searchForNunit(options) {
+  options = options || {};
+  const isX86 = (options.x86 || ((options.platform || options.architecture) === "x86"));
+  const runner = isX86 ? "/bin/nunit-console-x86.exe" : "/bin/nunit-console.exe";
+  return findWrapper(function () {
+    return findInstalledNUnit3() || nunit2Finder(runner, options);
+  }, "nunit-console runner");
+}
+
+function findTool(exeName, underFolder) {
+  const allResults = lsR(underFolder || getToolsFolder()).filter(function (p) {
+    return p.toLowerCase().endsWith(exeName.toLowerCase());
+  }).sort();
+  return allResults[0] || which(exeName);
+}
+
+function locateDotCover(options) {
+  options = options || {};
+  return initialToolSearch("dotCover.exe", "DOTCOVER") ||
+    findWrapper(function () {
+      return finder([programFilesFolder, localAppDataFolder], "JetBrains/Installations", "dotCover", "dotCover.exe", options)
+        || finder([programFilesFolder], "JetBrains/dotCover", "v", "Bin/dotCover.exe", options);
+    }, "dotCover");
+}
+
+function latestDotCover(options) {
+  const result = locateDotCover(options);
+  debug(`Using dotCover: ${result || "NOT FOUND"}`);
+  return result;
+}
+
+function initialToolSearch(toolExe, environmentVariable) {
+  const fromEnvironment = process.env[environmentVariable];
+  if (fromEnvironment) {
+    if (!fs.existsSync(fromEnvironment)) {
+      throw new ZarroError(`${fromEnvironment} specified in environment variable ${environmentVariable} not found`);
+    }
+    return fromEnvironment;
+  }
+  return findTool(toolExe);
+}
+
+function latestOpenCover() {
+  const result = initialToolSearch("OpenCover.Console.exe", "OPENCOVER");
+  debug(`Using opencover: ${result || "NOT FOUND"}`);
+  return result;
+}
+
+module.exports = {
+  latestNUnit: latestNUnit,
+  latestDotCover: latestDotCover,
+  latestOpenCover: latestOpenCover,
+  findTool: findTool,
+  nunit2Finder: nunit2Finder
+};