zarro 1.121.0 → 1.121.2

package/gulp-tasks/modules/spawn.js

@@ -84,6 +84,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
                         if (exited) {
                             return;
                         }
+                        destroyPipesOn(child);
                         exited = true;
                         debug(`child ${eventName}s: ${code}`);
                         result.exitCode = code;
@@ -131,5 +132,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
             stream.on("data", handle);
         }
     }
+    function destroyPipesOn(child) {
+        for (const pipe of [child.stdout, child.stderr, child.stdin]) {
+            if (pipe) {
+                try {
+                    // I've seen times when child processes are dead, but the
+                    // IO pipes are kept alive, preventing node from exiting.
+                    // Specifically, when running dotnet test against a certain
+                    // project - but not in any other project for the same
+                    // usage. So this is just a bit of paranoia here - explicitly
+                    // shut down any pipes on the child process - we're done
+                    // with them anyway
+                    pipe.destroy();
+                }
+                catch (e) {
+                    // suppress: if the pipe is already dead, that's fine.
+                }
+            }
+        }
+    }
     module.exports = spawn;
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zarro",
-  "version": "1.121.0",
+  "version": "1.121.2",
   "description": "Some glue to make gulp easier, perhaps even zero- or close-to-zero-conf",
   "bin": {
     "zarro": "./index.js"
@@ -64,8 +64,8 @@
     "yafs": "^1.23.0"
   },
   "files": [
-    "gulp-tasks/**/*",
-    "index-modules/**/*",
+    "gulp-tasks/**/*.js",
+    "index-modules/**/*.js",
     "types.d.ts",
     "tsconfig.json"
   ],

package/gulp-tasks/.editorconfig

@@ -1,8 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-insert_final_newline = true
-indent_style = space
-indent_size = 2
-trim_trailing_whitespace = true

package/gulp-tasks/.git

@@ -1 +0,0 @@
-gitdir: ../.git/modules/gulp-tasks

package/gulp-tasks/.gitignore

@@ -1,9 +0,0 @@
-node_modules
-*.swp
-*.swo
-*.un~
-npm-debug.log*
-modules/nuget.exe
-modules/nuget.exe.completed
-modules/nuget.exe.part
-.idea

package/gulp-tasks/LICENSE

@@ -1,24 +0,0 @@
-Copyright (c) 2015, Davyd McColl
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-

package/gulp-tasks/README.md

@@ -1,144 +0,0 @@
-# gulp-tasks
-### A gulp starter-pack
----
-
-
-
-Some gulp tasks and utilities for building and testing .net and Javascript projects, favouring convention over configuration.
-     * Disclaimer: yes, I realise that this is a very opinionated take on the problem. *
-           * Feel free to submit requests (or better yet, pull requests) *
-
-
-## How to use this?
-
-This is a starting-point which you can use (and track) to get gulp building your project fairly painlessly.
-Here's what you do:
-
-1. add this repo as a submodule of your repo, at the root level
-2. copy `start/gulpfile.js` to the root of your repo
-3. run `node gulpfile.js` in the root of your repo. This should guide you through:
-    - initializing a `package.json` with your repo's details
-    - installing the node modules required by `gulp-tasks` to run
-    - setting up two npm scripts:
-      - `gulp` which can be used to run gulp commands without a globally-installed gulp. Simply do something like `npm run gulp {taskname}`
-      - `test` which will run the `test-dotnet` task from `gulp-tasks`
-4. if you know some gulp, you may augment tasks by creating new tasks in the `local-tasks` folder parallel to the `gulp-tasks` folder
-5. override provided tasks by copying them to the `local-tasks` folder
-    - edit them to your heart's content: you only have to edit the ones you want to change.
-6. First time: run `npm install` to install required modules
-7. Either:
-    - run `node node_modules/gulp/bin/gulp.js` OR
-    - install gulp globally with `npm install -g gulp` and then run `gulp`
-
-## Assumptions
-1. You're using MSBuild to build your stuff and Visual Studio for development (at least somewhere, so you get .sln files)
-- You're using NUnit for testing
-- You're using (or capable of installing) dotCover CLI (not required, but used by default)
-
-
-## What's in the box?
-
-Available tasks (at time of writing) include:
-
-- default
-    - this is the default task invoked if you just run gulp from the commandline. It should just contain a sequence of tasks to run for the default build
-    - the default will attempt:
-        * purge: remove all binary artifacts in bin and obj folders
-        * git-submodules: pull latest for any submodules
-        * install nuget packages for all solutions in the repo
-        * install tooling required by shell `install-tools` task
-        * build: msbuild your solution(s): all .sln files in the repo
-        * cover-dotnet: run all NUnit tests through dotCover (searches for dotCover and NUnit in
-            expected locations)
-        * run shell `generate-reports` task to output pretty reports.
-- build
-    - builds all Visual Studio solutions\*
-- clean
-    - invokes the 'Clean' target in all Visual Studio solutions\*
-- test-javascript
-    - runs karma in a single-run mode, recording coverage\*\*
-- git-submodules
-    - attempts to update all git submodules with the latest (HEAD) from the repositories they
-        point at. Think along the lines of svn:externals
-- nuget-restore
-    - attempts to restore all nuget packages for all solutions\*. Will download it's own
-    `nuget.exe` unless you specify otherwise.
-- test-dotnet
-    - (currently) attempts to run nunit tests from all Test projects, using a
-        convention-over-configuration method: All assemblies that it can find which end in
-        .Tests.dll are candidates for testing -- the ones selected must reside in the Debug build
-        output of a corresponding project folder, ie
-        `SomeProject.Tests/bin/Debug/SomeProject.Tests.dll`. The task will also look one up from
-        this if the Debug folder isn't found, so you can use this against test projects which are
-        Web projects at heart. \*\*\*
-- cover-dotnet
-    - attempts to run tests with coverage on your test assemblies. You will most likely want to
-      edit this task to add exclusions for external libraries and such that your test project is
-      using, though the defaults are sane. Will attempt to find installed or local dotCover
-      or OpenCover to run coverage with
-- install-tools (now a default part of the pipeline - see the `install-tools.js` file for information on how to disable this task, if it's not interesting to you)
-    - install local build tools to the tools/ folder in your solution (by default, can be overridden by the BUILD_TOOLS_FOLDER environment variable)
-    - depends on `default-tools-installer`, providing:
-        - nunit.console
-        - opencover
-        - reportgenerator
-- shell tasks (have no default behavior, but hook into the build pipeline):
-    - generate-reports
-        - generate reports after building
-        - you can get sane behavior by creating a local task which depends on
-            `default-report-generator` which uses reportgenerator to give
-            html coverage reports.
-
-
-\* That can be found in the current folder or any descendant folders
-\*\* Looking for (presently) a karma.conf.js in the same folder as the gulpfile. There are plans to make this task also seek out karma.conf.js files in descendant folders but the actual need hasn't arisen yet.
-\*\*\* These tasks attempt to find the highest stable releases of their dependancies (dotcover.exe and nunit-console-{platform}.exe) according to default install paths by default.
-
-## Shell tasks
-Shell tasks do nothing out of the box. You have to opt into the default behavior or write your
-own. If you think that the default behavior is what you want, create a task which simply depends
-on the default behavior. For example, if you want local tooling and reports out of the box, you
-could create `local-tasks/use-default-tasks.js` with:
-```
-const gulp = requireModule("gulp");
-gulp.task("generate-reports", "Generate coverage reports", ["default-report-generator"]);
-```
-
-The default behaviors here are left out so as not to interfere with existing users. `install-tools` has been included by default now that I find I need it more often than not. Anyone who updates their reference to `gulp-tasks` and sees extra stuff being done should follow the instructions in `install-tools.js`.
-
-## Using modules from `gulp-tasks`
-If you want to use any of the modules found under `gulp-tasks/modules`, make use of the
-globally-available `requireModule` function. Some available modules include:
-- `gulp`
-    - uses `gulp-help` (for v3 gulp) to provide a modified `gulp` where a second parameter can
-        be provided to give useful help. Read more on the `gulp-help` documentation.
-- `http-downloader`
-    - provides a simple async http downloading class
-- `spawn`, `exec`
-    - provides fairly safe ways to start processes on Windows
-- others can be seen in use in provided tasks
-
-## Convention over configuration
-
-These tasks were designed to cater, unedited, for the majority of build requirements\*, for example:
-- One main .sln file (if you have multiple, *all* are built -- override in your own build.js)
-- Test assemblies are named {Project}.Tests.dll (this is important: the test assembly collector will be quite stoic about it)
-- karma.conf.js lives alongside your gulpfile (if running JavaScript tests)
-- msbuild is set to build in x86 output using tools version 4.0 for Mono compatibility
-
-However, these (and other) assumptions may not fit your needs. The ethos of the project is that, in
-providing smaller task files, you can select only the ones you want and make changes to them if you
-need to to suit your needs. If you really want to merge in upstream changes, it should be an easy
-task because of the separation. It should also be easy to extend with your own tasks -- just add them
-to the gulp-tasks folder and reference them in your default pipeline to have them run by default.
-
-
-## Kudos
-
-All of this is only possible because of Node, Gulp and all of the contributions for tasks and modules,
-not to mention NUnit and dotCover (both free and excellent).
-Before attempting to write your own pipelining module for Gulp, look online -- someone has quite
-likely already done it. But if you *must*, then I highly recommend having a look at the
-gulp-nunit-runner module: it was the basis that I ripped off for the gulp-dotnetcover module (which I
-probably should try to get into official npm sources at some point, but for now, it lives
-under gulp-tasks/modules)

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

@@ -1,17 +0,0 @@
-const
-  alterPackageJsonVersion = requireModule<AlterPackageJson>("alter-package-json-version"),
-  env = requireModule<Env>("env"),
-  gulp = requireModule<GulpWithHelp>("gulp"),
-  taskName = "increment-package-json-version";
-
-env.associate([
-  env.DRY_RUN,
-  env.PACKAGE_JSON,
-  env.VERSION_INCREMENT_STRATEGY,
-  env.VERSION_INCREMENT_ZERO,
-  env.INITIAL_RELEASE
-], taskName);
-
-gulp.task(taskName, async () => {
-  return await alterPackageJsonVersion();
-});

package/gulp-tasks/modules/alter-package-json-version.ts

@@ -1,117 +0,0 @@
-export interface AlterPackageJsonVersionOptions {
-  packageJsonPath?: string;
-  dryRun?: boolean;
-  strategy?: string;
-  zero?: boolean;
-  loadUnsetFromEnvironment?: boolean;
-  incrementBy?: number
-}
-
-interface CompleteOptions extends AlterPackageJsonVersionOptions {
-  packageJsonPath: string;
-  dryRun: boolean;
-  strategy: string;
-  zero: boolean;
-  incrementBy: number
-}
-
-(function() {
-  const
-    gutil = requireModule<GulpUtil>("gulp-util"),
-    env = requireModule<Env>("env"),
-    { stat } = require("fs").promises,
-    readTextFile = requireModule<ReadTextFile>("read-text-file"),
-    writeTextFile = requireModule<WriteTextFile>("write-text-file"),
-    incrementVersion = requireModule<IncrementVersion>("increment-version");
-
-  async function alterPackageJsonVersion(
-    inputOpts?: AlterPackageJsonVersionOptions
-  ) {
-    if (env.resolveFlag(env.INITIAL_RELEASE)) {
-      return;
-    }
-    return new Promise<void>(async (resolve, reject) => {
-      const
-        opts = fillInFromEnvironment(inputOpts),
-        st = await stat(opts.packageJsonPath);
-      if (!st) {
-        return reject(`Can't find file at '${ opts.packageJsonPath }'`);
-      }
-      try {
-        const
-          json = await readTextFile(opts.packageJsonPath),
-          indent = guessIndent(json),
-          index = JSON.parse(json),
-          currentVersion = index.version || "0.0.0",
-          incremented = incrementVersion(
-            currentVersion,
-            opts.strategy,
-            opts.zero,
-            opts.incrementBy
-          );
-        index.version = incremented;
-        const newJson = JSON.stringify(index, null, indent);
-        if (opts.dryRun) {
-          gutil.log(
-            gutil.colors.green(
-              `dry run: would increment version in '${ opts.packageJsonPath }' from '${ currentVersion }' to '${ incremented }'`
-            )
-          );
-        }
-        await writeTextFile(opts.packageJsonPath, newJson);
-        resolve();
-      } catch (e) {
-        reject(e);
-      }
-    });
-  }
-
-  function shouldFillInFromEnvironment(opts?: AlterPackageJsonVersionOptions) {
-    if (!opts) {
-      return true;
-    }
-    if (opts.loadUnsetFromEnvironment) {
-      return true;
-    }
-    return (Object.keys(opts).length === 0);
-  }
-
-  function fillInFromEnvironment(opts?: AlterPackageJsonVersionOptions): CompleteOptions {
-    if (!shouldFillInFromEnvironment(opts)) {
-      return opts as CompleteOptions;
-    }
-    const result = { ...opts } as CompleteOptions;
-    if (result.packageJsonPath === undefined) {
-      result.packageJsonPath = env.resolve(env.PACKAGE_JSON);
-    }
-    if (result.dryRun === undefined) {
-      result.dryRun = env.resolveFlag(env.DRY_RUN)
-    }
-    if (result.strategy === undefined) {
-      result.strategy = env.resolve(env.VERSION_INCREMENT_STRATEGY);
-    }
-    if (result.zero === undefined) {
-      result.zero = env.resolveFlag(env.VERSION_INCREMENT_ZERO);
-    }
-    if (result.incrementBy === undefined) {
-      result.incrementBy = env.resolveNumber(env.PACK_INCREMENT_VERSION_BY);
-    }
-    return result as CompleteOptions;
-  }
-
-  function guessIndent(text: string) {
-    const
-      lines = text.split("\n"),
-      firstIndented = lines.find(line => line.match(/^\s+/));
-    if (!firstIndented) {
-      return 2; // guess
-    }
-    const
-      firstMatch = firstIndented.match(/(^\s+)/) || [],
-      leadingWhitespace = firstMatch[0] || "  ",
-      asSpaces = leadingWhitespace.replace(/\t/g, "  ");
-    return asSpaces.length;
-  }
-
-  module.exports = alterPackageJsonVersion;
-})();

package/gulp-tasks/modules/ask.ts

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

package/gulp-tasks/modules/chalk.ts

@@ -1,17 +0,0 @@
-(function () {
-  const
-    env = requireModule<Env>("env"),
-    actual = require("ansi-colors"),
-    shim = {} as any,
-    functions = Object.keys(actual)
-      .filter(k => typeof actual[k] === "function");
-  for (const fn of functions) {
-    shim[fn] = (s: string) => {
-      if (env.resolveFlag("NO_COLOR")) {
-        return s;
-      }
-      return actual[fn](s);
-    };
-  }
-  module.exports = shim;
-})();

package/gulp-tasks/modules/collect-files.ts

@@ -1,16 +0,0 @@
-import * as vinyl from "vinyl";
-
-(function() {
-  // collects the files from a gulp stream
-  const
-    es = require("event-stream");
-  module.exports = function collectFiles(target: vinyl.BufferFile[]) {
-    const stream = es.through(function data(file: vinyl.BufferFile) {
-      target.push(file);
-      stream.emit("data", file);
-    }, function end() {
-      stream.emit("end");
-    });
-    return stream;
-  }
-})();

package/gulp-tasks/modules/dotnet-cli.ts

@@ -1,56 +0,0 @@
-(function () {
-  const spawn = requireModule<Spawn>("spawn");
-
-  async function test(opts: DotNetTestOptions): Promise<SpawnResult | SpawnError> {
-    const args = [
-      "test",
-      opts.target
-    ];
-    pushIfSet(args, opts.verbosity, "-v");
-    pushIfSet(args, opts.configuration, "-c");
-    pushFlag(args, opts.noBuild, "--no-build");
-    pushFlag(args, opts.noRestore, "--no-restore");
-
-    pushLoggers(args, opts.loggers);
-
-    try {
-      return await spawn("dotnet", args, {
-        stdout: opts.stdout,
-        stderr: opts.stderr
-      });
-    } catch (e) {
-      return e as SpawnError;
-    }
-  }
-
-  function pushLoggers(args: string[], loggers: Optional<DotNetTestLoggers>) {
-    if (!loggers) {
-      return;
-    }
-    for (const loggerName of Object.keys(loggers)) {
-      const build = [loggerName];
-      const options = loggers[loggerName];
-      for (const key of Object.keys(options)) {
-        const value = options[key];
-        build.push([key, value].join("="));
-      }
-      args.push("--logger", build.join(";"));
-    }
-  }
-
-  function pushIfSet(args: string[], value: Optional<string>, cliSwitch: string) {
-    if (value) {
-      args.push(cliSwitch, value);
-    }
-  }
-
-  function pushFlag(args: string[], value: Optional<boolean>, cliSwitch: string) {
-    if (value) {
-      args.push(cliSwitch);
-    }
-  }
-
-  module.exports = {
-    test
-  };
-})();

package/gulp-tasks/modules/env-helpers.ts

@@ -1,67 +0,0 @@
-(function() {
-  const { ZarroError } = requireModule("zarro-error");
-
-  function env(name: string, fallback?: string): string {
-    const value = process.env[name];
-    if (value !== undefined) {
-      return value;
-    }
-    const argCount = Array.from(arguments).length;
-    if (argCount > 1) {
-      return fallback as string;
-    }
-    throw new ZarroError(
-      `environment variable '${ name }' is not defined and no fallback provided`
-    );
-  }
-
-  function envNumber(name: string, fallback?: number): number {
-    const
-      haveFallback = fallback !== undefined,
-      value = haveFallback ? env(name, fallback?.toString()) : env(name),
-      parsed = parseInt(value, 10);
-    if (!isNaN(parsed)) {
-      return parsed;
-    }
-    throw new ZarroError(
-      `environment variable '${ name }' is invalid: expected numeric value but found '${ value }'`
-    );
-  }
-
-  function envFlag(name: string, fallback?: boolean): boolean {
-    const
-      haveFallback = fallback !== undefined,
-      value = haveFallback ? env(name, fallback?.toString()) : env(name);
-    return parseBool(name, value);
-  }
-
-  const truthy = [
-      "1",
-      "yes",
-      "true"
-    ],
-    falsey = [
-      "0",
-      "no",
-      "false"
-    ];
-
-  function parseBool(name: string, value: string): boolean {
-    if (truthy.indexOf(value?.toString()) > -1) {
-      return true;
-    }
-    if (falsey.indexOf(value?.toString()) > -1) {
-      return false;
-    }
-    throw new ZarroError(
-      `environment variable '${name}' is invalid: could not parse '${value}' as a boolean value`
-    );
-  }
-
-  module.exports = {
-    env,
-    envNumber,
-    envFlag
-  }
-
-})();