zarro 1.92.0

package/gulp-tasks/modules/gulp.js

@@ -0,0 +1,92 @@
+// this module attempts to make gulp able to provide help
+// -> in 3.x, we can use the gulp-help package to do so
+// -> in 4.x, this is shimmed in. In addition, we need to
+//    - facilitate forward references, as per original gulp
+//    -
+const setTaskName = requireModule("set-task-name"),
+  gulpVersion = requireModule("gulp-version");
+
+if (gulpVersion.major === 3) {
+  module.exports = require("gulp-help")(require("gulp"));
+} else {
+  const
+    quieter = requireModule("reduce-gulp-noise");
+    gulp = require("gulp"),
+    help = {},
+    FwdRef = require("undertaker-forward-reference");
+
+  gulp.registry(new FwdRef());
+
+  const
+    originalTask = gulp.task,
+    newTask = function() {
+      let
+        args = Array.from(arguments),
+        taskName = args[0],
+        helpMessage = "";
+      if (typeof args[1] === "string") {
+        helpMessage = args[1];
+        args.splice(1, 1);
+      }
+      if (Array.isArray(args[1])) {
+        const parallel = gulp.parallel(
+          args[1].map(name => {
+            // this allows late-overriding of tasks, as per assistance
+            // at: https://github.com/gulpjs/gulp/issues/2337
+            return setTaskName((...args) => gulp.series(name)(...args), quieter.markForSuppression(name)); // `${quieter.marker}(${name})`);
+          }));
+        setTaskName(parallel, `pre-${taskName}`);
+        args[1] = gulp.series(
+          parallel,
+          args[2] || (() => Promise.resolve())
+        );
+        setTaskName(args[1], `[${taskName}]`);
+        args.splice(2, 1);
+      }
+      help[taskName] = helpMessage;
+      originalTask.call(gulp, taskName, args[1]);
+      const generatedTask = originalTask.call(gulp, taskName);
+      generatedTask.description = helpMessage;
+      return generatedTask;
+    };
+  gulp.task = newTask.bind(gulp);
+  gulp.task("help", () => {
+    const chalk = require("ansi-colors"),
+      green = chalk.greenBright.bind(chalk),
+      yellow = chalk.yellowBright.bind(chalk),
+      cyan = chalk.cyanBright.bind(chalk);
+
+    return new Promise((resolve, reject) => {
+      console.log(yellow("Task help"));
+      console.log(yellow(" - Tasks marked with * are affected by environment variables"));
+      console.log(yellow(" - run the help:environment task for more info"));
+      const keys = Object.keys(help).sort();
+      const longestKeyLength = keys.reduce(function (acc, cur) {
+        return cur.length > acc ? cur.length : acc;
+      }, 0);
+      keys.forEach(function(key) {
+        if (!help[key]) {
+          return console.log(cyan(key));
+        }
+        const helpMessage = help[key];
+        while (key.length < longestKeyLength) {
+          key += " ";
+        }
+        console.log(cyan(key) + "  " + green(helpMessage));
+      });
+      resolve();
+    });
+  });
+  module.exports = gulp;
+}
+
+(function() {
+  const
+    env = requireModule("env"),
+    gulp = module.exports;
+
+    gulp.task("help:environment", () => {
+      env.printHelp();
+      return Promise.resolve();
+    });
+})();

package/gulp-tasks/modules/http-downloader.js

@@ -0,0 +1,113 @@
+var
+  fs = require('fs'),
+  path = require("path"),
+  ensureFolderExists = require("./ensure-folder-exists"),
+  request = require('request'),
+  debug = require('debug')('http-downloader');
+
+function HttpDownloader(infoLogFunction, debugLogFunction) {
+  this._info = infoLogFunction || console.log;
+  this._debug = debugLogFunction || debug;
+  this.assumeDownloadedIfExistsAndSizeMatches = true;
+}
+
+HttpDownloader.prototype = {
+  download: function (url, target) {
+    const partFile = `${target}.part`;
+    ensureFolderExists(path.dirname(partFile));
+    return new Promise((resolve, reject) => {
+      this._request = request.get(url, { timeout: 30000 })
+        .on("response", (response) => {
+          this._debug(`got response: ${JSON.stringify(response)}`);
+          this._downloadSize = parseInt(response.headers["content-length"]);
+          this._statusSuffix = '% of ' + this._humanSize(this._downloadSize);
+        })
+        .on("error", (e) => {
+          this._debug(`got error: ${e}`);
+          reject(e);
+        })
+        .on("data", (data) => {
+          this._debug(`got ${data.length} bytes`);
+          this._updateStatus(data);
+        })
+        .on("end", () => {
+          this._clear();
+          this._rename(resolve, reject, partFile, target);
+        }).pipe(fs.createWriteStream(partFile));
+    });
+  },
+  abort: function () {
+    if (this._request) {
+      self._errored = true;
+      this._request.abort();
+      this._clear();
+    }
+  },
+  _updateStatus: function (data) {
+    if (process.env.SUPPRESS_DOWNLOAD_PROGRESS || process.env.BUILD_NUMBER /* automatically disable at Jenkins CI */) {
+      return;
+    }
+    this._written = this._written || 0;
+    this._written += data.length;
+    var perc = Math.round((100 * this._written) / this._downloadSize);
+    if (perc != this._lastPerc) {
+      this._writeStatus(perc + this._statusSuffix);
+      this._lastPerc = perc;
+    }
+  },
+  _writeStatus: function (msg) {
+    this._clearStatus();
+    process.stdout.write(msg);
+  },
+  _rename: function (resolve, reject, src, dst, attempts) {
+    try {
+      this._debug('attempt rename of temp file');
+      fs.renameSync(src, dst)
+      this._clearStatus();
+      this._info(`-> ${dst} download complete!`);
+      resolve(dst)
+    } catch (e) {
+      this._debug('rename error:', e);
+      if (attempts > 99) {
+        reject(['Unable to rename "', src, '" to "', ds, '": ', e].join(''));
+      } else {
+        setTimeout(()=> {
+          this._rename(resolve, reject, src, dst, attempts++);
+        }, 100);
+      }
+    }
+  },
+  _clearStatus: function () {
+    process.stdout.write('\r               \r');
+  },
+  _humanSize: function (size) {
+    var suffixes = ['b', 'kb', 'mb', 'tb', 'pb'];
+    for (var i = 0; i < suffixes.length - 1; i++) {
+      if (size < 1024) {
+        return size.toFixed(2) + suffixes[i];
+      }
+      size /= 1024;
+    }
+    return size.toFixed(2) + suffixes[suffixes.length - 1];
+  },
+  _clear: function () {
+    var self = this;
+    ['_request', '_response', '_downloadSize', '_lastPerc',
+      '_resolveFunction', '_rejectFunction', '_lastData', '_statusSuffix'
+    ].forEach(function (prop) {
+      self[prop] = undefined;
+    });
+  },
+  _alreadyDownloaded: function () {
+    if (!this.assumeDownloadedIfExistsAndSizeMatches) {
+      return false;
+    }
+    if (!fs.existsSync(this._target)) {
+      return false;
+    }
+    var lstat = fs.lstatSync(this._target);
+    return lstat.size === this._downloadSize;
+  }
+}
+
+module.exports = HttpDownloader;

package/gulp-tasks/modules/import-npm-tasks.js

@@ -0,0 +1,33 @@
+/*
+  Overriding in your own source tree:
+
+  If you don't want to import npm scripts as gulp tasks or perhaps you'd
+  just like to define a different behavior, create one of the following,
+  parallel to gulp-tasks:
+  - override-tasks/import-npm-tasks.js
+  - local-tasks/import-npm-tasks.js
+
+  If you just want to disable the functionality, an empty file will do
+*/
+const path = require("path"),
+  debug = require("debug")("import-npm-tasks"),
+  fs = require("fs"),
+  search = [ "local-tasks", "override-tasks" ];
+module.exports = function() {
+  let overridden = false;
+  search.forEach(function (dir) {
+    const lookFor = path.join("..", dir, __filename);
+    if (fs.existsSync(lookFor)) {
+      console.log("overriding gulp-npm-run default behaviour with: ", lookFor);
+      require(lookFor);
+      overridden = true;
+    }
+  });
+  if (!overridden) {
+    debug("importing npm scripts as gulp tasks")
+    const gulpNpmRun = requireModule("gulp-npm-run");
+    const gulp = requireModule("gulp");
+    gulpNpmRun(gulp);
+    debug("-> done");
+  }
+};

package/gulp-tasks/modules/increment-version-string.js

@@ -0,0 +1,18 @@
+const { ZarroError } = requireModule("zarro-error");
+
+function testNaN(version) {
+  Object.keys(version).forEach(k => {
+    if (isNaN(version[k])) {
+      throw new ZarroError(`${k} is not an integer`);
+    }
+  });
+}
+
+module.exports = function incrementVersion(versionString) {
+  const parts = versionString.split("."),
+    major = parseInt(parts[0]),
+    minor = parseInt(parts[1]),
+    patch = parseInt(parts[2]);
+  testNaN({ major, minor, patch });
+  return `${major}.${minor}.${patch + 1}`;
+};

package/gulp-tasks/modules/increment-version.js

@@ -0,0 +1,30 @@
+"use strict";
+const { ZarroError } = requireModule("zarro-error");
+function zeroFrom(parts, startIndex) {
+    for (let i = startIndex; i < parts.length; i++) {
+        parts[i] = 0;
+    }
+}
+function incrementAt(parts, index, incrementBy) {
+    if (parts[index] === undefined) {
+        throw new ZarroError(`version '${parts.join(".")}' has no value at position ${index}`);
+    }
+    parts[index] += incrementBy;
+}
+const incrementLookup = {
+    "major": 0,
+    "minor": 1,
+    "patch": 2
+};
+module.exports = function incrementVersion(version, strategy, zeroLowerOrder, incrementBy = 1) {
+    const parts = version.split(".").map(i => parseInt(i));
+    let toIncrement = incrementLookup[(strategy || "").toLowerCase()];
+    if (toIncrement === undefined) {
+        throw new ZarroError(`Unknown version increment strategy: ${strategy}\n try one of 'major', 'minor' or 'patch'`);
+    }
+    incrementAt(parts, toIncrement, incrementBy);
+    if (zeroLowerOrder) {
+        zeroFrom(parts, toIncrement + 1);
+    }
+    return parts.join(".");
+};

package/gulp-tasks/modules/increment-version.ts

@@ -0,0 +1,41 @@
+const { ZarroError } = requireModule("zarro-error");
+
+function zeroFrom(parts: number[], startIndex: number) {
+  for (let i = startIndex; i < parts.length; i++) {
+    parts[i] = 0;
+  }
+}
+
+function incrementAt(
+  parts: number[],
+  index: number,
+  incrementBy: number) {
+  if (parts[index] === undefined) {
+    throw new ZarroError(`version '${parts.join(".")}' has no value at position ${index}`);
+  }
+  parts[index] += incrementBy;
+}
+
+const incrementLookup: { [key: string]: number } = {
+  "major": 0,
+  "minor": 1,
+  "patch": 2
+};
+
+
+module.exports = function incrementVersion(
+  version: string,
+  strategy: "major" | "minor" | "patch",
+  zeroLowerOrder: boolean,
+  incrementBy: number = 1): string {
+  const parts = version.split(".").map(i => parseInt(i));
+  let toIncrement = incrementLookup[(strategy || "").toLowerCase()]
+  if (toIncrement === undefined) {
+    throw new ZarroError(`Unknown version increment strategy: ${strategy}\n try one of 'major', 'minor' or 'patch'`);
+  }
+  incrementAt(parts, toIncrement, incrementBy);
+  if (zeroLowerOrder) {
+    zeroFrom(parts, toIncrement + 1);
+  }
+  return parts.join(".");
+}

package/gulp-tasks/modules/install-local-tools.js

@@ -0,0 +1,122 @@
+const resolveNuget = require("./resolve-nuget"),
+  downloadNuget = require("./download-nuget"),
+  nugetUpdateSelf = require("./nuget-update-self"),
+  debug = require("debug")("install-local-tools"),
+  gutil = requireModule("gulp-util"),
+  path = require("path"),
+  fs = require("fs"),
+  getToolsFolder = require("./get-tools-folder"),
+  nuget = require("./nuget"),
+  ensureFolderExists = require("./ensure-folder-exists"),
+  { ZarroError } = requireModule("zarro-error"),
+  del = require("del");
+
+function cleanFoldersFrom(toolsFolder) {
+  const dirs = fs
+    .readdirSync(toolsFolder)
+    .map(p => path.join(toolsFolder, p))
+    .filter(p => {
+      const stat = fs.lstatSync(p);
+      return stat.isDirectory();
+    });
+  if (dirs.length) {
+    debug(`Will delete the following tools sub-folders:`);
+    dirs.forEach(d => {
+      debug(` - ${d}`);
+    });
+  }
+  return del(dirs);
+}
+
+function downloadOrUpdateNuget(targetFolder) {
+  const nugetPath = path.join(targetFolder, "nuget.exe");
+  const nuget = resolveNuget(nugetPath, false);
+  if (nuget && !nuget.match(/dotnet/i)) {
+    if (!process.env.SKIP_NUGET_UPDATES) {
+      gutil.log("nuget.exe already exists... attempting self-update");
+      console.log(`NUGET: (${nuget})`);
+      return nugetUpdateSelf(nuget);
+    }
+    return nuget;
+  }
+  debug(`Attempting to get tools nuget to: ${targetFolder}`);
+  return downloadNuget(targetFolder);
+}
+
+function generateNugetSourcesOptions(toolSpecifiedSource) {
+  if (toolSpecifiedSource) {
+    return ["-source", toolSpecifiedSource];
+  }
+  return (process.env.NUGET_SOURCES || "")
+    .split(",")
+    .reduce((acc, cur) => acc.concat(cur ? ["-source", cur] : []), []);
+}
+
+function generateNugetInstallArgsFor(toolSpec) {
+  // accept a tool package in the formats:
+  // packagename (eg 'nunit')
+  //  - retrieves the package according to the system config (original & default behavior)
+  // source/packagename (eg 'proget.mycompany.moo/nunit')
+  //  - retrieves the package from the named source (same as nuget.exe install nunit -source proget.mycompany.moo}
+  //  - allows consumer to be specific about where the package should come from
+  //  - allows third-parties to be specific about their packages being from, eg, nuget.org
+  var parts = toolSpec.split("/");
+  var toolPackage = parts.splice(parts.length - 1);
+  return ["install", toolPackage].concat(generateNugetSourcesOptions(parts[0]));
+}
+
+// gulp4 doesn't seem to protect against repeated dependencies, so this is a safeguard
+//  here to prevent accidental parallel install
+let
+  installingPromise = null,
+  installingRequest = null;
+module.exports = {
+  install: (requiredTools, overrideToolsFolder) => {
+    if (!requiredTools) {
+      throw new ZarroError("No required tools set");
+    }
+    if (!Array.isArray(requiredTools)) {
+      requiredTools = [requiredTools];
+    }
+    const target = overrideToolsFolder || getToolsFolder();
+    // TODO: should allow subsequent installations, ie if
+    //       a prior install asked for tools "A" and "B", a subsequent
+    //       request for "C" should just wait and then do the work
+    if (installingPromise) {
+      debug("default tools installer already running...");
+      const missing = requiredTools.reduce((acc, cur) => {
+        if (installingRequest.indexOf(cur) === -1) {
+          acc.push(cur);
+        }
+        return acc;
+      }, []);
+      if (missing.length) {
+        return Promist.reject("multiple tools installations are not (yet) supported");
+      }
+      return installingPromise;
+    }
+    installingRequest = requiredTools;
+    return installingPromise = ensureFolderExists(target)
+      .then(() => cleanFoldersFrom(target))
+      .then(() => downloadOrUpdateNuget(target))
+      .then(() =>
+        Promise.all(
+          requiredTools.map(tool => {
+            debug(`install: ${tool}`);
+            return nuget(
+              generateNugetInstallArgsFor(tool),
+              { cwd: target }
+            );
+          })
+        )
+      )
+      .then(() => {
+        debug("tool installation complete");
+      });
+  },
+  clean: overrideToolsFolder => {
+    debug("cleaning tools folder");
+    const target = overrideToolsFolder || getToolsFolder();
+    return cleanFoldersFrom(target);
+  }
+};