@jdeighan/coffee-utils 7.0.58 → 7.0.61

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,159 +10,118 @@ 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'
 
-callStack = new CallStack()
-
 # --- set in resetDebugging() and setDebugging()
+export callStack = new CallStack()
 export shouldLog = () -> undef
-export lFuncList = []
 
-# --- internal debugging
-doDebugDebug = false
-lFunctions = undef     # --- only used when doDebugDebug is true
+lFuncList = []          # names of functions being debugged
+strFuncList = undef     # original string
 
 # ---------------------------------------------------------------------------
 
-export setDebugDebugging = (value=true) ->
-	# --- value can be a boolean or string of words
+export debug = (orgLabel, lObjects...) ->
 
-	if isBoolean(value)
-		doDebugDebug = value
-	else if isString(value)
-		doDebugDebug = true
-		lFunctions = words(value)
-	else
-		croak "Bad value: #{OL(value)}"
-	return
+	assert isString(orgLabel), "1st arg #{OL(orgLabel)} should be a string"
 
-# ---------------------------------------------------------------------------
+	[type, funcName] = getType(orgLabel, lObjects)
+	label = shouldLog(orgLabel, type, funcName, callStack)
 
-logif = (label, lObjects...) ->
+	switch type
 
-	if ! doDebugDebug
-		return
+		when 'enter'
+			if defined(label)
+				doTheLogging type, label, lObjects
+			callStack.enter funcName, lObjects, defined(label)
 
-	assert isString(label), "1st arg #{OL(label)} should be a string"
-	nObjects = lObjects.length
-	[type, funcName] = getType(label, nObjects)
+			debug2 "enter debug()", orgLabel, lObjects
+			debug2 "type = #{OL(type)}, funcName = #{OL(funcName)}"
+			debug2 "return from debug()"
 
-	level = callStack.getLevel()
-	prefix = getPrefix(level)
-	itemPrefix = removeLastVbar(prefix)
-	sep = dashes(itemPrefix, 40)
+		when 'return'
+			debug2 "enter debug()", orgLabel, lObjects
+			debug2 "type = #{OL(type)}, funcName = #{OL(funcName)}"
+			debug2 "return from debug()"
 
-	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
+			if defined(label)
+				doTheLogging type, label, lObjects
+			callStack.returnFrom funcName
 
-	doTheLogging type, label, lObjects
+		when 'string'
+			debug2 "enter debug()", orgLabel, lObjects
+			debug2 "type = #{OL(type)}, funcName = #{OL(funcName)}"
 
-	if (type == 'return')
-		callStack.returnFrom funcName
+			if defined(label)
+				doTheLogging type, label, lObjects
+			debug2 "return from debug()"
 
-	return
+	return true   # allow use in boolean expressions
 
 # ---------------------------------------------------------------------------
 
-export debug = (label, lObjects...) ->
-
-	logif "enter debug(#{OL(label)})", lObjects...
-
-	assert isString(label), "1st arg #{OL(label)} should be a string"
+export debug2 = (orgLabel, lObjects...) ->
 
-	# --- 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)
-	logif "type = #{OL(type)}"
-	logif "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'
-			callStack.enter funcName
-			label = shouldLog(label, type, funcName, callStack)
+			if defined(label)
+				doTheLogging 'enter', label, lObjects
+			callStack.enter funcName, lObjects, defined(label)
+
 		when 'return'
-			label = shouldLog(label, type, funcName, callStack)
+			if defined(label)
+				doTheLogging 'return', label, lObjects
+			callStack.returnFrom funcName
+
 		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)
-	logif "doLog = #{OL(doLog)}"
-	logif "#{nObjects} objects"
-
-	if doLog
-		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()"
+			if defined(label)
+				doTheLogging 'string', label, lObjects
+
 	return true   # allow use in boolean expressions
 
 # ---------------------------------------------------------------------------
 
 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"
-
-	logif "callStack", callStack
-	logif "level = #{OL(level)}"
-	logif "prefix = #{OL(prefix)}"
-	logif "itemPrefix = #{OL(itemPrefix)}"
-	logif "sep = #{OL(sep)}"
+	sep = '-'.repeat(40)
 
 	switch type
+
 		when 'enter'
-			log label, {prefix}
+			log label, prefix(level)
+			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
 
 # ---------------------------------------------------------------------------
@@ -171,50 +130,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"
-
-	logif "stdShouldLog(#{OL(label)}, #{OL(type)}, #{OL(funcName)}, stack)"
-	logif "stack", stack
-	logif "lFuncList", lFuncList
 
-	switch type
-		when 'enter'
-			if funcMatch(stack, lFuncList)
-				return label
+	if funcMatch(funcName || stack.curFunc())
+		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
+	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
 
-				prevLogged = stack.isLoggingPrev()
-				if prevLogged
-					return label.replace('enter', 'call')
-		else
-			if funcMatch(stack, lFuncList)
-				return label
+		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
@@ -229,6 +192,7 @@ export setDebugging = (option) ->
 
 export getFuncList = (str) ->
 
+	strFuncList = str     # store original string for debugging
 	lFuncList = []
 	for word in words(str)
 		if lMatches = word.match(///^
@@ -258,29 +222,21 @@ export getFuncList = (str) ->
 # ---------------------------------------------------------------------------
 # --- export only to allow unit tests
 
-export funcMatch = (stack, lFuncList) ->
+export funcMatch = (funcName) ->
 
 	assert isArray(lFuncList), "not an array #{OL(lFuncList)}"
-
-	curFunc = stack.curFunc()
-	logif "funcMatch(): curFunc = #{OL(curFunc)}"
-	logif stack.dump('   ')
-	logif 'lFuncList', lFuncList
 	for h in lFuncList
 		{name, object, plus} = h
-		if (name == curFunc)
-			logif "   curFunc in lFuncList - match successful"
+		if (name == funcName)
 			return true
-		if plus && stack.isActive(name)
-			logif "   func #{OL(name)} is active - match successful"
+		if plus && callStack.isActive(name)
 			return true
-	logif "   - 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*
@@ -291,7 +247,6 @@ export getType = (str, nObjects) ->
 
 		# --- We are entering function curFunc
 		return ['enter', lMatches[1]]
-
 	else if lMatches = str.match(///^
 			\s*
 			return
@@ -301,9 +256,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]
 
@@ -317,3 +269,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)
+
+# ---------------------------------------------------------------------------