zarro 1.90.0 → 1.94.0

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

@@ -1,103 +1,104 @@
-const
-  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 Error(`${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;
-  });
-};
-
+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

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

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

@@ -1,5 +1,6 @@
 "use strict";
 (function () {
+    const { ZarroError } = requireModule("zarro-error");
     function env(name, fallback) {
         const value = process.env[name];
         if (value !== undefined) {
@@ -9,14 +10,14 @@
         if (argCount > 1) {
             return fallback;
         }
-        throw new Error(`environment variable '${name}' is not defined and no fallback provided`);
+        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 Error(`environment variable '${name}' is invalid: expected numeric value but found '${value}'`);
+        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);
@@ -38,7 +39,7 @@
         if (falsey.indexOf(value === null || value === void 0 ? void 0 : value.toString()) > -1) {
             return false;
         }
-        throw new Error(`environment variable '${name}' is invalid: could not parse '${value}' as a boolen value`);
+        throw new ZarroError(`environment variable '${name}' is invalid: could not parse '${value}' as a boolean value`);
     }
     module.exports = {
         env,

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

@@ -1,4 +1,6 @@
 (function() {
+  const { ZarroError } = requireModule("zarro-error");
+
   function env(name: string, fallback?: string): string {
     const value = process.env[name];
     if (value !== undefined) {
@@ -8,7 +10,7 @@
     if (argCount > 1) {
       return fallback as string;
     }
-    throw new Error(
+    throw new ZarroError(
       `environment variable '${ name }' is not defined and no fallback provided`
     );
   }
@@ -21,7 +23,7 @@
     if (!isNaN(parsed)) {
       return parsed;
     }
-    throw new Error(
+    throw new ZarroError(
       `environment variable '${ name }' is invalid: expected numeric value but found '${ value }'`
     );
   }
@@ -51,8 +53,8 @@
     if (falsey.indexOf(value?.toString()) > -1) {
       return false;
     }
-    throw new Error(
-      `environment variable '${name}' is invalid: could not parse '${value}' as a boolen value`
+    throw new ZarroError(
+      `environment variable '${name}' is invalid: could not parse '${value}' as a boolean value`
     );
   }
 

package/gulp-tasks/modules/env.js

@@ -9,6 +9,7 @@ if (!Array.prototype.flatMap) {
   }
 }
 const
+  { ZarroError } = requireModule("zarro-error"),
   chalk = require("ansi-colors"),
   debug = require("debug")("env"),
   registeredEnvironmentVariables = {},
@@ -51,7 +52,7 @@ function fallback(name, defaultValue) {
 function register(config) {
   let { name, help, tasks, overriddenBy, when } = config;
   if (toExport[name] !== undefined) {
-    throw new Error(`env var already registered: ${name}`);
+    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...
@@ -328,7 +329,7 @@ function resolveNumber(name) {
   const value = resolveInternal(name),
     asNumber = parseInt(value, 10);
   if (isNaN(asNumber)) {
-    throw new Error(`${value} is not a valid numeric value for ${name}`);
+    throw new ZarroError(`${value} is not a valid numeric value for ${name}`);
   }
   logResolved(name, asNumber);
   return asNumber;
@@ -347,7 +348,7 @@ function resolveFlag(name) {
     logResolved(name, false);
     return false;
   }
-  throw new Error(`environmental flag not set and no default: ${name}`);
+  throw new ZarroError(`environmental flag not set and no default: ${name}`);
 }
 
 function explode(str, delimiter) {

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

@@ -1,41 +1,42 @@
-const
-  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 Error(`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());
-};
+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

@@ -1,78 +1,79 @@
-const
-  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 Error(`${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;
+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;