@jdeighan/coffee-utils 7.0.60 → 7.0.63

package/src/debug_utils.coffee

@@ -2,7 +2,7 @@
 
 import {
 	assert, undef, error, croak, warn, defined,
-	isString, isFunction, isBoolean,
+	isString, isFunction, isBoolean, patchStr,
 	OL, escapeStr, isNumber, isArray, words, pass,
 	} from '@jdeighan/coffee-utils'
 import {blockToArray} from '@jdeighan/coffee-utils/block'
@@ -10,141 +10,79 @@ import {untabify} from '@jdeighan/coffee-utils/indent'
 import {slurp} from '@jdeighan/coffee-utils/fs'
 import {CallStack} from '@jdeighan/coffee-utils/stack'
 import {
-	getPrefix, addArrow, removeLastVbar,
+	prefix, addArrow, removeLastVbar, vbar,
 	} from '@jdeighan/coffee-utils/arrow'
 import {
-	log, logItem, LOG, shortEnough, dashes,
+	log, logItem, logBareItem, LOG, shortEnough,
 	} from '@jdeighan/coffee-utils/log'
 
 # --- set in resetDebugging() and setDebugging()
 export callStack = new CallStack()
 export shouldLog = () -> 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 dumpCallStack = () ->
-
-	LOG callStack.dump()
-	return
-
-# ---------------------------------------------------------------------------
+export debug = (orgLabel, lObjects...) ->
 
-export setDebugDebugging = (value=true) ->
-	# --- value can be a boolean or string of words
+	assert isString(orgLabel), "1st arg #{OL(orgLabel)} should be a string"
 
-	if isBoolean(value)
-		doDebugDebug = value
-	else if isString(value)
-		doDebugDebug = true
-		lFunctions = words(value)
-	else
-		croak "Bad value: #{OL(value)}"
-	return
-
-# ---------------------------------------------------------------------------
-
-debugDebug = (label, lObjects...) ->
-	# --- For debugging functions in this module
-
-	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)
+	[type, funcName] = getType(orgLabel, lObjects)
+	label = shouldLog(orgLabel, type, funcName, callStack)
 
 	switch type
+
 		when 'enter'
-			assert defined(funcName), "type enter, funcName = undef"
-			callStack.enter funcName, lObjects
-			doLog = (lFunctions == undef) || (funcName in lFunctions)
+			if defined(label)
+				doTheLogging type, label, lObjects
+			callStack.enter funcName, lObjects, defined(label)
 
-		when 'return'
-			assert defined(funcName), "type return, funcName = undef"
-			doLog = (lFunctions == undef) || (funcName in lFunctions)
+			debug2 "enter debug()", orgLabel, lObjects
+			debug2 "type = #{OL(type)}, funcName = #{OL(funcName)}"
+			debug2 "return from debug()"
 
-		when 'string'
-			assert (funcName == undef), "type string, funcName defined"
-			assert (nObjects == 0), "Objects not allowed for #{OL(type)}"
-			doLog = true
+		when 'return'
+			debug2 "enter debug()", orgLabel, lObjects
+			debug2 "type = #{OL(type)}, funcName = #{OL(funcName)}"
+			debug2 "return from debug()"
 
-		when 'objects'
-			assert (funcName == undef), "type objects, funcName defined"
-			assert (nObjects > 0), "Objects required for #{OL(type)}"
-			dolog = true
+			if defined(label)
+				doTheLogging type, label, lObjects
+			callStack.returnFrom funcName
 
-	if doLog
-		doTheLogging type, label, lObjects
+		when 'string'
+			debug2 "enter debug()", orgLabel, lObjects
+			debug2 "type = #{OL(type)}, funcName = #{OL(funcName)}"
 
-	if (type == 'enter') && doLog
-		callStack.logCurFunc(funcName)
-	else if (type == 'return')
-		callStack.returnFrom funcName
+			if defined(label)
+				doTheLogging type, label, lObjects
+			debug2 "return from debug()"
 
-	doDebugDebug = true
-	return
+	return true   # allow use in boolean expressions
 
 # ---------------------------------------------------------------------------
 
-export debug = (label, lObjects...) ->
-
-	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, lObjects
+export debug2 = (orgLabel, lObjects...) ->
 
-	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
+	[type, funcName] = getType(orgLabel, lObjects)
+	label = shouldLog(orgLabel, type, funcName, callStack)
 
 	switch type
 		when 'enter'
-			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),
-					"Objects not allowed for #{OL(type)}"
-		when '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 defined(label)
+				doTheLogging 'enter', label, lObjects
+			callStack.enter funcName, lObjects, defined(label)
 
-	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()"
+		when 'return'
+			if defined(label)
+				doTheLogging 'return', label, lObjects
+			callStack.returnFrom funcName
 
-	if (type == 'return')
-		callStack.returnFrom funcName
+		when 'string'
+			if defined(label)
+				doTheLogging 'string', label, lObjects
 
 	return true   # allow use in boolean expressions
 
@@ -152,42 +90,41 @@ export debug = (label, lObjects...) ->
 
 export doTheLogging = (type, label, lObjects) ->
 
+	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
+
 		when '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 obj,i in lObjects
-				if (i > 0)
-					log sep
-				logItem undef, obj, {itemPrefix}
+				logItem "arg[#{i}]", obj, pre, itemPre
+
 		when 'return'
-			log label, {prefix: addArrow(prefix)}
+			log label, prefix(level, 'withArrow')
+			pre = prefix(level, 'noLastVbar')
+			itemPre = prefix(level+1, 'noLast2Vbars')
 			for obj,i in lObjects
-				if (i > 0)
-					log sep
-				logItem undef, obj, {itemPrefix}
+				logItem "ret[#{i}]", obj, pre, itemPre
 		when 'string'
-			log label, {prefix}
-		when '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 obj in lObjects
-					logItem undef, obj, {prefix}
+					logBareItem obj, itemPre
 	return
 
 # ---------------------------------------------------------------------------
@@ -196,53 +133,54 @@ 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"
+	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)"
+	if funcMatch(funcName || stack.curFunc())
+		return label
 
-	switch type
-		when 'enter'
-			if funcMatch()
-				debugDebug "return #{OL(label)} from stdShouldLog() - funcMatch"
-				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
 
-			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
-		else
-			if funcMatch()
-				debugDebug "return #{OL(label)} from stdShouldLog()"
-				return label
-	debugDebug "return undef from stdShouldLog()"
+		if funcMatch(stack.curFunc())
+			result = label.replace('enter', 'call')
+			return result
 	return undef
 
 # ---------------------------------------------------------------------------
 
+export isMyFunc = (funcName) ->
+
+	return funcName in words('debug debug2 doTheLogging
+			stdShouldLog setDebugging getFuncList funcMatch
+			getType dumpCallStack')
+
+# ---------------------------------------------------------------------------
+
+export trueShouldLog = (label, type, funcName, stack) ->
+
+	if isMyFunc(funcName || stack.curFunc())
+		return undef
+	else
+		return label
+
+# ---------------------------------------------------------------------------
+
 export setDebugging = (option) ->
 
 	callStack.reset()
 	if isBoolean(option)
 		if option
-			shouldLog = (label, type, funcName, stack) -> label
+			shouldLog = trueShouldLog
 		else
-			shouldLog = (label, type, funcName, stack) -> undef
+			shouldLog = () -> return undef
 	else if isString(option)
 		lFuncList = getFuncList(option)
 		shouldLog = stdShouldLog
@@ -287,29 +225,21 @@ export getFuncList = (str) ->
 # ---------------------------------------------------------------------------
 # --- export only to allow unit tests
 
-export funcMatch = () ->
+export funcMatch = (funcName) ->
 
 	assert isArray(lFuncList), "not an array #{OL(lFuncList)}"
-
-	debugDebug "enter funcMatch()"
-	curFunc = callStack.curFunc()
-	debugDebug "curFunc = #{OL(curFunc)}"
-	debugDebug "lFuncList = #{strFuncList}"
 	for h in lFuncList
 		{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'
+# --- type is one of: 'enter', 'return', 'string'
 
-export getType = (str, nObjects) ->
+export getType = (str, lObjects) ->
 
 	if lMatches = str.match(///^
 			\s*
@@ -320,7 +250,6 @@ export getType = (str, nObjects) ->
 
 		# --- We are entering function curFunc
 		return ['enter', lMatches[1]]
-
 	else if lMatches = str.match(///^
 			\s*
 			return
@@ -330,9 +259,6 @@ export getType = (str, nObjects) ->
 			([A-Za-z_][A-Za-z0-9_\.]*)
 			///)
 		return ['return', lMatches[1]]
-
-	else if (nObjects > 0)
-		return ['objects', undef]
 	else
 		return ['string', undef]
 
@@ -346,3 +272,19 @@ reMethod = ///^
 
 # ---------------------------------------------------------------------------
 
+export dumpDebugGlobals = () ->
+
+	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 funcName in lFuncList
+		LOG "   #{OL(funcName)}"
+	LOG '='.repeat(40)
+
+# ---------------------------------------------------------------------------