@jdeighan/coffee-utils 4.1.10 → 4.1.14

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "4.1.10",
+	"version": "4.1.14",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -10,6 +10,7 @@
 		"./log": "./src/log_utils.js",
 		"./block": "./src/block_utils.js",
 		"./indent": "./src/indent_utils.js",
+		"./stack": "./src/call_stack.js",
 		"./debug": "./src/debug_utils.js",
 		"./svelte": "./src/svelte_utils.js",
 		"./test": "./src/UnitTester.js",

package/src/UnitTester.coffee

@@ -176,6 +176,10 @@ export class UnitTester
 		assert isInteger(lineNum),
 			"UnitTester.test(): arg 1 must be an integer"
 
+		if process.env.TEST_LINE_NUMBER
+			if Math.abs(lineNum) != parseInt(process.env.TEST_LINE_NUMBER)
+				return
+
 		@initialize()
 		@lineNum = lineNum    # set an object property
 
@@ -196,7 +200,7 @@ export class UnitTester
 				got = @normalize(got)
 		catch err
 			errMsg = err.message || 'UNKNOWN ERROR'
-			log "got ERROR: #{errMsg}"
+			log "got ERROR in unit test: #{errMsg}"
 
 		expected = @transformExpected(expected)
 		if isString(expected)

package/src/UnitTester.js

@@ -186,6 +186,11 @@ export var UnitTester = class UnitTester {
   test(lineNum, input, expected) {
     var err, errMsg, got, whichTest;
     assert(isInteger(lineNum), "UnitTester.test(): arg 1 must be an integer");
+    if (process.env.TEST_LINE_NUMBER) {
+      if (Math.abs(lineNum) !== parseInt(process.env.TEST_LINE_NUMBER)) {
+        return;
+      }
+    }
     this.initialize();
     this.lineNum = lineNum; // set an object property
     if ((lineNum < 0) && process.env.FINALTEST) {
@@ -207,7 +212,7 @@ export var UnitTester = class UnitTester {
     } catch (error1) {
       err = error1;
       errMsg = err.message || 'UNKNOWN ERROR';
-      log(`got ERROR: ${errMsg}`);
+      log(`got ERROR in unit test: ${errMsg}`);
     }
     expected = this.transformExpected(expected);
     if (isString(expected)) {

package/src/block_utils.coffee

@@ -86,7 +86,7 @@ export joinBlocks = (lBlocks...) ->
 
 	lNonEmptyBlocks = []
 	for block in lBlocks
-		assert isString(block), "joinBlocks(): block #{block} is not a string"
+		assert isString(block), "joinBlocks(): #{block} is not a string"
 		if nonEmpty(block)
 			lNonEmptyBlocks.push block
 	return lNonEmptyBlocks.join('\n')

package/src/block_utils.js

@@ -110,7 +110,7 @@ export var joinBlocks = function(...lBlocks) {
   lNonEmptyBlocks = [];
   for (i = 0, len1 = lBlocks.length; i < len1; i++) {
     block = lBlocks[i];
-    assert(isString(block), `joinBlocks(): block ${block} is not a string`);
+    assert(isString(block), `joinBlocks(): ${block} is not a string`);
     if (nonEmpty(block)) {
       lNonEmptyBlocks.push(block);
     }

package/src/call_stack.coffee

@@ -0,0 +1,43 @@
+# call_stack.coffee
+
+import {undef, croak} from '@jdeighan/coffee-utils'
+import {log} from '@jdeighan/coffee-utils/log'
+
+# ---------------------------------------------------------------------------
+
+export class CallStack
+
+	constructor: () ->
+
+		@reset()
+
+	# ........................................................................
+
+	call: (funcName, hInfo) ->
+
+		@lStack.push({funcName, hInfo})
+		return
+
+	# ........................................................................
+
+	returnFrom: (fName) ->
+
+		{funcName, hInfo} = @lStack.pop()
+		if funcName != fName
+			croak "returnFrom('#{fName}') but TOS is '#{funcName}'"
+		return hInfo
+
+	# ........................................................................
+
+	reset: () ->
+
+		@lStack = []
+
+	# ........................................................................
+
+	dump: (label='CALL STACK') ->
+
+		log "#{label}:"
+		for item, i in @lStack
+			log "#{i}: #{JSON.stringify(item)}"
+		return

package/src/call_stack.js

@@ -0,0 +1,49 @@
+// Generated by CoffeeScript 2.6.1
+  // call_stack.coffee
+import {
+  undef,
+  croak
+} from '@jdeighan/coffee-utils';
+
+import {
+  log
+} from '@jdeighan/coffee-utils/log';
+
+// ---------------------------------------------------------------------------
+export var CallStack = class CallStack {
+  constructor() {
+    this.reset();
+  }
+
+  // ........................................................................
+  call(funcName, hInfo) {
+    this.lStack.push({funcName, hInfo});
+  }
+
+  // ........................................................................
+  returnFrom(fName) {
+    var funcName, hInfo;
+    ({funcName, hInfo} = this.lStack.pop());
+    if (funcName !== fName) {
+      croak(`returnFrom('${fName}') but TOS is '${funcName}'`);
+    }
+    return hInfo;
+  }
+
+  // ........................................................................
+  reset() {
+    return this.lStack = [];
+  }
+
+  // ........................................................................
+  dump(label = 'CALL STACK') {
+    var i, item, j, len, ref;
+    log(`${label}:`);
+    ref = this.lStack;
+    for (i = j = 0, len = ref.length; j < len; i = ++j) {
+      item = ref[i];
+      log(`${i}: ${JSON.stringify(item)}`);
+    }
+  }
+
+};

package/src/coffee_utils.coffee

@@ -34,7 +34,7 @@ export assert = (cond, msg) ->
 export croak = (err, label, obj) ->
 
 	message = if (typeof err == 'object') then err.message else err
-	log "ERROR: #{message}"
+	log "ERROR (croak): #{message}"
 	log label, obj
 	if (typeof err == 'object')
 		throw err
@@ -74,6 +74,12 @@ export isString = (x) ->
 
 # ---------------------------------------------------------------------------
 
+export isBoolean = (x) ->
+
+	return typeof x == 'boolean'
+
+# ---------------------------------------------------------------------------
+
 export isNumber = (x) ->
 
 	return typeof x == 'number' || x instanceof Number

package/src/coffee_utils.js

@@ -37,7 +37,7 @@ export var assert = function(cond, msg) {
 export var croak = function(err, label, obj) {
   var message;
   message = (typeof err === 'object') ? err.message : err;
-  log(`ERROR: ${message}`);
+  log(`ERROR (croak): ${message}`);
   log(label, obj);
   if (typeof err === 'object') {
     throw err;
@@ -77,6 +77,11 @@ export var isString = function(x) {
   return typeof x === 'string' || x instanceof String;
 };
 
+// ---------------------------------------------------------------------------
+export var isBoolean = function(x) {
+  return typeof x === 'boolean';
+};
+
 // ---------------------------------------------------------------------------
 export var isNumber = function(x) {
   return typeof x === 'number' || x instanceof Number;

package/src/debug_utils.coffee

@@ -1,12 +1,13 @@
 # debug_utils.coffee
 
 import {
-	assert, undef, error, croak, warn, words, isString, isFunction,
-	oneline, escapeStr, isNumber, isArray,
+	assert, undef, error, croak, warn, isString, isFunction, isBoolean,
+	oneline, escapeStr, isNumber, isArray, words,
 	} from '@jdeighan/coffee-utils'
 import {blockToArray} from '@jdeighan/coffee-utils/block'
 import {log, setLogger} from '@jdeighan/coffee-utils/log'
 import {slurp} from '@jdeighan/coffee-utils/fs'
+import {CallStack} from '@jdeighan/coffee-utils/stack'
 
 vbar = '│'       # unicode 2502
 hbar = '─'       # unicode 2500
@@ -17,91 +18,105 @@ indent = vbar + '   '
 arrow = corner + hbar + arrowhead + ' '
 
 debugLevel = 0   # controls amount of indentation - we ensure it's never < 0
+stdLogger = false
 
-lDebugStack = []
-
-# --- These are saved/restored in lDebugStack
+# --- These are saved/restored on the call stack
 export debugging = false
-ifMatches = undef
-lDebugFuncs = undef   # --- names of functions to debug
+shouldDebug = shouldLog = undef
 
-stdLogger = false
+stack = new CallStack()
 
 # ---------------------------------------------------------------------------
 
-export useStdLogger = (flag=true) ->
+export resetDebugging = (funcDoDebug=undef, funcDoLog=undef) ->
 
-	stdLogger = flag
+	debugging = false
+	debugLevel = 0
+	stack.reset()
+	shouldDebug = (funcName) -> debugging
+	shouldLog   = (str)      -> debugging
+	if funcDoDebug
+		setDebugging funcDoDebug, funcDoLog
 	return
 
 # ---------------------------------------------------------------------------
 
-logger = (lArgs...) ->
+export setDebugging = (funcDoDebug=undef, funcDoLog=undef) ->
 
-	if stdLogger
-		log lArgs...
+	if isBoolean(funcDoDebug)
+		debugging = funcDoDebug
+	else if isString(funcDoDebug)
+		debugging = false
+		lFuncNames = words(funcDoDebug)
+		assert isArray(lFuncNames), "words('#{funcDoDebug}') returned non-array"
+		shouldDebug = (funcName) ->
+			debugging || funcMatch(funcName, lFuncNames)
+	else if isFunction(funcDoDebug)
+		shouldDebug = funcDoDebug
 	else
-		orgLogger = setLogger(console.log)
-		log lArgs...
-		setLogger(orgLogger)
+		croak "setDebugging(): bad parameter #{oneline(funcDoDebug)}"
+
+	if funcDoLog
+		assert isFunction(funcDoLog), "setDebugging: arg 2 not a function"
+		shouldLog = funcDoLog
 	return
 
 # ---------------------------------------------------------------------------
+# --- export only to allow unit tests
 
-stripArrow = (prefix) ->
+export funcMatch = (curFunc, lFuncNames) ->
 
-	return prefix.replace(arrow, '    ')
+	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 debugIfLineMatches = (regexp=undef) ->
+curEnv = () ->
 
-	ifMatches = regexp
-	return
+	return {debugging, shouldDebug, shouldLog}
 
 # ---------------------------------------------------------------------------
 
-saveDebugEnv = () ->
+setEnv = (hEnv) ->
 
-	lDebugStack.push({
-		debugging,
-		ifMatches,
-		lDebugFuncs,
-		})
+	{debugging, shouldDebug, shouldLog} = hEnv
 	return
 
-restoreDebugEnv = () ->
+# ---------------------------------------------------------------------------
 
-	if (lDebugStack.length == 0)
-		debugging = false
-		ifMatches = undef
-		lDebugFuncs = undef
-	else
-		h = lDebugStack.pop()
-		{debugging, ifMatches, lDebugFuncs} = h
+export useStdLogger = (flag=true) ->
 
+	stdLogger = flag
 	return
 
 # ---------------------------------------------------------------------------
 
-export setDebugging = (x) ->
+logger = (lArgs...) ->
 
-	if (x==false)
-		restoreDebugEnv()
+	if stdLogger
+		log lArgs...
 	else
-		# --- save current setting
-		saveDebugEnv()
-		if (x==true)
-			debugging = true
-		else if isString(x)
-			debugging = false
-			lDebugFuncs = words(x)
-		else
-			croak "setDebugging(): bad parameter #{oneline(x)}"
+		orgLogger = setLogger(console.log)
+		log lArgs...
+		setLogger(orgLogger)
 	return
 
 # ---------------------------------------------------------------------------
 
+stripArrow = (prefix) ->
+
+	return prefix.replace(arrow, '    ')
+
+# ---------------------------------------------------------------------------
+
 getPrefix = (level) ->
 
 	if (level < 0)
@@ -111,17 +126,6 @@ getPrefix = (level) ->
 
 # ---------------------------------------------------------------------------
 
-export resetDebugging = () ->
-
-	debugging = false
-	debugLevel = 0
-	ifMatches = undef
-	lDebugFuncs = undef
-	lDebugStack = []
-	return
-
-# ---------------------------------------------------------------------------
-
 export debug = (lArgs...) ->
 	# --- either 1 or 2 args
 
@@ -130,7 +134,7 @@ export debug = (lArgs...) ->
 	#     when debugging is off
 
 	nArgs = lArgs.length
-	assert ((nArgs >= 1) && (nArgs <= 2)), "debug(); Bad # args #{nArgs}"
+	assert ((nArgs == 1) || (nArgs == 2)), "debug(); Bad # args #{nArgs}"
 	str = lArgs[0]
 
 	# --- str must always be a string
@@ -153,6 +157,8 @@ export debug = (lArgs...) ->
 			///))
 		entering = true
 		curFunc = lMatches[1]
+		stack.call(curFunc, curEnv())
+		debugging = shouldDebug(curFunc, debugging)
 	else if (lMatches = str.match(///^
 			\s*
 			return
@@ -163,11 +169,9 @@ export debug = (lArgs...) ->
 			///))
 		returning = true
 		curFunc = lMatches[1]
+		hInfo = stack.returnFrom(curFunc)
 
-	if entering && lDebugFuncs && funcMatch(curFunc)
-		setDebugging true
-
-	if debugging && (! ifMatches? || str.match(ifMatches))
+	if debugging && shouldLog(str)
 
 		# --- set the prefix, i.e. indentation to use
 		if returning
@@ -186,14 +190,15 @@ export debug = (lArgs...) ->
 				logItem: true,
 				itemPrefix: stripArrow(prefix),
 				}
-		if returning && (debugLevel > 0)
-			debugLevel -= 1
 
-	if returning && lDebugFuncs && funcMatch(curFunc)
-		setDebugging false    # revert to previous setting - might still be on
-
-	if debugging && entering
-		debugLevel += 1
+	# --- Adjust debug level
+	if returning
+		if debugLevel > 0
+			debugLevel -= 1
+		setEnv(hInfo)
+	else if entering
+		if debugging
+			debugLevel += 1
 	return
 
 # ---------------------------------------------------------------------------
@@ -204,21 +209,6 @@ reMethod = ///^
 	([A-Za-z_][A-Za-z0-9_]*)
 	$///
 
-# ---------------------------------------------------------------------------
-# --- export only to allow unit tests
-
-export funcMatch = (curFunc) ->
-
-	assert isString(curFunc), "funcMatch(): not a string"
-	if lDebugFuncs.includes(curFunc)
-		return true
-	else if (lMatches = curFunc.match(reMethod)) \
-			&& ([_, cls, meth] = lMatches) \
-			&& lDebugFuncs.includes(meth)
-		return true
-	else
-		return false
-
 # ---------------------------------------------------------------------------
 
 export checkTrace = (block) ->
@@ -256,9 +246,5 @@ export checkTrace = (block) ->
 	return
 
 # ---------------------------------------------------------------------------
-# --- export only to allow unit tests
 
-export checkTraceFile = (filepath) ->
-
-	checkTrace(slurp(filepath))
-	return
+resetDebugging()

package/src/debug_utils.js

@@ -1,6 +1,6 @@
 // Generated by CoffeeScript 2.6.1
 // debug_utils.coffee
-var arrow, arrowhead, corner, debugLevel, getPrefix, hbar, ifMatches, indent, lDebugFuncs, lDebugStack, logger, reMethod, restoreDebugEnv, saveDebugEnv, stdLogger, stripArrow, vbar;
+var arrow, arrowhead, corner, curEnv, debugLevel, getPrefix, hbar, indent, logger, reMethod, setEnv, shouldDebug, shouldLog, stack, stdLogger, stripArrow, vbar;
 
 import {
   assert,
@@ -8,13 +8,14 @@ import {
   error,
   croak,
   warn,
-  words,
   isString,
   isFunction,
+  isBoolean,
   oneline,
   escapeStr,
   isNumber,
-  isArray
+  isArray,
+  words
 } from '@jdeighan/coffee-utils';
 
 import {
@@ -30,6 +31,10 @@ import {
   slurp
 } from '@jdeighan/coffee-utils/fs';
 
+import {
+  CallStack
+} from '@jdeighan/coffee-utils/stack';
+
 vbar = '│'; // unicode 2502
 
 hbar = '─'; // unicode 2500
@@ -44,77 +49,99 @@ arrow = corner + hbar + arrowhead + ' ';
 
 debugLevel = 0; // controls amount of indentation - we ensure it's never < 0
 
-lDebugStack = [];
+stdLogger = false;
 
-// --- These are saved/restored in lDebugStack
+// --- These are saved/restored on the call stack
 export var debugging = false;
 
-ifMatches = undef;
+shouldDebug = shouldLog = undef;
 
-lDebugFuncs = undef; // --- names of functions to debug
+stack = new CallStack();
 
-stdLogger = false;
+// ---------------------------------------------------------------------------
+export var resetDebugging = function(funcDoDebug = undef, funcDoLog = undef) {
+  debugging = false;
+  debugLevel = 0;
+  stack.reset();
+  shouldDebug = function(funcName) {
+    return debugging;
+  };
+  shouldLog = function(str) {
+    return debugging;
+  };
+  if (funcDoDebug) {
+    setDebugging(funcDoDebug, funcDoLog);
+  }
+};
 
 // ---------------------------------------------------------------------------
-export var useStdLogger = function(flag = true) {
-  stdLogger = flag;
+export var setDebugging = function(funcDoDebug = undef, funcDoLog = undef) {
+  var lFuncNames;
+  if (isBoolean(funcDoDebug)) {
+    debugging = funcDoDebug;
+  } else if (isString(funcDoDebug)) {
+    debugging = false;
+    lFuncNames = words(funcDoDebug);
+    assert(isArray(lFuncNames), `words('${funcDoDebug}') returned non-array`);
+    shouldDebug = function(funcName) {
+      return debugging || funcMatch(funcName, lFuncNames);
+    };
+  } else if (isFunction(funcDoDebug)) {
+    shouldDebug = funcDoDebug;
+  } else {
+    croak(`setDebugging(): bad parameter ${oneline(funcDoDebug)}`);
+  }
+  if (funcDoLog) {
+    assert(isFunction(funcDoLog), "setDebugging: arg 2 not a function");
+    shouldLog = funcDoLog;
+  }
 };
 
 // ---------------------------------------------------------------------------
-logger = function(...lArgs) {
-  var orgLogger;
-  if (stdLogger) {
-    log(...lArgs);
+// --- export only to allow unit tests
+export var funcMatch = function(curFunc, lFuncNames) {
+  var _, cls, lMatches, meth;
+  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 {
-    orgLogger = setLogger(console.log);
-    log(...lArgs);
-    setLogger(orgLogger);
+    return false;
   }
 };
 
 // ---------------------------------------------------------------------------
-stripArrow = function(prefix) {
-  return prefix.replace(arrow, '    ');
+curEnv = function() {
+  return {debugging, shouldDebug, shouldLog};
 };
 
 // ---------------------------------------------------------------------------
-export var debugIfLineMatches = function(regexp = undef) {
-  ifMatches = regexp;
+setEnv = function(hEnv) {
+  ({debugging, shouldDebug, shouldLog} = hEnv);
 };
 
 // ---------------------------------------------------------------------------
-saveDebugEnv = function() {
-  lDebugStack.push({debugging, ifMatches, lDebugFuncs});
+export var useStdLogger = function(flag = true) {
+  stdLogger = flag;
 };
 
-restoreDebugEnv = function() {
-  var h;
-  if (lDebugStack.length === 0) {
-    debugging = false;
-    ifMatches = undef;
-    lDebugFuncs = undef;
+// ---------------------------------------------------------------------------
+logger = function(...lArgs) {
+  var orgLogger;
+  if (stdLogger) {
+    log(...lArgs);
   } else {
-    h = lDebugStack.pop();
-    ({debugging, ifMatches, lDebugFuncs} = h);
+    orgLogger = setLogger(console.log);
+    log(...lArgs);
+    setLogger(orgLogger);
   }
 };
 
 // ---------------------------------------------------------------------------
-export var setDebugging = function(x) {
-  if (x === false) {
-    restoreDebugEnv();
-  } else {
-    // --- save current setting
-    saveDebugEnv();
-    if (x === true) {
-      debugging = true;
-    } else if (isString(x)) {
-      debugging = false;
-      lDebugFuncs = words(x);
-    } else {
-      croak(`setDebugging(): bad parameter ${oneline(x)}`);
-    }
-  }
+stripArrow = function(prefix) {
+  return prefix.replace(arrow, '    ');
 };
 
 // ---------------------------------------------------------------------------
@@ -126,25 +153,16 @@ getPrefix = function(level) {
   return '   '.repeat(level);
 };
 
-// ---------------------------------------------------------------------------
-export var resetDebugging = function() {
-  debugging = false;
-  debugLevel = 0;
-  ifMatches = undef;
-  lDebugFuncs = undef;
-  lDebugStack = [];
-};
-
 // ---------------------------------------------------------------------------
 export var debug = function(...lArgs) {
-  var curFunc, entering, item, lMatches, nArgs, prefix, returning, str;
+  var curFunc, entering, hInfo, item, lMatches, nArgs, prefix, returning, str;
   // --- either 1 or 2 args
 
   // --- 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
   nArgs = lArgs.length;
-  assert((nArgs >= 1) && (nArgs <= 2), `debug(); Bad # args ${nArgs}`);
+  assert((nArgs === 1) || (nArgs === 2), `debug(); Bad # args ${nArgs}`);
   str = lArgs[0];
   // --- str must always be a string
   //     if 2 args, then str is meant to be a label for the item
@@ -158,14 +176,14 @@ export var debug = function(...lArgs) {
   if ((lMatches = str.match(/^\s*enter\s+([A-Za-z_][A-Za-z0-9_\.]*)/))) {
     entering = true;
     curFunc = lMatches[1];
+    stack.call(curFunc, curEnv());
+    debugging = shouldDebug(curFunc, debugging);
   } else if ((lMatches = str.match(/^\s*return.*from\s+([A-Za-z_][A-Za-z0-9_\.]*)/))) {
     returning = true;
     curFunc = lMatches[1];
+    hInfo = stack.returnFrom(curFunc);
   }
-  if (entering && lDebugFuncs && funcMatch(curFunc)) {
-    setDebugging(true);
-  }
-  if (debugging && ((ifMatches == null) || str.match(ifMatches))) {
+  if (debugging && shouldLog(str)) {
     // --- set the prefix, i.e. indentation to use
     if (returning) {
       if (debugLevel === 0) {
@@ -185,35 +203,23 @@ export var debug = function(...lArgs) {
         itemPrefix: stripArrow(prefix)
       });
     }
-    if (returning && (debugLevel > 0)) {
+  }
+  // --- Adjust debug level
+  if (returning) {
+    if (debugLevel > 0) {
       debugLevel -= 1;
     }
-  }
-  if (returning && lDebugFuncs && funcMatch(curFunc)) {
-    setDebugging(false); // revert to previous setting - might still be on
-  }
-  if (debugging && entering) {
-    debugLevel += 1;
+    setEnv(hInfo);
+  } else if (entering) {
+    if (debugging) {
+      debugLevel += 1;
+    }
   }
 };
 
 // ---------------------------------------------------------------------------
 reMethod = /^([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/;
 
-// ---------------------------------------------------------------------------
-// --- export only to allow unit tests
-export var funcMatch = function(curFunc) {
-  var _, cls, lMatches, meth;
-  assert(isString(curFunc), "funcMatch(): not a string");
-  if (lDebugFuncs.includes(curFunc)) {
-    return true;
-  } else if ((lMatches = curFunc.match(reMethod)) && ([_, cls, meth] = lMatches) && lDebugFuncs.includes(meth)) {
-    return true;
-  } else {
-    return false;
-  }
-};
-
 // ---------------------------------------------------------------------------
 export var checkTrace = function(block) {
   var funcName, i, lMatches, lStack, len, len1, line, ref;
@@ -244,7 +250,4 @@ export var checkTrace = function(block) {
 };
 
 // ---------------------------------------------------------------------------
-// --- export only to allow unit tests
-export var checkTraceFile = function(filepath) {
-  checkTrace(slurp(filepath));
-};
+resetDebugging();