zarro 1.92.0

package/gulp-tasks/start/_package.json

@@ -0,0 +1,39 @@
+{
+  "name": "this-is-used-as-a-reference-for-dev-dependencies-only-disregarding-versions",
+  "devDependencies": {
+    "ansi-colors": "^4.0.1",
+    "chai": "^4.2.0",
+    "chalk": "^2.4.2",
+    "cross-env": "^5.2.0",
+    "debug": "^4.1.1",
+    "del": "^4.1.1",
+    "event-stream": "^4.0.1",
+    "fancy-log": "^1.3.3",
+    "gulp": "^4.0.2",
+    "gulp-debug": "^4.0.0",
+    "gulp-dotnet-cli": "^1.1.0",
+    "gulp-edit-xml": "https://github.com/fluffynuts/gulp-edit-xml.git#pass-file-to-transform",
+    "gulp-filter": "^6.0.0",
+    "gulp-help": "^1.6.1",
+    "gulp-msbuild": "^0.5.5",
+    "gulp-nunit-runner": "^1.2.3",
+    "inquirer": "^6.4.1",
+    "mkdirp": "^0.5.1",
+    "nodemon": "^1.19.1",
+    "npm-run-all": "^4.1.5",
+    "plugin-error": "^1.0.1",
+    "proxyquire": "^2.1.0",
+    "q": "^1.5.1",
+    "readline": "^1.3.0",
+    "request": "^2.88.0",
+    "require-dir": "^1.2.0",
+    "requirejs": "^2.3.6",
+    "run-sequence": "^2.2.1",
+    "simple-git": "^1.116.0",
+    "temp": "^0.9.0",
+    "through2": "^3.0.1",
+    "undertaker-forward-reference": "^1.0.2",
+    "which": "^1.3.1",
+    "xml2js": "^0.4.19"
+  }
+}

package/gulp-tasks/start/gulpfile.js

@@ -0,0 +1,204 @@
+/*
+  Welcome new user!
+
+  To get started, copy this gulpfile.js to the root of your repo and run:
+  `node gulpfile.js`
+  You should be guided through the basic setup. More information in README.md. In
+  particular, I highly recommend reading about how to use `local-tasks` to extend
+  and / or override the default task-set.
+ */
+
+const
+  path = require("path"),
+  fs = require("fs");
+
+function tryFindGulpTasks() {
+  const attempts = [
+    path.join(__dirname, "gulp-tasks"),
+    path.join(__dirname, "..", "..", "gulp-tasks")
+  ];
+  for (let attempt of attempts) {
+    try {
+      const st = fs.statSync(attempt);
+      if (st && st.isDirectory()) {
+        return attempt;
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+  throw new Error("Can't automagically find gulp-tasks folder; try defining GULP_TASKS_FOLDER env var");
+}
+
+const
+  gulpTasksFolder = process.env.GULP_TASKS_FOLDER || tryFindGulpTasks(),
+  requireModule = require(path.join(gulpTasksFolder, "modules", "require-module"));
+
+if (!fs.existsSync(gulpTasksFolder)) {
+  console.error("Either clone `gulp-tasks` to the `gulp-tasks` folder or modify this script to avoid sadness");
+  process.exit(2);
+}
+
+let autoWorking = null;
+
+function pauseWhilstWorking() {
+  const
+    args = process.argv,
+    lastTwo = args.slice(args.length - 2),
+    runningGulp = isGulpJs(lastTwo[0]),
+    task = lastTwo[1];
+  if (!runningGulp || !task) {
+    return;
+  }
+  autoWorking = true;
+  try {
+    const localGulp = require("gulp");
+    localGulp.task(task, function () {
+      console.log(`--- taking over your ${task} task whilst we do some bootstrapping ---`);
+      return new Promise(function watchWorker(resolve, reject) {
+        if (!autoWorking) {
+          return resolve();
+        }
+        setTimeout(function () {
+          watchWorker(resolve, reject);
+        }, 500);
+      });
+    });
+  } catch (e) {
+    /* suppress: may not have deps installed yet */
+  }
+}
+
+function isGulpJs(filePath) {
+  return path.basename(filePath) === "gulp.js";
+}
+
+if (!fs.existsSync("package.json")) {
+  pauseWhilstWorking();
+  console.log(
+    "You need to set up a package.json first. I'll run `npm init` for you (:"
+  );
+  initializeNpm().then(() => autoWorking = false);
+} else if (mustInstallDeps()) {
+  pauseWhilstWorking();
+  console.log(
+    "Now we just need to install the dependencies required for gulp-tasks to run (:"
+  );
+  installGulpTaskDependencies().then(() => {
+    console.log("You're good to go with `gulp-tasks`. Try running `npm run gulp build`");
+    autoWorking = false;
+  });
+} else {
+  bootstrapGulp();
+}
+
+function requiredDeps() {
+  const starter = require(path.join(gulpTasksFolder, "start", "package.json"));
+  return Object.keys(starter.devDependencies);
+}
+
+function mustInstallDeps() {
+  if (process.env.RUNNING_AS_ZARRO) {
+    // deps should be properly handled by zarro package index and initial installation
+    return false;
+  }
+  const package = require("./package.json"),
+    devDeps = package.devDependencies || {},
+    haveDeps = Object.keys(devDeps),
+    needDeps = requiredDeps();
+  const result = needDeps.reduce((acc, cur) => {
+    return acc || haveDeps.indexOf(cur) == -1;
+  }, false);
+  return result;
+}
+
+function initializeNpm() {
+  const spawn = requireModule("spawn");
+  const os = require("os");
+  return runNpmWith([ "init" ])
+    .then(() => {
+      if (os.platform() === "win32") {
+        spawn("cmd", [ "/c", "node", process.argv[1] ]);
+      } else {
+        spawn("node", [ process.argv[1] ]);
+      }
+    });
+}
+
+function addMissingScript(package, name, script) {
+  package.scripts[name] = package.scripts[name] || script;
+}
+
+function installGulpTaskDependencies() {
+  const findFirstMissing = function () {
+      const args = Array.from(arguments);
+      return args.reduce((acc, cur) => acc || (fs.existsSync(cur) ? acc : cur), undefined);
+    },
+    deps = requiredDeps(),
+    package = require("./package.json"),
+    buildTools = findFirstMissing("tools", "build-tools", ".tools", ".build-tools"),
+    prepend = `cross-env BUILD_TOOLS_FOLDER=${buildTools}`;
+
+  addMissingScript(package, "gulp", `${prepend} gulp`);
+  addMissingScript(package, "test", "run-s \"gulp test-dotnet\"");
+
+  fs.writeFileSync("package.json", JSON.stringify(package, null, 4), { encoding: "utf8" });
+  return runNpmWith([ "install", "--save-dev" ].concat(deps));
+}
+
+function bootstrapGulp() {
+  const importNpmTasks = requireModule("import-npm-tasks");
+  try {
+    importNpmTasks();
+    const requireDir = require("require-dir");
+    requireDir(gulpTasksFolder);
+    [ "local-tasks", "override-tasks" ].forEach(function (dirname) {
+      const fullPath = path.join(process.cwd(), dirname);
+      if (fs.existsSync(fullPath)) {
+        requireDir(fullPath);
+      }
+    });
+  } catch (e) {
+    if (shouldDump(e)) {
+      console.error(e);
+    } else {
+      if (!process.env.DEBUG) {
+        console.log(
+          "Error occurred. For more info, set the DEBUG environment variable (eg set DEBUG=*)."
+        );
+      }
+    }
+    process.exit(1);
+  }
+
+  function shouldDump(e) {
+    return isZarroError(e) ||
+      process.env.ALWAYS_DUMP_GULP_ERRORS ||
+      process.env.DEBUG === "*" ||
+      probablyNotReportedByGulp(e);
+  }
+
+  function isZarroError(e) {
+    return e && e.constructor.name === "ZarroError";
+  }
+
+  function probablyNotReportedByGulp(e) {
+    const
+      message = (e || "").toString().toLowerCase();
+    return [ "cannot find module", "referenceerror", "syntaxerror" ].reduce(
+      (acc, cur) => {
+        return acc || message.indexOf(cur) > -1;
+      },
+      false
+    );
+  }
+}
+
+function runNpmWith(args) {
+  const spawn = requireModule("spawn");
+  const os = require("os");
+
+  return os.platform() === "win32"
+    ? spawn("cmd", [ "/c", "npm" ].concat(args))
+    : spawn("npm", args);
+}

package/gulp-tasks/start/update-starter-packages.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+const
+	path = require("path"),
+	fs = require("fs"),
+	ioOpts = {
+		encoding: "utf-8"
+	},
+	log = function() {
+		try {
+			console.log.apply(console, Array.from(arguments));
+			return true;
+		} catch (e) {
+			return false;
+		}
+	},
+	srcFile = "package.json",
+	srcPath = path.join(path.dirname(__dirname), srcFile),
+	targetPath = path.join(__dirname, "start", srcFile),
+	readJson = function (p) {
+		return JSON.parse(fs.readFileSync(p, ioOpts.encoding));
+	},
+	srcConfig = readJson(srcPath),
+	targetConfig = readJson(targetPath),
+	updateKeys = function (src, target) {
+    let updated = 0;
+    Object.keys(src).forEach(k => {
+			if (!target[k] || target[k] === src[k]) {
+				return;
+			}
+			log(`${k}: ${target[k]} -> ${src[k]}`);
+			target[k] = src[k];
+			updated++;
+		});
+		return updated;
+	},
+	updateConfigSection = function (srcConfig, targetConfig, section) {
+		const
+			srcSection = srcConfig[section] || {},
+			targetSection = targetConfig[section] || {};
+		return updateKeys(srcSection, targetSection);
+	},
+	updated = ["dependencies", "devDependencies"]
+						.reduce((acc, cur) => acc += updateConfigSection(srcConfig, targetConfig, cur), 0),
+	prettyJson = function(data) {
+		return JSON.stringify(data, null, 2);
+	},
+	rewrite = function(updated, filePath, data) {
+		try {
+			fs.writeFileSync(filePath, prettyJson(data), ioOpts);
+			return { success: true };
+		} catch (e) {
+			return { success: false, error: e };
+		}
+	},
+	status = updated
+						? rewrite(updated, targetPath, targetConfig)
+						: { success: true, error: "No dependencies to update" },
+	logged = log(
+					status.success
+					? status.error || `Updated ${updated} dependency versions`
+					: status.error
+	);
+process.exit(logged && status.success ? 0 : 1);

package/gulp-tasks/test-dotnet.js

@@ -0,0 +1,195 @@
+const
+  seed = requireModule("seed"),
+  gulp = requireModule("gulp"),
+  log = requireModule("log"),
+  path = require("path"),
+  gulpDebug = require("gulp-debug"),
+  debug = require("debug")("test-dotnet"),
+  filter = require("gulp-filter"),
+  fs = require("fs"),
+  promisifyStream = requireModule("promisify"),
+  { test } = require("gulp-dotnet-cli"),
+  nunit = require("./modules/gulp-nunit-runner"),
+  testUtilFinder = requireModule("testutil-finder"),
+  env = requireModule("env"),
+  resolveTestMasks = requireModule("resolve-test-masks"),
+  logConfig = requireModule("log-config"),
+  gatherPaths = requireModule("gather-paths"),
+  netFrameworkTestAssemblyFilter = requireModule("net-framework-test-assembly-filter");
+
+gulp.task(
+  "test-dotnet",
+  `Runs all tests in your solution via NUnit *`,
+  [ "build" ],
+  runTests
+);
+
+gulp.task(
+  "quick-test-dotnet",
+  `Tests whatever test assemblies have been recently built *`,
+  runTests
+);
+
+const myTasks = [ "test-dotnet", "quick-test-dotnet" ],
+  myVars = [
+    "BUILD_CONFIGURATION",
+    "DOTNET_CORE",
+    "TEST_INCLUDE",
+    "TEST_EXCLUDE",
+    "MAX_NUNIT_AGENTS",
+    "MAX_CONCURRENCY",
+    "BUILD_REPORT_XML",
+    "NUNIT_ARCHITECTURE",
+    "NUNIT_LABELS",
+    "TEST_VERBOSITY",
+    "DOTNET_TEST_PARALLEL"
+  ];
+env.associate(myVars, myTasks);
+
+async function runTests() {
+  const buildReportFolder = path.dirname(env.resolve("BUILD_REPORT_XML"));
+  if (!fs.existsSync(buildReportFolder)) {
+    fs.mkdirSync(buildReportFolder);
+  }
+
+  const dotNetCore = env.resolveFlag("DOTNET_CORE");
+  const testMasks = resolveTestMasks(dotNetCore),
+    configuration = env.resolve("BUILD_CONFIGURATION"),
+    tester = dotNetCore ? testAsDotnetCore : testWithNunitCli;
+
+  debug({
+    tester,
+    configuration,
+    testMasks
+  });
+  return tester(configuration, testMasks);
+}
+
+function consolidatePathEnvVar() {
+  const keys = Object.keys(process.env)
+    .filter(k => k.toLowerCase() === "path");
+  if (keys.length === 1) {
+    return;
+  }
+  const sep = process.platform === "win32"
+    ? ";"
+    : ":";
+  const include = [];
+  keys.forEach(k => {
+    const parts = process.env[k].split(sep);
+    parts.forEach(p => {
+      if (include.indexOf(p) === -1) {
+        include.push(p);
+      }
+    });
+  });
+  keys.forEach(k => process.env[k] = "");
+  process.env.PATH = include.join(sep);
+}
+
+function testWithNunitCli(configuration, source) {
+  consolidatePathEnvVar();
+  const agents = env.resolveNumber("MAX_NUNIT_AGENTS");
+  const seenAssemblies = [];
+  const config = {
+    executable: testUtilFinder.latestNUnit({
+      architecture: env.resolve("NUNIT_ARCHITECTURE")
+    }),
+    options: {
+      result: env.resolve("BUILD_REPORT_XML"),
+      agents: agents,
+      labels: env.resolve("NUNIT_LABELS"),
+    }
+  };
+  const nunitProcess = env.resolve("NUNIT_PROCESS");
+  const logInfo = {
+    result: "Where to store test result (xml file)",
+    labels: "What labels NUnit should display as tests run",
+    agents: "How many NUnit agents to run"
+  }
+  if (nunitProcess !== "auto") {
+    config.options.process = nunitProcess;
+    logInfo.process = "Process model for NUnit";
+  }
+  log.info(`Using NUnit runner at ${config.executable}`);
+  log.info("Find files:", source);
+  logConfig(config.options, logInfo);
+  debug({
+    config
+  });
+  return promisifyStream(
+    gulp
+      .src(source, {
+        read: false
+      })
+      .pipe(
+        filter(netFrameworkTestAssemblyFilter(configuration))
+      )
+      .pipe(gulpDebug({ title: "before filter", logger: debug }))
+      .pipe(filter(file => isDistinctFile(file.path, seenAssemblies)))
+      .pipe(gulpDebug({ title: "after filter", logger: debug }))
+      .pipe(nunit(config))
+  );
+}
+
+function makeTestsPromise(
+  projectPaths,
+  configuration
+) {
+  if (!Array.isArray(projectPaths)) {
+    projectPaths = [ projectPaths ];
+  }
+  return promisifyStream(
+    gulp.src(projectPaths).pipe(
+      test({
+        verbosity: env.resolve("TEST_VERBOSITY"),
+        configuration,
+        noBuild: true
+      })
+    )
+  );
+}
+
+
+async function testAsDotnetCore(configuration, testProjects) {
+  // TODO: collect all projects in an array and then
+  //  run test projects in parallel, throttled by MAX_CONCURRENCY
+  if (env.resolveFlag("DOTNET_TEST_PARALLEL")) {
+    const
+      testProjectPaths = await gatherPaths(testProjects),
+      concurrency = env.resolveNumber("MAX_CONCURRENCY"),
+      chains = seed(concurrency).map(() => Promise.resolve());
+    let p, current = 0;
+    while (p = testProjectPaths.shift()) {
+      p = p.replace(/\\/g, "/");
+      console.log("add test run:", p);
+      const
+        idx = current++ % concurrency,
+        localP = p;
+      chains[idx] = chains[idx].then(() => {
+        console.log(`${idx}  start test run: ${localP}`);
+        return makeTestsPromise(localP, configuration);
+      });
+    }
+    return Promise.all(chains);
+  } else {
+    return promisifyStream(
+      gulp.src(testProjects).pipe(
+        test({
+          verbosity: env.resolve("TEST_VERBOSITY"),
+          configuration,
+          noBuild: true
+        })
+      )
+    );
+  }
+}
+
+function isDistinctFile(filePath, seenFiles) {
+  const basename = path.basename(filePath),
+    result = seenFiles.indexOf(basename) === -1;
+  if (result) {
+    seenFiles.push(basename);
+  }
+  return result;
+}