zarro 1.99.0 → 1.99.3

package/gulp-tasks/build.js

@@ -33,7 +33,8 @@ const myTasks = ["build"],
     "BUILD_EXCLUDE",
     "BUILD_ADDITIONAL_EXCLUDE",
     "BUILD_SHOW_INFO",
-    "BUILD_FAIL_ON_ERROR"
+    "BUILD_FAIL_ON_ERROR",
+    "BUILD_RETRIES"
   ];
 env.associate(myVars, myTasks);
 
@@ -41,20 +42,41 @@ gulp.task(
   "build",
   "Builds Visual Studio solutions in tree",
   ["prebuild"],
-  build
+  tryBuild
 );
 
-gulp.task("quick-build", "Quick build without pre-cursors", build);
+gulp.task("quick-build", "Quick build without pre-cursors", tryBuild);
+
+async function tryBuild() {
+  let attempts = env.resolveNumber("BUILD_RETRIES") + 1;
+  if (attempts < 0) {
+    attempts = 1;
+  }
+  const originalAttempts = attempts;
+
+  while (attempts-- > 0) {
+    try {
+      await build();
+    } catch (e) {
+      if (attempts > 0) {
+        console.error(chalk.red(`Build fails: ${e}`));
+        console.log(`Retrying (${originalAttempts - attempts} / ${originalAttempts})`);
+      } else {
+        throw e;
+      }
+    }
+  }
+}
 
 async function build() {
-  const slnMasks = resolveMasks("BUILD_INCLUDE", [ "BUILD_EXCLUDE", "BUILD_ADDITIONAL_EXCLUDE"]);
+  const slnMasks = resolveMasks("BUILD_INCLUDE", ["BUILD_EXCLUDE", "BUILD_ADDITIONAL_EXCLUDE"]);
   debug({
     slnMasks,
     cwd: process.cwd()
   });
   const solutions = gulp
     .src(slnMasks, { allowEmpty: true })
-    .pipe(throwIfNoFiles(`No solutions found matching masks: ${slnMasks}}`));
+    .pipe(throwIfNoFiles(`No solutions found matching masks: ${ slnMasks }}`));
 
   // TODO: find a reliable, quick way to determine if the projects to be compiled
   //       are all dotnet core -- trawling *.csproj is slow and has caused hangups

package/gulp-tasks/clean.js

@@ -1,37 +1,37 @@
-const gulp = requireModule("gulp"),
-  msbuild = require("gulp-msbuild"),
-  env = requireModule("env");
-
-const myVars = [
-  "BUILD_TOOLSVERSION",
-  "BUILD_CONFIGURATION",
-  "BUILD_VERBOSITY",
-  "BUILD_MAX_CPU_COUNT",
-  "BUILD_FAIL_ON_ERROR",
-  "BUILD_PLATFORM",
-  "BUILD_ARCHITECTURE",
-  "BUILD_MSBUILD_NODE_REUSE"
-];
-env.associate(myVars, "clean");
-
-gulp.task(
-  "clean",
-  "Invokes the 'Clean' target on all solutions in the tree",
-  function() {
-    return gulp.src("**/*.sln").pipe(
-      msbuild({
-        toolsVersion: env.resolve("BUILD_TOOLSVERSION"),
-        targets: ["Clean"],
-        configuration: env.resolve("BUILD_CONFIGURATION"),
-        stdout: true,
-        logCommand: true,
-        errorOnFail: env.resolveFlag("BUILD_FAIL_ON_ERROR"),
-        solutionPlatform: env.resolve("BUILD_PLATFORM"),
-        architecture: env.resolve("BUILD_ARCHITECTURE"),
-        verbosity: env.resolve("BUILD_VERBOSITY"),
-        nodeReuse: env.resolveFlag("BUILD_MSBUILD_NODE_REUSE"),
-        maxcpucount: env.resolveNumber("BUILD_MAX_CPU_COUNT")
-      })
-    );
-  }
-);
+const gulp = requireModule("gulp"),
+  msbuild = require("gulp-msbuild"),
+  env = requireModule("env");
+
+const myVars = [
+  "BUILD_TOOLSVERSION",
+  "BUILD_CONFIGURATION",
+  "BUILD_VERBOSITY",
+  "BUILD_MAX_CPU_COUNT",
+  "BUILD_FAIL_ON_ERROR",
+  "BUILD_PLATFORM",
+  "BUILD_ARCHITECTURE",
+  "BUILD_MSBUILD_NODE_REUSE"
+];
+env.associate(myVars, "clean");
+
+gulp.task(
+  "clean",
+  "Invokes the 'Clean' target on all solutions in the tree",
+  function() {
+    return gulp.src("**/*.sln").pipe(
+      msbuild({
+        toolsVersion: env.resolve("BUILD_TOOLSVERSION"),
+        targets: ["Clean"],
+        configuration: env.resolve("BUILD_CONFIGURATION"),
+        stdout: true,
+        logCommand: true,
+        errorOnFail: env.resolveFlag("BUILD_FAIL_ON_ERROR"),
+        solutionPlatform: env.resolve("BUILD_PLATFORM"),
+        architecture: env.resolve("BUILD_ARCHITECTURE"),
+        verbosity: env.resolve("BUILD_VERBOSITY"),
+        nodeReuse: env.resolveFlag("BUILD_MSBUILD_NODE_REUSE"),
+        maxcpucount: env.resolveNumber("BUILD_MAX_CPU_COUNT")
+      })
+    );
+  }
+);

package/gulp-tasks/cover-dotnet.js

@@ -1,56 +1,56 @@
-const gulp = requireModule("gulp"),
-  dotNetCover = requireModule("gulp-dotnetcover"),
-  resolveMasks = requireModule("resolve-masks"),
-  filter = require("gulp-filter"),
-  assemblyFilter = requireModule("net-framework-test-assembly-filter"),
-  env = requireModule("env");
-
-const myVars = [
-  "BUILD_CONFIGURATION",
-  "BUILD_PLATFORM",
-  "BUILD_ARCHITECTURE",
-  "BUILD_TARGETS",
-  "BUILD_TOOLSVERSION",
-  "BUILD_VERBOSITY",
-  "TEST_ARCHITECTURE",
-  "TEST_EXCLUDE",
-  "TEST_INCLUDE",
-  "COVERAGE_ADDITIONAL_EXCLUDE",
-  "COVERAGE_EXCLUDE"
-];
-env.associate(myVars, [ "cover-dotnet", "quick-cover-dotnet" ]);
-
-const help = "Runs .NET tests with OpenCover or DotCover";
-
-function cover() {
-  const
-    configuration = env.resolve("BUILD_CONFIGURATION"),
-    inputMasks = resolveMasks(
-      "TEST_INCLUDE",
-      "TEST_EXCLUDE"
-    ).map(
-      s => `${s}.dll`
-    ),
-    exclusions = env
-      .resolveArray("COVERAGE_EXCLUDE")
-      .concat(env.resolveArray("COVERAGE_ADDITIONAL_EXCLUDE")),
-    include = env
-      .resolveArray("COVERAGE_INCLUDE"),
-    exclude = exclusions.filter(e => include.indexOf(e) === -1);
-
-  return gulp
-    .src(inputMasks, { allowEmpty: true })
-    .pipe(filter(
-      assemblyFilter(configuration)
-    ))
-    .pipe(
-      dotNetCover({
-        debug: false,
-        architecture: env.resolve("TEST_ARCHITECTURE"),
-        exclude
-      })
-    );
-}
-
-gulp.task("cover-dotnet", help, [ "build" ], cover);
-gulp.task("quick-cover-dotnet", help, cover);
+const gulp = requireModule("gulp"),
+  dotNetCover = requireModule("gulp-dotnetcover"),
+  resolveMasks = requireModule("resolve-masks"),
+  filter = require("gulp-filter"),
+  assemblyFilter = requireModule("net-framework-test-assembly-filter"),
+  env = requireModule("env");
+
+const myVars = [
+  "BUILD_CONFIGURATION",
+  "BUILD_PLATFORM",
+  "BUILD_ARCHITECTURE",
+  "BUILD_TARGETS",
+  "BUILD_TOOLSVERSION",
+  "BUILD_VERBOSITY",
+  "TEST_ARCHITECTURE",
+  "TEST_EXCLUDE",
+  "TEST_INCLUDE",
+  "COVERAGE_ADDITIONAL_EXCLUDE",
+  "COVERAGE_EXCLUDE"
+];
+env.associate(myVars, [ "cover-dotnet", "quick-cover-dotnet" ]);
+
+const help = "Runs .NET tests with OpenCover or DotCover";
+
+function cover() {
+  const
+    configuration = env.resolve("BUILD_CONFIGURATION"),
+    inputMasks = resolveMasks(
+      "TEST_INCLUDE",
+      "TEST_EXCLUDE"
+    ).map(
+      s => `${s}.dll`
+    ),
+    exclusions = env
+      .resolveArray("COVERAGE_EXCLUDE")
+      .concat(env.resolveArray("COVERAGE_ADDITIONAL_EXCLUDE")),
+    include = env
+      .resolveArray("COVERAGE_INCLUDE"),
+    exclude = exclusions.filter(e => include.indexOf(e) === -1);
+
+  return gulp
+    .src(inputMasks, { allowEmpty: true })
+    .pipe(filter(
+      assemblyFilter(configuration)
+    ))
+    .pipe(
+      dotNetCover({
+        debug: false,
+        architecture: env.resolve("TEST_ARCHITECTURE"),
+        exclude
+      })
+    );
+}
+
+gulp.task("cover-dotnet", help, [ "build" ], cover);
+gulp.task("quick-cover-dotnet", help, cover);

package/gulp-tasks/dotnet-publish.js

@@ -1,24 +1,24 @@
-const
-  { publish } = require("gulp-dotnet-cli"),
-  env = requireModule("env"),
-  gulp = requireModule("gulp");
-
-gulp.task(
-  "dotnet-publish",
-  "Performs `dotnet publish` on all non-test projects in the tree",
-  () => {
-    const publishOpts = {
-      configuration: env.resolve("DOTNET_PUBLISH_BUILD_CONFIGURATION", "BUILD_CONFIGURATION"),
-      runtime: env.resolve("DOTNET_PUBLISH_RUNTIMES"),
-      output: env.resolve("OUTPUT"),
-    };
-
-    const testInclusionsInverted = env.resolveArray("TEST_INCLUDE")
-      .map(p => `!${p}.csproj`);
-    return gulp
-      .src(["**/*.csproj"].concat(testInclusionsInverted))
-      .pipe(
-        publish(publishOpts)
-      );
-  }
-);
+const
+  { publish } = require("gulp-dotnet-cli"),
+  env = requireModule("env"),
+  gulp = requireModule("gulp");
+
+gulp.task(
+  "dotnet-publish",
+  "Performs `dotnet publish` on all non-test projects in the tree",
+  () => {
+    const publishOpts = {
+      configuration: env.resolve("DOTNET_PUBLISH_BUILD_CONFIGURATION", "BUILD_CONFIGURATION"),
+      runtime: env.resolve("DOTNET_PUBLISH_RUNTIMES"),
+      output: env.resolve("OUTPUT"),
+    };
+
+    const testInclusionsInverted = env.resolveArray("TEST_INCLUDE")
+      .map(p => `!${p}.csproj`);
+    return gulp
+      .src(["**/*.csproj"].concat(testInclusionsInverted))
+      .pipe(
+        publish(publishOpts)
+      );
+  }
+);

package/gulp-tasks/git-submodules.js

@@ -1,83 +1,83 @@
-const spawn = requireModule("spawn"),
-  gulp = requireModule("gulp"),
-  log = requireModule("log"),
-  fs = requireModule("fs"),
-  subModulesFile = ".gitmodules";
-
-gulp.task('git-submodules', 'Updates (with --init) all submodules in tree', function () {
-  return spawn('git', ['submodule', 'update', '--init', '--recursive']);
-});
-
-gulp.task('git-submodules-as-externals', function () {
-  return new Promise((resolve, reject) => {
-  if (!fs.existsSync(subModulesFile)) {
-    log.notice('no submodules file found');
-    return resolve();
-  } else {
-    log.notice('performing submodule init/update...');
-    spawn('git', ['submodule', 'update', '--init', '--recursive']).then(function () {
-      log.info('getting list of local submodules...');
-      return fs.readFile(subModulesFile);
-    }).then(function (buffer) {
-      log.info('grokking paths of local submodules...');
-      const fileContents = buffer.toString();
-      const lines = fileContents.split("\n");
-      const submodulePaths = lines.reduce(function (acc, cur) {
-        const parts = cur.split(" = ").map(function (item) {
-          return item.trim();
-        });
-        if (parts.length > 1 && parts[0] === "path") {
-          acc.push(parts[1]);
-        }
-        return acc;
-      }, []);
-      return submodulePaths;
-    }).then(function (modulePaths) {
-      const mkdir = function (path) {
-        const parts = path.split("/");
-        let current = "";
-        parts.forEach(function (part) {
-          current += current ? "/" : "";
-          current += part;
-          if (!fs.existsSync(current)) {
-            fs.mkdirSync(current);
-          }
-        });
-      };
-      modulePaths.forEach(function (path) {
-        mkdir(path);
-      });
-      return modulePaths;
-    }).then(function (modulePaths) {
-      log.info('making sure local submodules are up to date...');
-      const innerDeferred = q.defer();
-      const spawnOptions = {
-        stdio: [ process.stdin, process.stdout, process.stderr, "pipe" ]
-      };
-      const finalPromise = modulePaths.reduce(function (acc, cur) {
-        const workingFolder = [ process.cwd(), cur ].join("/");
-        log.info("working with submodule at: " + cur);
-        spawnOptions.cwd = workingFolder;
-        return acc.then(function () {
-          log.debug(" - fetch changes");
-          return spawn("git", [ "fetch" ], spawnOptions).then(function () {
-            log.debug(" - switch to master");
-            return spawn("git", [ "checkout", "master" ], spawnOptions);
-          }).then(function () {
-            log.debug(" - fast-forward to HEAD");
-            return spawn("git", [ "rebase" ], spawnOptions);
-          });
-        });
-      }, innerDeferred.promise);
-      innerDeferred.resolve();
-      return finalPromise;
-    }).then(function () {
-      log.info('git submodule magick complete');
-      resolve();
-    }).catch(function (err) {
-      reject(err);
-    });
-  }
-  });
-});
-
+const spawn = requireModule("spawn"),
+  gulp = requireModule("gulp"),
+  log = requireModule("log"),
+  fs = requireModule("fs"),
+  subModulesFile = ".gitmodules";
+
+gulp.task('git-submodules', 'Updates (with --init) all submodules in tree', function () {
+  return spawn('git', ['submodule', 'update', '--init', '--recursive']);
+});
+
+gulp.task('git-submodules-as-externals', function () {
+  return new Promise((resolve, reject) => {
+  if (!fs.existsSync(subModulesFile)) {
+    log.notice('no submodules file found');
+    return resolve();
+  } else {
+    log.notice('performing submodule init/update...');
+    spawn('git', ['submodule', 'update', '--init', '--recursive']).then(function () {
+      log.info('getting list of local submodules...');
+      return fs.readFile(subModulesFile);
+    }).then(function (buffer) {
+      log.info('grokking paths of local submodules...');
+      const fileContents = buffer.toString();
+      const lines = fileContents.split("\n");
+      const submodulePaths = lines.reduce(function (acc, cur) {
+        const parts = cur.split(" = ").map(function (item) {
+          return item.trim();
+        });
+        if (parts.length > 1 && parts[0] === "path") {
+          acc.push(parts[1]);
+        }
+        return acc;
+      }, []);
+      return submodulePaths;
+    }).then(function (modulePaths) {
+      const mkdir = function (path) {
+        const parts = path.split("/");
+        let current = "";
+        parts.forEach(function (part) {
+          current += current ? "/" : "";
+          current += part;
+          if (!fs.existsSync(current)) {
+            fs.mkdirSync(current);
+          }
+        });
+      };
+      modulePaths.forEach(function (path) {
+        mkdir(path);
+      });
+      return modulePaths;
+    }).then(function (modulePaths) {
+      log.info('making sure local submodules are up to date...');
+      const innerDeferred = q.defer();
+      const spawnOptions = {
+        stdio: [ process.stdin, process.stdout, process.stderr, "pipe" ]
+      };
+      const finalPromise = modulePaths.reduce(function (acc, cur) {
+        const workingFolder = [ process.cwd(), cur ].join("/");
+        log.info("working with submodule at: " + cur);
+        spawnOptions.cwd = workingFolder;
+        return acc.then(function () {
+          log.debug(" - fetch changes");
+          return spawn("git", [ "fetch" ], spawnOptions).then(function () {
+            log.debug(" - switch to master");
+            return spawn("git", [ "checkout", "master" ], spawnOptions);
+          }).then(function () {
+            log.debug(" - fast-forward to HEAD");
+            return spawn("git", [ "rebase" ], spawnOptions);
+          });
+        });
+      }, innerDeferred.promise);
+      innerDeferred.resolve();
+      return finalPromise;
+    }).then(function () {
+      log.info('git submodule magick complete');
+      resolve();
+    }).catch(function (err) {
+      reject(err);
+    });
+  }
+  });
+});
+

package/gulp-tasks/modules/ask.ts

@@ -1,41 +1,41 @@
-(function() {
-  const
-    readline = require("readline");
-
-  interface AskOptions {
-    inputStream: NodeJS.ReadStream,
-    outputStream: NodeJS.WriteStream,
-    done: ((data: string) => boolean)
-  }
-
-  const defaultOptions: AskOptions = {
-    inputStream: process.stdin,
-    outputStream: process.stdout,
-    done: (s: string) => true // grab only the first line
-  };
-
-  async function ask(message: string, opts?: AskOptions): Promise<string> {
-    opts = Object.assign({}, defaultOptions, opts || {});
-    const { done } = opts;
-    const rl = readline.createInterface({
-      input: opts.inputStream,
-      output: opts.outputStream
-    });
-
-    const lines: string[] = [];
-    return new Promise((resolve, reject) => {
-      rl.question(message, (line: string) => {
-        lines.push(line);
-        const all = lines.join("\n");
-        if (done(all)) {
-          rl.close();
-          resolve(all);
-        }
-      });
-    });
-  }
-
-  module.exports = {
-    ask
-  }
-})();
+(function() {
+  const
+    readline = require("readline");
+
+  interface AskOptions {
+    inputStream: NodeJS.ReadStream,
+    outputStream: NodeJS.WriteStream,
+    done: ((data: string) => boolean)
+  }
+
+  const defaultOptions: AskOptions = {
+    inputStream: process.stdin,
+    outputStream: process.stdout,
+    done: (s: string) => true // grab only the first line
+  };
+
+  async function ask(message: string, opts?: AskOptions): Promise<string> {
+    opts = Object.assign({}, defaultOptions, opts || {});
+    const { done } = opts;
+    const rl = readline.createInterface({
+      input: opts.inputStream,
+      output: opts.outputStream
+    });
+
+    const lines: string[] = [];
+    return new Promise((resolve, reject) => {
+      rl.question(message, (line: string) => {
+        lines.push(line);
+        const all = lines.join("\n");
+        if (done(all)) {
+          rl.close();
+          resolve(all);
+        }
+      });
+    });
+  }
+
+  module.exports = {
+    ask
+  }
+})();