@jdeighan/coffee-utils 7.0.59 → 7.0.62

package/src/debug_utils.js

@@ -1,6 +1,6 @@
 // Generated by CoffeeScript 2.7.0
   // debug_utils.coffee
-var debugDebug, doDebugDebug, lFuncList, lFunctions, reMethod, strFuncList,
+var lFuncList, reMethod, strFuncList,
   indexOf = [].indexOf;
 
 import {
@@ -13,6 +13,7 @@ import {
   isString,
   isFunction,
   isBoolean,
+  patchStr,
   OL,
   escapeStr,
   isNumber,
@@ -38,17 +39,18 @@ import {
 } from '@jdeighan/coffee-utils/stack';
 
 import {
-  getPrefix,
+  prefix,
   addArrow,
-  removeLastVbar
+  removeLastVbar,
+  vbar
 } from '@jdeighan/coffee-utils/arrow';
 
 import {
   log,
   logItem,
+  logBareItem,
   LOG,
-  shortEnough,
-  dashes
+  shortEnough
 } from '@jdeighan/coffee-utils/log';
 
 // --- set in resetDebugging() and setDebugging()
@@ -58,122 +60,70 @@ export var shouldLog = function() {
   return undef;
 };
 
-lFuncList = [];
+lFuncList = []; // names of functions being debugged
 
 strFuncList = undef; // original string
 
 
-// --- internal debugging
-doDebugDebug = false;
-
-lFunctions = undef; // --- only used when doDebugDebug is true
-
-
-// ---------------------------------------------------------------------------
-export var dumpCallStack = function(label) {
-  LOG(callStack.dump('', label));
-};
-
-// ---------------------------------------------------------------------------
-export var setDebugDebugging = function(value = true) {
-  // --- value can be a boolean or string of words
-  if (isBoolean(value)) {
-    doDebugDebug = value;
-  } else if (isString(value)) {
-    doDebugDebug = true;
-    lFunctions = words(value);
-  } else {
-    croak(`Bad value: ${OL(value)}`);
-  }
-};
-
 // ---------------------------------------------------------------------------
-debugDebug = function(label, ...lObjects) {
-  var doLog, dolog, funcName, nObjects, type;
-  if (!doDebugDebug) {
-    return;
-  }
-  // --- At this point, doDebugDebug is true
-  doDebugDebug = false; // temp - reset before returning
-  assert(isString(label), `1st arg ${OL(label)} should be a string`);
-  nObjects = lObjects.length;
-  [type, funcName] = getType(label, nObjects);
+export var debug = function(orgLabel, ...lObjects) {
+  var funcName, label, type;
+  assert(isString(orgLabel), `1st arg ${OL(orgLabel)} should be a string`);
+  [type, funcName] = getType(orgLabel, lObjects);
+  label = shouldLog(orgLabel, type, funcName, callStack);
   switch (type) {
     case 'enter':
-      assert(defined(funcName), "type enter, funcName = undef");
-      callStack.enter(funcName);
-      doLog = (lFunctions === undef) || (indexOf.call(lFunctions, funcName) >= 0);
+      if (defined(label)) {
+        doTheLogging(type, label, lObjects);
+      }
+      callStack.enter(funcName, lObjects, defined(label));
+      debug2("enter debug()", orgLabel, lObjects);
+      debug2(`type = ${OL(type)}, funcName = ${OL(funcName)}`);
+      debug2("return from debug()");
       break;
     case 'return':
-      assert(defined(funcName), "type return, funcName = undef");
-      doLog = (lFunctions === undef) || (indexOf.call(lFunctions, funcName) >= 0);
+      debug2("enter debug()", orgLabel, lObjects);
+      debug2(`type = ${OL(type)}, funcName = ${OL(funcName)}`);
+      debug2("return from debug()");
+      if (defined(label)) {
+        doTheLogging(type, label, lObjects);
+      }
+      callStack.returnFrom(funcName);
       break;
     case 'string':
-      assert(funcName === undef, "type string, funcName defined");
-      assert(nObjects === 0, `Objects not allowed for ${OL(type)}`);
-      doLog = true;
-      break;
-    case 'objects':
-      assert(funcName === undef, "type objects, funcName defined");
-      assert(nObjects > 0, `Objects required for ${OL(type)}`);
-      dolog = true;
-  }
-  if (doLog) {
-    doTheLogging(type, label, lObjects);
-  }
-  if ((type === 'enter') && doLog) {
-    callStack.logCurFunc(funcName);
-  } else if (type === 'return') {
-    callStack.returnFrom(funcName);
+      debug2("enter debug()", orgLabel, lObjects);
+      debug2(`type = ${OL(type)}, funcName = ${OL(funcName)}`);
+      if (defined(label)) {
+        doTheLogging(type, label, lObjects);
+      }
+      debug2("return from debug()");
   }
-  doDebugDebug = true;
+  return true; // allow use in boolean expressions
 };
 
+
 // ---------------------------------------------------------------------------
-export var debug = function(label, ...lObjects) {
-  var doLog, funcName, nObjects, type;
-  assert(isString(label), `1st arg ${OL(label)} should be a string`);
-  // --- If label is "enter <funcname>, we need to put that on the stack
-  //     BEFORE we do any internal logging
-  nObjects = lObjects.length;
-  [type, funcName] = getType(label, nObjects);
-  if (type === 'enter') {
-    callStack.enter(funcName);
-  }
-  debugDebug(`enter debug(${OL(label)})`, ...lObjects);
-  debugDebug(`type = ${OL(type)}`);
-  debugDebug(`funcName = ${OL(funcName)}`);
-  // --- function shouldLog() returns the (possibly modified) label
-  //     if we should log this, else it returns undef
+export var debug2 = function(orgLabel, ...lObjects) {
+  var funcName, label, type;
+  [type, funcName] = getType(orgLabel, lObjects);
+  label = shouldLog(orgLabel, type, funcName, callStack);
   switch (type) {
     case 'enter':
-      label = shouldLog(label, type, funcName, callStack);
+      if (defined(label)) {
+        doTheLogging('enter', label, lObjects);
+      }
+      callStack.enter(funcName, lObjects, defined(label));
       break;
     case 'return':
-      label = shouldLog(label, type, funcName, callStack);
+      if (defined(label)) {
+        doTheLogging('return', label, lObjects);
+      }
+      callStack.returnFrom(funcName);
       break;
     case 'string':
-      label = shouldLog(label, type, undef, callStack);
-      assert(nObjects === 0, `Objects not allowed for ${OL(type)}`);
-      break;
-    case 'objects':
-      label = shouldLog(label, type, undef, callStack);
-      assert(nObjects > 0, `Objects required for ${OL(type)}`);
-  }
-  assert((label === undef) || isString(label), `label not a string: ${OL(label)}`);
-  doLog = defined(label);
-  debugDebug(`doLog = ${OL(doLog)}`);
-  debugDebug(`${nObjects} objects`);
-  if (doLog) {
-    doTheLogging(type, label, lObjects);
-  }
-  if ((type === 'enter') && doLog && (label.indexOf('call') === -1)) {
-    callStack.logCurFunc(funcName);
-  }
-  // --- This must be called BEFORE we return from funcName
-  debugDebug("return from debug()");
-  if (type === 'return') {
-    callStack.returnFrom(funcName);
+      if (defined(label)) {
+        doTheLogging('string', label, lObjects);
+      }
   }
   return true; // allow use in boolean expressions
 };
@@ -181,54 +131,48 @@ export var debug = function(label, ...lObjects) {
 
 // ---------------------------------------------------------------------------
 export var doTheLogging = function(type, label, lObjects) {
-  var i, itemPrefix, j, k, l, len, len1, len2, level, obj, prefix, sep;
+  var i, itemPre, j, k, l, len, len1, len2, level, obj, pre;
+  assert(isString(label), `non-string label ${OL(label)}`);
   level = callStack.getLevel();
-  prefix = getPrefix(level);
-  itemPrefix = removeLastVbar(prefix);
-  sep = dashes(itemPrefix, 40);
-  assert(isString(sep), "sep is not a string");
-  debugDebug("callStack", callStack);
-  debugDebug(`level = ${OL(level)}`);
-  debugDebug(`prefix = ${OL(prefix)}`);
-  debugDebug(`itemPrefix = ${OL(itemPrefix)}`);
-  debugDebug(`sep = ${OL(sep)}`);
   switch (type) {
     case 'enter':
-      log(label, {prefix});
+      log(label, prefix(level));
+      if (label.match(/^\s*call/)) {
+        pre = prefix(level + 1, 'noLastVbar');
+        itemPre = prefix(level + 2, 'noLast2Vbars');
+      } else {
+        pre = prefix(level + 1);
+        itemPre = prefix(level + 2, 'noLastVbar');
+      }
       for (i = j = 0, len = lObjects.length; j < len; i = ++j) {
         obj = lObjects[i];
-        if (i > 0) {
-          log(sep);
-        }
-        logItem(undef, obj, {itemPrefix});
+        logItem(`arg[${i}]`, obj, pre, itemPre);
       }
       break;
     case 'return':
-      log(label, {
-        prefix: addArrow(prefix)
-      });
+      log(label, prefix(level, 'withArrow'));
+      pre = prefix(level, 'noLastVbar');
+      itemPre = prefix(level + 1, 'noLast2Vbars');
       for (i = k = 0, len1 = lObjects.length; k < len1; i = ++k) {
         obj = lObjects[i];
-        if (i > 0) {
-          log(sep);
-        }
-        logItem(undef, obj, {itemPrefix});
+        logItem(`ret[${i}]`, obj, pre, itemPre);
       }
       break;
     case 'string':
-      log(label, {prefix});
-      break;
-    case 'objects':
-      if ((lObjects.length === 1) && shortEnough(label, lObjects[0])) {
-        logItem(label, lObjects[0], {prefix});
+      pre = prefix(level);
+      itemPre = prefix(level + 1, 'noLastVbar');
+      if (lObjects.length === 0) {
+        log(label, pre);
+      } else if ((lObjects.length === 1) && shortEnough(label, lObjects[0])) {
+        logItem(label, lObjects[0], pre);
       } else {
         if (label.indexOf(':') !== label.length - 1) {
           label += ':';
         }
-        log(label, {prefix});
+        log(label, pre);
         for (l = 0, len2 = lObjects.length; l < len2; l++) {
           obj = lObjects[l];
-          logItem(undef, obj, {prefix});
+          logBareItem(obj, itemPre);
         }
       }
   }
@@ -236,59 +180,54 @@ export var doTheLogging = function(type, label, lObjects) {
 
 // ---------------------------------------------------------------------------
 export var stdShouldLog = function(label, type, funcName, stack) {
-  var prevLogged, result;
+  var result;
   // --- if type is 'enter', then funcName won't be on the stack yet
   //     returns the (possibly modified) label to log
-
-  // --- If we're logging now,
-  //     but we won't be logging when funcName is activated
-  //     then change 'enter' to 'call'
   assert(isString(label), `label ${OL(label)} not a string`);
   assert(isString(type), `type ${OL(type)} not a string`);
+  assert(stack instanceof CallStack, "not a call stack object");
   if ((type === 'enter') || (type === 'return')) {
     assert(isString(funcName), `func name ${OL(funcName)} not a string`);
   } else {
     assert(funcName === undef, `func name ${OL(funcName)} not undef`);
   }
-  assert(stack instanceof CallStack, "not a call stack object");
-  debugDebug(`enter stdShouldLog(${OL(label)}, ${OL(type)}, ${OL(funcName)}, stack)`);
-  switch (type) {
-    case 'enter':
-      if (funcMatch()) {
-        debugDebug(`return ${OL(label)} from stdShouldLog() - funcMatch`);
-        return label;
-      } else {
-        // --- As a special case, if we enter a function where we will not
-        //     be logging, but we were logging in the calling function,
-        //     we'll log out the call itself
-        prevLogged = stack.isLoggingPrev();
-        if (prevLogged) {
-          result = label.replace('enter', 'call');
-          debugDebug(`return ${OL(result)} from stdShouldLog() - s/enter/call/`);
-          return result;
-        }
-      }
-      break;
-    default:
-      if (funcMatch()) {
-        debugDebug(`return ${OL(label)} from stdShouldLog()`);
-        return label;
-      }
+  if (funcMatch(funcName || stack.curFunc())) {
+    return label;
+  }
+  if ((type === 'enter') && !isMyFunc(funcName)) {
+    // --- As a special case, if we enter a function where we will not
+    //     be logging, but we were logging in the calling function,
+    //     we'll log out the call itself
+    if (funcMatch(stack.curFunc())) {
+      result = label.replace('enter', 'call');
+      return result;
+    }
   }
-  debugDebug("return undef from stdShouldLog()");
   return undef;
 };
 
+// ---------------------------------------------------------------------------
+export var isMyFunc = function(funcName) {
+  return indexOf.call(words('debug debug2 doTheLogging stdShouldLog setDebugging getFuncList funcMatch getType dumpCallStack'), funcName) >= 0;
+};
+
+// ---------------------------------------------------------------------------
+export var trueShouldLog = function(label, type, funcName, stack) {
+  if (isMyFunc(funcName || stack.curFunc())) {
+    return undef;
+  } else {
+    return label;
+  }
+};
+
 // ---------------------------------------------------------------------------
 export var setDebugging = function(option) {
   callStack.reset();
   if (isBoolean(option)) {
     if (option) {
-      shouldLog = function(label, type, funcName, stack) {
-        return label;
-      };
+      shouldLog = trueShouldLog;
     } else {
-      shouldLog = function(label, type, funcName, stack) {
+      shouldLog = function() {
         return undef;
       };
     }
@@ -334,40 +273,31 @@ export var getFuncList = function(str) {
 
 // ---------------------------------------------------------------------------
 // --- export only to allow unit tests
-export var funcMatch = function() {
-  var curFunc, h, j, len, name, object, plus;
+export var funcMatch = function(funcName) {
+  var h, j, len, name, object, plus;
   assert(isArray(lFuncList), `not an array ${OL(lFuncList)}`);
-  debugDebug("enter funcMatch()");
-  curFunc = callStack.curFunc();
-  debugDebug(`curFunc = ${OL(curFunc)}`);
-  debugDebug(`lFuncList = ${strFuncList}`);
   for (j = 0, len = lFuncList.length; j < len; j++) {
     h = lFuncList[j];
     ({name, object, plus} = h);
-    if (name === curFunc) {
-      debugDebug("return from funcMatch() - curFunc in lFuncList");
+    if (name === funcName) {
       return true;
     }
     if (plus && callStack.isActive(name)) {
-      debugDebug(`return from funcMatch() - func ${OL(name)} is active`);
       return true;
     }
   }
-  debugDebug("return from funcMatch() - no match");
   return false;
 };
 
 // ---------------------------------------------------------------------------
-// --- type is one of: 'enter', 'return', 'string', 'object'
-export var getType = function(str, nObjects) {
+// --- type is one of: 'enter', 'return', 'string'
+export var getType = function(str, lObjects) {
   var lMatches;
   if (lMatches = str.match(/^\s*enter\s+([A-Za-z_][A-Za-z0-9_\.]*)/)) {
     // --- We are entering function curFunc
     return ['enter', lMatches[1]];
   } else if (lMatches = str.match(/^\s*return.+from\s+([A-Za-z_][A-Za-z0-9_\.]*)/)) {
     return ['return', lMatches[1]];
-  } else if (nObjects > 0) {
-    return ['objects', undef];
   } else {
     return ['string', undef];
   }
@@ -377,3 +307,23 @@ export var getType = function(str, nObjects) {
 reMethod = /^([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/;
 
 // ---------------------------------------------------------------------------
+export var dumpDebugGlobals = function() {
+  var funcName, j, len;
+  LOG('='.repeat(40));
+  LOG(callStack.dump());
+  if (shouldLog === stdShouldLog) {
+    LOG("using stdShouldLog");
+  } else if (shouldLog === trueShouldLog) {
+    LOG("using trueShouldLog");
+  } else {
+    LOG("using custom shouldLog");
+  }
+  LOG("lFuncList:");
+  for (j = 0, len = lFuncList.length; j < len; j++) {
+    funcName = lFuncList[j];
+    LOG(`   ${OL(funcName)}`);
+  }
+  return LOG('='.repeat(40));
+};
+
+// ---------------------------------------------------------------------------

package/src/log_utils.coffee

@@ -20,12 +20,6 @@ fourSpaces  = '    '
 
 # ---------------------------------------------------------------------------
 
-export dashes = (prefix, totalLen=64, ch='-') ->
-
-	return prefix + ch.repeat(totalLen - prefix.length)
-
-# ---------------------------------------------------------------------------
-
 export debugLog = (flag=true) ->
 
 	doDebugLog = flag
@@ -62,6 +56,15 @@ export DEBUG = LOG   # synonym
 
 # ---------------------------------------------------------------------------
 
+export LOGLINES = (label, lLines) ->
+
+	LOG "#{label}:"
+	for line in lLines
+		LOG "#{OL(line)}"
+	return
+
+# ---------------------------------------------------------------------------
+
 export setStringifier = (func) ->
 
 	orgStringifier = stringify
@@ -109,7 +112,7 @@ export tamlStringify = (obj, escape=false) ->
 		lineWidth: -1
 		replacer: if escape then escReplacer else (name,value) -> value
 		})
-	return "---\n" + tabify(str, 1)
+	return "---\n" + str
 
 # ---------------------------------------------------------------------------
 
@@ -123,7 +126,7 @@ export orderedStringify = (obj, escape=false) ->
 		replacer: if escape then escReplacer else (name,value) -> value
 		})
 
-	return "---\n" + tabify(str, 1)
+	return "---\n" + str
 
 # ---------------------------------------------------------------------------
 
@@ -131,14 +134,12 @@ maxOneLine = 32
 
 # ---------------------------------------------------------------------------
 
-export log = (str, hOptions={}) ->
-	# --- valid options:
-	#   prefix
+export log = (str, prefix='') ->
 
+	assert isString(prefix), "not a string: #{OL(prefix)}"
 	assert isString(str),      "log(): not a string: #{OL(str)}"
 	assert isFunction(putstr), "putstr not properly set"
-	assert isHash(hOptions),   "log(): arg 2 not a hash: #{OL(hOptions)}"
-	prefix = fixForTerminal(hOptions.prefix)
+	prefix = fixForTerminal(prefix)
 
 	if doDebugLog
 		LOG "CALL log(#{OL(str)}), prefix = #{OL(prefix)}"
@@ -148,42 +149,51 @@ export log = (str, hOptions={}) ->
 
 # ---------------------------------------------------------------------------
 
-export logItem = (label, item, hOptions={}) ->
-	# --- valid options:
-	#   prefix
+export logBareItem = (item, pre='') ->
 
+	logItem undef, item, pre
+	return
+
+# ---------------------------------------------------------------------------
+
+export logItem = (label, item, pre='', itemPre=undef) ->
+
+	assert isString(pre), "not a string: #{OL(pre)}"
 	assert isFunction(putstr), "putstr not properly set"
 	assert !label || isString(label), "label a non-string"
-	assert isHash(hOptions), "arg 3 not a hash"
+	if (itemPre == undef)
+		itemPre = pre
 
-	label = fixForTerminal(label)
-	prefix = fixForTerminal(hOptions.prefix)
-	assert prefix.indexOf("\t") == -1, "prefix has TAB"
+	assert pre.indexOf("\t") == -1, "pre has TAB"
+	assert itemPre.indexOf("\t") == -1, "itemPre has TAB"
 
 	if doDebugLog
 		LOG "CALL logItem(#{OL(label)}, #{OL(item)})"
-		LOG "prefix = #{OL(prefix)}"
+		LOG "pre = #{OL(pre)}"
+		LOG "itemPre = #{OL(itemPre)}"
 
 	labelStr = if label then "#{label} = " else ""
 
 	if (item == undef)
-		putstr "#{prefix}#{labelStr}undef"
+		putstr "#{pre}#{labelStr}undef"
 	else if (item == null)
-		putstr "#{prefix}#{labelStr}null"
+		putstr "#{pre}#{labelStr}null"
+	else if isNumber(item)
+		putstr "#{pre}#{labelStr}#{item}"
 	else if isString(item)
 		if (item.length <= maxOneLine)
-			putstr "#{prefix}#{labelStr}'#{escapeStr(item)}'"
+			putstr "#{pre}#{labelStr}'#{escapeStr(item)}'"
 		else
 			if label
-				putstr "#{prefix}#{label}:"
-			putBlock item, prefix + fourSpaces
-	else if isNumber(item)
-		putstr "#{prefix}#{labelStr}#{item}"
+				putstr "#{pre}#{label}:"
+			putBlock item, itemPre
 	else
 		if label
-			putstr "#{prefix}#{label}:"
-		for str in blockToArray(stringify(item, true))  # escape special chars
-			putstr "#{prefix + fourSpaces}#{fixForTerminal(str)}"
+			putstr "#{pre}#{label}:"
+
+		# --- escape special chars
+		for str in blockToArray(stringify(item, true))
+			putstr "#{itemPre}#{str}"
 
 	return true