zarro 1.92.0

package/gulp-tasks/modules/gulp-npm-run.ts

@@ -0,0 +1,52 @@
+(function() {
+  // replaces the gulp-npm-run node module
+  // which relies on ramda -- that keeps on having
+  // breaking changes released. NO MORE.
+  const
+    { readFileSync } = require("fs"),
+    debug = require("debug")("gulp-npm-run"),
+    exec = require("./exec") as Exec,
+    path = require("path"),
+    chalk = require("ansi-colors"),
+    { ZarroError } = requireModule("zarro-error"),
+    findNpmBase = require("./find-npm-base");
+
+  function gulpNpmRun(gulp: GulpWithHelp) {
+    const
+      packageIndex = findPackageIndex(),
+      scripts = packageIndex.scripts || {};
+    Object.keys(scripts).forEach(k => {
+      gulp.task(k, `npm script: ${k}`, async () => {
+        // npm run produces extra output, prefixed with >
+        // at the start, including package information and the script line
+        // -> we'll ignore it unless someone _really_ wants it
+        let ignoredFirstLine = false;
+        await exec("npm", [ "run", k ], undefined, {
+          stderr: (d: string) => console.error(chalk.red(d)),
+          stdout: (d: string) => {
+            if (!ignoredFirstLine) {
+              debug(`npm diagnostics:\n${d}`);
+              ignoredFirstLine = true;
+              return;
+            }
+            console.log(chalk.yellow(d))
+          }
+        });
+      });
+    });
+  }
+
+  function findPackageIndex(): PackageIndex {
+    const
+      packageIndexFolder = findNpmBase(),
+      packageIndexPath = path.join(packageIndexFolder, "package.json");
+    try {
+      const contents = readFileSync(packageIndexPath, { encoding: "utf8" });
+      return JSON.parse(contents);
+    } catch (e) {
+      throw new ZarroError(`Unable to read package.json at ${packageIndexPath}`);
+    }
+  }
+
+  module.exports = gulpNpmRun;
+})();

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

@@ -0,0 +1,168 @@
+const
+  temp = require("temp"),
+  Vinyl = require("vinyl"),
+  fs = require("./fs"),
+  path = require("path"),
+  parseXml = requireModule("parse-xml"),
+  looksLikeAPromise = requireModule("looks-like-a-promise"),
+  gutil = requireModule("gulp-util"),
+  spawnNuget = requireModule("spawn-nuget"),
+  debug = require("debug")("gulp-nuget-pack"),
+  env = requireModule("env"),
+  es = require("event-stream");
+
+env.associate([
+  "PACK_BASE_PATH",
+  "PACK_VERSION",
+  "PACK_INCLUDE_EMPTY_DIRECTORIES",
+  "PACK_INCLUDE_SYMBOLS",
+  "PACK_LEGACY_SYMBOLS"
+], "pack");
+
+async function grokNuspec(xmlString) {
+  const pkg = await parseXml(xmlString),
+    metadata = pkg.package.metadata[0];
+  return {
+    packageName: metadata.id[0],
+    packageVersion: metadata.version[0]
+  };
+}
+
+async function resolveAll(obj) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    if (looksLikeAPromise(obj[key])) {
+      result[key] = await obj[key];
+    } else {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+
+function resolveRelativeBasePathOn(options, nuspecPath) {
+  if (!options.basePath) {
+    return;
+  }
+  if (options.basePath.indexOf("~") === 0) {
+    const packageDir = path.dirname(nuspecPath).replace(/\\/g, "/"),
+      sliced = options.basePath.substr(1).replace(/\\/g, "/");
+    options.basePath = path.join(packageDir, sliced);
+  }
+}
+
+/**
+ * @param {PackOptions} options
+ * @param {string[]} args
+ * @returns void
+ */
+function addOptionalParameters(options, args) {
+  if (options.basePath) {
+    gutil.log(`packaging with base path: ${options.basePath}`);
+    args.splice(args.length, 0, "-BasePath", options.basePath);
+  }
+  if (options.excludeEmptyDirectories) {
+    args.splice(args.length, 0, "-ExcludeEmptyDirectories");
+  }
+  if (options.version) {
+    gutil.log(`Overriding package version with: ${options.version}`);
+    args.splice(args.length, 0, "-version", options.version);
+  }
+  if (options.symbols) {
+    args.splice(args.length, 0, "-Symbols");
+    if (!options.legacySymbols) {
+      args.splice(args.length, 0, "-SymbolPackageFormat", "snupkg");
+    }
+  }
+}
+
+/**
+ * @param {PackOptions} options
+ * @returns {ReadableStream}
+ */
+function gulpNugetPack(options) {
+  options = Object.assign({}, options);
+  options.basePath = env.resolve("PACK_BASE_PATH") || options.basePath;
+  if (options.excludeEmptyDirectories === undefined) {
+    options.excludeEmptyDirectories = env.resolve("PACK_INCLUDE_EMPTY_DIRECTORIES");
+  }
+  if (options.version === undefined) {
+    options.version = env.resolve("PACK_VERSION");
+  }
+  if (options.symbols === undefined) {
+    options.symbols = env.resolve("PACK_INCLUDE_SYMBOLS");
+  }
+  if (options.legacySymbols === undefined) {
+    options.legacySymbols = env.resolve("PACK_LEGACY_SYMBOLS");
+  }
+
+  const
+    tracked = temp.track(),
+    workDir = tracked.mkdirSync();
+  let
+    promise = Promise.resolve();
+  return es.through(
+    function write(file) {
+      promise = promise.then(async () => {
+        options = await resolveAll(options);
+        resolveRelativeBasePathOn(options, file.path);
+        const { packageName, packageVersion } = await grokNuspec(
+          file.contents.toString()
+          ),
+          version = options.version || packageVersion,
+          expectedFileName = path.join(
+            workDir,
+            `${packageName}.${version}.nupkg`
+          ),
+          args = [ "pack", file.path, "-OutputDirectory", workDir ];
+
+        await fs.ensureDirectoryExists(workDir);
+        addOptionalParameters(options, args);
+
+        await spawnNuget(args, {
+          stdout: () => {
+            /* suppress stdout: it's confusing anyway because it mentions temp files */
+          }
+        });
+
+        const outputExists = await fs.exists(expectedFileName);
+        if (!outputExists) {
+          const err = `file not found: ${expectedFileName}`;
+          this.emit("error", err);
+          throw err;
+        } else {
+          logBuilt(expectedFileName);
+          this.emit(
+            "data",
+            new Vinyl({
+              path: path.basename(expectedFileName),
+              contents: await fs.readFile(expectedFileName)
+            })
+          );
+        }
+      });
+    },
+    async function end() {
+      let errored = false;
+      await promise.catch(err => {
+        errored = true;
+        this.emit("error", err);
+      });
+      if (!errored) {
+        tracked.cleanupSync();
+        this.emit("end");
+      }
+    }
+  );
+}
+
+function logBuilt(packagePath) {
+  debug(`built intermediate package: ${packagePath}`);
+  gutil.log(
+    gutil.colors.yellow(`built package: ${path.basename(packagePath)}`)
+  );
+}
+
+module.exports = {
+  pack: gulpNugetPack
+};

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

@@ -0,0 +1,106 @@
+'use strict';
+var
+  path = require("path"),
+  gutil = requireModule('gulp-util'),
+  es = require('event-stream'),
+  spawn = require('./spawn'),
+  log = require('./log'),
+  resolveNuget = require('./resolve-nuget'),
+  env = requireModule("env"),
+  isDotnetCore = env.resolveFlag("DOTNET_CORE"),
+  nugetExe = isDotnetCore ? (process.platform === "win32" ? "dotnet.exe" : "dotnet") : "nuget.exe",
+  debug = require('debug')('gulp-nuget-restore');
+
+var PLUGIN_NAME = 'gulp-nuget-restore';
+var DEBUG = true;
+
+function nugetRestore(options) {
+  options = options || {};
+  DEBUG = options.debug || process.env.DEBUG === "*" || false;
+  options.force = options.force || false;
+  if (DEBUG) {
+    log.setThreshold(log.LogLevels.Debug);
+  }
+  var solutionFiles = [];
+  var stream = es.through(function write(file) {
+    if (!file) {
+      fail(stream, 'file may not be empty or undefined');
+    }
+    solutionFiles.push(file);
+    this.emit('data', file);
+  }, function end() {
+    restoreNugetPackagesWith(this, solutionFiles, options);
+  });
+  return stream;
+}
+
+function fail(stream, msg) {
+  stream.emit('error', new gutil.PluginError(PLUGIN_NAME, msg));
+}
+function end(stream) {
+  stream.emit('end');
+}
+
+function determineRestoreCommandFor(nugetPath, stream) {
+  try {
+    var nuget = resolveNuget(nugetPath);
+    debug('Resolved restore tool at: ' + nuget);
+    return nuget;
+  } catch (ex) {
+    fail(stream, [
+      `No restore tool (nuget / dotnet) resolved: ${ex}`,
+      `stack: ${ex.stack || "no stack"}`
+    ].join("\n"));
+  }
+}
+
+function runNuget(restoreCommand, solutions, stream) {
+  debug(`restoreCmd: ${restoreCommand}`);
+  var deferred = Promise.resolve();
+  var final = solutions.reduce(function (promise, item) {
+    log.info('Restoring packages for: ' + item);
+    var pathParts = item.split(/[\\|\/]/g);
+    var sln = pathParts[pathParts.length - 1];
+    var slnFolder = pathParts.slice(0, pathParts.length - 1).join(path.sep);
+    var args = ['restore', sln];
+    if (env.resolveFlag("ENABLE_NUGET_PARALLEL_PROCESSING")) {
+      log.warning("Processing restore in parallel. If you get strange build errors, unset ENABLE_NUGET_PARALLEL_PROCESSING");
+    } else {
+      if (isDotnetCore) {
+        args.push("--disable-parallel");
+      } else {
+        args.push("-DisableParallelProcessing");
+      }
+    }
+    return promise.then(function () {
+      return spawn(restoreCommand, args, { cwd: slnFolder }).then(function () {
+        'Packages restored for: ' + item;
+      }).catch(function (err) {
+        throw err;
+      });
+    });
+  }, deferred);
+  final.then(function () {
+    end(stream);
+  }).catch(function (err) {
+    fail(stream, err);
+  });
+}
+
+function restoreNugetPackagesWith(stream, solutionFiles, options) {
+  var solutions = solutionFiles.map(file => file.path);
+  if (solutions.length === 0) {
+    if (solutionFiles.length == 0) {
+      return fail(stream, 'No solutions defined for nuget restore');
+    }
+  }
+  var nuget = options.nuget || nugetExe;
+  var nugetCmd = determineRestoreCommandFor(nuget, stream);
+  if (nugetCmd) {
+    runNuget(nugetCmd, solutions, stream);
+  } else {
+    fail(stream, "Can't determine nuget command");
+  }
+}
+
+module.exports = nugetRestore;

package/gulp-tasks/modules/gulp-nunit-runner/.jshintrc

@@ -0,0 +1,5 @@
+{
+	"globals": {
+		"Promise": true
+	}
+}

package/gulp-tasks/modules/gulp-nunit-runner/.npmignore

@@ -0,0 +1,16 @@
+node_modules
+test
+.editorconfig
+.gitignore
+.jscsrc
+.travis.yml
+gulpfile.js
+
+# Created by .ignore support plugin (hsz.mobi)
+### JetBrains template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio
+
+*.iml
+
+## Directory-based project format:
+.idea/

package/gulp-tasks/modules/gulp-nunit-runner/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Keith Morris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/gulp-tasks/modules/gulp-nunit-runner/README.md

@@ -0,0 +1,300 @@
+# gulp-nunit-runner
+This is an embedded fork of [gulp-nunit-runner](https://www.npmjs.com/package/gulp-nunit-runner) since the latter appears to be unmaintained.
+
+A [Gulp.js](http://gulpjs.com/) plugin to facilitate running [NUnit](http://www.nunit.org/) tests on .NET assemblies. Much of this work was inspired by the [gulp-nunit](https://github.com/stormid/gulp-nunit) plugin.
+
+## Installation
+
+From the root of your project (where your `gulpfile.js` is), issue the following command:
+
+```bat
+npm install --save-dev gulp-nunit-runner
+```
+
+## Usage
+
+The plugin uses standard `gulp.src` globs to retrieve a list of assemblies that should be tested with Nunit. By default the plugin looks for the NUnit console runner in your `PATH`. You can optionally specify the NUnit `bin` folder or the full path of the runner as demonstrated below. You should add `{read: false}` to your `gulp.src` so that it doesn't actually read the files and only grabs the file names.
+
+```javascript
+var gulp = require('gulp'),
+    nunit = require('gulp-nunit-runner');
+
+gulp.task('unit-test', function () {
+    return gulp.src(['**/*.Test.dll'], {read: false})
+        .pipe(nunit({
+            executable: 'C:/nunit/bin/nunit-console.exe',
+        }));
+});
+
+```
+This would result in the following command being executed (assuming you had Database and Services Test assemblies.)
+
+```bat
+C:/nunit/bin/nunit-console.exe "C:\full\path\to\Database.Test.dll" "C:\full\path\to\Services.Test.dll"
+```
+
+Note: If you use Windows paths with `\`'s, you need to escape them with another `\`. (e.g. `C:\\nunit\\bin\\nunit-console.exe`). However, you may also use forward slashes `/` instead which don't have to be escaped.
+
+You may also add options that will be used as NUnit command line switches.
+Any property that is a boolean `true` will simply be added to the command 
+line, String values will be added to the switch parameter separated by a 
+colon and arrays will be a comma seperated list of values.
+
+For more information on available switches, see the NUnit documentation:
+
+[http://www.nunit.org/index.php?p=consoleCommandLine&r=2.6.3](http://www.nunit.org/index.php?p=consoleCommandLine&r=2.6.3)
+
+```javascript
+var gulp = require('gulp'),
+    nunit = require('gulp-nunit-runner');
+
+gulp.task('unit-test', function () {
+    return gulp.src(['**/*.Test.dll'], {read: false})
+        .pipe(nunit({
+            executable: 'C:/nunit/bin/nunit-console.exe',
+            options: {
+                nologo: true,
+                config: 'Release',
+                transform: 'myTransform.xslt'
+            }
+        }));
+});
+```
+This would result in the following command:
+
+```bat
+C:/nunit/bin/nunit-console.exe /nologo /config:"Release" /transform:"myTransform.xslt" "C:\full\path\to\Database.Test.dll" "C:\full\path\to\Services.Test.dll"
+```
+
+## Options
+
+Below are all available options. With the release of NUnit 3.x, some options have been removed and some added. Version specific options have been labeled with the version they apply to. For more information on deprecated options see [here](https://github.com/nunit/nunit/wiki/Breaking-Changes#console-command-line-options). For more information on new options see [here](https://github.com/nunit/nunit/wiki/Console-Command-Line).
+
+```js
+nunit({
+
+    // The NUnit bin folder or the full path of the console runner.
+    // If not specified the NUnit bin folder must be in the `PATH`.
+    executable: 'c:/Program Files/NUnit/bin',
+
+    // [2.x] If the full path of the console runner is not specified this determines
+    // what version of the console runner is used. Defaults to anycpu.
+    // NOTE: This has been superseded by the 'x86' option below in 3.x.
+    // http://www.nunit.org/index.php?p=nunit-console&r=2.6.3
+    platform: 'anycpu|x86',
+
+    // [2.x] Output TeamCity service messages.
+    // NOTE: This has been superseded by the 'teamcity' option below in 3.x.
+    // https://confluence.jetbrains.com/display/TCD8/Build+Script+Interaction+with+TeamCity
+    teamcity: true|false,
+
+    // Do not throw a gulp error and stop the stream on failing NUnit tests.
+    // This is useful on TeamCity, where tests can be muted after the tests
+    // are run, which allow the build to pass.
+    continueOnError: true|false,
+
+    // The options below map directly to the NUnit console runner. See here
+    // for more info: http://www.nunit.org/index.php?p=consoleCommandLine&r=2.6.3
+    options: {
+
+        // [3.x] Name of the test case(s), fixture(s) or namespace(s) to run.
+        test: ['TestSuite.Unit', 'TestSuite.Integration'],
+
+        // [3.x] Name of a file containing a list of the tests to run, one per line.
+        testist: 'TestsToRun.txt',
+
+        // [2.x] Name of the test case(s), fixture(s) or namespace(s) to run.
+        // NOTE: This has been superseded by the 'test' option above in 3.x.
+        run: ['TestSuite.Unit', 'TestSuite.Integration'],
+
+        // [2.x] Name of a file containing a list of the tests to run, one per line.
+        // NOTE: This has been superseded by the 'testlist' option above in 3.x.
+        runlist: 'TestsToRun.txt',
+
+        // [2.x] List of categories to include.
+        include: ['BaseLine', 'Unit'],
+
+        // [2.x] List of categories to exclude.
+        exclude: ['Database', 'Network'],
+
+        // [3.x] Test selection expression
+        where: 'cat != critical',
+
+        // Project configuration (e.g.: Debug) to load.
+        config: 'Debug',
+
+        // Process model for tests.
+        process: 'Single|Separate|Multiple',
+
+        // AppDomain Usage for tests.
+        domain: 'None|Single|Multiple',
+
+        // Framework version to be used for tests.
+        framework: 'net-1.1',
+
+        // [3.x] Run tests in a 32-bit process on 64-bit systems.
+        x86: true|false,
+
+        // [3.x] Dispose each test runner after it has finished running its tests.
+        "dispose-runners": true|false,
+
+        // Timeout for each test case in milliseconds.
+        timeout: 1000,
+
+        // [3.x] Random seed used to generate test cases.
+        seed: 5150,
+
+        // [3.x] Number of worker threads to be used in running tests.
+        workers: 5,
+
+        // Stop after the first test failure or error.
+        stoponerror: true|false,
+
+        // Wait for input before closing console window.
+        wait: true|false,
+
+        // [3.x] Pause before run to allow debugging.
+        pause: true|false,
+
+        // Work directory for output files.
+        work: 'BuildArtifacts',
+
+        // File to receive test output.
+        output: 'TestOutput.txt',
+
+        // File to receive test error output.
+        err: 'TestErrors.txt',
+
+        // Name of XML result file (Default: TestResult.xml)
+        result: 'TestResult.xml',
+
+        // [3.x] Save test info rather than running tests. Name of output file.
+        explore: 'TestInfo.xml',
+
+        // Suppress XML result output.
+        noresult: true|false,
+
+        // Label each test in stdOut.
+        labels: true|false,
+
+        // Set internal trace level.
+        trace: 'Off|Error|Warning|Info|Verbose',
+
+        // [3.x] Tells .NET to copy loaded assemblies to the shadowcopy directory.
+        shadowcopy: true|false,
+
+        // [2.x] Disable shadow copy when running in separate domain.
+        // NOTE In 3.x, The console runner now disables shadow copy by
+        // default. use new 'shadowcopy' option in 3.x to turn it on.
+        noshadow: true|false,
+
+        // [3.x] Turns on use of TeamCity service messages.
+        teamcity: true|false,
+
+        // [3.x] Suppress display of program information at start of run.
+        noheader: true|false,
+
+        // [3.x] Displays console output without color.
+        nocolor: true|false,
+
+        // [3.x] Display additional information as the test runs.
+        verbose: true|false,
+
+        // [2.x] Do not display the logo.
+        nologo: true|false,
+
+        // [2.x] Do not display progress.
+        nodots: true|false,
+
+        // [2.x] Apartment for running tests (Default is MTA).
+        apartment: 'MTA|STA',
+
+        // [2.x] Disable use of a separate thread for tests.
+        nothread: true|false,
+
+        // [2.x] Base path to be used when loading the assemblies.
+        basepath: 'src',
+
+        // [2.x] Additional directories to be probed when loading assemblies.
+        privatebinpath: ['lib', 'bin'],
+
+        // [2.x] Erase any leftover cache files and exit.
+        cleanup: true|false
+
+    }
+});
+```
+
+## Release Notes
+
+### 1.2.3
+
+- Updated event-stream dependency for security issue. (thanks [alexmaris](https://github.com/alexmaris))
+
+### 1.2.2
+
+- Add parsing for number type options/switches ([alexmaris](https://github.com/alexmaris))
+
+### 1.2.1
+
+- Update dev dependencies
+
+### 1.2.0
+
+- Add continueOnError option ([cable729](https://github.com/cable729))
+
+### 1.1.0
+
+- Force using the `mono` command to execute the `nunit-console.exe` on non-windows systems ([dbones](https://github.com/dbones))
+
+### 1.0.0
+
+- Add handling of where switch for nunit3-console test runner ([Tuukka Turto](https://github.com/tuturto))
+- Dependency update
+- Update Travis tests to also test on node versions 4.x and 6.x
+- Bump version to 1.0.0
+
+### 0.5.2
+
+- Add check for output file before creating the TeamCity output. ([Mike O'Brien](https://github.com/mikeobrien))
+- Clean up publish package with `.npmignore`
+
+### 0.5.1
+- Fix #13 Running from Visual Studio Task Runner Fails
+
+### 0.5.0
+- Make the command line switch aware of OS so that it uses the correct character when running under mono on linux/mac.
+
+### 0.4.2 (28 June 2015)
+- Add NUnit 3.x options and labled 2.x options to README.md
+
+### 0.4.1 (20 Nov 2014)
+- Remove quotes around multi args.
+
+### 0.4.0 (13 Nov 2014)
+- Add build script with test, lint and watch.
+- Add Travis CI integration.
+- Add a TeamCity reporter.
+- Add support for multi options e.g. include, exclude and privatebinpath.
+- Add the ability to omit the explicit nunit path entirely and rely on it being in the PATH.
+- Add the ability to just supply the path to the bin folder but not explicitly specify the filename.
+- Add a platform flag that goes along with both exectable options to chose the x86 or anycpu version of nunit; defaults to anycpu.
+- Document all the config options in the README.
+
+### 0.3.0 (30 Sept 2014)
+- Fixes large amount of writes by NUnit tests causing node to crash
+- Switched to using `child_process::spawn`, much simpler command building.
+
+### 0.2.0 (28 Sept 2014)
+- Fixes #2 "Simultaneous runs of test tasks cause duplication"
+- Major rearchitecture of plugin by @VoiceOfWisdom
+- Adds release notes to README.md
+
+### 0.1.2 (4 Sept 2014)
+- Fixes #1 "runner fails if executable path has space"
+
+### 0.1.1 (10 Aug 2014)
+- Documentation update
+
+### 0.1.0 (10 Aug 2014)
+- Initial release