zarro 1.130.0 → 1.130.2

package/gulp-tasks/build.js

@@ -78,6 +78,7 @@ async function build() {
 }
 
 function buildForNetCore(solutions) {
+  const { build } = requireModule("gulp-dotnet-cli");
   log.info(gutil.colors.yellow("Building with dotnet core"));
   const
     configuration = env.resolve("BUILD_CONFIGURATION"),
@@ -85,18 +86,26 @@ function buildForNetCore(solutions) {
   if (!env.resolveFlag("BUILD_MSBUILD_NODE_REUSE")) {
     msbuildArgs.push("/nodeReuse:false");
   }
+  /** @type DotNetBuildOptions */
+  const options = {
+    target: "[not set]",
+    verbosity: env.resolve("BUILD_VERBOSITY"),
+    configuration,
+    additionalArguments: msbuildArgs
+  };
   return promisifyStream(
     solutions
       .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
-        })
+        // 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
+        // })
+        build(options)
       )
   );
 }

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

@@ -1,26 +1,124 @@
 "use strict";
 (function () {
     const spawn = requireModule("spawn");
+    const q = requireModule("quote-if-required");
+    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);
+        pushProperties(args, opts);
+        pushAdditionalArgs(args, opts);
+        return runDotNetWith(args, opts);
+    }
     async function test(opts) {
         const args = [
             "test",
-            opts.target
+            q(opts.target)
         ];
-        pushIfSet(args, opts.verbosity, "-v");
-        pushIfSet(args, opts.configuration, "-c");
-        pushFlag(args, opts.noBuild, "--no-build");
-        pushFlag(args, opts.noRestore, "--no-restore");
+        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);
+        pushProperties(args, opts);
+        pushEnvVars(args, opts.env);
+        pushAdditionalArgs(args, opts);
+        return runDotNetWith(args, opts);
+    }
+    async function pack(opts) {
+        const args = [
+            "pack",
+            q(opts.target)
+        ];
+        pushVerbosity(args, opts);
+        pushOutput(args, opts);
+        pushConfiguration(args, opts);
+        pushNoBuild(args, opts);
+        pushFlag(args, opts.includeSymbols, "--include-symbols");
+        pushFlag(args, opts.includeSource, "--include-source");
+        pushNoRestore(args, opts);
+        pushVersionSuffix(args, opts);
+        return runDotNetWith(args, opts);
+    }
+    function pushCommonBuildArgs(args, opts) {
+        pushVerbosity(args, opts);
+        pushConfiguration(args, opts);
+        pushIfSet(args, opts.framework, "--framework");
+        pushIfSet(args, opts.runtime, "--runtime");
+        pushIfSet(args, opts.arch, "--arch");
+        pushIfSet(args, opts.os, "--os");
+        pushOutput(args, opts);
+    }
+    function pushVersionSuffix(args, opts) {
+        pushIfSet(args, opts.versionSuffix, "--version-suffix");
+    }
+    function pushNoRestore(args, opts) {
+        pushFlag(args, opts.noRestore, "--no-restore");
+    }
+    function pushNoBuild(args, opts) {
+        pushFlag(args, opts.noBuild, "--no-build");
+    }
+    function validate(opts) {
+        if (!opts) {
+            throw new Error("no options provided");
+        }
+        if (!opts.target) {
+            throw new Error("target not set");
+        }
+    }
+    function pushOutput(args, opts) {
+        pushIfSet(args, opts.output, "--output");
+    }
+    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);
+        }
+    }
+    async function runDotNetWith(args, consumers) {
         try {
             return await spawn("dotnet", args, {
-                stdout: opts.stdout,
-                stderr: opts.stderr
+                stdout: consumers.stdout,
+                stderr: consumers.stderr
             });
         }
         catch (e) {
             return e;
         }
     }
+    function pushProperties(args, opts) {
+        if (!opts.msbuildProperties) {
+            return;
+        }
+        for (const key of Object.keys(opts.msbuildProperties)) {
+            args.push(`/p:${q(key)}=${q(opts.msbuildProperties[key])}`);
+        }
+    }
+    function pushEnvVars(args, env) {
+        if (!env) {
+            return;
+        }
+        for (const key of Object.keys(env)) {
+            args.push("-e");
+            args.push(`${q(key)}=${q(env[key])}`);
+        }
+    }
     function pushLoggers(args, loggers) {
         if (!loggers) {
             return;
@@ -37,7 +135,7 @@
     }
     function pushIfSet(args, value, cliSwitch) {
         if (value) {
-            args.push(cliSwitch, value);
+            args.push(cliSwitch, q(value));
         }
     }
     function pushFlag(args, value, cliSwitch) {
@@ -46,6 +144,8 @@
         }
     }
     module.exports = {
-        test
+        test,
+        build,
+        pack
     };
 })();

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

@@ -0,0 +1,40 @@
+"use strict";
+(function () {
+    const dotnetCli = requireModule("dotnet-cli");
+    const { streamify } = requireModule("streamify");
+    function wrap(fn) {
+        return async (opts) => {
+            const result = await fn(opts);
+            if (result instanceof Error) {
+                throw result;
+            }
+            // otherwise, discard the result
+        };
+    }
+    function pack(opts) {
+        return streamify(wrap(dotnetCli.pack), f => {
+            const copy = Object.assign({}, opts);
+            copy.target = f.path;
+            return copy;
+        }, "gulp-dotnet-cli-pack", "creating nuget package");
+    }
+    function build(opts) {
+        return streamify(wrap(dotnetCli.build), f => {
+            const copy = Object.assign({}, opts);
+            copy.target = f.path;
+            return copy;
+        }, "gulp-dotnet-cli-build", "building project or solution");
+    }
+    function test(opts) {
+        return streamify(wrap(dotnetCli.test), f => {
+            const copy = Object.assign({}, opts);
+            copy.target = f.path;
+            return copy;
+        }, "gulp-dotnet-cli-pack", "creating nuget package");
+    }
+    module.exports = {
+        build,
+        test,
+        pack
+    };
+})();

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

@@ -46,7 +46,6 @@
                 const errors = e.stderr.join("\n").trim(), isDuplicatePackageError = errors.match(/: 409 /);
                 if (isDuplicatePackageError && options.suppressDuplicateError) {
                     console.warn(`ignoring duplicate package error: ${errors}`);
-                    return e;
                 }
             }
             throw e;

package/gulp-tasks/modules/quote-if-required.js

@@ -1,14 +1,15 @@
-function isAlreadyQuoted(str) {
-  return str &&
-    str[0] === "\"" &&
-    str[str.length-1] === "\"";
-}
-
-module.exports = function quoteIfRequired(arg) {
-  arg = arg || "";
-  return (arg.indexOf(" ") > -1 || arg.indexOf(";") > -1) &&
-    arg.match(/^".*"$/) == null
-    ? isAlreadyQuoted(arg) ? arg : `"${arg}"`
-    : arg;
-}
-
+"use strict";
+(function () {
+    function isAlreadyQuoted(str) {
+        return !!str &&
+            str[0] === "\"" &&
+            str[str.length - 1] === "\"";
+    }
+    module.exports = function quoteIfRequired(arg) {
+        arg = arg || "";
+        return (arg.indexOf(" ") > -1 || arg.indexOf(";") > -1) &&
+            arg.match(/^".*"$/) == null
+            ? isAlreadyQuoted(arg) ? arg : `"${arg}"`
+            : arg;
+    };
+})();

package/gulp-tasks/modules/register-environment-variables.js

@@ -429,7 +429,7 @@ module.exports = function _env(env) {
   env.register({
     name: "PACK_CONFIGURATION",
     help: "Build configuration for dotnet-core packing",
-    default: "Release"
+    default: "Release",
   });
 
   env.register({

package/gulp-tasks/modules/streamify.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+(function () {
+    const through = require("through2");
+    const PluginError = require("plugin-error");
+    function streamify(fn, optionsFactory, pluginName, operation) {
+        return through.obj(async function (file, enc, cb) {
+            try {
+                const options = await optionsFactory(file);
+                await fn(options);
+                cb(null, file);
+            }
+            catch (e) {
+                const pluginError = new PluginError(pluginName, `${operation} failed: ${e.message || e}`);
+                this.emit("error", pluginError);
+                cb(pluginError, file);
+            }
+        });
+    }
+    module.exports = {
+        streamify
+    };
+})();

package/gulp-tasks/pack.js

@@ -12,8 +12,7 @@ const getToolsFolder = requireModule("get-tools-folder"),
   { rewriteFile } = requireModule("rewrite-file"),
   del = require("del"),
   debug = require("debug")("pack"),
-  gulp = requireModule("gulp"),
-  { pack } = requireModule("gulp-nuget-pack");
+  gulp = requireModule("gulp");
 
 env.associate(
   [
@@ -53,6 +52,7 @@ function removeBadEntities(buffer) {
 }
 
 function packWithNuget(target, incrementVersion) {
+  const { pack } = requireModule("gulp-nuget-pack");
   const nuspecs = resolveMasks(
     "PACK_INCLUDE_NUSPEC",
     "PACK_EXCLUDE_NUSPEC",
@@ -72,6 +72,7 @@ function packWithNuget(target, incrementVersion) {
 }
 
 function packWithDotnetCore(target, incrementVersion) {
+  const { pack } = requireModule("gulp-dotnet-cli");
   const projects = resolveMasks("PACK_INCLUDE_CSPROJ", "PACK_EXCLUDE_CSPROJ", p => {
     return (p || "").match(/\.csproj$/) ? p : `${p}.csproj`;
   });
@@ -92,15 +93,17 @@ function packWithDotnetCore(target, incrementVersion) {
       .pipe(incrementPackageVersion())
       .pipe(rewriteFile(removeBadEntities));
   }
+  /** @type DotnetPackOptions */
   const packConfig = {
+    target: "[not set]",
     output: path.resolve(target),
     configuration
   };
   if (process.env["PACK_VERSION"] !== undefined) {
-    packConfig.version = process.env["PACK_VERSION"]
+    packConfig.versionSuffix = process.env["PACK_VERSION"]
   }
   return stream.pipe(
-    dotnetPack(packConfig)
+    pack(packConfig)
   );
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zarro",
-  "version": "1.130.0",
+  "version": "1.130.2",
   "description": "Some glue to make gulp easier, perhaps even zero- or close-to-zero-conf",
   "bin": {
     "zarro": "./index.js"
@@ -14,7 +14,10 @@
     "clean-cache": "rimraf .jest-cache",
     "pretest": "run-s clean-cache build verify-submodules",
     "test": "jest",
-    "autotest": "jest --watch",
+    "quick-test": "jest -o --no-cache",
+    "clear-console": "console-cls",
+    "autotest-once": "run-s clear-console build quick-test",
+    "autotest": "nodemon -w gulp-tasks -w tests -w types.d.ts -x \"npm run autotest-once || cd .\" -e ts",
     "autobuild": "nodemon -w gulp-tasks -w tests -x \"npm run build || cd .\" -e ts",
     "prestart": "run-s build",
     "start": "node index.js",
@@ -84,10 +87,12 @@
     "@types/jest": "^26.0.20",
     "@types/node": "^13.13.40",
     "@types/rimraf": "^3.0.0",
+    "@types/through2": "^2.0.38",
     "@types/xml2js": "^0.4.8",
     "@types/yargs": "^15.0.13",
+    "console-cls": "^1.2.2",
     "debugger-is-attached": "^1.2.0",
-    "expect-even-more-jest": "^1.11.0",
+    "expect-even-more-jest": "^1.15.0",
     "filesystem-sandbox": "^1.20.0",
     "jest": "^26.6.3",
     "nodemon": "^2.0.19",

package/types.d.ts

@@ -1,11 +1,14 @@
+// noinspection JSUnusedGlobalSymbols
+
 import * as fs from "fs";
-import { Stream } from "stream";
+import { Stream, Transform } from "stream";
 import { StyleFunction } from "ansi-colors";
 import { AlterPackageJsonVersionOptions } from "./gulp-tasks/modules/alter-package-json-version";
 import { RimrafOptions } from "./gulp-tasks/modules/rimraf";
 import { ExecFileOptionsWithBufferEncoding } from "child_process";
 import { IoConsumer, IoHandlers } from "./gulp-tasks/modules/exec";
 import { StatsBase } from "fs";
+import * as vinyl from "vinyl";
 
 // copied out of @types/fancy-log because imports are being stupid
 interface Logger {
@@ -22,6 +25,8 @@ declare global {
   type VoidVoid = () => void;
   type AsyncVoidVoid = () => Promise<void>;
   type AsyncVoidFunc<T> = () => Promise<T>;
+  type AsyncTVoid<T> = (arg: T) => Promise<void>;
+  type OptionsFactory<T> = (file: vinyl.BufferFile) => T | Promise<T>;
   type ErrorReporter = (e: Error) => Promise<void> | void;
   type GulpCallback =
     (() => Promise<any> | NodeJS.EventEmitter) | ((done: VoidVoid) => Promise<any> | NodeJS.EventEmitter)
@@ -30,6 +35,10 @@ declare global {
   type ResolveNuget = (nugetPath: Optional<string>, errorOnMissing: boolean) => string;
   type FindLocalNuget = () => Promise<string>;
 
+  interface Streamify {
+    streamify<T>(fn: AsyncTVoid<T>, optionsFactory: OptionsFactory<T>, pluginName: string, operation: string):  Transform;
+  }
+
   interface GulpWithHelp {
     task(name: string, callback: GulpCallback): void;
     task(name: string, help: string, callback: GulpCallback): void;
@@ -405,6 +414,7 @@ declare global {
 
   type GitTagFromCsProj = (options?: GitTagOptions) => Stream;
   type GitFetch = (all: boolean) => Promise<void>;
+  type NugetPush = (packageFile: string, sourceName?: string, options?: NugetPushOpts) => Promise<void>;
 
   interface Log {
     setThreshold(level: number): void;
@@ -469,6 +479,7 @@ declare global {
   type GitTag = (tag: string | GitTagOptions, comment?: string, where?: string) => Promise<void>;
   type GitPush = (dryRun?: boolean | GitPushOptions, quiet?: boolean, where?: string) => Promise<void>;
   type GitPushTags = (dryRun?: boolean | GitPushOptions, comment?: string, where?: string) => Promise<void>;
+  type QuoteIfRequired = (str?: string) => string;
 
   type StdioOptions = "pipe" | "ignore" | "inherit" |
     Array<("pipe" | "ipc" | "ignore" | "inherit" | any | number | null | undefined)>;
@@ -534,21 +545,64 @@ declare global {
 
   type DotNetTestLoggers = Dictionary<Dictionary<string>>;
 
-  interface DotNetTestOptions {
-    target: string;
+  interface DotNetBaseOptions {
+    msbuildProperties?: Dictionary<string>;
+    additionalArguments?: string[]
     verbosity?: DotNetVerbosity,
+  }
+
+  interface DotNetCommonBuildOptions extends DotNetBaseOptions {
+    target: string;
+    configuration?: string;
+    framework?: string;
+    runtime?: string;
+    output?: string;
+    arch?: string;
+    os?: string;
+  }
+
+  interface DotnetPackOptions extends DotNetBaseOptions, IoConsumers {
+    target: string;
+    output?: string;
     configuration?: string;
     noBuild?: boolean;
+    includeSymbols?: boolean;
+    includeSource?: boolean;
     noRestore?: boolean;
-    loggers?: DotNetTestLoggers;
-    stdout?: IoConsumer,
-    stderr?: IoConsumer
+    versionSuffix?: string;
+  }
+
+  interface DotNetBuildOptions extends DotNetCommonBuildOptions, IoConsumers {
+    noIncremental?: boolean;
+    disableBuildServers?: boolean;
+    selfContained?: boolean;
+    noDependencies?: boolean;
+    noRestore?: boolean;
+    versionSuffix?: string;
+  }
+
+  interface IoConsumers {
+    stdout?: IoConsumer;
+    stderr?: IoConsumer;
   }
 
-  type DotNetTestFunction = (opts: DotNetTestOptions) => Promise<void>;
+  interface DotNetTestOptions extends DotNetCommonBuildOptions, IoConsumers {
+    noBuild?: boolean;
+    noRestore?: boolean;
+    loggers?: DotNetTestLoggers;
+    settingsFile?: string;
+    env?: Dictionary<string>;
+    filter?: string;
+    diagnostics?: string;
+  }
 
+  type DotNetTestFunction = (opts: DotNetTestOptions) => Promise<SpawnResult | SpawnError>;
+  type DotNetBuildFunction = (opts: DotNetBuildOptions) => Promise<SpawnResult | SpawnError>;
+  type DotNetPackFunction = (opts: DotnetPackOptions) => Promise<SpawnResult | SpawnError>;
   interface DotNetCli {
-    test: DotNetTestFunction
+    test: DotNetTestFunction;
+    build: DotNetBuildFunction;
+    pack: DotNetPackFunction;
   }
 
   // scraped from https://spdx.org/licenses/