zarro 1.92.0

package/gulp-tasks/modules/throw-if-no-files.js

@@ -0,0 +1,15 @@
+const
+  es = require("event-stream");
+
+module.exports = function(msg) {
+  const captured = [];
+  return es.through(function write(file) {
+    captured.push(file);
+    this.emit("data", file);
+  }, function end() {
+    if (captured.length === 0) {
+      return this.emit("error", msg || "No files processed");
+    }
+    this.emit("end");
+  });
+}

package/gulp-tasks/modules/uniq.js

@@ -0,0 +1,6 @@
+"use strict";
+(function () {
+    module.exports = function uniq(values) {
+        return Array.from(new Set(values));
+    };
+})();

package/gulp-tasks/modules/uniq.ts

@@ -0,0 +1,5 @@
+(function() {
+  module.exports = function uniq<T>(values: T[]): T[] {
+      return Array.from(new Set(values));
+  }
+})();

package/gulp-tasks/modules/verify-exe.js

@@ -0,0 +1,17 @@
+var exec = require('child_process').execSync,
+  fs = require('fs');
+
+module.exports = function(path) {
+  console.log('verifying executable at: ', path);
+  return new Promise(function(resolve, reject) {
+    try {
+      exec(path);
+      resolve();
+    } catch (ignore) {
+      console.error('-> executable is bad )\': (imma delete it!)');
+      console.info('Suggestion: add a nuget.exe binary to the folder hosting your gulp-tasks');
+      fs.unlinkSync(path);
+      reject();
+    }
+  })
+}

package/gulp-tasks/modules/version-reading-shared.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryReadVersionFrom = void 0;
+function readTextFrom(node) {
+    return node
+        ? node[0]
+        : undefined;
+}
+function tryReadVersionFrom(groups, nodeName) {
+    return groups.reduce((acc, cur) => acc || readTextFrom(cur[nodeName]), undefined);
+}
+exports.tryReadVersionFrom = tryReadVersionFrom;

package/gulp-tasks/modules/version-reading-shared.ts

@@ -0,0 +1,16 @@
+function readTextFrom(node: string[]): string | undefined {
+  return node
+    ? node[0]
+    : undefined;
+}
+
+export function tryReadVersionFrom(
+  groups: any[],
+  nodeName: string
+): string | undefined {
+  return groups.reduce(
+    (acc: string | undefined, cur: any) =>
+      acc || readTextFrom(cur[nodeName]),
+    undefined
+  );
+}

package/gulp-tasks/modules/write-text-file.js

@@ -0,0 +1,10 @@
+const fs = require("fs").promises;
+
+module.exports = async function(
+  path,
+  data,
+  options) {
+  options = options || {};
+  options.encoding = "utf8";
+  return await fs.writeFile(path, data, options)
+};

package/gulp-tasks/modules/zarro-error.js

@@ -0,0 +1,6 @@
+class ZarroError extends Error {
+}
+
+module.exports = {
+  ZarroError
+};

package/gulp-tasks/nuget-restore.js

@@ -0,0 +1,57 @@
+const
+  env = requireModule("env"),
+  gulp = requireModule("gulp"),
+  debug = require("debug")("nuget-restore"),
+  nugetRestore = requireModule("./gulp-nuget-restore"),
+  promisify = requireModule("promisify"),
+  resolveMasks = requireModule("resolve-masks"),
+  { ZarroError } = requireModule("zarro-error"),
+  findLocalNuget = requireModule("find-local-nuget");
+
+const myTasks = [ "nuget-restore" ],
+  myVars = [
+    "DOTNET_CORE",
+    "BUILD_INCLUDE",
+    "BUILD_EXCLUDE",
+    "BUILD_ADDITIONAL_EXCLUDE"
+  ];
+env.associate(myVars, myTasks);
+
+gulp.task(
+  "nuget-restore",
+  "Restores all nuget packages in all solutions",
+  [ "install-tools" ],
+  async () => {
+    const
+      allDNC = env.resolveFlag("DOTNET_CORE"),
+      slnMasks = resolveMasks("BUILD_INCLUDE", [ "BUILD_EXCLUDE", "BUILD_EXTRA_EXCLUDE" ]);
+    debug({
+      allDNC,
+      slnMasks,
+      cwd: process.cwd()
+    });
+    var options = {
+      debug: false
+    };
+    const start = allDNC
+      ? Promise.resolve()
+      : findLocalNuget();
+    if (allDNC) {
+      options.nuget = "dotnet";
+    }
+    return start.then(() => {
+      return promisify(
+        gulp
+          .src(slnMasks, { allowEmpty: true })
+          .pipe(
+            nugetRestore(options)
+          )
+      ).then(() => {
+        debug("nuget restore complete!");
+      }).catch(e => {
+        console.error("nugetRestore errs:", e);
+        throw new ZarroError(e);
+      });
+    });
+  }
+);

package/gulp-tasks/pack.js

@@ -0,0 +1,118 @@
+const getToolsFolder = requireModule("get-tools-folder"),
+  path = require("path"),
+  throwIfNoFiles = requireModule("throw-if-no-files"),
+  dotnetCli = require("gulp-dotnet-cli"),
+  dotnetPack = dotnetCli.pack,
+  { incrementPackageVersion } = requireModule(
+    "gulp-increment-nuget-package-version"
+  ),
+  resolveMasks = requireModule("resolve-masks"),
+  env = requireModule("env"),
+  fs = requireModule("fs"),
+  { rewriteFile } = requireModule("rewrite-file"),
+  del = require("del"),
+  debug = require("debug")("pack"),
+  gulp = requireModule("gulp"),
+  { pack } = requireModule("gulp-nuget-pack");
+
+env.associate(
+  [
+    "PACKAGE_TARGET_FOLDER",
+    "DOTNET_CORE",
+    "PACK_INCLUDE_CSPROJ",
+    "PACK_EXCLUDE_CSPROJ",
+    "PACK_INCLUDE_NUSPEC",
+    "PACK_EXCLUDE_NUSPEC",
+    "PACK_INCREMENT_VERSION"
+  ],
+  ["pack"]
+);
+
+gulp.task(
+  "pack",
+  "Creates nupkgs from all nuspec files in this repo",
+  ["prepack"],
+  () => {
+    const target = env.resolve("PACKAGE_TARGET_FOLDER"),
+      isDotnetCore = env.resolveFlag("DOTNET_CORE"),
+      incrementVersion = env.resolveFlag("PACK_INCREMENT_VERSION"),
+      packerFn = isDotnetCore ? packWithDotnetCore : packWithNuget;
+    debug({
+      isDotnetCore,
+      incrementVersion
+    });
+    return packerFn(target, incrementVersion);
+  }
+);
+
+function removeBadEntities(buffer) {
+  const
+    s = buffer.toString().replace(/
/g, "");
+  return Buffer.from(s);
+}
+
+function packWithNuget(target, incrementVersion) {
+  const nuspecs = resolveMasks(
+    "PACK_INCLUDE_NUSPEC",
+    "PACK_EXCLUDE_NUSPEC",
+    p => (p || "").match(/\.nuspec$/) ? p : `${p}.nuspec`
+  );
+  let stream = gulp
+    .src(nuspecs, `!${getToolsFolder()}/**/*`)
+    .pipe(throwIfNoFiles("No nuspec files found"));
+  if (incrementVersion) {
+    stream = stream
+      .pipe(incrementPackageVersion())
+      .pipe(rewriteFile(removeBadEntities));
+  }
+  return stream
+    .pipe(pack())
+    .pipe(gulp.dest(target));
+}
+
+function packWithDotnetCore(target, incrementVersion) {
+  const projects = resolveMasks("PACK_INCLUDE_CSPROJ", "PACK_EXCLUDE_CSPROJ", p => {
+    return (p || "").match(/\.csproj$/) ? p : `${p}.csproj`;
+  });
+  const configuration = env.resolve("PACK_CONFIGURATION");
+  debug({
+    projects,
+    configuration
+  });
+  let stream = gulp
+    .src(projects, `!${getToolsFolder()}/**/*`)
+    .pipe(
+      throwIfNoFiles(
+        "No target projects found to pack; check PACK_INCLUDE / PACK_EXCLUDE"
+      )
+    );
+  if (incrementVersion) {
+    stream = stream
+      .pipe(incrementPackageVersion())
+      .pipe(rewriteFile(removeBadEntities));
+  }
+  return stream.pipe(
+    dotnetPack({
+      output: path.resolve(target),
+      configuration
+    })
+  );
+}
+
+gulp.task(
+  "prepack",
+  "Skeleton task which you can replace to run logic just before packing",
+  () => {
+    return Promise.resolve();
+  }
+);
+
+gulp.task(
+  "clean-packages",
+  "Removes any existing package artifacts",
+  async () => {
+    const packageFolder = process.env.PACKAGE_TARGET_FOLDER || "packages";
+    await del(packageFolder);
+    await fs.ensureDirectoryExists(packageFolder);
+  }
+);

package/gulp-tasks/purge.js

@@ -0,0 +1,94 @@
+const gulp = requireModule("gulp"),
+  env = requireModule("env"),
+  path = require("path"),
+  rimraf = require("rimraf"),
+  findDirs = requireModule("find-dirs"),
+  log = requireModule("log"),
+  debug = require("debug")("purge");
+
+env.associate([
+  "DRY_RUN",
+  "PURGE_JS_DIRS",
+  "PURGE_DOTNET_DIRS",
+  "PURGE_ADDITIONAL_DIRS"
+], [
+  "purge", "purge-dotnet", "mega-purge"
+]);
+
+function isNotInRootDir(dir) {
+  // where 'root dir' refers to the gulp context current dir
+  var inRootDir = path.resolve(path.basename(dir));
+  return inRootDir !== dir;
+}
+
+function doRegularRm(dir, inRootToo) {
+  const
+    dryRun = env.resolveFlag("DRY_RUN"),
+    del = d => dryRun ? log.info(`del: ${d}`) : rimraf.sync(d);
+  return new Promise((resolve, reject) => {
+    try {
+      debug(`searching for folders matching: ${dir}`);
+      var matches = findDirs(".", dir, ["node_modules", "bower_components"]);
+      debug(`got: ${matches}`);
+      if (!inRootToo) {
+        matches = matches.filter(isNotInRootDir);
+      }
+      if (matches.length === 0) {
+        debug(`-> nothing to do for ${dir}`);
+        return resolve();
+      }
+      matches.forEach(f => {
+        debug(`should purge: ${f}`);
+        del(f);
+        debug(`purge complete: ${f}`);
+      });
+      resolve();
+    } catch (e) {
+      debug(`whoops! ${e}`);
+      reject(e);
+    }
+  });
+}
+
+
+function doPurge(dirs, includeRootFolders) {
+  return Promise.all(dirs.map(d => doRegularRm(d, includeRootFolders))).then(
+    () => {
+      debug("-- PURGE COMPLETE! ---");
+    }
+  );
+}
+
+function listPurgeDirs(...varNames) {
+  return varNames.reduce(
+    (acc, cur) => {
+      const resolved = env.resolveArray(cur);
+      acc.push.apply(acc, resolved);
+      return acc;
+    }, []);
+}
+
+const
+  js = "PURGE_JS_DIRS",
+  dotnet = "PURGE_DOTNET_DIRS",
+  other = "PURGE_ADDITIONAL_DIRS";
+
+gulp.task(
+  "purge",
+  "Purges all bins, objs, node_modules, bower_components and packages not in the root",
+  function() {
+    return doPurge(listPurgeDirs(dotnet, js, other), false);
+  }
+);
+
+gulp.task("purge-dotnet", "Purges dotnet artifacts", () => {
+  return doPurge(listPurgeDirs(dotnet, other), false);
+});
+
+gulp.task(
+  "mega-purge",
+  "Performs regular purge and in the root (you'll have to `npm install` afterwards!",
+  function() {
+    return doPurge(listPurgeDirs(dotnet, js, other), true);
+  }
+);

package/gulp-tasks/release-npm.js

@@ -0,0 +1,58 @@
+"use strict";
+(function () {
+    const Git = require("simple-git/promise"), spawn = requireModule("spawn"), gulp = requireModule("gulp"), gutil = requireModule("gulp-util"), gitTag = requireModule("git-tag"), gitPushTags = requireModule("git-push-tags"), gitPush = requireModule("git-push"), readGitInfo = requireModule("read-git-info"), env = requireModule("env"), readPackageVersion = requireModule("read-package-version"), alterPackageJsonVersion = requireModule("alter-package-json-version");
+    async function rollBackPackageJson() {
+        await alterPackageJsonVersion({ loadUnsetFromEnvironment: true, incrementBy: -1 });
+    }
+    gulp.task("release-npm", ["increment-package-json-version"], async () => {
+        const dryRun = env.resolveFlag("DRY_RUN"), git = new Git(), version = await readPackageVersion(), isBeta = env.resolveFlag("BETA"), tag = `v${version}`, gitInfo = await readGitInfo();
+        try {
+            if (gitInfo.isGitRepository) {
+                const branchInfo = await git.branch();
+                // ignore this error:  couldn't find remote ref HEAD
+                // -> means this is an unknown (new) branch: we should push -u
+                if (gitInfo.remotes.length) {
+                    try {
+                        await git.pull(gitInfo.primaryRemote, branchInfo.current, {
+                            "--rebase": true,
+                            "--autostash": true
+                        });
+                    }
+                    catch (e) {
+                        const isNewBranch = (e.message || "").indexOf("couldn't find remote ref HEAD") > -1;
+                        if (!isNewBranch) {
+                            throw e;
+                        }
+                    }
+                }
+            }
+            if (dryRun) {
+                gutil.log(gutil.colors.yellow(`would publish ${version}`));
+            }
+            else {
+                const access = env.resolve("NPM_PUBLISH_ACCESS"), args = ["publish", "--access", access];
+                if (isBeta) {
+                    args.push("--tag", "beta");
+                }
+                await spawn("npm", args);
+            }
+        }
+        catch (e) {
+            await rollBackPackageJson();
+            throw e;
+        }
+        if (dryRun) {
+            gutil.log(gutil.colors.yellow(`would commit all updated files`));
+            await rollBackPackageJson();
+        }
+        else if (gitInfo.isGitRepository) {
+            await git.add(":/");
+            await git.commit(`:bookmark: bump package version to ${version}`);
+            await gitTag({ tag });
+            await Promise.all([
+                gitPush(dryRun),
+                gitPushTags(dryRun)
+            ]);
+        }
+    });
+})();

package/gulp-tasks/release-npm.ts

@@ -0,0 +1,81 @@
+(function() {
+  const
+    Git = require("simple-git/promise"),
+    spawn = requireModule<Spawn>("spawn"),
+    gulp = requireModule<GulpWithHelp>("gulp"),
+    gutil = requireModule<GulpUtil>("gulp-util"),
+    gitTag = requireModule<GitTag>("git-tag"),
+    gitPushTags = requireModule<GitPushTags>("git-push-tags"),
+    gitPush = requireModule<GitPush>("git-push"),
+    readGitInfo = requireModule<ReadGitInfo>("read-git-info"),
+    env = requireModule<Env>("env"),
+    readPackageVersion = requireModule<ReadPackageVersion>("read-package-version"),
+    alterPackageJsonVersion = requireModule<AlterPackageJson>("alter-package-json-version");
+
+  async function rollBackPackageJson() {
+    await alterPackageJsonVersion({ loadUnsetFromEnvironment: true, incrementBy: -1 });
+  }
+
+  gulp.task("release-npm", ["increment-package-json-version"], async () => {
+
+    const
+      dryRun = env.resolveFlag("DRY_RUN"),
+      git = new Git(),
+      version = await readPackageVersion(),
+      isBeta = env.resolveFlag("BETA"),
+      tag = `v${ version }`,
+      gitInfo = await readGitInfo();
+
+    try {
+      if (gitInfo.isGitRepository) {
+        const branchInfo = await git.branch();
+        // ignore this error:  couldn't find remote ref HEAD
+        // -> means this is an unknown (new) branch: we should push -u
+        if (gitInfo.remotes.length) {
+          try {
+            await git.pull(
+              gitInfo.primaryRemote,
+              branchInfo.current, {
+                "--rebase": true,
+                "--autostash": true
+              });
+          } catch (e) {
+            const isNewBranch = (e.message || "").indexOf("couldn't find remote ref HEAD") > -1;
+            if (!isNewBranch) {
+              throw e;
+            }
+          }
+        }
+      }
+
+      if (dryRun) {
+        gutil.log(gutil.colors.yellow(`would publish ${ version }`));
+      } else {
+        const
+          access = env.resolve("NPM_PUBLISH_ACCESS"),
+          args = ["publish", "--access", access];
+        if (isBeta) {
+          args.push("--tag", "beta");
+        }
+        await spawn("npm", args);
+      }
+    } catch (e) {
+      await rollBackPackageJson();
+      throw e;
+    }
+
+    if (dryRun) {
+      gutil.log(gutil.colors.yellow(`would commit all updated files`));
+      await rollBackPackageJson();
+    } else if (gitInfo.isGitRepository) {
+      await git.add(":/");
+      await git.commit(`:bookmark: bump package version to ${ version }`);
+      await gitTag({ tag });
+      await Promise.all([
+        gitPush(dryRun),
+        gitPushTags(dryRun)
+      ]);
+    }
+  });
+
+})();