@jdeighan/coffee-utils 11.0.3 → 11.0.5

package/src/utils.js

@@ -1,53 +1,88 @@
 // Generated by CoffeeScript 2.7.0
   // utils.coffee
 import {
-  LOG,
   assert,
   croak
 } from '@jdeighan/exceptions';
 
-export var sep_dash = '-'.repeat(42);
-
-export var sep_eq = '='.repeat(42);
+import {
+  LOG,
+  sep_dash,
+  sep_eq
+} from '@jdeighan/exceptions/log';
 
-export const undef = undefined;
+import {
+  undef,
+  pass,
+  defined,
+  notdefined,
+  deepCopy,
+  escapeStr,
+  unescapeStr,
+  hasChar,
+  quoted,
+  OL,
+  isString,
+  isNumber,
+  isInteger,
+  isHash,
+  isArray,
+  isBoolean,
+  isConstructor,
+  isFunction,
+  isRegExp,
+  isObject,
+  getClassName,
+  jsType,
+  isEmpty,
+  nonEmpty,
+  chomp,
+  rtrim,
+  setCharsAt,
+  words
+} from '@jdeighan/exceptions/utils';
+
+export {
+  undef,
+  pass,
+  defined,
+  notdefined,
+  sep_dash,
+  sep_eq,
+  deepCopy,
+  escapeStr,
+  unescapeStr,
+  hasChar,
+  quoted,
+  OL,
+  isString,
+  isNumber,
+  isInteger,
+  isHash,
+  isArray,
+  isBoolean,
+  isConstructor,
+  isFunction,
+  isRegExp,
+  isObject,
+  getClassName,
+  jsType,
+  isEmpty,
+  nonEmpty,
+  chomp,
+  rtrim,
+  setCharsAt,
+  words
+};
 
 // ---------------------------------------------------------------------------
 // TEMP!!!!!
-export var isComment = function(line) {
+export var isComment = (line) => {
   var lMatches;
   lMatches = line.match(/^\s*\#(\s|$)/);
   return defined(lMatches);
 };
 
-// ---------------------------------------------------------------------------
-export var chomp = function(str) {
-  var len, tail;
-  len = str.length;
-  if (len === 0) {
-    return '';
-  } else if (len === 1) {
-    if ((str === "\r") || (str === "\n")) {
-      return '';
-    } else {
-      return str;
-    }
-  } else {
-    // --- check the last 2 characters
-    tail = str.substring(len - 2);
-    if (tail === "\r\n") {
-      return str.substring(0, len - 2);
-    } else {
-      tail = str.substring(len - 1);
-      if (tail === "\n") {
-        return str.substring(0, len - 1);
-      } else {
-        return str;
-      }
-    }
-  }
-};
-
 // ---------------------------------------------------------------------------
 export var isSubclassOf = function(subClass, superClass) {
   return (subClass === superClass) || (subClass.prototype instanceof superClass);
@@ -59,10 +94,6 @@ export var eval_expr = function(str) {
   return Function('"use strict";return (' + str + ')')();
 };
 
-// ---------------------------------------------------------------------------
-//   pass - do nothing
-export var pass = function() {};
-
 // ---------------------------------------------------------------------------
 export var patchStr = function(bigstr, pos, str) {
   var endpos;
@@ -91,68 +122,6 @@ export var oneof = function(word, ...lWords) {
   return lWords.indexOf(word) >= 0;
 };
 
-// ---------------------------------------------------------------------------
-export var isConstructor = function(f) {
-  var err;
-  try {
-    new f();
-  } catch (error) {
-    err = error;
-    if (err.message.indexOf('is not a constructor') >= 0) {
-      return false;
-    }
-  }
-  return true;
-};
-
-// ---------------------------------------------------------------------------
-export var jsType = function(x) {
-  var lKeys;
-  if (notdefined(x)) {
-    return [undef, undef];
-  } else if (isString(x)) {
-    if (x.match(/^\s*$/)) {
-      return ['string', 'empty'];
-    } else {
-      return ['string', undef];
-    }
-  } else if (isNumber(x)) {
-    if (Number.isInteger(x)) {
-      return ['number', 'integer'];
-    } else {
-      return ['number', undef];
-    }
-  } else if (isBoolean(x)) {
-    return ['boolean', undef];
-  } else if (isHash(x)) {
-    lKeys = Object.keys(x);
-    if (lKeys.length === 0) {
-      return ['hash', 'empty'];
-    } else {
-      return ['hash', undef];
-    }
-  } else if (isArray(x)) {
-    if (x.length === 0) {
-      return ['array', 'empty'];
-    } else {
-      return ['array', undef];
-    }
-  } else if (isConstructor(x)) {
-    return ['function', 'constructor'];
-  } else if (isFunction(x)) {
-    return ['function', undef];
-  } else if (isObject(x)) {
-    return ['object', undef];
-  } else {
-    return croak(`Unknown type: ${OL(x)}`);
-  }
-};
-
-// ---------------------------------------------------------------------------
-export var isString = function(x) {
-  return (typeof x === 'string') || (x instanceof String);
-};
-
 // ---------------------------------------------------------------------------
 export var isNonEmptyString = function(x) {
   if (typeof x !== 'string' && !(x instanceof String)) {
@@ -164,67 +133,11 @@ export var isNonEmptyString = function(x) {
   return true;
 };
 
-// ---------------------------------------------------------------------------
-export var isBoolean = function(x) {
-  return typeof x === 'boolean';
-};
-
-// ---------------------------------------------------------------------------
-export var isObject = function(x, lReqKeys = undef) {
-  var i, key, len1, result;
-  result = (typeof x === 'object') && !isString(x) && !isArray(x) && !isHash(x) && !isNumber(x);
-  if (result) {
-    if (defined(lReqKeys)) {
-      assert(isArray(lReqKeys), "lReqKeys is not an array");
-      for (i = 0, len1 = lReqKeys.length; i < len1; i++) {
-        key = lReqKeys[i];
-        if (!x.hasOwnProperty(key)) {
-          return false;
-        }
-      }
-    }
-    return true;
-  } else {
-    return false;
-  }
-};
-
-// ---------------------------------------------------------------------------
-export var getClassName = function(obj) {
-  if (typeof obj !== 'object') {
-    return undef;
-  }
-  return obj.constructor.name;
-};
-
-// ---------------------------------------------------------------------------
-export var isArray = function(x) {
-  return Array.isArray(x);
-};
-
 // ---------------------------------------------------------------------------
 export var isNonEmptyArray = function(x) {
   return isArray(x) && (x.length > 0);
 };
 
-// ---------------------------------------------------------------------------
-export var isHash = function(x, lKeys) {
-  var i, key, len1;
-  if (!x || (getClassName(x) !== 'Object')) {
-    return false;
-  }
-  if (defined(lKeys)) {
-    assert(isArray(lKeys), "isHash(): lKeys not an array");
-    for (i = 0, len1 = lKeys.length; i < len1; i++) {
-      key = lKeys[i];
-      if (!x.hasOwnProperty(key)) {
-        return false;
-      }
-    }
-  }
-  return true;
-};
-
 // ---------------------------------------------------------------------------
 export var isNonEmptyHash = function(x) {
   return isHash(x) && (Object.keys(x).length > 0);
@@ -237,46 +150,6 @@ export var hashHasKey = function(x, key) {
   return x.hasOwnProperty(key);
 };
 
-// ---------------------------------------------------------------------------
-//   isEmpty
-//      - string is whitespace, array has no elements, hash has no keys
-export var isEmpty = function(x) {
-  if ((x === undef) || (x === null)) {
-    return true;
-  }
-  if (isString(x)) {
-    return x.match(/^\s*$/);
-  }
-  if (isArray(x)) {
-    return x.length === 0;
-  }
-  if (isHash(x)) {
-    return Object.keys(x).length === 0;
-  } else {
-    return false;
-  }
-};
-
-// ---------------------------------------------------------------------------
-//   nonEmpty
-//      - string has non-whitespace, array has elements, hash has keys
-export var nonEmpty = function(x) {
-  if (x == null) {
-    return false;
-  }
-  if (isString(x)) {
-    return !x.match(/^\s*$/);
-  }
-  if (isArray(x)) {
-    return x.length > 0;
-  }
-  if (isHash(x)) {
-    return Object.keys(x).length > 0;
-  } else {
-    return croak("isEmpty(): Invalid parameter");
-  }
-};
-
 // ---------------------------------------------------------------------------
 export var notInArray = function(lItems, item) {
   return lItems.indexOf(item) === -1;
@@ -292,22 +165,13 @@ export var pushCond = function(lItems, item, doPush = notInArray) {
   }
 };
 
-// ---------------------------------------------------------------------------
-export var words = function(str) {
-  str = str.trim();
-  if (str === '') {
-    return [];
-  }
-  return str.split(/\s+/);
-};
-
 // ---------------------------------------------------------------------------
 export var isArrayOfHashes = function(lItems) {
-  var i, item, len1;
+  var i, item, len;
   if (!isArray(lItems)) {
     return false;
   }
-  for (i = 0, len1 = lItems.length; i < len1; i++) {
+  for (i = 0, len = lItems.length; i < len; i++) {
     item = lItems[i];
     if (!isHash(item)) {
       return false;
@@ -318,11 +182,11 @@ export var isArrayOfHashes = function(lItems) {
 
 // ---------------------------------------------------------------------------
 export var isArrayOfStrings = function(lItems) {
-  var i, item, len1;
+  var i, item, len;
   if (!isArray(lItems)) {
     return false;
   }
-  for (i = 0, len1 = lItems.length; i < len1; i++) {
+  for (i = 0, len = lItems.length; i < len; i++) {
     item = lItems[i];
     if (!isString(item)) {
       return false;
@@ -331,57 +195,9 @@ export var isArrayOfStrings = function(lItems) {
   return true;
 };
 
-// ---------------------------------------------------------------------------
-export var isFunction = function(x) {
-  return typeof x === 'function';
-};
-
-// ---------------------------------------------------------------------------
-export var isRegExp = function(x) {
-  return x instanceof RegExp;
-};
-
-// ---------------------------------------------------------------------------
-export var isNumber = function(x, hOptions = undef) {
-  var max, min, result;
-  result = (typeof x === 'number') || (x instanceof Number);
-  if (result && defined(hOptions)) {
-    assert(isHash(hOptions), `2nd arg not a hash: ${OL(hOptions)}`);
-    ({min, max} = hOptions);
-    if (defined(min) && (x < min)) {
-      result = false;
-    }
-    if (defined(max) && (x > max)) {
-      result = false;
-    }
-  }
-  return result;
-};
-
-// ---------------------------------------------------------------------------
-export var isInteger = function(x, hOptions = {}) {
-  var result;
-  if (typeof x === 'number') {
-    result = Number.isInteger(x);
-  } else if (x instanceof Number) {
-    result = Number.isInteger(x.valueOf());
-  } else {
-    result = false;
-  }
-  if (result) {
-    if (defined(hOptions.min) && (x < hOptions.min)) {
-      result = false;
-    }
-    if (defined(hOptions.max) && (x > hOptions.max)) {
-      result = false;
-    }
-  }
-  return result;
-};
-
 // ---------------------------------------------------------------------------
 export var isUniqueList = function(lItems, func = undef) {
-  var h, i, item, len1;
+  var h, i, item, len;
   if (lItems == null) {
     return true; // empty list is unique
   }
@@ -389,7 +205,7 @@ export var isUniqueList = function(lItems, func = undef) {
     assert(isFunction(func), `Not a function: ${OL(func)}`);
   }
   h = {};
-  for (i = 0, len1 = lItems.length; i < len1; i++) {
+  for (i = 0, len = lItems.length; i < len; i++) {
     item = lItems[i];
     if (defined(func) && !func(item)) {
       return false;
@@ -404,14 +220,14 @@ export var isUniqueList = function(lItems, func = undef) {
 
 // ---------------------------------------------------------------------------
 export var isUniqueTree = function(lItems, func = undef, hFound = {}) {
-  var i, item, len1;
+  var i, item, len;
   if (isEmpty(lItems)) {
     return true; // empty list is unique
   }
   if (defined(func)) {
     assert(isFunction(func), `Not a function: ${OL(func)}`);
   }
-  for (i = 0, len1 = lItems.length; i < len1; i++) {
+  for (i = 0, len = lItems.length; i < len; i++) {
     item = lItems[i];
     if (isArray(item)) {
       if (!isUniqueTree(item, func, hFound)) {
@@ -473,20 +289,6 @@ export var titleLine = function(title, char = '=', padding = 2, linelen = 42) {
   return strLeft + strMiddle + strRight;
 };
 
-// ---------------------------------------------------------------------------
-//   rtrim - strip trailing whitespace
-export var rtrim = function(line) {
-  var lMatches, n;
-  assert(isString(line), "rtrim(): line is not a string");
-  lMatches = line.match(/\s+$/);
-  if (lMatches != null) {
-    n = lMatches[0].length; // num chars to remove
-    return line.substring(0, line.length - n);
-  } else {
-    return line;
-  }
-};
-
 // ---------------------------------------------------------------------------
 //   rtrunc - strip nChars chars from right of a string
 export var rtrunc = function(str, nChars) {
@@ -499,66 +301,6 @@ export var ltrunc = function(str, nChars) {
   return str.substring(nChars);
 };
 
-// ---------------------------------------------------------------------------
-//   deepCopy - deep copy an array or object
-export var deepCopy = function(obj) {
-  var err, newObj, objStr;
-  if (obj === undef) {
-    return undef;
-  }
-  objStr = JSON.stringify(obj);
-  try {
-    newObj = JSON.parse(objStr);
-  } catch (error) {
-    err = error;
-    croak("ERROR: err.message", objStr);
-  }
-  return newObj;
-};
-
-// ---------------------------------------------------------------------------
-//   escapeStr - escape newlines, TAB chars, etc.
-export var hDefEsc = {
-  "\n": '®',
-  "\t": '→',
-  " ": '˳'
-};
-
-export var escapeStr = function(str, hEscape = hDefEsc) {
-  var ch, lParts;
-  assert(isString(str), "escapeStr(): not a string");
-  lParts = (function() {
-    var i, len1, ref, results;
-    ref = str.split('');
-    results = [];
-    for (i = 0, len1 = ref.length; i < len1; i++) {
-      ch = ref[i];
-      if (hEscape[ch] != null) {
-        results.push(hEscape[ch]);
-      } else {
-        results.push(ch);
-      }
-    }
-    return results;
-  })();
-  return lParts.join('');
-};
-
-// ---------------------------------------------------------------------------
-export var oneline = function(obj) {
-  if (obj != null) {
-    if (isString(obj)) {
-      return `'${escapeStr(obj)}'`;
-    } else {
-      return JSON.stringify(obj);
-    }
-  } else {
-    return 'undef';
-  }
-};
-
-export var OL = oneline;
-
 // ---------------------------------------------------------------------------
 export var removeCR = function(str) {
   return str.replace(/\r/g, '');
@@ -575,9 +317,9 @@ export var extractMatches = function(line, regexp, convertFunc = undef) {
   var lConverted, lStrings, str;
   lStrings = [...line.matchAll(regexp)];
   lStrings = (function() {
-    var i, len1, results;
+    var i, len, results;
     results = [];
-    for (i = 0, len1 = lStrings.length; i < len1; i++) {
+    for (i = 0, len = lStrings.length; i < len; i++) {
       str = lStrings[i];
       results.push(str[0]);
     }
@@ -585,9 +327,9 @@ export var extractMatches = function(line, regexp, convertFunc = undef) {
   })();
   if (convertFunc != null) {
     lConverted = (function() {
-      var i, len1, results;
+      var i, len, results;
       results = [];
-      for (i = 0, len1 = lStrings.length; i < len1; i++) {
+      for (i = 0, len = lStrings.length; i < len; i++) {
         str = lStrings[i];
         results.push(convertFunc(str));
       }
@@ -601,14 +343,14 @@ export var extractMatches = function(line, regexp, convertFunc = undef) {
 
 // ---------------------------------------------------------------------------
 export var envVarsWithPrefix = function(prefix, hOptions = {}) {
-  var h, i, key, len1, plen, ref;
+  var h, i, key, len, plen, ref;
   // --- valid options:
   //        stripPrefix
   assert(prefix, "envVarsWithPrefix: empty prefix!");
   plen = prefix.length;
   h = {};
   ref = Object.keys(process.env);
-  for (i = 0, len1 = ref.length; i < len1; i++) {
+  for (i = 0, len = ref.length; i < len; i++) {
     key = ref[i];
     if (key.indexOf(prefix) === 0) {
       if (hOptions.stripPrefix) {
@@ -639,9 +381,9 @@ export var getDateStr = function(date = undef) {
 
 // ---------------------------------------------------------------------------
 export var strcat = function(...lItems) {
-  var i, item, len1, str;
+  var i, item, len, str;
   str = '';
-  for (i = 0, len1 = lItems.length; i < len1; i++) {
+  for (i = 0, len = lItems.length; i < len; i++) {
     item = lItems[i];
     str += item.toString();
   }
@@ -672,16 +414,6 @@ export var replaceVars = function(line, hVars = {}, rx = /__(env\.)?([A-Za-z_]\w
   return line.replace(rx, replacerFunc);
 };
 
-// ---------------------------------------------------------------------------
-export var defined = function(obj) {
-  return (obj !== undef) && (obj !== null);
-};
-
-// ---------------------------------------------------------------------------
-export var notdefined = function(obj) {
-  return (obj === undef) || (obj === null);
-};
-
 // ---------------------------------------------------------------------------
 export var isIterable = function(obj) {
   if ((obj === undef) || (obj === null)) {
@@ -710,25 +442,14 @@ export var range = function(n) {
   }).apply(this);
 };
 
-// ---------------------------------------------------------------------------
-export var setCharsAt = function(str, pos, str2) {
-  assert(pos >= 0, `negative pos ${pos} not allowed`);
-  assert(pos < str.length, `pos ${pos} not in ${OL(str)}`);
-  if (pos + str2.length >= str.length) {
-    return str.substring(0, pos) + str2;
-  } else {
-    return str.substring(0, pos) + str2 + str.substring(pos + str2.length);
-  }
-};
-
 // ---------------------------------------------------------------------------
 export var getOptions = function(hOptions, hDefault = {}) {
-  var h, i, len1, ref, word;
+  var h, i, len, ref, word;
   // --- If hOptions is a string, break into words and set each to true
   if (isString(hOptions)) {
     h = {};
     ref = words(hOptions);
-    for (i = 0, len1 = ref.length; i < len1; i++) {
+    for (i = 0, len = ref.length; i < len; i++) {
       word = ref[i];
       h[word] = true;
     }

package/src/arrow.coffee

@@ -1,65 +0,0 @@
-# arrow.coffee
-
-import {assert} from '@jdeighan/exceptions'
-import {undef, OL, setCharsAt} from '@jdeighan/coffee-utils'
-
-# --- We use spaces here because Windows Terminal handles TAB chars badly
-
-export vbar = '│'       # unicode 2502
-export hbar = '─'       # unicode 2500
-export corner = '└'     # unicode 2514
-export arrowhead = '>'
-export space = ' '
-export dot = '.'
-
-export oneIndent   = vbar   + space + space     + space
-export arrow       = corner + hbar  + arrowhead + space
-export clearIndent = space  + space + space     + space
-export dotIndent   = dot    + space + space     + space
-
-# ---------------------------------------------------------------------------
-
-export prefix = (level, option='none') ->
-
-	switch option
-		when 'withArrow'
-			if (level == 0)
-				return arrow
-			else
-				return oneIndent.repeat(level-1) + arrow
-		when 'noLastVbar'
-			assert (level >= 1), "prefix(), noLastVbar but level=#{OL(level)}"
-			return oneIndent.repeat(level-1) + clearIndent
-		when 'noLast2Vbars'
-			assert (level >= 2), "prefix(), noLast2Vbars but level=#{OL(level)}"
-			return oneIndent.repeat(level-2) + clearIndent + clearIndent
-		when 'dotLastVbar'
-			assert (level >= 1), "prefix(), dotLastVbar but level=#{OL(level)}"
-			return oneIndent.repeat(level-1) + dotIndent
-		when 'dotLast2Vbars'
-			assert (level >= 2), "prefix(), dotLast2Vbars but level=#{OL(level)}"
-			return oneIndent.repeat(level-2) + dotIndent + clearIndent
-		else
-			return oneIndent.repeat(level)
-
-# ---------------------------------------------------------------------------
-
-export addArrow = (prefix) ->
-
-	pos = prefix.lastIndexOf(vbar)
-	if (pos == -1)
-		result = prefix
-	else
-		result = setCharsAt(prefix, pos, arrow)
-	return result
-
-# ---------------------------------------------------------------------------
-
-export removeLastVbar = (prefix) ->
-
-	pos = prefix.lastIndexOf(vbar)
-	if (pos == -1)
-		result = prefix
-	else
-		result = setCharsAt(prefix, pos, ' ')
-	return result