zarro 1.136.0 → 1.136.2

package/gulp-tasks/build.js

@@ -5,8 +5,6 @@ const
   gulp = requireModule("gulp"),
   debug = require("debug")("build"),
   promisifyStream = requireModule("promisify"),
-  dotnetCli = require("gulp-dotnet-cli"),
-  dotnetBuild = dotnetCli.build,
   throwIfNoFiles = requireModule("throw-if-no-files"),
   xbuild = requireModule("gulp-xbuild"),
   gutil = requireModule("gulp-util"),
@@ -90,7 +88,7 @@ function buildForNetCore(solutions) {
   const options = {
     target: "[not set]",
     verbosity: env.resolve("BUILD_VERBOSITY"),
-    configuration,
+    configurations: configuration,
     additionalArguments: msbuildArgs
   };
   return promisifyStream(

package/gulp-tasks/clean.js

@@ -5,7 +5,7 @@ const
   debug = require("debug")("clean"),
   throwIfNoFiles = requireModule("throw-if-no-files"),
   msbuild = require("gulp-msbuild"),
-  dotnetClean = require("gulp-dotnet-cli").clean,
+  dotnetClean = requireModule("gulp-dotnet-cli").clean,
   resolveMasks = requireModule("resolve-masks"),
   env = requireModule("env");
 const chalk = require("ansi-colors");
@@ -19,7 +19,8 @@ const myVars = [
   "BUILD_PLATFORM",
   "BUILD_ARCHITECTURE",
   "BUILD_MSBUILD_NODE_REUSE",
-  "BUILD_RETRIES"
+  "BUILD_RETRIES",
+  "BUILD_TARGETS"
 ];
 env.associate(myVars, "clean");
 
@@ -49,9 +50,11 @@ function clean() {
 async function cleanWithDotnet() {
   const
     configuration = env.resolve("BUILD_CONFIGURATION"),
-    slnMasks = resolveBuildSolutionMasks();
+    slnMasks = resolveBuildSolutionMasks(),
+    targets = env.resolveArray("BUILD_TARGETS");
   debug({
     slnMasks,
+    targets,
     cwd: process.cwd()
   });
   const solutions = gulp

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

@@ -1,9 +1,137 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 (function () {
-    // TODO: perhaps one day, this should become an npm module of its own
     const spawn = requireModule("spawn");
+    const { isSpawnError } = spawn;
     const q = requireModule("quote-if-required");
     let defaultNugetSource;
+    async function clean(opts) {
+        return runOnAllConfigurations(opts, configuration => {
+            const args = [
+                "clean",
+                q(opts.target)
+            ];
+            pushFramework(args, opts);
+            pushRuntime(args, opts);
+            pushConfiguration(args, configuration);
+            pushVerbosity(args, opts);
+            pushOutput(args, opts);
+            return runDotNetWith(args, opts);
+        });
+    }
+    async function build(opts) {
+        return runOnAllConfigurations(opts, configuration => {
+            const args = [
+                "build",
+                q(opts.target)
+            ];
+            pushCommonBuildArgs(args, opts, configuration);
+            pushFlag(args, opts.disableBuildServers, "--disable-build-servers");
+            pushFlag(args, opts.noIncremental, "--no-incremental");
+            pushFlag(args, opts.noDependencies, "--no-dependencies");
+            pushFlag(args, opts.noRestore, "--no-restore");
+            pushFlag(args, opts.selfContained, "--self-contained");
+            pushVersionSuffix(args, opts);
+            pushMsbuildProperties(args, opts);
+            pushAdditionalArgs(args, opts);
+            return runDotNetWith(args, opts);
+        });
+    }
+    async function test(opts) {
+        return runOnAllConfigurations(opts, configuration => {
+            const args = [
+                "test",
+                q(opts.target)
+            ];
+            pushCommonBuildArgs(args, opts, configuration);
+            pushIfSet(args, opts.settingsFile, "--settings");
+            pushIfSet(args, opts.filter, "--filter");
+            pushIfSet(args, opts.diagnostics, "--diag");
+            pushNoBuild(args, opts);
+            pushNoRestore(args, opts);
+            pushLoggers(args, opts.loggers);
+            pushMsbuildProperties(args, opts);
+            pushEnvVars(args, opts.env);
+            pushAdditionalArgs(args, opts);
+            // there's a lot of stdio/stderr from tests, and it
+            // should be shown already - including it in the
+            // error dump is not only unnecessary, it confuses
+            // the test handler wrt quackers output handling
+            opts.suppressStdIoInErrors = true;
+            return runDotNetWith(args, opts);
+        });
+    }
+    async function pack(opts) {
+        return runOnAllConfigurations(opts, configuration => {
+            const copy = Object.assign(Object.assign({}, opts), { msbuildProperties: Object.assign({}, opts.msbuildProperties) });
+            const args = [
+                "pack",
+                q(copy.target)
+            ];
+            pushConfiguration(args, configuration);
+            pushVerbosity(args, copy);
+            pushOutput(args, copy);
+            pushNoBuild(args, copy);
+            pushFlag(args, copy.includeSymbols, "--include-symbols");
+            pushFlag(args, copy.includeSource, "--include-source");
+            pushNoRestore(args, copy);
+            pushVersionSuffix(args, copy);
+            if (copy.nuspec) {
+                copy.msbuildProperties = copy.msbuildProperties || {};
+                copy.msbuildProperties["NuspecFile"] = copy.nuspec;
+            }
+            pushMsbuildProperties(args, copy);
+            return runDotNetWith(args, copy);
+        });
+    }
+    async function nugetPush(opts) {
+        validate(opts);
+        if (!opts.apiKey) {
+            throw new Error("apiKey was not specified");
+        }
+        const args = [
+            "nuget",
+            "push",
+            opts.target,
+            "--api-key",
+            opts.apiKey
+        ];
+        if (!opts.source) {
+            // dotnet core _demands_ that the source be set.
+            opts.source = await determineDefaultNugetSource();
+        }
+        pushIfSet(args, opts.source, "--source");
+        pushIfSet(args, opts.symbolApiKey, "--symbol-api-key");
+        pushIfSet(args, opts.symbolSource, "--symbol-source");
+        pushIfSet(args, opts.timeout, "--timeout");
+        pushFlag(args, opts.disableBuffering, "--disable-buffering");
+        pushFlag(args, opts.noSymbols, "--no-symbols");
+        pushFlag(args, opts.skipDuplicate, "--skip-duplicate");
+        pushFlag(args, opts.noServiceEndpoint, "--no-service-endpoint");
+        pushFlag(args, opts.forceEnglishOutput, "--force-english-output");
+        return runDotNetWith(args, opts);
+    }
+    async function runOnAllConfigurations(opts, toRun) {
+        validate(opts);
+        let configurations = resolveConfigurations(opts);
+        if (configurations.length < 1) {
+            configurations = [...defaultConfigurations];
+        }
+        let lastResult;
+        for (const configuration of configurations) {
+            const thisResult = await toRun(configuration);
+            if (isSpawnError(thisResult)) {
+                return thisResult;
+            }
+            lastResult = thisResult;
+        }
+        // for simplicity: return the last spawn result (at least for now, until there's a reason to get clever)
+        if (lastResult === undefined) {
+            // this is really here for TS
+            throw new Error(`No build configurations could be determined, which is odd, because there's even a fallback.`);
+        }
+        return lastResult;
+    }
     async function determineDefaultNugetSource() {
         if (defaultNugetSource) {
             return defaultNugetSource;
@@ -42,95 +170,42 @@
         }
         return result;
     }
-    async function nugetPush(opts) {
-        validate(opts);
-        if (!opts.apiKey) {
-            throw new Error("apiKey was not specified");
+    // this is actually a viable configuration... but we're going to use
+    // it as a flag to not put in -c at all
+    const defaultConfigurations = ["default"];
+    function resolveConfigurations(opts) {
+        if (!opts.configuration) {
+            return defaultConfigurations;
         }
-        const args = [
-            "nuget",
-            "push",
-            opts.target,
-            "--api-key",
-            opts.apiKey
-        ];
-        if (!opts.source) {
-            // dotnet core _demands_ that the source be set.
-            opts.source = await determineDefaultNugetSource();
-        }
-        pushIfSet(args, opts.source, "--source");
-        pushIfSet(args, opts.symbolApiKey, "--symbol-api-key");
-        pushIfSet(args, opts.symbolSource, "--symbol-source");
-        pushIfSet(args, opts.timeout, "--timeout");
-        pushFlag(args, opts.disableBuffering, "--disable-buffering");
-        pushFlag(args, opts.noSymbols, "--no-symbols");
-        pushFlag(args, opts.skipDuplicate, "--skip-duplicate");
-        pushFlag(args, opts.noServiceEndpoint, "--no-service-endpoint");
-        pushFlag(args, opts.forceEnglishOutput, "--force-english-output");
-        return runDotNetWith(args, opts);
-    }
-    async function build(opts) {
-        validate(opts);
-        const args = [
-            "build",
-            q(opts.target)
-        ];
-        pushCommonBuildArgs(args, opts);
-        pushFlag(args, opts.disableBuildServers, "--disable-build-servers");
-        pushFlag(args, opts.noIncremental, "--no-incremental");
-        pushFlag(args, opts.noDependencies, "--no-dependencies");
-        pushFlag(args, opts.noRestore, "--no-restore");
-        pushFlag(args, opts.selfContained, "--self-contained");
-        pushVersionSuffix(args, opts);
-        pushMsbuildProperties(args, opts);
-        pushAdditionalArgs(args, opts);
-        return runDotNetWith(args, opts);
-    }
-    async function test(opts) {
-        const args = [
-            "test",
-            q(opts.target)
-        ];
-        pushCommonBuildArgs(args, opts);
-        pushIfSet(args, opts.settingsFile, "--settings");
-        pushIfSet(args, opts.filter, "--filter");
-        pushIfSet(args, opts.diagnostics, "--diag");
-        pushNoBuild(args, opts);
-        pushNoRestore(args, opts);
-        pushLoggers(args, opts.loggers);
-        pushMsbuildProperties(args, opts);
-        pushEnvVars(args, opts.env);
-        pushAdditionalArgs(args, opts);
-        return runDotNetWith(args, opts);
+        return Array.isArray(opts.configuration)
+            ? opts.configuration
+            : [opts.configuration];
     }
-    async function pack(opts) {
-        validate(opts);
-        const copy = Object.assign(Object.assign({}, opts), { msbuildProperties: Object.assign({}, opts.msbuildProperties) });
-        const args = [
-            "pack",
-            q(copy.target)
-        ];
-        pushVerbosity(args, copy);
-        pushOutput(args, copy);
-        pushConfiguration(args, copy);
-        pushNoBuild(args, copy);
-        pushFlag(args, copy.includeSymbols, "--include-symbols");
-        pushFlag(args, copy.includeSource, "--include-source");
-        pushNoRestore(args, copy);
-        pushVersionSuffix(args, copy);
-        if (copy.nuspec) {
-            copy.msbuildProperties = copy.msbuildProperties || {};
-            copy.msbuildProperties["NuspecFile"] = copy.nuspec;
-        }
-        pushMsbuildProperties(args, copy);
-        return runDotNetWith(args, copy);
-    }
-    function pushCommonBuildArgs(args, opts) {
-        pushVerbosity(args, opts);
-        pushConfiguration(args, opts);
+    function pushFramework(args, opts) {
         pushIfSet(args, opts.framework, "--framework");
+    }
+    function pushRuntime(args, opts) {
         pushIfSet(args, opts.runtime, "--runtime");
+    }
+    function pushArch(args, opts) {
         pushIfSet(args, opts.arch, "--arch");
+    }
+    function pushConfiguration(args, configuration) {
+        debugger;
+        if (!configuration) {
+            return;
+        }
+        if (configuration.toLowerCase() === "default") {
+            return;
+        }
+        args.push.call(args, "--configuration", configuration);
+    }
+    function pushCommonBuildArgs(args, opts, configuration) {
+        pushVerbosity(args, opts);
+        pushConfiguration(args, configuration);
+        pushFramework(args, opts);
+        pushRuntime(args, opts);
+        pushArch(args, opts);
         pushIfSet(args, opts.os, "--os");
         pushOutput(args, opts);
     }
@@ -157,9 +232,6 @@
     function pushVerbosity(args, opts) {
         pushIfSet(args, opts.verbosity, "--verbosity");
     }
-    function pushConfiguration(args, opts) {
-        pushIfSet(args, opts.configuration, "--configuration");
-    }
     function pushAdditionalArgs(args, opts) {
         if (opts.additionalArguments) {
             args.push.apply(args, opts.additionalArguments);
@@ -169,7 +241,8 @@
         try {
             return await spawn("dotnet", args, {
                 stdout: opts.stdout,
-                stderr: opts.stderr
+                stderr: opts.stderr,
+                suppressStdIoInErrors: opts.suppressStdIoInErrors
             });
         }
         catch (e) {
@@ -224,6 +297,7 @@
         test,
         build,
         pack,
+        clean,
         nugetPush
     };
 })();

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

@@ -14,24 +14,19 @@
             // otherwise, discard the result
         };
     }
-    function pack(opts) {
-        return streamify(wrap(dotnetCli.pack), async (f) => {
+    function build(opts) {
+        return streamify(wrap(dotnetCli.build), f => {
             const copy = Object.assign({}, opts);
             copy.target = f.path;
-            const containingFolder = path.dirname(f.path);
-            const supplementaryNuspec = path.resolve(path.join(containingFolder, env.resolve(env.PACK_SUPPLEMENTARY_NUSPEC)));
-            if (await fileExists(supplementaryNuspec)) {
-                copy.nuspec = supplementaryNuspec;
-            }
             return copy;
-        }, "gulp-dotnet-cli-pack", "creating nuget package");
+        }, "gulp-dotnet-cli-build", "building project or solution");
     }
-    function build(opts) {
-        return streamify(wrap(dotnetCli.build), f => {
+    function clean(opts) {
+        return streamify(wrap(dotnetCli.clean), f => {
             const copy = Object.assign({}, opts);
             copy.target = f.path;
             return copy;
-        }, "gulp-dotnet-cli-build", "building project or solution");
+        }, "gulp-dotnet-cli-clean", "cleaning project or solution");
     }
     function test(opts) {
         return streamify(wrap(dotnetCli.test), f => {
@@ -40,6 +35,18 @@
             return copy;
         }, "gulp-dotnet-cli-pack", "creating nuget package");
     }
+    function pack(opts) {
+        return streamify(wrap(dotnetCli.pack), async (f) => {
+            const copy = Object.assign({}, opts);
+            copy.target = f.path;
+            const containingFolder = path.dirname(f.path);
+            const supplementaryNuspec = path.resolve(path.join(containingFolder, env.resolve(env.PACK_SUPPLEMENTARY_NUSPEC)));
+            if (await fileExists(supplementaryNuspec)) {
+                copy.nuspec = supplementaryNuspec;
+            }
+            return copy;
+        }, "gulp-dotnet-cli-pack", "creating nuget package");
+    }
     function nugetPush(opts) {
         return streamify(wrap(dotnetCli.nugetPush), f => {
             const copy = Object.assign({}, opts);
@@ -49,6 +56,7 @@
     }
     module.exports = {
         build,
+        clean,
         test,
         pack,
         nugetPush

package/gulp-tasks/modules/spawn.js

@@ -9,8 +9,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
             this._args = args;
             this._exe = exe;
             this._exitCode = exitCode;
-            this._stderr = [...stderr];
-            this._stdout = [...stdout];
+            this._stderr = stderr ? [...stderr] : null;
+            this._stdout = stdout ? [...stdout] : null;
         }
         get args() {
             return this._args;
@@ -22,16 +22,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
             return this._exitCode;
         }
         get stdout() {
-            return [...this._stdout];
+            return this._stdout ? [...this._stdout] : [];
         }
         get stderr() {
-            return [...this._stderr];
+            return this._stderr ? [...this._stderr] : [];
         }
         toString() {
             const lines = [
                 `${this.exe} ${this.args.join(" ")}`,
                 `Process exited with code: ${this.exitCode}`,
             ];
+            if (this._stderr === null && this._stdout === null) {
+                // io has been suppressed;
+                return lines.join("\n");
+            }
             const hasStdOut = this.stdout && this.stdout.length > 0;
             const hasStdErr = this.stderr && this.stderr.length > 0;
             const hasOutput = hasStdErr || hasStdOut;
@@ -156,7 +160,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
                 child.on("error", (err) => {
                     debug(`child error: ${err}`);
                     destroyPipesOn(child);
-                    const e = new SpawnError(`"${[executable].concat(args).join(" ")}" failed with "${err}"`, executable, quotedArgs, -1, stderr, stdout);
+                    const e = new SpawnError(`"${[executable].concat(args).join(" ")}" failed with "${err}"`, executable, quotedArgs, -1, opts.suppressStdIoInErrors ? null : stderr, opts.suppressStdIoInErrors ? null : stdout);
                     reject(e);
                 });
                 let exited = false;
@@ -181,7 +185,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
                         else {
                             const err = new SpawnError(`"${[executable]
                                 .concat(args)
-                                .join(" ")}" failed with exit code ${code}`, executable, args, code, stdout, stderr);
+                                .join(" ")}" failed with exit code ${code}`, executable, args, code, opts.suppressStdIoInErrors ? null : stdout, opts.suppressStdIoInErrors ? null : stderr);
                             reject(err);
                         }
                     };
@@ -239,5 +243,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
     }
     spawn.SpawnError = SpawnError;
     spawn.SpawnResult = SpawnResult;
+    spawn.isSpawnError = function (o) {
+        return o instanceof SpawnError;
+    };
+    spawn.isSpawnResult = function (o) {
+        return o instanceof SpawnResult;
+    };
     module.exports = spawn;
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zarro",
-  "version": "1.136.0",
+  "version": "1.136.2",
   "description": "Some glue to make gulp easier, perhaps even zero- or close-to-zero-conf",
   "bin": {
     "zarro": "./index.js"

package/types.d.ts

@@ -32,6 +32,7 @@ declare global {
     (() => Promise<any> | NodeJS.EventEmitter) | ((done: VoidVoid) => Promise<any> | NodeJS.EventEmitter)
   type TryDo<T> = (logic: AsyncVoidFunc<T>, retries: number | string, onTransientError?: ErrorReporter, onFinalFailure?: VoidVoid) => Promise<void>;
   type Optional<T> = T | undefined;
+  type Nullable<T> = T | null;
   type ResolveNuget = (nugetPath: Optional<string>, errorOnMissing: boolean) => string;
   type FindLocalNuget = () => Promise<string>;
 
@@ -516,6 +517,7 @@ declare global {
     * collection is done as the IO is left as "inherit"
      */
     interactive?: boolean;
+    suppressStdIoInErrors?: boolean
   }
 
   interface SpawnError extends Error {
@@ -539,6 +541,8 @@ declare global {
   interface Spawn extends SpawnFunction {
     SpawnResult: Function;
     SpawnError: Function;
+    isSpawnError: (o: any) => o is SpawnError;
+    isSpawnResult: (o: any) => o is SpawnResult;
   }
 
   type AskOptions = {}
@@ -568,11 +572,12 @@ declare global {
     verbosity?: DotNetVerbosity;
     // when set, errors are returned instead of thrown
     suppressErrors?: boolean;
+    suppressStdIoInErrors?: boolean;
   }
 
   interface DotNetCommonBuildOptions extends DotNetBaseOptions {
     target: string;
-    configuration?: string;
+    configuration?: string | string[];
     framework?: string;
     runtime?: string;
     output?: string;
@@ -583,7 +588,7 @@ declare global {
   interface DotNetPackOptions extends DotNetBaseOptions {
     target: string;
     output?: string;
-    configuration?: string;
+    configuration?: string | string[];
     noBuild?: boolean;
     includeSymbols?: boolean;
     includeSource?: boolean;
@@ -601,6 +606,14 @@ declare global {
     versionSuffix?: string;
   }
 
+  interface DotNetCleanOptions extends DotNetBaseOptions {
+    target: string;
+    framework?: string;
+    runtime?: string;
+    configuration?: string | string[],
+    output?: string;
+  }
+
   interface DotNetNugetPushOptions extends DotNetBaseOptions {
     target: string;
     apiKey: string;
@@ -634,14 +647,31 @@ declare global {
   type DotNetBuildFunction = (opts: DotNetBuildOptions) => Promise<SpawnResult | SpawnError>;
   type DotNetPackFunction = (opts: DotNetPackOptions) => Promise<SpawnResult | SpawnError>;
   type DotNetNugetPushFunction = (opts: DotNetNugetPushOptions) => Promise<SpawnResult | SpawnError>;
+  type DotNetCleanFunction = (opts: DotNetCleanOptions) => Promise<SpawnResult | SpawnError>;
 
   interface DotNetCli {
-    test: DotNetTestFunction;
+    clean: DotNetCleanFunction;
     build: DotNetBuildFunction;
+    test: DotNetTestFunction;
     pack: DotNetPackFunction;
     nugetPush: DotNetNugetPushFunction;
   }
 
+  type TransformFunction<T> = (opts: T) => Transform;
+  type GulpDotNetTestFunction = TransformFunction<DotNetTestOptions>;
+  type GulpDotNetBuildFunction = TransformFunction<DotNetBuildOptions>;
+  type GulpDotNetPackFunction = TransformFunction<DotNetPackOptions>;
+  type GulpDotNetNugetPushFunction = TransformFunction<DotNetNugetPushOptions>;
+  type GulpDotNetCleanFunction = TransformFunction<DotNetCleanOptions>;
+
+  interface GulpDotNetCli {
+    build: GulpDotNetBuildFunction;
+    clean: GulpDotNetCleanFunction;
+    test: GulpDotNetTestFunction;
+    pack: GulpDotNetPackFunction;
+    nugetPush: GulpDotNetNugetPushFunction;
+  }
+
   // scraped from https://spdx.org/licenses/
   // with the following fragment from FF dev console
   // copy(Array.from(document.querySelector("table").querySelectorAll("tr")).map(tr => {