@jdeighan/coffee-utils 7.0.51 → 7.0.52

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "7.0.51",
+	"version": "7.0.52",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -52,6 +52,6 @@
 		"svelte": "^3.48.0"
 	},
 	"devDependencies": {
-		"@jdeighan/unit-tester": "^2.0.3"
+		"@jdeighan/unit-tester": "^2.0.5"
 	}
 }

package/src/call_stack.coffee

@@ -1,7 +1,7 @@
 # call_stack.coffee
 
 import {
-	undef, defined, croak, assert, isBoolean, escapeStr,
+	undef, defined, croak, assert, OL, isBoolean, escapeStr,
 	} from '@jdeighan/coffee-utils'
 import {log, LOG} from '@jdeighan/coffee-utils/log'
 import {getPrefix} from '@jdeighan/coffee-utils/arrow'
@@ -36,14 +36,64 @@ export class CallStack
 
 	# ........................................................................
 
-	enter: (funcName, isLogged=false) ->
+	enter: (funcName, oldFlag=undef) ->
+		# --- funcName might be <object>.<method>
 
+		assert (oldFlag == undef), "enter() takes only 1 arg"
 		if doDebugStack
-			LOG "[--> CALL #{funcName}]"
+			LOG "[--> ENTER #{funcName}]"
+
+		lMatches = funcName.match(///^
+				([A-Za-z_][A-Za-z0-9_]*)
+				(?:
+					\.
+					([A-Za-z_][A-Za-z0-9_]*)
+					)?
+				$///)
+		assert defined(lMatches), "Bad funcName: #{OL(funcName)}"
+		[_, ident1, ident2] = lMatches
+		if ident2
+			@lStack.push({
+				fullName: "#{ident1}.#{ident2}"
+				funcName: ident2
+				isLogged: false
+				})
+		else
+			@lStack.push({
+				fullName: ident1
+				funcName: ident1
+				isLogged: false
+				})
+		return
+
+	# ........................................................................
+
+	isLogging: () ->
+
+		if (@lStack.length == 0)
+			return false
+		else
+			return @lStack[@lStack.length - 1].isLogged
+
+	# ........................................................................
+
+	isLoggingPrev: () ->
+
+		if (@lStack.length < 2)
+			return false
+		else
+			return @lStack[@lStack.length - 2].isLogged
+
+	# ........................................................................
+
+	logCurFunc: () ->
 
-		@lStack.push({funcName, isLogged})
-		if isLogged
-			@level += 1
+		# --- funcName must be  the current function
+		#     and the isLogged flag must currently be false
+		cur = @lStack[@lStack.length - 1]
+		assert (cur.isLogged == false), "isLogged is already true"
+		cur.isLogged = true
+		@level += 1
 		return
 
 	# ........................................................................
@@ -58,18 +108,18 @@ export class CallStack
 			LOG "ERROR: returnFrom('#{funcName}') but stack is empty"
 			return
 
-		{funcName, isLogged} = @lStack.pop()
+		{fullName, isLogged} = @lStack.pop()
 		if isLogged && (@level > 0)
 			@level -= 1
 
 		# --- This should do nothing
-		while (funcName != fName) && (@lStack.length > 0)
-			LOG "[MISSING RETURN FROM #{funcName} (return from #{fName})]"
-			{funcName, isLogged} = @lStack.pop()
+		while (fullName != fName) && (@lStack.length > 0)
+			LOG "[MISSING RETURN FROM #{fullName} (return from #{fName})]"
+			{fullName, isLogged} = @lStack.pop()
 			if isLogged && (@level > 0)
 				@level -= 1
 
-		if funcName != fName
+		if fullName != fName
 			@dump()
 			LOG "BAD BAD BAD BAD returnFrom('#{fName}')"
 		return
@@ -91,17 +141,19 @@ export class CallStack
 
 	# ........................................................................
 
-	isActive: (fName) ->
+	isActive: (funcName) ->
+		# --- funcName won't be <obj>.<method>
+		#     but the stack might contain that form
 
 		for h in @lStack
-			if (h.funcName == fName)
+			if (h.funcName == funcName)
 				return true
 		return false
 
 	# ........................................................................
 	# ........................................................................
 
-	dump: (label='CALL STACK') ->
+	dump: (prefix='', label='CALL STACK') ->
 
 		LOG "#{label}:"
 		if @lStack.length == 0

package/src/call_stack.js

@@ -7,6 +7,7 @@ import {
   defined,
   croak,
   assert,
+  OL,
   isBoolean,
   escapeStr
 } from '@jdeighan/coffee-utils';
@@ -44,20 +45,64 @@ export var CallStack = class CallStack {
   }
 
   // ........................................................................
-  enter(funcName, isLogged = false) {
+  enter(funcName, oldFlag = undef) {
+    var _, ident1, ident2, lMatches;
+    // --- funcName might be <object>.<method>
+    assert(oldFlag === undef, "enter() takes only 1 arg");
     if (doDebugStack) {
-      LOG(`[--> CALL ${funcName}]`);
+      LOG(`[--> ENTER ${funcName}]`);
     }
-    this.lStack.push({funcName, isLogged});
-    if (isLogged) {
-      this.level += 1;
+    lMatches = funcName.match(/^([A-Za-z_][A-Za-z0-9_]*)(?:\.([A-Za-z_][A-Za-z0-9_]*))?$/);
+    assert(defined(lMatches), `Bad funcName: ${OL(funcName)}`);
+    [_, ident1, ident2] = lMatches;
+    if (ident2) {
+      this.lStack.push({
+        fullName: `${ident1}.${ident2}`,
+        funcName: ident2,
+        isLogged: false
+      });
+    } else {
+      this.lStack.push({
+        fullName: ident1,
+        funcName: ident1,
+        isLogged: false
+      });
+    }
+  }
+
+  // ........................................................................
+  isLogging() {
+    if (this.lStack.length === 0) {
+      return false;
+    } else {
+      return this.lStack[this.lStack.length - 1].isLogged;
     }
   }
 
+  // ........................................................................
+  isLoggingPrev() {
+    if (this.lStack.length < 2) {
+      return false;
+    } else {
+      return this.lStack[this.lStack.length - 2].isLogged;
+    }
+  }
+
+  // ........................................................................
+  logCurFunc() {
+    var cur;
+    // --- funcName must be  the current function
+    //     and the isLogged flag must currently be false
+    cur = this.lStack[this.lStack.length - 1];
+    assert(cur.isLogged === false, "isLogged is already true");
+    cur.isLogged = true;
+    this.level += 1;
+  }
+
   // ........................................................................
   // --- if stack is empty, log the error, but continue
   returnFrom(fName) {
-    var funcName, isLogged;
+    var fullName, isLogged;
     if (doDebugStack) {
       LOG(`[<-- BACK ${fName}]`);
     }
@@ -65,19 +110,19 @@ export var CallStack = class CallStack {
       LOG(`ERROR: returnFrom('${funcName}') but stack is empty`);
       return;
     }
-    ({funcName, isLogged} = this.lStack.pop());
+    ({fullName, isLogged} = this.lStack.pop());
     if (isLogged && (this.level > 0)) {
       this.level -= 1;
     }
     // --- This should do nothing
-    while ((funcName !== fName) && (this.lStack.length > 0)) {
-      LOG(`[MISSING RETURN FROM ${funcName} (return from ${fName})]`);
-      ({funcName, isLogged} = this.lStack.pop());
+    while ((fullName !== fName) && (this.lStack.length > 0)) {
+      LOG(`[MISSING RETURN FROM ${fullName} (return from ${fName})]`);
+      ({fullName, isLogged} = this.lStack.pop());
       if (isLogged && (this.level > 0)) {
         this.level -= 1;
       }
     }
-    if (funcName !== fName) {
+    if (fullName !== fName) {
       this.dump();
       LOG(`BAD BAD BAD BAD returnFrom('${fName}')`);
     }
@@ -98,12 +143,14 @@ export var CallStack = class CallStack {
   }
 
   // ........................................................................
-  isActive(fName) {
+  isActive(funcName) {
     var h, j, len, ref;
     ref = this.lStack;
+    // --- funcName won't be <obj>.<method>
+    //     but the stack might contain that form
     for (j = 0, len = ref.length; j < len; j++) {
       h = ref[j];
-      if (h.funcName === fName) {
+      if (h.funcName === funcName) {
         return true;
       }
     }
@@ -112,7 +159,7 @@ export var CallStack = class CallStack {
 
   // ........................................................................
   // ........................................................................
-  dump(label = 'CALL STACK') {
+  dump(prefix = '', label = 'CALL STACK') {
     var i, item, j, len, ref;
     LOG(`${label}:`);
     if (this.lStack.length === 0) {

package/src/debug_utils.coffee

@@ -18,7 +18,125 @@ import {
 
 callStack = new CallStack()
 doDebugDebug = false
-shouldLog = undef     # set in resetDebugging() and setDebugging()
+
+export shouldLog = undef  # set in resetDebugging() and setDebugging()
+export lFuncList = []
+
+# ---------------------------------------------------------------------------
+
+export debug = (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)}"
+
+	switch type
+		when 'enter'
+			callStack.enter funcName
+			label = shouldLog(label, type, funcName, callStack)
+		when 'return'
+			label = shouldLog(label, type, funcName, callStack)
+		when 'string'
+			label = shouldLog(label, type, undef, callStack)
+			assert (nObjects == 0),
+					"multiple objects only 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)
+
+	if doDebugDebug
+		if nObjects == 0
+			LOG "debug(#{OL(label)}) - 1 arg"
+		else
+			LOG "debug(#{OL(label)}), #{nObjects} args"
+		LOG "doLog = #{OL(doLog)}"
+
+	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}
+				for obj,i in lObjects
+					if (i > 0)
+						log sep_dash, {prefix: removeLastVbar(prefix)}
+					logItem undef, obj, {prefix: removeLastVbar(prefix)}
+			when 'return'
+				log label, {prefix: addArrow(prefix)}
+				for obj,i in lObjects
+					if (i > 0)
+						log sep_dash, {prefix: removeLastVbar(prefix)}
+					logItem undef, obj, {prefix: removeLastVbar(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}
+
+	if (type == 'enter') && doLog
+		callStack.logCurFunc()
+	else if (type == 'return')
+		callStack.returnFrom funcName
+
+	return true   # allow use in boolean expressions
+
+# ---------------------------------------------------------------------------
+
+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
+
+	# --- 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"
+	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"
+	if doDebugDebug
+		LOG "stdShouldLog(#{OL(label)}, #{OL(type)}, #{OL(funcName)}, stack)"
+		LOG "stack", stack
+		LOG "lFuncList", lFuncList
+	switch type
+		when 'enter'
+			if funcMatch(stack, lFuncList)
+				return label
+
+			# --- 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
+			else if stack.isLoggingPrev()
+				return label.replace('enter', 'call')
+		else
+			if funcMatch(stack, lFuncList)
+				return label
+	return undef
 
 # ---------------------------------------------------------------------------
 
@@ -36,7 +154,7 @@ resetDebugging = () ->
 	if doDebugDebug
 		LOG "resetDebugging()"
 	callStack.reset()
-	shouldLog = (type, str, stack) -> false
+	shouldLog = (label, type, funcName, stack) -> undef
 	return
 
 # ---------------------------------------------------------------------------
@@ -45,44 +163,82 @@ export setDebugging = (option) ->
 
 	resetDebugging()
 	if isBoolean(option)
-		shouldLog = (type, str, stack) -> 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)
-		shouldLog = (type, str, stack) ->
-			lFuncs = words(option)
-			switch type
-				when 'enter'
-					return funcMatch(stack, lFuncs, str)
-				else
-					return funcMatch(stack, lFuncs)
+		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 "setDebugging(): bad parameter #{OL(option)}"
+		croak "bad parameter #{OL(option)}"
 	return
 
 # ---------------------------------------------------------------------------
 # --- export only to allow unit tests
 
-export funcMatch = (stack, lFuncNames, enteringFunc=undef) ->
+export getFuncList = (str) ->
+
+	lFuncList = []
+	for word in words(str)
+		if lMatches = word.match(///^
+				([A-Za-z_][A-Za-z0-9_]*)
+				(?:
+					\.
+					([A-Za-z_][A-Za-z0-9_]*)
+					)?
+				(\+)?
+				$///)
+			[_, ident1, ident2, plus] = lMatches
+			if ident2
+				lFuncList.push {
+					name: ident2
+					object: ident1
+					plus: (plus == '+')
+					}
+			else
+				lFuncList.push {
+					name: ident1
+					plus: (plus == '+')
+					}
+		else
+			croak "Bad word in func list: #{OL(word)}"
+	return lFuncList
+
+# ---------------------------------------------------------------------------
+# --- export only to allow unit tests
+
+export funcMatch = (stack, lFuncList) ->
 
-	if defined(enteringFunc) && (enteringFunc in lFuncNames)
-		return true
+	assert isArray(lFuncList), "not an array #{OL(lFuncList)}"
 
 	curFunc = stack.curFunc()
-	assert isString(curFunc), "funcMatch(): not a string #{OL(curFunc)}"
-	assert isArray(lFuncNames), "funcMatch(): bad array #{lFuncNames}"
-	if lFuncNames.includes(curFunc)
-		return true
-	else if (lMatches = curFunc.match(reMethod)) \
-			&& ([_, cls, meth] = lMatches) \
-			&& lFuncNames.includes(meth)
-		return true
-	else
-		return false
+	if doDebugDebug
+		LOG "funcMatch(): curFunc = #{OL(curFunc)}"
+		stack.dump('   ')
+		LOG 'lFuncList', lFuncList
+	for h in lFuncList
+		{name, object, plus} = h
+		if (name == curFunc)
+			if doDebugDebug
+				LOG "   curFunc in lFuncList - match successful"
+			return true
+		if plus && stack.isActive(name)
+			if doDebugDebug
+				LOG "   func #{OL(name)} is active - match successful"
+			return true
+	if doDebugDebug
+		LOG "   - no match"
+	return false
 
 # ---------------------------------------------------------------------------
 # --- type is one of: 'enter', 'return', 'string', 'object'
@@ -116,89 +272,6 @@ export getType = (str, nObjects) ->
 
 # ---------------------------------------------------------------------------
 
-export debug = (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)
-	switch type
-		when 'enter'
-			doLog = shouldLog(type, funcName, callStack)
-
-			# --- If we won't be logging when funcName is activated
-			#     then change 'enter' to 'call'
-			callStack.enter funcName       # add to call stack
-			if ! shouldLog('string', 'abc', callStack)
-				label = label.replace('enter', 'call')
-			callStack.returnFrom funcName  # remove from call stack
-		when 'return'
-			doLog = shouldLog(type, funcName, callStack)
-		when 'string'
-			doLog = shouldLog(type, label, callStack)
-			assert (nObjects == 0),
-					"multiple objects only not allowed for #{OL(type)}"
-		when 'objects'
-			doLog = shouldLog(type, label, callStack)
-			assert (nObjects > 0),
-					"multiple objects only not allowed 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)}"
-		LOG "type = #{OL(type)}"
-		LOG "funcName = #{OL(funcName)}"
-
-	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}
-				for obj,i in lObjects
-					if (i > 0)
-						log sep_dash, {prefix: removeLastVbar(prefix)}
-					logItem undef, obj, {prefix: removeLastVbar(prefix)}
-			when 'return'
-				log label, {prefix: addArrow(prefix)}
-				for obj,i in lObjects
-					if (i > 0)
-						log sep_dash, {prefix: removeLastVbar(prefix)}
-					logItem undef, obj, {prefix: removeLastVbar(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}
-
-	if (type == 'enter')
-		callStack.enter funcName, doLog
-	else if (type == 'return')
-		callStack.returnFrom funcName
-
-	return true   # allow use in boolean expressions
-
-# ---------------------------------------------------------------------------
-
 reMethod = ///^
 	([A-Za-z_][A-Za-z0-9_]*)
 	\.

package/src/debug_utils.js

@@ -1,7 +1,6 @@
 // Generated by CoffeeScript 2.7.0
-  // debug_utils.coffee
-var callStack, doDebugDebug, reMethod, resetDebugging, shouldLog,
-  indexOf = [].indexOf;
+// debug_utils.coffee
+var callStack, doDebugDebug, reMethod, resetDebugging;
 
 import {
   assert,
@@ -55,93 +54,9 @@ callStack = new CallStack();
 
 doDebugDebug = false;
 
-shouldLog = undef; // set in resetDebugging() and setDebugging()
+export var shouldLog = undef; // set in resetDebugging() and setDebugging()
 
-
-// ---------------------------------------------------------------------------
-export var debugDebug = function(flag = true) {
-  doDebugDebug = flag;
-  if (doDebugDebug) {
-    LOG(`doDebugDebug = ${flag}`);
-  }
-};
-
-// ---------------------------------------------------------------------------
-resetDebugging = function() {
-  if (doDebugDebug) {
-    LOG("resetDebugging()");
-  }
-  callStack.reset();
-  shouldLog = function(type, str, stack) {
-    return false;
-  };
-};
-
-// ---------------------------------------------------------------------------
-export var setDebugging = function(option) {
-  resetDebugging();
-  if (isBoolean(option)) {
-    shouldLog = function(type, str, stack) {
-      return option;
-    };
-  } else if (isString(option)) {
-    shouldLog = function(type, str, stack) {
-      var lFuncs;
-      lFuncs = words(option);
-      switch (type) {
-        case 'enter':
-          return funcMatch(stack, lFuncs, str);
-        default:
-          return funcMatch(stack, lFuncs);
-      }
-    };
-    if (doDebugDebug) {
-      LOG(`setDebugging FUNCS: ${option}`);
-    }
-  } else if (isFunction(option)) {
-    shouldLog = option;
-    if (doDebugDebug) {
-      LOG("setDebugging to custom func");
-    }
-  } else {
-    croak(`setDebugging(): bad parameter ${OL(option)}`);
-  }
-};
-
-// ---------------------------------------------------------------------------
-// --- export only to allow unit tests
-export var funcMatch = function(stack, lFuncNames, enteringFunc = undef) {
-  var _, cls, curFunc, lMatches, meth;
-  if (defined(enteringFunc) && (indexOf.call(lFuncNames, enteringFunc) >= 0)) {
-    return true;
-  }
-  curFunc = stack.curFunc();
-  assert(isString(curFunc), `funcMatch(): not a string ${OL(curFunc)}`);
-  assert(isArray(lFuncNames), `funcMatch(): bad array ${lFuncNames}`);
-  if (lFuncNames.includes(curFunc)) {
-    return true;
-  } else if ((lMatches = curFunc.match(reMethod)) && ([_, cls, meth] = lMatches) && lFuncNames.includes(meth)) {
-    return true;
-  } else {
-    return false;
-  }
-};
-
-// ---------------------------------------------------------------------------
-// --- type is one of: 'enter', 'return', 'string', 'object'
-export var getType = function(str, nObjects) {
-  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];
-  }
-};
+export var lFuncList = [];
 
 // ---------------------------------------------------------------------------
 export var debug = function(label, ...lObjects) {
@@ -152,28 +67,27 @@ export var debug = function(label, ...lObjects) {
   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)}`);
+  }
   switch (type) {
     case 'enter':
-      doLog = shouldLog(type, funcName, callStack);
-      // --- If we won't be logging when funcName is activated
-      //     then change 'enter' to 'call'
-      callStack.enter(funcName); // add to call stack
-      if (!shouldLog('string', 'abc', callStack)) {
-        label = label.replace('enter', 'call');
-      }
-      callStack.returnFrom(funcName); // remove from call stack
+      callStack.enter(funcName);
+      label = shouldLog(label, type, funcName, callStack);
       break;
     case 'return':
-      doLog = shouldLog(type, funcName, callStack);
+      label = shouldLog(label, type, funcName, callStack);
       break;
     case 'string':
-      doLog = shouldLog(type, label, callStack);
+      label = shouldLog(label, type, undef, callStack);
       assert(nObjects === 0, `multiple objects only not allowed for ${OL(type)}`);
       break;
     case 'objects':
-      doLog = shouldLog(type, label, callStack);
+      label = shouldLog(label, type, undef, callStack);
       assert(nObjects > 0, `multiple objects only not allowed for ${OL(type)}`);
   }
+  doLog = defined(label);
   if (doDebugDebug) {
     if (nObjects === 0) {
       LOG(`debug(${OL(label)}) - 1 arg`);
@@ -181,8 +95,6 @@ export var debug = function(label, ...lObjects) {
       LOG(`debug(${OL(label)}), ${nObjects} args`);
     }
     LOG(`doLog = ${OL(doLog)}`);
-    LOG(`type = ${OL(type)}`);
-    LOG(`funcName = ${OL(funcName)}`);
   }
   if (doLog) {
     level = callStack.getLevel();
@@ -241,8 +153,8 @@ export var debug = function(label, ...lObjects) {
         }
     }
   }
-  if (type === 'enter') {
-    callStack.enter(funcName, doLog);
+  if ((type === 'enter') && doLog) {
+    callStack.logCurFunc();
   } else if (type === 'return') {
     callStack.returnFrom(funcName);
   }
@@ -250,6 +162,176 @@ export var debug = function(label, ...lObjects) {
 };
 
 
+// ---------------------------------------------------------------------------
+export var stdShouldLog = function(label, type, funcName, stack) {
+  // --- 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`);
+  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");
+  if (doDebugDebug) {
+    LOG(`stdShouldLog(${OL(label)}, ${OL(type)}, ${OL(funcName)}, stack)`);
+    LOG("stack", stack);
+    LOG("lFuncList", lFuncList);
+  }
+  switch (type) {
+    case 'enter':
+      if (funcMatch(stack, lFuncList)) {
+        return label;
+      // --- 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
+      } else if (stack.isLoggingPrev()) {
+        return label.replace('enter', 'call');
+      }
+      break;
+    default:
+      if (funcMatch(stack, lFuncList)) {
+        return label;
+      }
+  }
+  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();
+  if (isBoolean(option)) {
+    if (option) {
+      shouldLog = function(label, type, funcName, stack) {
+        return label;
+      };
+    } else {
+      shouldLog = function(label, type, funcName, stack) {
+        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)}`);
+  }
+};
+
+// ---------------------------------------------------------------------------
+// --- export only to allow unit tests
+export var getFuncList = function(str) {
+  var _, ident1, ident2, j, lMatches, len1, plus, ref, word;
+  lFuncList = [];
+  ref = words(str);
+  for (j = 0, len1 = ref.length; j < len1; 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;
+      if (ident2) {
+        lFuncList.push({
+          name: ident2,
+          object: ident1,
+          plus: plus === '+'
+        });
+      } else {
+        lFuncList.push({
+          name: ident1,
+          plus: plus === '+'
+        });
+      }
+    } else {
+      croak(`Bad word in func list: ${OL(word)}`);
+    }
+  }
+  return lFuncList;
+};
+
+// ---------------------------------------------------------------------------
+// --- export only to allow unit tests
+export var funcMatch = function(stack, lFuncList) {
+  var curFunc, h, j, len1, 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++) {
+    h = lFuncList[j];
+    ({name, object, plus} = h);
+    if (name === curFunc) {
+      if (doDebugDebug) {
+        LOG("   curFunc in lFuncList - match successful");
+      }
+      return true;
+    }
+    if (plus && stack.isActive(name)) {
+      if (doDebugDebug) {
+        LOG(`   func ${OL(name)} is active - match successful`);
+      }
+      return true;
+    }
+  }
+  if (doDebugDebug) {
+    LOG("   - no match");
+  }
+  return false;
+};
+
+// ---------------------------------------------------------------------------
+// --- type is one of: 'enter', 'return', 'string', 'object'
+export var getType = function(str, nObjects) {
+  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];
+  }
+};
+
 // ---------------------------------------------------------------------------
 reMethod = /^([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/;
 

package/src/log_utils.coffee

@@ -36,9 +36,9 @@ export LOG = (lArgs...) ->
 	if lArgs.length > 1
 		# --- There's both a label and an item
 		if (item == undef)
-			console.log "#{label}: UNDEFINED"
+			console.log "#{label} = undef"
 		else if (item == null)
-			console.log "#{label}: NULL"
+			console.log "#{label} = null"
 		else
 			console.log sep_dash
 			console.log "#{label}:"

package/src/log_utils.js

@@ -55,9 +55,9 @@ export var LOG = function(...lArgs) {
   if (lArgs.length > 1) {
     // --- There's both a label and an item
     if (item === undef) {
-      console.log(`${label}: UNDEFINED`);
+      console.log(`${label} = undef`);
     } else if (item === null) {
-      console.log(`${label}: NULL`);
+      console.log(`${label} = null`);
     } else {
       console.log(sep_dash);
       console.log(`${label}:`);