zarro 1.92.0

package/gulp-tasks/modules/gulp-git-tag-from-csproj.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+(function () {
+    const PLUGIN_NAME = __filename.replace(/\.js$/, ""), gutil = requireModule("gulp-util"), loadXmlFile = requireModule("load-xml-file"), es = require("event-stream"), gitTag = requireModule("git-tag"), gitPushTags = requireModule("git-push-tags"), gitPush = requireModule("git-push"), { ZarroError } = requireModule("zarro-error"), defaultOptions = {
+        push: true,
+        dryRun: false
+    };
+    module.exports = function gitTagFromCsProj(options) {
+        const opts = Object.assign({}, defaultOptions, options);
+        const csprojFiles = [];
+        return es.through(async function write(file) {
+            csprojFiles.push(file.path);
+            this.emit("data", file);
+        }, async function end() {
+            if (csprojFiles.length == 0) {
+                throw new ZarroError("no csproj files found to tag from?");
+            }
+            if (csprojFiles.length > 1) {
+                throw new ZarroError(`too many csproj files! specify the one to use for creating a versioned tag!\n${csprojFiles.join("\n- ")}`);
+            }
+            const xml = await loadXmlFile(csprojFiles[0]), version = findPackageVersion(xml, csprojFiles[0]);
+            if (opts.dryRun) {
+                console.log(`Dry run: would have tagged at ${version}`);
+                return this.emit("end");
+            }
+            try {
+                await gitTag({
+                    tag: `v${version}`,
+                    comment: `:bookmark: ${version}`
+                });
+                if (opts.push) {
+                    await gitPushTags();
+                    await gitPush();
+                    gutil.log(gutil.colors.green("-> all commits and tags pushed!"));
+                }
+                this.emit("end");
+            }
+            catch (e) {
+                this.emit("error", new gutil.PluginError(PLUGIN_NAME, e));
+            }
+        });
+    };
+    function findPackageVersion(xml, fileName) {
+        const packageVersionPropGroup = xml.Project.PropertyGroup.filter((g) => !!g.PackageVersion)[0];
+        if (!packageVersionPropGroup || (packageVersionPropGroup.PackageVersion[0] || "").trim() === "") {
+            throw new ZarroError(`No valid PackageVersion node found in any PropertyGroup within ${fileName}`);
+        }
+        return packageVersionPropGroup.PackageVersion[0].trim();
+    }
+})();

package/gulp-tasks/modules/gulp-git-tag-from-csproj.ts

@@ -0,0 +1,71 @@
+import * as vinyl from "vinyl";
+import { Stream } from "stream";
+
+(function() {
+  const
+    PLUGIN_NAME = __filename.replace(/\.js$/, ""),
+    gutil = requireModule<GulpUtil>("gulp-util"),
+    loadXmlFile = requireModule<LoadXmlFile>("load-xml-file"),
+    es = require("event-stream"),
+    gitTag = requireModule<GitTag>("git-tag"),
+    gitPushTags = requireModule<GitPushTags>("git-push-tags"),
+    gitPush = requireModule<GitPush>("git-push"),
+    { ZarroError } = requireModule("zarro-error"),
+    defaultOptions = {
+      push: true,
+      dryRun: false
+    } as Partial<GitTagOptions>;
+
+  module.exports = function gitTagFromCsProj(options?: GitTagFromCsProjOptions) {
+    const opts = Object.assign({}, defaultOptions, options) as GitTagFromCsProjOptions;
+    const csprojFiles: string[] = [];
+    return es.through(
+      async function write(this: Stream, file: vinyl.BufferFile) {
+        csprojFiles.push(file.path);
+        this.emit("data", file);
+      },
+      async function end(this: Stream) {
+        if (csprojFiles.length == 0) {
+          throw new ZarroError("no csproj files found to tag from?");
+        }
+        if (csprojFiles.length > 1) {
+          throw new ZarroError(
+            `too many csproj files! specify the one to use for creating a versioned tag!\n${ csprojFiles.join(
+              "\n- "
+            ) }`
+          );
+        }
+        const xml = await loadXmlFile(csprojFiles[0]),
+          version = findPackageVersion(xml, csprojFiles[0]);
+        if (opts.dryRun) {
+          console.log(`Dry run: would have tagged at ${ version }`);
+          return this.emit("end");
+        }
+        try {
+          await gitTag({
+            tag: `v${ version }`,
+            comment: `:bookmark: ${ version }`
+          });
+          if (opts.push) {
+            await gitPushTags();
+            await gitPush();
+            gutil.log(gutil.colors.green("-> all commits and tags pushed!"));
+          }
+          this.emit("end");
+        } catch (e) {
+          this.emit("error", new gutil.PluginError(PLUGIN_NAME, e));
+        }
+      }
+    );
+  };
+
+  function findPackageVersion(xml: any, fileName: string) {
+    const packageVersionPropGroup = xml.Project.PropertyGroup.filter(
+      (g: any) => !!g.PackageVersion
+    )[0];
+    if (!packageVersionPropGroup || (packageVersionPropGroup.PackageVersion[0] || "").trim() === "") {
+      throw new ZarroError(`No valid PackageVersion node found in any PropertyGroup within ${ fileName }`);
+    }
+    return packageVersionPropGroup.PackageVersion[0].trim();
+  }
+})();

package/gulp-tasks/modules/gulp-git-tag-from-package-nuspec.js

@@ -0,0 +1,55 @@
+const
+  PLUGIN_NAME = __filename.replace(/\.js$/, ""),
+  gutil = requireModule("gulp-util"),
+  loadXmlFile = requireModule("load-xml-file"),
+  es = require("event-stream"),
+  gitTag = requireModule("git-tag"),
+  gitPushTags = requireModule("git-push-tags"),
+  gitPush = requireModule("git-push"),
+  { ZarroError } = requireModule("zarro-error"),
+  defaultOptions = {
+    push: true,
+    dryRun: false
+  };
+
+module.exports = function gitTagFromPackageNuspec(options) {
+  options = Object.assign({}, defaultOptions, options);
+  const nuspecs = [];
+  return es.through(
+    async function write(file) {
+      nuspecs.push(file.path);
+      this.emit("data", file);
+    },
+    async function end() {
+      if (nuspecs.length == 0) {
+        throw new ZarroError("no nuspecs found to tag from?");
+      }
+      if (nuspecs.length > 1) {
+        throw new ZarroError(
+          `too many nuspecs! specify the one to use for creating a versioned tag!\n${nuspecs.join(
+            "\n- "
+          )}`
+        );
+      }
+      const xml = await loadXmlFile(nuspecs[0]),
+        version = xml.package.metadata[0].version[0].trim();
+
+      if (options.dryRun) {
+        console.log(`Dry run: would have tagged at ${version}`);
+        return this.emit("end");
+      }
+
+      try {
+        await gitTag(`v${version}`, `:bookmark: ${version}`);
+        if (options.push) {
+          await gitPushTags();
+          await gitPush();
+          gutil.log(gutil.colors.green("-> all commits and tags pushed!"));
+        }
+        this.emit("end");
+      } catch (e) {
+        this.emit("error", new gutil.PluginError(PLUGIN_NAME, e));
+      }
+    }
+  );
+};

package/gulp-tasks/modules/gulp-increment-nuget-package-dependency-version.js

@@ -0,0 +1,40 @@
+const
+  gutil = requireModule("gulp-util"),
+  editXml = require("gulp-edit-xml"),
+  incrementVersion = require("./increment-version-string");
+
+module.exports = function incrementDependencyVersion(packageMatch) {
+  if (typeof packageMatch === "string") {
+    packageMatch = new RegExp(`^${packageMatch}$`);
+  }
+  return editXml(
+    xml => {
+      const
+        meta = xml.package.metadata[0],
+        packageId = meta.id[0],
+        dependencies = meta.dependencies[0].group;
+      dependencies.forEach(dep => {
+        var dependency = (dep.dependency || [])[0];
+        if (!dependency) {
+          return;
+        }
+        if ((dependency.$.id || "").match(packageMatch)) {
+          const newVersion = incrementVersion(dependency.$.version);
+          gutil.log(
+            gutil.colors.yellow(
+              `${packageId}: dependency ${
+                dependency.$.id
+              } version incremented to: ${newVersion}`
+            )
+          );
+          dependency.$.version = newVersion;
+        }
+      });
+      return xml;
+    },
+    {
+      builderOptions: { renderOpts: { pretty: true } }
+    }
+  );
+}
+

package/gulp-tasks/modules/gulp-increment-nuget-package-version.js

@@ -0,0 +1,87 @@
+"use strict";
+(function () {
+    const gutil = requireModule("gulp-util"), debug = require("debug")("gulp-increment-nuget-package-version"), editXml = require("gulp-edit-xml"), incrementVersion = require("./increment-version-string"), { ZarroError } = requireModule("zarro-error"), xmlOpts = {
+        builderOptions: {
+            renderOpts: {
+                pretty: true
+            }
+        }
+    };
+    // FIXME: proper types plz
+    function incrementPackageVersionInCsProj(xml, file) {
+        debug(JSON.stringify(xml, null, 2));
+        const packageVersionPropGroup = xml.Project.PropertyGroup.filter((g) => !!g.PackageVersion)[0];
+        if (!packageVersionPropGroup) {
+            debug("No PropertyGroup found with PackageVersion node");
+            return xml;
+        }
+        const node = packageVersionPropGroup.PackageVersion;
+        const newVersion = incrementVersion(node[0]);
+        node[0] = newVersion;
+        let packageIdPropGroup = xml.Project.PropertyGroup.filter((g) => !!g.PackageId)[0];
+        let packageName = "(unknown)";
+        if (!packageIdPropGroup) {
+            if (!file) {
+                throw new ZarroError([
+                    `the installed version of gulp-edit-xml does not pass in the file being operated on.`,
+                    `either:`,
+                    `- update to the latest version`,
+                    `  or`,
+                    `- set the version to use "https://github.com/fluffynuts/gulp-edit-xml.git#pass-file-to-transform"`,
+                    ` (if the update doesn't make this message go away)`
+                ].join("\n"));
+            }
+            const filePath = file.history[0];
+            packageIdPropGroup = xml.Project.PropertyGroup.filter((g) => !!g.AssemblyName)[0];
+            if (!packageIdPropGroup) {
+                debug({
+                    file: JSON.stringify(file),
+                    fileName: file.name,
+                    stat: file.stat,
+                    string: file.toString(),
+                    hist: filePath
+                });
+                if (filePath) {
+                    const parts = filePath.split(/[\\/]/);
+                    debug({
+                        parts
+                    });
+                    packageName = parts[parts.length - 2] || packageName;
+                }
+            }
+            else {
+                packageName = (packageIdPropGroup.AssemblyName[0] || packageName).trim();
+            }
+        }
+        else {
+            packageName = (packageIdPropGroup.PackageId[0] || packageName).trim();
+        }
+        gutil.log(gutil.colors.yellow(`${packageName}: package version incremented to: ${newVersion}`));
+        debug({
+            label: "final xml",
+            doc: JSON.stringify(xml, null, 2)
+        });
+        return xml;
+    }
+    function incrementPackageVersionInNuspec(xml, file) {
+        const meta = xml.package.metadata[0], packageName = meta.id[0], node = meta.version, current = node[0];
+        const newVersion = incrementVersion(current);
+        node[0] = newVersion;
+        gutil.log(gutil.colors.yellow(`${packageName}: package version incremented to: ${newVersion}`));
+        return xml;
+    }
+    function incrementPackageVersion() {
+        return editXml((xml, file) => {
+            if (xml.package) {
+                return incrementPackageVersionInNuspec(xml, file);
+            }
+            else if (xml.Project) {
+                return incrementPackageVersionInCsProj(xml, file);
+            }
+            throw new ZarroError(`Don't know how to increment package version in document:\n\n${JSON.stringify(xml)}`);
+        }, xmlOpts);
+    }
+    module.exports = {
+        incrementPackageVersion
+    };
+})();

package/gulp-tasks/modules/gulp-increment-nuget-package-version.ts

@@ -0,0 +1,122 @@
+(function () {
+  const gutil = requireModule<GulpUtil>("gulp-util"),
+    debug = require("debug")("gulp-increment-nuget-package-version"),
+    editXml = require("gulp-edit-xml"),
+    incrementVersion = require("./increment-version-string"),
+    { ZarroError } = requireModule("zarro-error"),
+    xmlOpts = {
+      builderOptions: {
+        renderOpts: {
+          pretty: true
+        }
+      }
+    };
+
+  // FIXME: proper types plz
+  function incrementPackageVersionInCsProj(xml: any, file: any) {
+    debug(JSON.stringify(xml, null, 2));
+    const packageVersionPropGroup = xml.Project.PropertyGroup.filter(
+      (g: any) => !!g.PackageVersion
+    )[0];
+    if (!packageVersionPropGroup) {
+      debug("No PropertyGroup found with PackageVersion node");
+      return xml;
+    }
+    const node = packageVersionPropGroup.PackageVersion;
+    const newVersion = incrementVersion(node[0]);
+    node[0] = newVersion;
+
+    let packageIdPropGroup = xml.Project.PropertyGroup.filter(
+      (g: any) => !!g.PackageId
+    )[0];
+    let packageName = "(unknown)";
+    if (!packageIdPropGroup) {
+      if (!file) {
+        throw new ZarroError([
+          `the installed version of gulp-edit-xml does not pass in the file being operated on.`,
+          `either:`,
+          `- update to the latest version`,
+          `  or`,
+          `- set the version to use "https://github.com/fluffynuts/gulp-edit-xml.git#pass-file-to-transform"`,
+          ` (if the update doesn't make this message go away)`
+        ].join("\n"));
+      }
+      const filePath = file.history[0];
+      packageIdPropGroup = xml.Project.PropertyGroup.filter(
+        (g: any) => !!g.AssemblyName
+      )[0];
+      if (!packageIdPropGroup) {
+        debug({
+          file: JSON.stringify(file),
+          fileName: file.name,
+          stat: file.stat,
+          string: file.toString(),
+          hist: filePath
+        });
+
+        if (filePath) {
+          const parts = filePath.split(/[\\/]/);
+          debug({
+            parts
+          });
+          packageName = parts[parts.length - 2] || packageName;
+        }
+      } else {
+        packageName = (packageIdPropGroup.AssemblyName[0] || packageName).trim();
+      }
+    } else {
+      packageName = (packageIdPropGroup.PackageId[0] || packageName).trim();
+    }
+
+    gutil.log(
+      gutil.colors.yellow(
+        `${packageName}: package version incremented to: ${newVersion}`
+      )
+    );
+
+    debug({
+      label: "final xml",
+      doc: JSON.stringify(xml, null, 2)
+    });
+
+    return xml;
+  }
+
+  function incrementPackageVersionInNuspec(xml: any, file: any) {
+    const meta = xml.package.metadata[0],
+      packageName = meta.id[0],
+      node = meta.version,
+      current = node[0];
+    const newVersion = incrementVersion(current);
+    node[0] = newVersion;
+    gutil.log(
+      gutil.colors.yellow(
+        `${packageName}: package version incremented to: ${newVersion}`
+      )
+    );
+    return xml;
+  }
+
+  function incrementPackageVersion() {
+    return editXml(
+      (xml: any, file: any) => {
+        if (xml.package) {
+          return incrementPackageVersionInNuspec(xml, file);
+        } else if (xml.Project) {
+          return incrementPackageVersionInCsProj(xml, file);
+        }
+        throw new ZarroError(
+          `Don't know how to increment package version in document:\n\n${JSON.stringify(
+            xml
+          )}`
+        );
+      },
+      xmlOpts
+    );
+  }
+
+  module.exports = {
+    incrementPackageVersion
+  };
+
+})();

package/gulp-tasks/modules/gulp-msbuild.js

@@ -0,0 +1 @@
+module.exports = require("gulp-msbuild");

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

@@ -0,0 +1,40 @@
+"use strict";
+(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"), path = require("path"), chalk = require("ansi-colors"), { ZarroError } = requireModule("zarro-error"), findNpmBase = require("./find-npm-base");
+    function gulpNpmRun(gulp) {
+        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) => console.error(chalk.red(d)),
+                    stdout: (d) => {
+                        if (!ignoredFirstLine) {
+                            debug(`npm diagnostics:\n${d}`);
+                            ignoredFirstLine = true;
+                            return;
+                        }
+                        console.log(chalk.yellow(d));
+                    }
+                });
+            });
+        });
+    }
+    function findPackageIndex() {
+        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;
+})();