@jdeighan/coffee-utils 7.0.50 → 7.0.53

package/src/debug_utils.coffee

@@ -2,7 +2,7 @@
 
 import {
 	assert, undef, error, croak, warn, defined,
-	isString, isFunction, isBoolean,
+	isString, isFunction, isBoolean, sep_dash,
 	OL, escapeStr, isNumber, isArray, words, pass,
 	} from '@jdeighan/coffee-utils'
 import {blockToArray} from '@jdeighan/coffee-utils/block'
@@ -10,17 +10,134 @@ import {untabify} from '@jdeighan/coffee-utils/indent'
 import {slurp} from '@jdeighan/coffee-utils/fs'
 import {CallStack} from '@jdeighan/coffee-utils/stack'
 import {
-	log, logItem, LOG, setStringifier, orderedStringify,
+	getPrefix, addArrow, removeLastVbar,
+	} from '@jdeighan/coffee-utils/arrow'
+import {
+	log, logItem, LOG, shortEnough,
 	} from '@jdeighan/coffee-utils/log'
 
-# --- These are saved/restored on the call stack
-export debugging = false
-shouldLogFunc   = (func) -> return debugging
-shouldLogString = (str)  -> return debugging
-
-stack = new CallStack()
+callStack = new CallStack()
 doDebugDebug = false
 
+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
+
 # ---------------------------------------------------------------------------
 
 export debugDebug = (flag=true) ->
@@ -34,183 +151,124 @@ export debugDebug = (flag=true) ->
 
 resetDebugging = () ->
 
-	debugging = false
 	if doDebugDebug
-		LOG "resetDebugging() - debugging = false"
-	stack.reset()
-	shouldLogFunc = (func)  -> return debugging
-	shouldLogString = (str) -> return debugging
+		LOG "resetDebugging()"
+	callStack.reset()
+	shouldLog = (label, type, funcName, stack) -> undef
 	return
 
 # ---------------------------------------------------------------------------
 
-export setDebugging = (funcDoDebug=undef, funcDoLog=undef) ->
+export setDebugging = (option) ->
 
 	resetDebugging()
-	if isBoolean(funcDoDebug)
-		debugging = funcDoDebug
+	if isBoolean(option)
+		if option
+			shouldLog = (label, type, funcName, stack) -> label
+		else
+			shouldLog = (label, type, funcName, stack) -> undef
 		if doDebugDebug
-			LOG "setDebugging(): debugging = #{funcDoDebug}"
-	else if isString(funcDoDebug)
-		debugging = false
-		lFuncNames = words(funcDoDebug)
-		assert isArray(lFuncNames), "words('#{funcDoDebug}') returned non-array"
-		shouldLogFunc = (funcName) ->
-			funcMatch(funcName, lFuncNames)
+			LOG "setDebugging = #{option}"
+	else if isString(option)
+		lFuncList = getFuncList(option)
+		shouldLog = stdShouldLog
 		if doDebugDebug
-			LOG "setDebugging FUNCS: #{lFuncNames.join(',')}, debugging = false"
-	else if isFunction(funcDoDebug)
-		shouldLogFunc = funcDoDebug
+			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(funcDoDebug)}"
-
-	if isFunction(funcDoLog)
-		assert isFunction(funcDoLog), "setDebugging: arg 2 not a function"
-		shouldLogString = funcDoLog
+		croak "bad parameter #{OL(option)}"
 	return
 
 # ---------------------------------------------------------------------------
 # --- export only to allow unit tests
 
-export funcMatch = (curFunc, lFuncNames) ->
+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
 
-	assert isString(curFunc), "funcMatch(): not a string"
-	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
+# ---------------------------------------------------------------------------
+# --- export only to allow unit tests
+
+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
+	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
 
 # ---------------------------------------------------------------------------
-# 1. adjust call stack on 'enter' or 'return from'
-# 2. adjust debugging flag
-# 3. return [mainPrefix, auxPrefix, hEnv, type] - hEnv can be undef
-# 4. disable logging by setting type to undef
+# --- type is one of: 'enter', 'return', 'string', 'object'
 
-adjustStack = (str) ->
+export getType = (str, nObjects) ->
 
-	if (lMatches = str.match(///^
+	if lMatches = str.match(///^
 			\s*
 			enter
 			\s+
 			([A-Za-z_][A-Za-z0-9_\.]*)
-			///))
+			///)
 
 		# --- We are entering function curFunc
-		curFunc = lMatches[1]
-
-		hEnv = {
-			debugging
-			shouldLogFunc
-			shouldLogString
-			}
+		return ['enter', lMatches[1]]
 
-		debugging = shouldLogFunc(curFunc)
-		if doDebugDebug
-			trans = "#{hEnv.debugging} => #{debugging}"
-			LOG "   ENTER #{curFunc}, debugging: #{trans}"
-		[mainPre, auxPre] = stack.doCall(curFunc, hEnv, debugging)
-		return [
-			mainPre
-			auxPre
-			undef
-			if shouldLogFunc(curFunc) then 'enter' else undef
-			]
-	else if (lMatches = str.match(///^
+	else if lMatches = str.match(///^
 			\s*
 			return
 			.+
 			from
 			\s+
 			([A-Za-z_][A-Za-z0-9_\.]*)
-			///))
-		curFunc = lMatches[1]
-		[mainPre, auxPre, hEnv] = stack.returnFrom(curFunc)
-		if doDebugDebug
-			LOG "   RETURN FROM #{curFunc}"
-		return [
-			mainPre
-			auxPre
-			hEnv
-			if shouldLogFunc(curFunc) then 'return' else undef
-			]
-	else
-		[mainPre, auxPre, _] = stack.logStr()
-		return [
-			mainPre
-			auxPre
-			undef
-			if shouldLogString(str) then 'string' else undef
-			]
-
-# ---------------------------------------------------------------------------
-
-export debug = (lArgs...) ->
-
-	# --- We want to allow item to be undef. Therefore, we need to
-	#     distinguish between 1 arg sent vs. 2 args sent
-	nArgs = lArgs.length
-	assert (nArgs==1) || (nArgs==2), "debug(): #{nArgs} args"
+			///)
+		return ['return', lMatches[1]]
 
-	# --- label must always be there, and be a string
-	#     item is optional
-	[label, item] = lArgs
-	assert isString(label),
-			"debug(): 1st arg #{OL(label)} should be a string"
-
-	if doDebugDebug
-		if nArgs==1
-			LOG "debug('#{escapeStr(label)}') - 1 arg"
-		else
-			LOG "debug('#{escapeStr(label)}', #{typeof item}) - 2 args"
-		LOG "debugging flag = #{OL(debugging)}"
-
-	# --- We always need to manipulate the stack when we encounter
-	#     either "enter X" or "return from X", so we can't short-circuit
-	#     when debugging is off
-
-	lResult = adjustStack(label)
-	if doDebugDebug
-		LOG 'lResult', lResult
-	[mainPre, auxPre, hEnv, type] = lResult
-	if doDebugDebug && (type == undef)
-		LOG "type is undef - NOT LOGGING"
-
-	hOptions = {
-		prefix: mainPre
-		itemPrefix: auxPre
-		}
-
-	switch type
-		when 'enter'
-			log label, hOptions
-			if (nArgs==2)
-				# --- don't repeat the label
-				logItem undef, item, hOptions
-		when 'return'
-			log label, hOptions
-			if (nArgs==2)
-				# --- don't repeat the label
-				logItem undef, item, hOptions
-		when 'string'
-			if (nArgs==2)
-				logItem label, item, hOptions
-			else
-				log label, hOptions
-
-	if hEnv
-		orgDebugging = debugging
-		{debugging, shouldLogFunc, shouldLogString} = hEnv
-		if doDebugDebug
-			trans = "#{orgDebugging} => #{debugging}"
-			LOG "   Restore hEnv: debugging: #{trans}"
-	return true   # allow use in boolean expressions
+	else if (nObjects > 0)
+		return ['objects', undef]
+	else
+		return ['string', undef]
 
 # ---------------------------------------------------------------------------