zarro 1.92.0

package/gulp-tasks/modules/load-xml-file.js

@@ -0,0 +1,12 @@
+"use strict";
+(function () {
+    const fs = require("./fs"), { ZarroError } = requireModule("zarro-error"), parse = requireModule("./parse-xml-string");
+    module.exports = async function (filePath) {
+        const st = await fs.stat(filePath);
+        if (!st.isFile()) {
+            throw new ZarroError(`File not found: ${filePath}`);
+        }
+        const data = await fs.readFile(filePath, { encoding: "utf-8" });
+        return parse(data);
+    };
+})();

package/gulp-tasks/modules/load-xml-file.ts

@@ -0,0 +1,15 @@
+(function () {
+  const
+    fs = require("./fs"),
+    { ZarroError } = requireModule("zarro-error"),
+    parse = requireModule<ParseXmlString>("./parse-xml-string");
+
+  module.exports = async function (filePath: string) {
+    const st = await fs.stat(filePath);
+    if (!st.isFile()) {
+      throw new ZarroError(`File not found: ${filePath}`);
+    }
+    const data = await fs.readFile(filePath, { encoding: "utf-8" });
+    return parse(data);
+  }
+})();

package/gulp-tasks/modules/log-config.js

@@ -0,0 +1,31 @@
+const
+  padRight = require("./pad-right"),
+  log = requireModule("log"),
+  chalk = require("ansi-colors");
+
+function output(logLines) {
+  const longest = logLines
+    .map(o => o.title.length)
+    .reduce((acc, cur) => (acc > cur ? acc : cur), 0);
+  logLines
+    .sort((a, b) => (a.title > b.title ? 1 : 0))
+    .forEach(line => {
+      const pre = chalk.yellowBright(padRight(line.title, longest)),
+        next = chalk.cyanBright(`${line.value}`);
+      log.info(`${pre} : ${next}`);
+    });
+}
+
+function store(logLines, config, prop, title) {
+  const value = config[prop];
+  if (value !== undefined) {
+    logLines.push({ title, value });
+  }
+  return logLines
+}
+
+module.exports = function logConfig(config, labels) {
+  const logLines = Object.keys(labels).reduce(
+    (acc, cur) => store(acc, config, cur, labels[cur]), []);
+  output(logLines);
+}

package/gulp-tasks/modules/log.js

@@ -0,0 +1,142 @@
+const gutil = requireModule("gulp-util"),
+  DEBUG = 1,
+  INFO = 2,
+  NOTICE = 3,
+  WARNING = 4,
+  ERROR = 5,
+  levels = {
+    DEBUG,
+    INFO,
+    NOTICE,
+    WARNING
+  };
+const LogLevels = function () {
+};
+LogLevels.prototype = {
+  get Debug() {
+    return DEBUG;
+  },
+  get Info() {
+    return INFO;
+  },
+  get Notice() {
+    return NOTICE;
+  },
+  get Warning() {
+    return WARNING;
+  },
+  get Error() {
+    return ERROR;
+  }
+};
+const Logger = function () {
+  this.LogLevels = new LogLevels();
+  const logLevel = (process.env.LOG_LEVEL || "").toUpperCase();
+  this.setThreshold(levels[logLevel] || INFO);
+  this._timestamp = true;
+};
+Logger.prototype = {
+  get threshold() {
+    return this._threshold;
+  },
+  setThreshold: function(value) {
+    const intValue = parseInt(value);
+    if (isNaN(intValue) || intValue < 1 || intValue > 5) {
+      throw value +
+        " is not a valid integer value. Try use one of (logger).LogLevels.{Debug|Info|Notice|Warning|Error}";
+    }
+    this._threshold = intValue;
+  },
+  debug: function() {
+    const message = this._resolve(Array.from(arguments));
+    if (this._threshold > DEBUG) return;
+    this._print(message, "grey");
+  },
+  info: function() {
+    const message = this._resolve(Array.from(arguments));
+    if (this._threshold > INFO) return;
+    this._print(message, "yellow");
+  },
+  warning: function() {
+    const message = this._resolve(Array.from(arguments));
+    if (this._threshold > WARNING) return;
+    this._print(message, "magenta");
+  },
+  error: function() {
+    const message = this._resolve(Array.from(arguments));
+    this._print(message, "red", "bold");
+  },
+  fail: function() {
+    const message = this._resolve(Array.from(arguments));
+    this.error(message);
+  },
+  ok: function() {
+    const message = this._resolve(Array.from(arguments));
+    this._print(message, "green");
+  },
+  notice: function() {
+    const message = this._resolve(Array.from(arguments));
+    if (this._threshold > NOTICE) return;
+    this._print(message, "cyan");
+  },
+  suppressTimeStamps: function() {
+    this._timestamp = false;
+  },
+  showTimeStamps: function() {
+    this._timestamp = true;
+  },
+  _resolve: function(args) {
+    return args
+      .map(a => {
+        if (a === undefined) {
+          return "(undefined)";
+        }
+        if (a === null) {
+          return "(null)";
+        }
+        if (Array.isArray(a)) {
+          return a.join(",");
+        }
+        if (typeof a === "object") {
+          return JSON.stringify(a);
+        }
+        return a.toString();
+      })
+      .join(" ");
+  },
+  _print: function() {
+    const message = arguments[0];
+    const styles = [];
+    for (let i = 1; i < arguments.length; i++) {
+      styles.push(arguments[i]); // because arguments is an object, not an array...
+    }
+    const styleFunction = styles.reduce(
+      function (acc, cur) {
+        const fn = gutil.colors[cur];
+        if (fn === undefined) {
+          return acc;
+        }
+        return function (s) {
+          return fn(acc(s));
+        };
+      },
+      function (s) {
+        return s;
+      }
+    );
+    if (this._timestamp) {
+      gutil.log(styleFunction(message));
+    } else {
+      console.log(styleFunction(message));
+    }
+  }
+};
+const logger = new Logger();
+if (logger.threshold === DEBUG) {
+  logger.debug(" -- testing logger outputs -- ");
+  logger.debug("debug message");
+  logger.info("info message");
+  logger.warning("warning message");
+  logger.error("error message");
+}
+module.exports = logger;

package/gulp-tasks/modules/longest-string-length.js

@@ -0,0 +1,13 @@
+module.exports = function longestStringLength(arr) {
+  if (!arr) {
+    arr = "";
+  }
+  if (!Array.isArray(arr)) {
+    arr = [arr];
+  }
+  return arr.reduce(
+    (acc, cur) => {
+      const currentLength = ((cur || "").toString()).length;
+      return acc > currentLength ? acc : currentLength;
+    }, 0);
+}

package/gulp-tasks/modules/looks-like-a-promise.js

@@ -0,0 +1,11 @@
+module.exports = function(obj) {
+  if (!obj) {
+    return false;
+  }
+  if (obj instanceof Promise) {
+    return true;
+  }
+  return typeof obj === "object" &&
+          obj.then &&
+          typeof obj.then === "function";
+}

package/gulp-tasks/modules/ls-r.js

@@ -0,0 +1,52 @@
+var fs = require('fs'),
+  path = require('path'),
+  debug = require('debug')('ls-r');
+
+function isDir(p) {
+  try {
+    return fs.lstatSync(p).isDirectory();
+  } catch (ignore) {
+    return false;
+  }
+}
+
+function push(arr, item) {
+  arr.push(item);
+  return arr;
+}
+
+var defaultIgnores = [/node_modules/, /\.git/, /bower_components/];
+function tryReadDirSync(dir) {
+  try {
+    return fs.readdirSync(dir);
+  } catch (e) {
+    debug(`Error reading dir contents for ${dir} : ${e}`);
+    return [];
+  }
+}
+
+function ls_R(dir, ignores) {
+  dir = path.resolve(dir);
+  if (!fs.existsSync(dir)) {
+    return [];
+  }
+  ignores = ignores || defaultIgnores;
+  var current = tryReadDirSync(dir);
+  return current.reduce((acc, cur) => {
+    var fullPath = path.join(dir, cur);
+    var shouldIgnore = ignores.reduce((acc, cur) => {
+      return acc || cur.test(fullPath);
+    }, false);
+    if (shouldIgnore) {
+      debug(`ignoring ${fullPath}`);
+      return acc;
+    }
+    return isDir(fullPath)
+      ? acc.concat(ls_R(fullPath, ignores))
+      : push(acc, fullPath);
+  }, []);
+}
+
+ls_R.DEFAULT_IGNORES = defaultIgnores;
+
+module.exports = ls_R;

package/gulp-tasks/modules/multi-split.js

@@ -0,0 +1,29 @@
+function flatten(arrayOrValue) {
+  return arrayOrValue.reduce((acc, cur) => {
+    if (Array.isArray(cur)) {
+      acc.push.apply(acc, flatten(cur));
+    } else {
+      acc.push(cur);
+    }
+    return acc;
+  }, []);
+}
+module.exports = function multiSplit(str, delimiters) {
+  if (!str) {
+    return [];
+  }
+  delimiters = delimiters || "";
+  if (!Array.isArray(delimiters)) {
+    delimiters = [delimiters];
+  }
+  return flatten(
+    delimiters.reduce(
+      (allIterations, currentDelimiter) => {
+        return allIterations.reduce((subParts, part) => {
+          return subParts.concat(part.split(currentDelimiter));
+        }, []);
+      },
+      [str]
+    )
+  );
+};

package/gulp-tasks/modules/net-framework-test-assembly-filter.js

@@ -0,0 +1,45 @@
+const multiSplit = require("./multi-split"),
+  debug = require("debug")("net-framework-test-assembly-filter");
+
+function findBuildConfigFrom(pathParts) {
+  const oneUp = pathParts[pathParts.length - 2];
+  if (oneUp === undefined) {
+    return "";
+  }
+  if (oneUp.match(/^net(standard\d\.\d|\d{3}|coreapp\d\.\d)$/)) {
+    // one-up is a release target... travel one higher
+    return pathParts[pathParts.length - 3] || "";
+  }
+  return oneUp;
+}
+
+module.exports = function generateFilter(configuration) {
+  return function netFrameworkTestAssemblyFilter(vinylFile) {
+    const parts = multiSplit(vinylFile.path, ["/", "\\"]),
+      isNetCore = !!parts.filter(p => p.match(/^netcore/)).length,
+      assemblyName = parts[parts.length - 1].replace(/\.dll$/gi, ""),
+      isPrimary = !!parts
+        .slice(0, parts.length - 1)
+        .filter(p => p.toLowerCase() === assemblyName.toLowerCase()).length;
+    (isBin = !!parts.filter(p => p.match(/^bin$/i)).length),
+      (buildConfig = findBuildConfigFrom(parts)),
+      (isDebug = buildConfig.toLowerCase() === "debug"),
+      (isForConfig = buildConfig.toLowerCase() === configuration.toLowerCase()),
+      (isAny = (parts[parts.length - 1] || "").toLowerCase() === "bin"),
+      (include =
+        !isNetCore && isPrimary && isBin && (isDebug || isAny || isForConfig));
+    debug({
+      path: vinylFile.path,
+      parts,
+      buildConfig,
+      isNetCore,
+      isPrimary,
+      isDebug,
+      isAny,
+      isBin,
+      isForConfig,
+      include
+    });
+    return include;
+  };
+};

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

@@ -0,0 +1,66 @@
+const
+  spawn = require("./spawn"),
+  quoteIfRequired = require("./quote-if-required"),
+  splitPath = require("./split-path"),
+  env = require("./env"),
+  findLocalNuget = require("./find-local-nuget");
+
+function isDotnetCore(binaryPath) {
+  const
+    trimmed = binaryPath.replace(/^"/, "")
+              .replace(/"$/, ""),
+    parts = splitPath(trimmed),
+    executable = (parts[parts.length-1] || "");
+  return !!executable.match(/^dotnet(:?\.exe)?$/i);
+}
+
+async function nugetPush(
+  packageFile,
+  sourceName,
+  options) {
+  options = options || {};
+  options.suppressDuplicateError = options.suppressDuplicateError === undefined
+    ? env.resolveFlag("NUGET_IGNORE_DUPLICATE_PACKAGES")
+    : options.suppressDuplicateError;
+
+  const
+    apiKey = env.resolve("NUGET_API_KEY"),
+    nuget = await findLocalNuget(),
+    dnc = isDotnetCore(nuget),
+    sourceArg = dnc ? "--source" : "-Source",
+    // ffs dotnet core breaks things that used to be simple
+    // -> _some_ nuget commands require 'dotnet nuget ...'
+    // -> _others_ don't, eg 'dotnet restore'
+    start = dnc ? [ "nuget" ] : [],
+    args = start.concat([
+      "push",
+      quoteIfRequired(packageFile),
+      sourceArg,
+      sourceName || "nuget.org"
+    ]),
+    apiKeyArg = dnc ? "-k" : "-ApiKey";
+  if (apiKey) {
+    args.push.call(args, apiKeyArg, apiKey);
+  }
+  if (env.resolveFlag("DRY_RUN")) {
+    console.log(`nuget publish dry run: ${nuget} ${args.join(" ")}`);
+    return;
+  }
+  console.log(`pushing package ${packageFile}`);
+  try {
+    return await spawn(nuget, args);
+  } catch (e) {
+    if (e.info && Array.isArray(e.info.stderr)) {
+      const
+        errors = e.stderr.join("\n").trim(),
+        isDuplicatePackageError = errors.match(/: 409 /);
+      if (isDuplicatePackageError && options.suppressDuplicateError) {
+        console.warn(`ignoring duplicate package error: ${errors}`);
+        return e.info;
+      }
+    }
+    throw e;
+  }
+}
+
+module.exports = nugetPush;

package/gulp-tasks/modules/nuget-update-self.js

@@ -0,0 +1,9 @@
+const
+  exec = requireModule("exec");
+let updating = null;
+module.exports = function (nugetPath) {
+  if (updating) {
+    return updating;
+  }
+  return exec(nugetPath, [ "update", "-self" ]);
+}

package/gulp-tasks/modules/nuget.js

@@ -0,0 +1,8 @@
+"use strict";
+(function () {
+    const resolveNuget = require("./resolve-nuget"), findLocalNuget = require("./find-local-nuget"), exec = require("./exec");
+    module.exports = async function (args, execOpts) {
+        const resolvedNuget = await resolveNuget(null, false), nugetPath = resolvedNuget || await findLocalNuget(), argsCopy = args.slice();
+        return exec(nugetPath, argsCopy, execOpts);
+    };
+})();