zarro 1.92.0

package/gulp-tasks/build.js

@@ -0,0 +1,135 @@
+const
+  chalk = require("ansi-colors"),
+  os = require("os"),
+  env = requireModule("env"),
+  gulp = requireModule("gulp"),
+  debug = require("debug")("build"),
+  promisifyStream = requireModule("promisify"),
+  dotnetCli = require("gulp-dotnet-cli"),
+  dotnetClean = dotnetCli.clean,
+  dotnetBuild = dotnetCli.build,
+  throwIfNoFiles = requireModule("throw-if-no-files"),
+  xbuild = requireModule("gulp-xbuild"),
+  gutil = requireModule("gulp-util"),
+  log = requireModule("log"),
+  resolveMasks = requireModule("resolve-masks"),
+  logConfig = requireModule("log-config"),
+  msbuild = require("gulp-msbuild");
+
+gulp.task("prebuild", ["nuget-restore"]);
+
+const myTasks = ["build"],
+  myVars = [
+    "BUILD_CONFIGURATION",
+    "BUILD_PLATFORM",
+    "BUILD_ARCHITECTURE",
+    "BUILD_TARGETS",
+    "BUILD_TOOLSVERSION",
+    "BUILD_VERBOSITY",
+    "BUILD_MSBUILD_NODE_REUSE",
+    "BUILD_MAX_CPU_COUNT",
+    "MAX_CONCURRENCY",
+    "BUILD_INCLUDE",
+    "BUILD_EXCLUDE",
+    "BUILD_ADDITIONAL_EXCLUDE",
+    "BUILD_SHOW_INFO",
+    "BUILD_FAIL_ON_ERROR"
+  ];
+env.associate(myVars, myTasks);
+
+gulp.task(
+  "build",
+  "Builds Visual Studio solutions in tree",
+  ["prebuild"],
+  build
+);
+
+gulp.task("quick-build", "Quick build without pre-cursors", build);
+
+async function build() {
+  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}}`));
+
+  // 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
+  //       here, so for now, DNC build must be requested via env DONET_CORE
+  return env.resolveFlag("DOTNET_CORE")
+    ? buildForNetCore(solutions)
+    : buildForNETFramework(solutions);
+}
+
+function buildForNetCore(solutions) {
+  log.info(gutil.colors.yellow("Building with dotnet core"));
+  const
+    configuration = env.resolve("BUILD_CONFIGURATION"),
+    msbuildArgs = [];
+  if (!env.resolveFlag("BUILD_MSBUILD_NODE_REUSE")) {
+    msbuildArgs.push("/nodeReuse:false")
+  }
+  return promisifyStream(
+    solutions
+      .pipe(
+        dotnetClean({
+          configuration
+        })
+      )
+      .pipe(
+        dotnetBuild({
+          verbosity: env.resolve("BUILD_VERBOSITY"),
+          configuration,
+          // msbuild attempts to re-use nodes, which causes issues
+          // if you're building unrelated projects on the same machine with,
+          // eg, different versions of Microsoft.Net.Compilers
+          msbuildArgs,
+          echo: true
+        })
+      )
+  );
+}
+
+function buildForNETFramework(solutions) {
+  log.info(chalk.yellowBright("Building with MsBuild"));
+  return promisifyStream(buildAsStream(solutions));
+}
+
+function buildAsStream(solutions) {
+  const builder = os.platform() === "win32" ? msbuild : xbuild;
+  const config = {
+    toolsVersion: env.resolve("BUILD_TOOLSVERSION"),
+    targets: env.resolveArray("BUILD_TARGETS"),
+    configuration: env.resolve("BUILD_CONFIGURATION"),
+    stdout: true,
+    verbosity: env.resolve("BUILD_VERBOSITY"),
+    errorOnFail: env.resolveFlag("BUILD_FAIL_ON_ERROR"),
+    solutionPlatform: env.resolve("BUILD_PLATFORM"),
+    // NB: this is the MSBUILD architecture, NOT your desired output architecture
+    architecture: env.resolve("BUILD_ARCHITECTURE"),
+    nologo: false,
+    logCommand: true,
+    nodeReuse: env.resolveFlag("BUILD_MSBUILD_NODE_REUSE"),
+    maxcpucount: env.resolveNumber("BUILD_MAX_CPU_COUNT")
+  };
+
+  if (env.resolveFlag("BUILD_SHOW_INFO")) {
+    logConfig(config, {
+      toolsVersion: "Tools version",
+      targets: "Build targets",
+      configuration: "Build configuration",
+      stdout: "Log to stdout",
+      verbosity: "Build verbosity",
+      errorOnFail: "Any error fails the build",
+      solutionPlatform: "Build platform",
+      architecture: "Build architecture",
+      nodeReuse: "Re-use MSBUILD nodes",
+      maxcpucount: "Max CPUs to use for build",
+    });
+  }
+  return solutions
+    .pipe(builder(config));
+}

package/gulp-tasks/clean.js

@@ -0,0 +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_ERROR_ON_FAIL",
+  "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_ERROR_ON_FAIL"),
+        solutionPlatfor: 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

@@ -0,0 +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);

package/gulp-tasks/default-report-generator.js

@@ -0,0 +1,51 @@
+const gulp = requireModule("gulp"),
+  path = require("path"),
+  findTool = requireModule("testutil-finder").findTool,
+  spawn = requireModule("spawn"),
+  fs = requireModule("fs"),
+  quoteIfRequired = requireModule("quote-if-required"),
+  del = require("del"),
+  env = requireModule("env");
+
+env.associate(["COVERAGE_XML", "COVERAGE_REPORTING_EXCLUDE"], "cover-dotnet");
+
+gulp.task(
+  "default-report-generator",
+  `Generates HTML reports from existing coverage XML reports`,
+  () => {
+    const reportGenerator = findTool("ReportGenerator.exe");
+    if (!reportGenerator) {
+      return Promise.reject("No ReportGenerator.exe found in tools folder");
+    }
+    const coverageXml = env.resolve("COVERAGE_XML");
+    if (!fs.existsSync(coverageXml)) {
+      return Promise.reject(`Can't find ${coverageXml}`);
+    }
+
+    var inclusions = env.resolveArray("COVERAGE_INCLUDE");
+    const exclusions = env
+      .resolveArray("COVERAGE_EXCLUDE")
+      .concat(env.resolveArray("COVERAGE_ADDITIONAL_EXCLUDE"))
+      .filter(e => inclusions.indexOf(e) === -1);
+    const
+      coverageExclude = exclusions.map(e => `-${e}`).join(";"),
+      coverageInclude = inclusions.map(e => `+${e}`).join(";"),
+      assemblyfilters = `${coverageInclude};${coverageExclude}`;
+
+
+    return spawn(reportGenerator, [
+      `-reports:${quoteIfRequired(coverageXml)}`,
+      `-targetdir:${quoteIfRequired(path.join("buildreports", "coverage"))}`,
+      `"-assemblyfilters:${assemblyfilters}"`
+    ]);
+  }
+);
+
+gulp.task("clean-reports", `Cleans out the build reports folder`, async () => {
+  const buildReportsFolder = path.dirname(env.resolve("COVERAGE_XML")),
+    exists = await fs.exists(buildReportsFolder);
+  if (exists) {
+    await del(buildReportsFolder);
+  }
+  await fs.mkdir(buildReportsFolder);
+});

package/gulp-tasks/default-tools-installer.js

@@ -0,0 +1,33 @@
+const debug = require("debug")("default-tools-installer"),
+  gulp = requireModule("gulp"),
+  nugetSourceName = process.env.NUGET_SOURCE || "nuget.org",
+  installLocalTools = requireModule("install-local-tools"),
+  env = requireModule("env"),
+  tools = [
+    `${nugetSourceName}/nunit.console`,
+    `${nugetSourceName}/opencover`,
+    `${nugetSourceName}/Jetbrains.dotCover.CommandLineTools`,
+    `${nugetSourceName}/reportgenerator`
+  ];
+
+env.associate("default-tools-installer", [ "BUILD_TOOLS_FOLDER", "DOTNET_CORE" ]);
+
+gulp.task(
+  "default-tools-installer",
+  `Installs the default toolset: ${tools.join(", ")}`,
+  () => {
+    if (env.resolveFlag("DOTNET_CORE")) {
+      debug("not invoked for dotnet core builds");
+      return Promise.resolve();
+    }
+    return installLocalTools.install(tools);
+  }
+);
+
+gulp.task(
+  "clean-tools-folder",
+  "Cleans out folders under the tools folder (will always be done as part of tool installation)",
+  () => {
+    return installLocalTools.clean();
+  }
+);

package/gulp-tasks/default.js

@@ -0,0 +1,17 @@
+var gulp = requireModule("gulp"),
+  gutil = requireModule("gulp-util"),
+  runSequence = requireModule("run-sequence");
+
+gulp.task("default", "Purges, updates git submodules, builds, covers dotnet", function () {
+  runSequence("purge", "build", "cover-dotnet", "generate-reports", function (err) {
+    return new Promise(function (resolve, reject) {
+      if (err) {
+        gutil.log(gutil.colors.red(gutil.colors.bold(err)));
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
+});
+

package/gulp-tasks/dotnet-publish.js

@@ -0,0 +1,23 @@
+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/generate-reports.js

@@ -0,0 +1,7 @@
+var gulp = requireModule("gulp");
+
+gulp.task(
+"generate-reports",
+"runs 'default-report-generator'",
+[ "default-report-generator" ],
+done => done());

package/gulp-tasks/get-local-nuget.js

@@ -0,0 +1,16 @@
+const
+  gulp = requireModule("gulp"),
+  downloadNuget = requireModule("download-nuget"),
+  env = requireModule("env"),
+  path = require("path"),
+  configGenerator = requireModule("config-generator");
+
+env.associate("BUILD_TOOLS_FOLDER", "get-local-nuget");
+
+gulp.task(
+  "get-local-nuget",
+  "Attempts to download the latest nuget.exe to the build tooling folder", () => {
+    const config = configGenerator();
+    return downloadNuget(path.dirname(config.localNuget))
+      .then(() => console.log("get-local-nuget completes"));
+});

package/gulp-tasks/git-submodules.js

@@ -0,0 +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);
+    });
+  }
+  });
+});
+