@jdeighan/coffee-utils 7.0.55 → 7.0.58

package/Debugging.md

@@ -0,0 +1,6 @@
+Debugging CoffeeScript:
+
+1. install JetBrains IntellijIDE
+2. create file test/counting.coffee
+3. compile the file with the sourcemap option:
+      coffee -c -m test/counting.coffee

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "7.0.55",
+	"version": "7.0.58",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {

package/src/call_stack.coffee

@@ -105,7 +105,7 @@ export class CallStack
 			LOG "[<-- BACK #{fName}]"
 
 		if @lStack.length == 0
-			LOG "ERROR: returnFrom('#{funcName}') but stack is empty"
+			LOG "ERROR: returnFrom('#{fName}') but stack is empty"
 			return
 
 		{fullName, isLogged} = @lStack.pop()
@@ -155,10 +155,10 @@ export class CallStack
 
 	dump: (prefix='', label='CALL STACK') ->
 
-		LOG "#{label}:"
+		lLines = ["#{label}:"]
 		if @lStack.length == 0
-			LOG "   <EMPTY>"
+			lLines.push "   <EMPTY>"
 		else
 			for item, i in @lStack
-				LOG "   #{i}: #{item.fullName} #{item.isLogged}"
-		return
+				lLines.push "   #{i}: #{item.fullName} #{item.isLogged}"
+		return lLines.join("\n") + "\n"

package/src/call_stack.js

@@ -107,7 +107,7 @@ export var CallStack = class CallStack {
       LOG(`[<-- BACK ${fName}]`);
     }
     if (this.lStack.length === 0) {
-      LOG(`ERROR: returnFrom('${funcName}') but stack is empty`);
+      LOG(`ERROR: returnFrom('${fName}') but stack is empty`);
       return;
     }
     ({fullName, isLogged} = this.lStack.pop());
@@ -160,17 +160,18 @@ export var CallStack = class CallStack {
   // ........................................................................
   // ........................................................................
   dump(prefix = '', label = 'CALL STACK') {
-    var i, item, j, len, ref;
-    LOG(`${label}:`);
+    var i, item, j, lLines, len, ref;
+    lLines = [`${label}:`];
     if (this.lStack.length === 0) {
-      LOG("   <EMPTY>");
+      lLines.push("   <EMPTY>");
     } else {
       ref = this.lStack;
       for (i = j = 0, len = ref.length; j < len; i = ++j) {
         item = ref[i];
-        LOG(`   ${i}: ${item.fullName} ${item.isLogged}`);
+        lLines.push(`   ${i}: ${item.fullName} ${item.isLogged}`);
       }
     }
+    return lLines.join("\n") + "\n";
   }
 
 };

package/src/debug_utils.coffee

@@ -17,15 +17,66 @@ import {
 	} from '@jdeighan/coffee-utils/log'
 
 callStack = new CallStack()
-doDebugDebug = false
 
-export shouldLog = undef  # set in resetDebugging() and setDebugging()
+# --- set in resetDebugging() and setDebugging()
+export shouldLog = () -> undef
 export lFuncList = []
 
+# --- internal debugging
+doDebugDebug = false
+lFunctions = undef     # --- only used when doDebugDebug is true
+
+# ---------------------------------------------------------------------------
+
+export setDebugDebugging = (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)}"
+	return
+
+# ---------------------------------------------------------------------------
+
+logif = (label, lObjects...) ->
+
+	if ! doDebugDebug
+		return
+
+	assert isString(label), "1st arg #{OL(label)} should be a string"
+	nObjects = lObjects.length
+	[type, funcName] = getType(label, nObjects)
+
+	level = callStack.getLevel()
+	prefix = getPrefix(level)
+	itemPrefix = removeLastVbar(prefix)
+	sep = dashes(itemPrefix, 40)
+
+	if (type == 'enter')
+		if defined(lFunctions) && (funcName not in lFunctions)
+			return
+		callStack.enter funcName
+	else if (type == 'return')
+		if defined(lFunctions) && (funcName not in lFunctions)
+			return
+
+	doTheLogging type, label, lObjects
+
+	if (type == 'return')
+		callStack.returnFrom funcName
+
+	return
+
 # ---------------------------------------------------------------------------
 
 export debug = (label, lObjects...) ->
 
+	logif "enter debug(#{OL(label)})", lObjects...
+
 	assert isString(label), "1st arg #{OL(label)} should be a string"
 
 	# --- We want to allow objects to be undef. Therefore, we need to
@@ -34,9 +85,11 @@ export debug = (label, lObjects...) ->
 
 	# --- funcName is only set for types 'enter' and 'return'
 	[type, funcName] = getType(label, nObjects)
-	if doDebugDebug
-		LOG "debug(): type = #{OL(type)}"
-		LOG "debug(): funcName = #{OL(funcName)}"
+	logif "type = #{OL(type)}"
+	logif "funcName = #{OL(funcName)}"
+
+	# --- function shouldLog() returns the (possibly modified) label
+	#     if we should log this, else it returns undef
 
 	switch type
 		when 'enter'
@@ -47,65 +100,73 @@ export debug = (label, lObjects...) ->
 		when 'string'
 			label = shouldLog(label, type, undef, callStack)
 			assert (nObjects == 0),
-					"multiple objects only not allowed for #{OL(type)}"
+					"Objects not allowed for #{OL(type)}"
 		when 'objects'
 			label = shouldLog(label, type, undef, callStack)
 			assert (nObjects > 0),
-					"multiple objects only not allowed for #{OL(type)}"
-	doLog = defined(label)
+					"Objects required for #{OL(type)}"
 
-	if doDebugDebug
-		if nObjects == 0
-			LOG "debug(#{OL(label)}) - 1 arg"
-		else
-			LOG "debug(#{OL(label)}), #{nObjects} args"
-		LOG "doLog = #{OL(doLog)}"
+	assert (label == undef) || isString(label),
+			"label not a string: #{OL(label)}"
+	doLog = defined(label)
+	logif "doLog = #{OL(doLog)}"
+	logif "#{nObjects} objects"
 
 	if doLog
-		level = callStack.getLevel()
-		prefix = getPrefix(level)
-
-		if doDebugDebug
-			LOG "callStack", callStack
-			LOG "level = #{OL(level)}"
-			LOG "prefix = #{OL(prefix)}"
-
-		switch type
-			when 'enter'
-				log label, {prefix}
-				prefix = removeLastVbar(prefix)
-				for obj,i in lObjects
-					if (i > 0)
-						log dashes(prefix)
-					logItem undef, obj, {prefix}
-			when 'return'
-				log label, {prefix: addArrow(prefix)}
-				prefix = removeLastVbar(prefix)
-				for obj,i in lObjects
-					if (i > 0)
-						log dashes(prefix)
-					logItem undef, obj, {prefix}
-			when 'string'
-				log label, {prefix}
-			when 'objects'
-				if (nObjects==1) && shortEnough(label, lObjects[0])
-					logItem label, lObjects[0], {prefix}
-				else
-					if (label.indexOf(':') != label.length - 1)
-						label += ':'
-					log label, {prefix}
-					for obj in lObjects
-						logItem undef, obj, {prefix}
+		doTheLogging type, label, lObjects
 
 	if (type == 'enter') && doLog && (label.indexOf('call') == -1)
 		callStack.logCurFunc()
 	else if (type == 'return')
 		callStack.returnFrom funcName
 
+	logif "return from debug()"
 	return true   # allow use in boolean expressions
 
 # ---------------------------------------------------------------------------
 
+export doTheLogging = (type, label, lObjects) ->
+
+	level = callStack.getLevel()
+	prefix = getPrefix(level)
+	itemPrefix = removeLastVbar(prefix)
+	sep = dashes(itemPrefix, 40)
+	assert isString(sep), "sep is not a string"
+
+	logif "callStack", callStack
+	logif "level = #{OL(level)}"
+	logif "prefix = #{OL(prefix)}"
+	logif "itemPrefix = #{OL(itemPrefix)}"
+	logif "sep = #{OL(sep)}"
+
+	switch type
+		when 'enter'
+			log label, {prefix}
+			for obj,i in lObjects
+				if (i > 0)
+					log sep
+				logItem undef, obj, {itemPrefix}
+		when 'return'
+			log label, {prefix: addArrow(prefix)}
+			for obj,i in lObjects
+				if (i > 0)
+					log sep
+				logItem undef, obj, {itemPrefix}
+		when 'string'
+			log label, {prefix}
+		when 'objects'
+			if (lObjects.length==1) && shortEnough(label, lObjects[0])
+				logItem label, lObjects[0], {prefix}
+			else
+				if (label.indexOf(':') != label.length - 1)
+					label += ':'
+				log label, {prefix}
+				for obj in lObjects
+					logItem undef, obj, {prefix}
+	return
+
+# ---------------------------------------------------------------------------
+
 export stdShouldLog = (label, type, funcName, stack) ->
 	# --- if type is 'enter', then funcName won't be on the stack yet
 	#     returns the (possibly modified) label to log
@@ -122,10 +183,9 @@ export stdShouldLog = (label, type, funcName, stack) ->
 		assert funcName == undef, "func name #{OL(funcName)} not undef"
 	assert stack instanceof CallStack, "not a call stack object"
 
-	if doDebugDebug
-		LOG "stdShouldLog(#{OL(label)}, #{OL(type)}, #{OL(funcName)}, stack)"
-		LOG "stack", stack
-		LOG "lFuncList", lFuncList
+	logif "stdShouldLog(#{OL(label)}, #{OL(type)}, #{OL(funcName)}, stack)"
+	logif "stack", stack
+	logif "lFuncList", lFuncList
 
 	switch type
 		when 'enter'
@@ -147,45 +207,19 @@ export stdShouldLog = (label, type, funcName, stack) ->
 
 # ---------------------------------------------------------------------------
 
-export debugDebug = (flag=true) ->
-
-	doDebugDebug = flag
-	if doDebugDebug
-		LOG "doDebugDebug = #{flag}"
-	return
-
-# ---------------------------------------------------------------------------
-
-resetDebugging = () ->
-
-	if doDebugDebug
-		LOG "resetDebugging()"
-	callStack.reset()
-	shouldLog = (label, type, funcName, stack) -> undef
-	return
-
-# ---------------------------------------------------------------------------
-
 export setDebugging = (option) ->
 
-	resetDebugging()
+	callStack.reset()
 	if isBoolean(option)
 		if option
 			shouldLog = (label, type, funcName, stack) -> label
 		else
 			shouldLog = (label, type, funcName, stack) -> undef
-		if doDebugDebug
-			LOG "setDebugging = #{option}"
 	else if isString(option)
 		lFuncList = getFuncList(option)
 		shouldLog = stdShouldLog
-		if doDebugDebug
-			LOG "setDebugging FUNCS: #{option}"
-			LOG 'lFuncList', lFuncList
 	else if isFunction(option)
 		shouldLog = option
-		if doDebugDebug
-			LOG "setDebugging to custom func"
 	else
 		croak "bad parameter #{OL(option)}"
 	return
@@ -229,22 +263,18 @@ export funcMatch = (stack, lFuncList) ->
 	assert isArray(lFuncList), "not an array #{OL(lFuncList)}"
 
 	curFunc = stack.curFunc()
-	if doDebugDebug
-		LOG "funcMatch(): curFunc = #{OL(curFunc)}"
-		stack.dump('   ')
-		LOG 'lFuncList', lFuncList
+	logif "funcMatch(): curFunc = #{OL(curFunc)}"
+	logif stack.dump('   ')
+	logif 'lFuncList', lFuncList
 	for h in lFuncList
 		{name, object, plus} = h
 		if (name == curFunc)
-			if doDebugDebug
-				LOG "   curFunc in lFuncList - match successful"
+			logif "   curFunc in lFuncList - match successful"
 			return true
 		if plus && stack.isActive(name)
-			if doDebugDebug
-				LOG "   func #{OL(name)} is active - match successful"
+			logif "   func #{OL(name)} is active - match successful"
 			return true
-	if doDebugDebug
-		LOG "   - no match"
+	logif "   - no match"
 	return false
 
 # ---------------------------------------------------------------------------
@@ -287,40 +317,3 @@ reMethod = ///^
 
 # ---------------------------------------------------------------------------
 
-export checkTrace = (block) ->
-	# --- export only to allow unit tests
-
-	lStack = []
-
-	for line in blockToArray(block)
-		if lMatches = line.match(///
-				enter
-				\s+
-				([A-Za-z_][A-Za-z0-9_\.]*)
-				///)
-			funcName = lMatches[1]
-			lStack.push funcName
-		else if lMatches = line.match(///
-				return
-				.*
-				from
-				\s+
-				([A-Za-z_][A-Za-z0-9_\.]*)
-				///)
-			funcName = lMatches[1]
-			len = lStack.length
-			if (len == 0)
-				log "return from #{funcName} with empty stack"
-			else if (lStack[len-1] == funcName)
-				lStack.pop()
-			else if (lStack[len-2] == funcName)
-				log "missing return from #{lStack[len-2]}"
-				lStack.pop()
-				lStack.pop()
-			else
-				log "return from #{funcName} - not found on stack"
-	return
-
-# ---------------------------------------------------------------------------
-
-resetDebugging()

package/src/debug_utils.js

@@ -1,6 +1,7 @@
 // Generated by CoffeeScript 2.7.0
-// debug_utils.coffee
-var callStack, doDebugDebug, reMethod, resetDebugging;
+  // debug_utils.coffee
+var callStack, doDebugDebug, lFunctions, logif, reMethod,
+  indexOf = [].indexOf;
 
 import {
   assert,
@@ -52,25 +53,75 @@ import {
 
 callStack = new CallStack();
 
+// --- set in resetDebugging() and setDebugging()
+export var shouldLog = function() {
+  return undef;
+};
+
+export var lFuncList = [];
+
+// --- internal debugging
 doDebugDebug = false;
 
-export var shouldLog = undef; // set in resetDebugging() and setDebugging()
+lFunctions = undef; // --- only used when doDebugDebug is true
 
-export var lFuncList = [];
+
+// ---------------------------------------------------------------------------
+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)}`);
+  }
+};
+
+// ---------------------------------------------------------------------------
+logif = function(label, ...lObjects) {
+  var funcName, itemPrefix, level, nObjects, prefix, sep, type;
+  if (!doDebugDebug) {
+    return;
+  }
+  assert(isString(label), `1st arg ${OL(label)} should be a string`);
+  nObjects = lObjects.length;
+  [type, funcName] = getType(label, nObjects);
+  level = callStack.getLevel();
+  prefix = getPrefix(level);
+  itemPrefix = removeLastVbar(prefix);
+  sep = dashes(itemPrefix, 40);
+  if (type === 'enter') {
+    if (defined(lFunctions) && (indexOf.call(lFunctions, funcName) < 0)) {
+      return;
+    }
+    callStack.enter(funcName);
+  } else if (type === 'return') {
+    if (defined(lFunctions) && (indexOf.call(lFunctions, funcName) < 0)) {
+      return;
+    }
+  }
+  doTheLogging(type, label, lObjects);
+  if (type === 'return') {
+    callStack.returnFrom(funcName);
+  }
+};
 
 // ---------------------------------------------------------------------------
 export var debug = function(label, ...lObjects) {
-  var doLog, funcName, i, j, k, l, len1, len2, len3, level, nObjects, obj, prefix, type;
+  var doLog, funcName, nObjects, type;
+  logif(`enter debug(${OL(label)})`, ...lObjects);
   assert(isString(label), `1st arg ${OL(label)} should be a string`);
   // --- We want to allow objects to be undef. Therefore, we need to
   //     distinguish between 1 arg sent vs. 2 or more args sent
   nObjects = lObjects.length;
   // --- funcName is only set for types 'enter' and 'return'
   [type, funcName] = getType(label, nObjects);
-  if (doDebugDebug) {
-    LOG(`debug(): type = ${OL(type)}`);
-    LOG(`debug(): funcName = ${OL(funcName)}`);
-  }
+  logif(`type = ${OL(type)}`);
+  logif(`funcName = ${OL(funcName)}`);
+  // --- function shouldLog() returns the (possibly modified) label
+  //     if we should log this, else it returns undef
   switch (type) {
     case 'enter':
       callStack.enter(funcName);
@@ -81,81 +132,84 @@ export var debug = function(label, ...lObjects) {
       break;
     case 'string':
       label = shouldLog(label, type, undef, callStack);
-      assert(nObjects === 0, `multiple objects only not allowed for ${OL(type)}`);
+      assert(nObjects === 0, `Objects not allowed for ${OL(type)}`);
       break;
     case 'objects':
       label = shouldLog(label, type, undef, callStack);
-      assert(nObjects > 0, `multiple objects only not allowed for ${OL(type)}`);
+      assert(nObjects > 0, `Objects required for ${OL(type)}`);
   }
+  assert((label === undef) || isString(label), `label not a string: ${OL(label)}`);
   doLog = defined(label);
-  if (doDebugDebug) {
-    if (nObjects === 0) {
-      LOG(`debug(${OL(label)}) - 1 arg`);
-    } else {
-      LOG(`debug(${OL(label)}), ${nObjects} args`);
-    }
-    LOG(`doLog = ${OL(doLog)}`);
-  }
+  logif(`doLog = ${OL(doLog)}`);
+  logif(`${nObjects} objects`);
   if (doLog) {
-    level = callStack.getLevel();
-    prefix = getPrefix(level);
-    if (doDebugDebug) {
-      LOG("callStack", callStack);
-      LOG(`level = ${OL(level)}`);
-      LOG(`prefix = ${OL(prefix)}`);
-    }
-    switch (type) {
-      case 'enter':
-        log(label, {prefix});
-        prefix = removeLastVbar(prefix);
-        for (i = j = 0, len1 = lObjects.length; j < len1; i = ++j) {
-          obj = lObjects[i];
-          if (i > 0) {
-            log(dashes(prefix));
-          }
-          logItem(undef, obj, {prefix});
-        }
-        break;
-      case 'return':
-        log(label, {
-          prefix: addArrow(prefix)
-        });
-        prefix = removeLastVbar(prefix);
-        for (i = k = 0, len2 = lObjects.length; k < len2; i = ++k) {
-          obj = lObjects[i];
-          if (i > 0) {
-            log(dashes(prefix));
-          }
-          logItem(undef, obj, {prefix});
-        }
-        break;
-      case 'string':
-        log(label, {prefix});
-        break;
-      case 'objects':
-        if ((nObjects === 1) && shortEnough(label, lObjects[0])) {
-          logItem(label, lObjects[0], {prefix});
-        } else {
-          if (label.indexOf(':') !== label.length - 1) {
-            label += ':';
-          }
-          log(label, {prefix});
-          for (l = 0, len3 = lObjects.length; l < len3; l++) {
-            obj = lObjects[l];
-            logItem(undef, obj, {prefix});
-          }
-        }
-    }
+    doTheLogging(type, label, lObjects);
   }
   if ((type === 'enter') && doLog && (label.indexOf('call') === -1)) {
     callStack.logCurFunc();
   } else if (type === 'return') {
     callStack.returnFrom(funcName);
   }
+  logif("return from debug()");
   return true; // allow use in boolean expressions
 };
 
 
+// ---------------------------------------------------------------------------
+export var doTheLogging = function(type, label, lObjects) {
+  var i, itemPrefix, j, k, l, len, len1, len2, level, obj, prefix, sep;
+  level = callStack.getLevel();
+  prefix = getPrefix(level);
+  itemPrefix = removeLastVbar(prefix);
+  sep = dashes(itemPrefix, 40);
+  assert(isString(sep), "sep is not a string");
+  logif("callStack", callStack);
+  logif(`level = ${OL(level)}`);
+  logif(`prefix = ${OL(prefix)}`);
+  logif(`itemPrefix = ${OL(itemPrefix)}`);
+  logif(`sep = ${OL(sep)}`);
+  switch (type) {
+    case 'enter':
+      log(label, {prefix});
+      for (i = j = 0, len = lObjects.length; j < len; i = ++j) {
+        obj = lObjects[i];
+        if (i > 0) {
+          log(sep);
+        }
+        logItem(undef, obj, {itemPrefix});
+      }
+      break;
+    case 'return':
+      log(label, {
+        prefix: addArrow(prefix)
+      });
+      for (i = k = 0, len1 = lObjects.length; k < len1; i = ++k) {
+        obj = lObjects[i];
+        if (i > 0) {
+          log(sep);
+        }
+        logItem(undef, obj, {itemPrefix});
+      }
+      break;
+    case 'string':
+      log(label, {prefix});
+      break;
+    case 'objects':
+      if ((lObjects.length === 1) && shortEnough(label, lObjects[0])) {
+        logItem(label, lObjects[0], {prefix});
+      } else {
+        if (label.indexOf(':') !== label.length - 1) {
+          label += ':';
+        }
+        log(label, {prefix});
+        for (l = 0, len2 = lObjects.length; l < len2; l++) {
+          obj = lObjects[l];
+          logItem(undef, obj, {prefix});
+        }
+      }
+  }
+};
+
 // ---------------------------------------------------------------------------
 export var stdShouldLog = function(label, type, funcName, stack) {
   var prevLogged;
@@ -173,11 +227,9 @@ export var stdShouldLog = function(label, type, funcName, stack) {
     assert(funcName === undef, `func name ${OL(funcName)} not undef`);
   }
   assert(stack instanceof CallStack, "not a call stack object");
-  if (doDebugDebug) {
-    LOG(`stdShouldLog(${OL(label)}, ${OL(type)}, ${OL(funcName)}, stack)`);
-    LOG("stack", stack);
-    LOG("lFuncList", lFuncList);
-  }
+  logif(`stdShouldLog(${OL(label)}, ${OL(type)}, ${OL(funcName)}, stack)`);
+  logif("stack", stack);
+  logif("lFuncList", lFuncList);
   switch (type) {
     case 'enter':
       if (funcMatch(stack, lFuncList)) {
@@ -200,28 +252,9 @@ export var stdShouldLog = function(label, type, funcName, stack) {
   return undef;
 };
 
-// ---------------------------------------------------------------------------
-export var debugDebug = function(flag = true) {
-  doDebugDebug = flag;
-  if (doDebugDebug) {
-    LOG(`doDebugDebug = ${flag}`);
-  }
-};
-
-// ---------------------------------------------------------------------------
-resetDebugging = function() {
-  if (doDebugDebug) {
-    LOG("resetDebugging()");
-  }
-  callStack.reset();
-  shouldLog = function(label, type, funcName, stack) {
-    return undef;
-  };
-};
-
 // ---------------------------------------------------------------------------
 export var setDebugging = function(option) {
-  resetDebugging();
+  callStack.reset();
   if (isBoolean(option)) {
     if (option) {
       shouldLog = function(label, type, funcName, stack) {
@@ -232,21 +265,11 @@ export var setDebugging = function(option) {
         return undef;
       };
     }
-    if (doDebugDebug) {
-      LOG(`setDebugging = ${option}`);
-    }
   } else if (isString(option)) {
     lFuncList = getFuncList(option);
     shouldLog = stdShouldLog;
-    if (doDebugDebug) {
-      LOG(`setDebugging FUNCS: ${option}`);
-      LOG('lFuncList', lFuncList);
-    }
   } else if (isFunction(option)) {
     shouldLog = option;
-    if (doDebugDebug) {
-      LOG("setDebugging to custom func");
-    }
   } else {
     croak(`bad parameter ${OL(option)}`);
   }
@@ -255,10 +278,10 @@ export var setDebugging = function(option) {
 // ---------------------------------------------------------------------------
 // --- export only to allow unit tests
 export var getFuncList = function(str) {
-  var _, ident1, ident2, j, lMatches, len1, plus, ref, word;
+  var _, ident1, ident2, j, lMatches, len, plus, ref, word;
   lFuncList = [];
   ref = words(str);
-  for (j = 0, len1 = ref.length; j < len1; j++) {
+  for (j = 0, len = ref.length; j < len; j++) {
     word = ref[j];
     if (lMatches = word.match(/^([A-Za-z_][A-Za-z0-9_]*)(?:\.([A-Za-z_][A-Za-z0-9_]*))?(\+)?$/)) {
       [_, ident1, ident2, plus] = lMatches;
@@ -284,33 +307,25 @@ export var getFuncList = function(str) {
 // ---------------------------------------------------------------------------
 // --- export only to allow unit tests
 export var funcMatch = function(stack, lFuncList) {
-  var curFunc, h, j, len1, name, object, plus;
+  var curFunc, h, j, len, name, object, plus;
   assert(isArray(lFuncList), `not an array ${OL(lFuncList)}`);
   curFunc = stack.curFunc();
-  if (doDebugDebug) {
-    LOG(`funcMatch(): curFunc = ${OL(curFunc)}`);
-    stack.dump('   ');
-    LOG('lFuncList', lFuncList);
-  }
-  for (j = 0, len1 = lFuncList.length; j < len1; j++) {
+  logif(`funcMatch(): curFunc = ${OL(curFunc)}`);
+  logif(stack.dump('   '));
+  logif('lFuncList', lFuncList);
+  for (j = 0, len = lFuncList.length; j < len; j++) {
     h = lFuncList[j];
     ({name, object, plus} = h);
     if (name === curFunc) {
-      if (doDebugDebug) {
-        LOG("   curFunc in lFuncList - match successful");
-      }
+      logif("   curFunc in lFuncList - match successful");
       return true;
     }
     if (plus && stack.isActive(name)) {
-      if (doDebugDebug) {
-        LOG(`   func ${OL(name)} is active - match successful`);
-      }
+      logif(`   func ${OL(name)} is active - match successful`);
       return true;
     }
   }
-  if (doDebugDebug) {
-    LOG("   - no match");
-  }
+  logif("   - no match");
   return false;
 };
 
@@ -334,33 +349,3 @@ export var getType = function(str, nObjects) {
 reMethod = /^([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/;
 
 // ---------------------------------------------------------------------------
-export var checkTrace = function(block) {
-  var funcName, j, lMatches, lStack, len, len1, line, ref;
-  // --- export only to allow unit tests
-  lStack = [];
-  ref = blockToArray(block);
-  for (j = 0, len1 = ref.length; j < len1; j++) {
-    line = ref[j];
-    if (lMatches = line.match(/enter\s+([A-Za-z_][A-Za-z0-9_\.]*)/)) {
-      funcName = lMatches[1];
-      lStack.push(funcName);
-    } else if (lMatches = line.match(/return.*from\s+([A-Za-z_][A-Za-z0-9_\.]*)/)) {
-      funcName = lMatches[1];
-      len = lStack.length;
-      if (len === 0) {
-        log(`return from ${funcName} with empty stack`);
-      } else if (lStack[len - 1] === funcName) {
-        lStack.pop();
-      } else if (lStack[len - 2] === funcName) {
-        log(`missing return from ${lStack[len - 2]}`);
-        lStack.pop();
-        lStack.pop();
-      } else {
-        log(`return from ${funcName} - not found on stack`);
-      }
-    }
-  }
-};
-
-// ---------------------------------------------------------------------------
-resetDebugging();

package/src/log_utils.coffee

@@ -135,9 +135,9 @@ export log = (str, hOptions={}) ->
 	# --- valid options:
 	#   prefix
 
+	assert isString(str),      "log(): not a string: #{OL(str)}"
 	assert isFunction(putstr), "putstr not properly set"
-	assert isString(str),      "log(): not a string"
-	assert isHash(hOptions),   "log(): arg 2 not a hash"
+	assert isHash(hOptions),   "log(): arg 2 not a hash: #{OL(hOptions)}"
 	prefix = fixForTerminal(hOptions.prefix)
 
 	if doDebugLog

package/src/log_utils.js

@@ -158,9 +158,9 @@ export var log = function(str, hOptions = {}) {
   var prefix;
   // --- valid options:
   //   prefix
+  assert(isString(str), `log(): not a string: ${OL(str)}`);
   assert(isFunction(putstr), "putstr not properly set");
-  assert(isString(str), "log(): not a string");
-  assert(isHash(hOptions), "log(): arg 2 not a hash");
+  assert(isHash(hOptions), `log(): arg 2 not a hash: ${OL(hOptions)}`);
   prefix = fixForTerminal(hOptions.prefix);
   if (doDebugLog) {
     LOG(`CALL log(${OL(str)}), prefix = ${OL(prefix)}`);