zarro 1.92.0

package/gulp-tasks/modules/collect-files.ts

@@ -0,0 +1,16 @@
+import * as vinyl from "vinyl";
+
+(function() {
+  // collects the files from a gulp stream
+  const
+    es = require("event-stream");
+  module.exports = function collectFiles(target: vinyl.BufferFile[]) {
+    const stream = es.through(function data(file: vinyl.BufferFile) {
+      target.push(file);
+      stream.emit("data", file);
+    }, function end() {
+      stream.emit("end");
+    });
+    return stream;
+  }
+})();

package/gulp-tasks/modules/config-generator.js

@@ -0,0 +1,10 @@
+var env = requireModule("env"),
+  path = require("path");
+
+module.exports = function configGenerator() {
+  return {
+    localNuget: path.join(env.resolve("BUILD_TOOLS_FOLDER"), "nuget.exe"),
+    nugetDownloadUrl:
+      "http://dist.nuget.org/win-x86-commandline/latest/nuget.exe"
+  };
+};

package/gulp-tasks/modules/defaults.js

@@ -0,0 +1,9 @@
+module.exports = function defaults(config, fallback) {
+  const result = { ...config };
+  Object.keys(fallback || {}).forEach(k => {
+    if (result[k] === undefined) {
+      result[k] = fallback[k];
+    }
+  });
+  return result;
+}

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

@@ -0,0 +1,104 @@
+const
+  { ZarroError } = requireModule("zarro-error"),
+  HttpDownloader = require("./http-downloader"),
+  nugetUpdateSelf = require("./nuget-update-self"),
+  logger = require("./log"),
+  path = require("path"),
+  url = 'http://dist.nuget.org/win-x86-commandline/latest/nuget.exe';
+
+function downloadNugetTo(targetFolder) {
+  logger.debug(`Attempting to download nuget.exe to ${targetFolder}`);
+  const
+    downloader = new HttpDownloader(),
+    target = path.join(targetFolder, "nuget.exe");
+  return downloader
+    .download(url, path.join(targetFolder, "nuget.exe"))
+    .then(() => validateCanRunExe(target));
+}
+
+const
+  validators = {},
+  cached = {};
+
+function validateCanRunExe(exePath) {
+  if (validators[exePath]) {
+    return validators[exePath];
+  }
+  const shouldLog = !validators[exePath];
+  if (shouldLog) {
+    logger.debug(`validating exe at: ${exePath}`);
+  }
+  return validators[exePath] = new Promise((resolve, reject) => {
+    let lastMessage = "unknown error",
+      attempts = 0;
+    setTimeout(function testExe() {
+      if (cached[exePath]) {
+        return resolve(exePath);
+      }
+      if (attempts === 10) {
+        return reject(`Unable to run executable at ${exePath}: ${lastMessage}`);
+      }
+      attempts++;
+      if (shouldLog) {
+        logger.debug(`attempt #${attempts} to run ${exePath}`);
+      }
+      const a = attempts;
+      nugetUpdateSelf(exePath).then(() => {
+        if (shouldLog) {
+          const sub = a > 1 ? ` (${a})` : "";
+          logger.info(`nuget.exe appears to be valid!${sub}`);
+        }
+        cached[exePath] = true;
+        return resolve(exePath);
+      }).catch(e => {
+        lastMessage = e.message || lastMessage;
+        if (shouldLog) {
+          logger.debug(`failed to run executable (${
+            e.message
+          }); ${
+            attempts < 9
+              ? "will try again"
+              : "giving up"
+          }`);
+        }
+        setTimeout(testExe, 1000);
+      });
+    }, 1000);
+  });
+}
+
+function retry(fn, attempt, maxAttempts, wait) {
+  attempt = attempt || 0;
+  maxAttempts = maxAttempts || 10;
+  wait = wait || 5000;
+  if (wait < 1000) {
+    wait *= 1000;
+  }
+  return fn().catch(e => {
+    if (attempt >= maxAttempts) {
+      throw new ZarroError(`${e} (giving up after ${attempt} attempts)`);
+    } else {
+      return new Promise((resolve, reject) => {
+        setTimeout(() => {
+          console.warn(e);
+          console.log(`trying again in ${wait / 1000}s (${++attempt} / ${maxAttempts})`);
+          retry(fn, attempt, maxAttempts).then(function () {
+            resolve(Array.from(arguments));
+          }).catch(function () {
+            reject(Array.from(arguments));
+          });
+        }, wait);
+      });
+    }
+  });
+}
+
+module.exports = function downloadNuget(targetFolder) {
+  return retry(() =>
+    downloadNugetTo(targetFolder)
+  ).then(downloaded => {
+    console.log(`nuget downloaded to: ${downloaded}`);
+    return downloaded;
+  });
+};
+

package/gulp-tasks/modules/ensure-folder-exists.js

@@ -0,0 +1,21 @@
+const
+  fs = require("fs"),
+  debug = require("debug")("ensure-folder-exists")
+
+module.exports = function ensureFolderExists(folder) {
+  debug(`Ensuring existence of tools folder "${folder}"`);
+  return new Promise((resolve, reject) => {
+    try {
+      if (!fs.existsSync(folder)) {
+        fs.mkdirSync(folder);
+      }
+      debug(`${folder} exists!`);
+      resolve();
+    } catch (e) {
+      debug(`${folder} doesn't exist and not creatable`);
+      debug(e);
+      reject(e);
+    }
+  });
+}
+

package/gulp-tasks/modules/env-helpers.js

@@ -0,0 +1,49 @@
+"use strict";
+(function () {
+    const { ZarroError } = requireModule("zarro-error");
+    function env(name, fallback) {
+        const value = process.env[name];
+        if (value !== undefined) {
+            return value;
+        }
+        const argCount = Array.from(arguments).length;
+        if (argCount > 1) {
+            return fallback;
+        }
+        throw new ZarroError(`environment variable '${name}' is not defined and no fallback provided`);
+    }
+    function envNumber(name, fallback) {
+        const haveFallback = fallback !== undefined, value = haveFallback ? env(name, fallback === null || fallback === void 0 ? void 0 : fallback.toString()) : env(name), parsed = parseInt(value, 10);
+        if (!isNaN(parsed)) {
+            return parsed;
+        }
+        throw new ZarroError(`environment variable '${name}' is invalid: expected numeric value but found '${value}'`);
+    }
+    function envFlag(name, fallback) {
+        const haveFallback = fallback !== undefined, value = haveFallback ? env(name, fallback === null || fallback === void 0 ? void 0 : fallback.toString()) : env(name);
+        return parseBool(name, value);
+    }
+    const truthy = [
+        "1",
+        "yes",
+        "true"
+    ], falsey = [
+        "0",
+        "no",
+        "false"
+    ];
+    function parseBool(name, value) {
+        if (truthy.indexOf(value === null || value === void 0 ? void 0 : value.toString()) > -1) {
+            return true;
+        }
+        if (falsey.indexOf(value === null || value === void 0 ? void 0 : value.toString()) > -1) {
+            return false;
+        }
+        throw new ZarroError(`environment variable '${name}' is invalid: could not parse '${value}' as a boolean value`);
+    }
+    module.exports = {
+        env,
+        envNumber,
+        envFlag
+    };
+})();

package/gulp-tasks/modules/env-helpers.ts

@@ -0,0 +1,67 @@
+(function() {
+  const { ZarroError } = requireModule("zarro-error");
+
+  function env(name: string, fallback?: string): string {
+    const value = process.env[name];
+    if (value !== undefined) {
+      return value;
+    }
+    const argCount = Array.from(arguments).length;
+    if (argCount > 1) {
+      return fallback as string;
+    }
+    throw new ZarroError(
+      `environment variable '${ name }' is not defined and no fallback provided`
+    );
+  }
+
+  function envNumber(name: string, fallback?: number): number {
+    const
+      haveFallback = fallback !== undefined,
+      value = haveFallback ? env(name, fallback?.toString()) : env(name),
+      parsed = parseInt(value, 10);
+    if (!isNaN(parsed)) {
+      return parsed;
+    }
+    throw new ZarroError(
+      `environment variable '${ name }' is invalid: expected numeric value but found '${ value }'`
+    );
+  }
+
+  function envFlag(name: string, fallback?: boolean): boolean {
+    const
+      haveFallback = fallback !== undefined,
+      value = haveFallback ? env(name, fallback?.toString()) : env(name);
+    return parseBool(name, value);
+  }
+
+  const truthy = [
+      "1",
+      "yes",
+      "true"
+    ],
+    falsey = [
+      "0",
+      "no",
+      "false"
+    ];
+
+  function parseBool(name: string, value: string): boolean {
+    if (truthy.indexOf(value?.toString()) > -1) {
+      return true;
+    }
+    if (falsey.indexOf(value?.toString()) > -1) {
+      return false;
+    }
+    throw new ZarroError(
+      `environment variable '${name}' is invalid: could not parse '${value}' as a boolean value`
+    );
+  }
+
+  module.exports = {
+    env,
+    envNumber,
+    envFlag
+  }
+
+})();

package/gulp-tasks/modules/env.js

@@ -0,0 +1,364 @@
+if (!Array.prototype.flatMap) {
+  try {
+    const flatMap = require("array.prototype.flatmap");
+    flatMap.shim();
+  } catch (e) {
+    console.error(
+      "Array.prototype.flatmap is required -- either use a newer Node or install the npm package array.prototype.flatmap"
+    );
+  }
+}
+const
+  { ZarroError } = requireModule("zarro-error"),
+  chalk = require("ansi-colors"),
+  debug = require("debug")("env"),
+  registeredEnvironmentVariables = {},
+  longestStringLength = require("./longest-string-length"),
+  padRight = require("./pad-right"),
+  padLeft = require("./pad-left"),
+  toExport = {
+    flag,
+    fallback,
+    register,
+    printHelp,
+    taskHelp,
+    resolve,
+    associate,
+    resolveArray,
+    explode,
+    overrideDefault,
+    resolveNumber,
+    resolveFlag
+  };
+
+const positives = [ "1", "yes", "true" ];
+if (process.env.POSITIVE_FLAG) {
+  positives.push(process.env.POSITIVE_FLAG);
+}
+
+function flag(name, defaultValue) {
+  const envVar = fallback(name, defaultValue);
+
+  return (
+    envVar === true || positives.indexOf((envVar || "").toLowerCase()) > -1
+  );
+}
+
+function fallback(name, defaultValue) {
+  const envVar = process.env[name];
+  return envVar === undefined ? defaultValue : envVar;
+}
+
+function register(config) {
+  let { name, help, tasks, overriddenBy, when } = config;
+  if (toExport[name] !== undefined) {
+    throw new ZarroError(`env var already registered: ${name}`);
+  }
+  toExport[name] = name;
+  // 'default' seems like a more natural name, but we can't use it for a var name...
+  let fallback = config.default;
+  if (registeredEnvironmentVariables[name]) {
+    return update(name, fallback, help, tasks, overriddenBy, when);
+  }
+  tasks = normaliseArray(tasks);
+  help = trim(help);
+  fallback = trim(fallback);
+
+  registeredEnvironmentVariables[name] = {
+    help,
+    tasks,
+    default: fallback,
+    overriddenBy: overriddenBy || [],
+    when
+  };
+  if (pendingAssociations[name]) {
+    const otherTasks = pendingAssociations[name];
+    delete pendingAssociations[name];
+    tasks.push.apply(tasks, otherTasks);
+  }
+  if (pendingDefaultOverrides[name]) {
+    registeredEnvironmentVariables[name].default =
+      pendingDefaultOverrides[name];
+    delete pendingDefaultOverrides[name];
+  }
+  debug({
+    label: `register env var: ${name}`,
+    config: registeredEnvironmentVariables[name]
+  });
+  return toExport;
+}
+
+const pendingAssociations = {};
+
+function associate(varName, tasks) {
+  if (Array.isArray(varName)) {
+    varName.forEach(v => associate(v, tasks));
+    return toExport;
+  }
+
+  if (!varName || !tasks || tasks.length === 0) {
+    return toExport;
+  }
+  if (!Array.isArray(tasks)) {
+    tasks = [ tasks ];
+  }
+
+  const target = registeredEnvironmentVariables[varName]
+    ? registeredEnvironmentVariables[varName].tasks
+    : (pendingAssociations[varName] = pendingAssociations[varName] || []);
+  tasks.forEach(task => {
+    if (target.indexOf(task) > -1) {
+      return;
+    }
+    target.push(task);
+  });
+  return toExport;
+}
+
+const pendingDefaultOverrides = {};
+
+function overrideDefault(varName, newDefault) {
+  const target = registeredEnvironmentVariables[varName];
+  if (target) {
+    target.default = newDefault;
+  } else {
+    pendingDefaultOverrides[varName] = newDefault;
+  }
+}
+
+function normaliseArray(arr) {
+  if (!arr) {
+    return [];
+  }
+  return Array.isArray(arr) ? arr : [ arr ];
+}
+
+function update(varName, fallbackValue, help, tasks, overriddenBy, when) {
+  const target = registeredEnvironmentVariables[varName];
+  if (!target.help) {
+    target.help = trim(help);
+  }
+  if (!target.default) {
+    target.default = trim(fallbackValue);
+  }
+  tasks = normaliseArray(tasks);
+  target.tasks = target.tasks.concat(tasks);
+  target.overriddenBy = target.overriddenBy.concat(overriddenBy || []);
+  // TODO: composite when? this code is first-come-first-wins
+  target.when = target.when || when;
+  debug({
+    label: `update env var: ${varName}`,
+    config: target
+  });
+  return toExport;
+}
+
+function trim(str) {
+  if (str === null || str === undefined) {
+    return "";
+  }
+  if (Array.isArray(str)) {
+    return str.map(s => s.trim());
+  }
+  return str.toString().trim();
+}
+
+function printHelp() {
+  printHelpFor(listVars());
+}
+
+function printHelpFor(vars) {
+  const longest = longestStringLength(vars);
+  vars.forEach(k =>
+    createHelpFor(k, longest).forEach(line => console.log(line))
+  );
+}
+
+function indent(str, howMany) {
+  if (howMany === undefined || howMany < 1) {
+    howMany = 1;
+  }
+  return padLeft(str, howMany * 2 + str.length);
+}
+
+const tasksPre = chalk.greenBright("tasks"),
+  defaultPre = chalk.cyanBright("default");
+
+function createHelpFor(k, longest) {
+  if (longest === undefined) {
+    // take a guess
+    longest = 16;
+  }
+  const result = [];
+  result.push(chalk.yellow(`${padRight(k, longest)}`));
+  const target = registeredEnvironmentVariables[k];
+  if (target.help) {
+    result.push(indent(chalk.gray(target.help)));
+  }
+  if (target.default) {
+    result.push(indent(`${defaultPre}: ${target.default}`, 2));
+  }
+  if (target.tasks && target.tasks.length) {
+    result.push(
+      indent(
+        `${tasksPre}: ${target.tasks
+          .map(t => t.trim())
+          .filter(t => t)
+          .sort()
+          .join(", ")}`,
+        2
+      )
+    );
+  }
+  if (target.overriddenBy !== undefined) {
+    const overrides = Array.isArray(target.overriddenBy)
+      ? target.overriddenBy.join(",")
+      : target.overriddenBy;
+    if (overrides.trim()) {
+      result.push(indent(chalk.magenta(`overridden by: ${overrides}`)));
+    }
+  }
+  return result;
+}
+
+function listVars() {
+  return Object.keys(registeredEnvironmentVariables).sort();
+}
+
+function taskHelp(task) {
+  const keys = listVars(),
+    matchingRequest = keys.filter(cur => {
+      return registeredEnvironmentVariables[cur].tasks.indexOf(task) > -1;
+    });
+  printHelpFor(matchingRequest);
+}
+
+function resolve() {
+  const names = Array.from(arguments).flatMap(a => a);
+  const result = resolveInternal(names);
+  logResolved(names, result);
+  return result;
+}
+
+function resolveFirst(names, ignoreDefault) {
+  return names
+    .reduce((acc, cur) =>
+      acc === undefined
+        ? resolveInternal(cur, ignoreDefault)
+        : acc, undefined);
+}
+
+function resolveInternal(name, ignoreDefault) {
+  if (Array.isArray(name)) {
+    // attempt to resolve the first defined variable
+    const firstDefined = resolveFirst(name, true);
+    // if that doesn't work, get the first default value
+    return firstDefined === undefined
+      ? resolveFirst(name, false)
+      : firstDefined;
+  }
+
+  const target = registeredEnvironmentVariables[name] || {},
+    configuredOverrides = target.overriddenBy,
+    overrides = configuredOverrides
+      ? Array.isArray(configuredOverrides)
+        ? configuredOverrides
+        : [ configuredOverrides ]
+      : [],
+    overrideValues = overrides
+      .map(s => process.env[s])
+      .filter(s => s !== undefined),
+    initialValue =
+      (!ignoreDefault && process.env[name] === undefined) ? target.default : process.env[name];
+  if (overrideValues.length === 0) {
+    return initialValue;
+  }
+  if (target.when === undefined) {
+    if (overrideValues.length > 0) {
+      console.warn(
+        `multiple override values found for '${name}' and no strategy for discriminating set; selecting the first`
+      );
+      debug({
+        when: target.when,
+        overrides,
+        overrideValues,
+        initialValue
+      });
+    }
+    return overrideValues[0];
+  }
+
+  const result = overrideValues.reduce((acc, cur) => {
+    debug({
+      label: "invoke override discriminator",
+      when: target.when,
+      acc,
+      cur
+    });
+    return target.when(acc, cur) ? cur : acc;
+  }, initialValue);
+
+  debug({
+    when: target.when,
+    overrides,
+    overrideValues,
+    initialValue,
+    envVar: name,
+    envValue: process.env[name],
+  });
+
+  return result;
+}
+
+function logResolved(name, value) {
+  debug(`resolved: ${name} => ${quoteString(value)}`);
+}
+
+function quoteString(val) {
+  return typeof val === "string" ? `"${val}"` : val;
+}
+
+function resolveArray(name, delimiter) {
+  const value = resolveInternal(name) || "",
+    valueArray = Array.isArray(value) ? value : explode(value, delimiter);
+  logResolved(name, valueArray);
+  return valueArray;
+}
+
+function resolveNumber(name) {
+  const value = resolveInternal(name),
+    asNumber = parseInt(value, 10);
+  if (isNaN(asNumber)) {
+    throw new ZarroError(`${value} is not a valid numeric value for ${name}`);
+  }
+  logResolved(name, asNumber);
+  return asNumber;
+}
+
+const positiveFlags = [ "yes", "true", "1" ];
+const negativeFlags = [ "no", "false", "0" ];
+
+function resolveFlag(name) {
+  const value = (resolveInternal(name) || "").toLowerCase();
+  if (positiveFlags.indexOf(value) > -1) {
+    logResolved(name, true);
+    return true;
+  }
+  if (negativeFlags.indexOf(value) > -1) {
+    logResolved(name, false);
+    return false;
+  }
+  throw new ZarroError(`environmental flag not set and no default: ${name}`);
+}
+
+function explode(str, delimiter) {
+  return str
+    .split(delimiter || ",")
+    .map(p => p.trim())
+    .filter(p => !!p);
+}
+
+const registerEnvironmentVariables = require("./register-environment-variables");
+registerEnvironmentVariables(toExport);
+
+module.exports = toExport;