@jdeighan/coffee-utils 6.0.0 → 6.0.3

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "6.0.0",
+	"version": "6.0.3",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -14,6 +14,7 @@
 		"./indent": "./src/indent_utils.js",
 		"./stack": "./src/call_stack.js",
 		"./debug": "./src/debug_utils.js",
+		"./arrow": "./src/arrow.js",
 		"./svelte": "./src/svelte_utils.js",
 		"./store": "./src/DataStores.js",
 		"./taml": "./src/taml.js",
@@ -46,6 +47,7 @@
 	"dependencies": {
 		"cross-env": "^7.0.3",
 		"js-yaml": "^4.1.0",
+		"n-readlines": "^1.0.1",
 		"readline-sync": "^1.4.10",
 		"svelte": "^3.46.4"
 	},

package/src/arrow.coffee

@@ -0,0 +1,39 @@
+# arrow.coffee
+
+vbar = '│'       # unicode 2502
+hbar = '─'       # unicode 2500
+corner = '└'     # unicode 2514
+arrowhead = '>'
+
+oneIndent = vbar + '   '
+export arrow = corner + hbar + arrowhead + ' '
+
+# ---------------------------------------------------------------------------
+
+export getPrefix = (level, withArrow) ->
+
+	if withArrow
+		return oneIndent.repeat(level-1) + arrow
+	else
+		return oneIndent.repeat(level)
+	return
+
+# ---------------------------------------------------------------------------
+
+export hasArrow = (str) ->
+
+	return str.indexOf(arrow) > -1
+
+# ---------------------------------------------------------------------------
+
+export removeArrow = (str, useVbar) ->
+
+	if hasArrow(str)
+		if useVbar
+			return str.replace(arrow, oneIndent)
+		else
+			return str.replace(arrow, '    ')
+	else
+		return str
+
+# ---------------------------------------------------------------------------

package/src/arrow.js

@@ -0,0 +1,44 @@
+// Generated by CoffeeScript 2.6.1
+// arrow.coffee
+var arrowhead, corner, hbar, oneIndent, vbar;
+
+vbar = '│'; // unicode 2502
+
+hbar = '─'; // unicode 2500
+
+corner = '└'; // unicode 2514
+
+arrowhead = '>';
+
+oneIndent = vbar + '   ';
+
+export var arrow = corner + hbar + arrowhead + ' ';
+
+// ---------------------------------------------------------------------------
+export var getPrefix = function(level, withArrow) {
+  if (withArrow) {
+    return oneIndent.repeat(level - 1) + arrow;
+  } else {
+    return oneIndent.repeat(level);
+  }
+};
+
+// ---------------------------------------------------------------------------
+export var hasArrow = function(str) {
+  return str.indexOf(arrow) > -1;
+};
+
+// ---------------------------------------------------------------------------
+export var removeArrow = function(str, useVbar) {
+  if (hasArrow(str)) {
+    if (useVbar) {
+      return str.replace(arrow, oneIndent);
+    } else {
+      return str.replace(arrow, '    ');
+    }
+  } else {
+    return str;
+  }
+};
+
+// ---------------------------------------------------------------------------

package/src/debug_utils.coffee

@@ -1,7 +1,7 @@
 # debug_utils.coffee
 
 import {
-	assert, error, croak, warn, isString, isFunction, isBoolean,
+	assert, undef, error, croak, warn, isString, isFunction, isBoolean,
 	oneline, escapeStr, isNumber, isArray, words,
 	} from '@jdeighan/coffee-utils'
 import {blockToArray} from '@jdeighan/coffee-utils/block'
@@ -9,25 +9,32 @@ import {untabify} from '@jdeighan/coffee-utils/indent'
 import {slurp} from '@jdeighan/coffee-utils/fs'
 import {CallStack} from '@jdeighan/coffee-utils/stack'
 import {
-	log, setStringifier, orderedStringify,
+	log, LOG, setStringifier, orderedStringify,
 	} from '@jdeighan/coffee-utils/log'
-
-undef = undefined
-vbar = '│'       # unicode 2502
-hbar = '─'       # unicode 2500
-corner = '└'     # unicode 2514
-arrowhead = '>'
-
-indent = vbar + '   '
-arrow = corner + hbar + arrowhead + ' '
+import {getPrefix, arrow, removeArrow} from '@jdeighan/coffee-utils/arrow'
 
 debugLevel = 0   # controls amount of indentation - we ensure it's never < 0
 
 # --- These are saved/restored on the call stack
 export debugging = false
-shouldDebug = shouldLog = undef
+
+# --- By default, when entering a function, keep the debugging flag
+#     as it was
+shouldDebugFunc = (func) -> debugging
+
+# --- By default, log everything when debugging flag is on
+shouldLogString = (str) -> debugging
 
 stack = new CallStack()
+DEBUGDEBUG = false
+
+# ---------------------------------------------------------------------------
+
+export setDEBUGDEBUG = (flag=true) ->
+
+	DEBUGDEBUG = flag
+	console.log "DEBUGDEBUG = #{flag}"
+	return
 
 # ---------------------------------------------------------------------------
 
@@ -36,8 +43,8 @@ export resetDebugging = (funcDoDebug=undef, funcDoLog=undef) ->
 	debugging = false
 	debugLevel = 0
 	stack.reset()
-	shouldDebug = (funcName, curDebugging) -> curDebugging
-	shouldLog   = (str) -> debugging || process.env.DEBUG
+	shouldDebugFunc = (func) -> debugging
+	shouldLogString = (str)  -> debugging
 	if funcDoDebug
 		setDebugging funcDoDebug, funcDoLog
 	return
@@ -47,21 +54,27 @@ export resetDebugging = (funcDoDebug=undef, funcDoLog=undef) ->
 export setDebugging = (funcDoDebug=undef, funcDoLog=undef) ->
 
 	if isBoolean(funcDoDebug)
+		if DEBUGDEBUG
+			console.log "setDebugging #{funcDoDebug}"
 		debugging = funcDoDebug
 	else if isString(funcDoDebug)
 		debugging = false
 		lFuncNames = words(funcDoDebug)
 		assert isArray(lFuncNames), "words('#{funcDoDebug}') returned non-array"
-		shouldDebug = (funcName, curDebugging) ->
-			curDebugging || funcMatch(funcName, lFuncNames)
+		shouldDebugFunc = (funcName) ->
+			funcMatch(funcName, lFuncNames)
+		if DEBUGDEBUG
+			console.log "setDebugging FUNCS: #{lFuncNames.join(',')}"
 	else if isFunction(funcDoDebug)
-		shouldDebug = funcDoDebug
+		shouldDebugFunc = funcDoDebug
+		if DEBUGDEBUG
+			console.log "setDebugging to custom func"
 	else
 		croak "setDebugging(): bad parameter #{oneline(funcDoDebug)}"
 
 	if funcDoLog
 		assert isFunction(funcDoLog), "setDebugging: arg 2 not a function"
-		shouldLog = funcDoLog
+		shouldLogString = funcDoLog
 	return
 
 # ---------------------------------------------------------------------------
@@ -84,71 +97,37 @@ export funcMatch = (curFunc, lFuncNames) ->
 
 curEnv = () ->
 
-	return {debugging, shouldDebug, shouldLog}
+	return {debugging, shouldDebugFunc, shouldLogString}
 
 # ---------------------------------------------------------------------------
 
 setEnv = (hEnv) ->
 
-	{debugging, shouldDebug, shouldLog} = hEnv
-	return
-
-# ---------------------------------------------------------------------------
-# --- 2 possible signatures:
-#        (item) - just log out the string
-#        (item, hOptions) - log out the object, with a label
-
-logger = (item, hOptions=undef) ->
-
-	log item, hOptions
+	{debugging, shouldDebugFunc, shouldLogString} = hEnv
 	return
 
 # ---------------------------------------------------------------------------
 
-getPrefix = (level) ->
-
-	if (level < 0)
-		warn "You have mismatched debug 'enter'/'return' somewhere!"
-		return ''
-	return '   '.repeat(level)
-
-# ---------------------------------------------------------------------------
-
-envSaysDebug = (curFunc) ->
-
-	if process.env.DEBUG_FUNC?
-		return curFunc == process.env.DEBUG_FUNC
-	else if process.env.DEBUG_FUNCS?
-		return process.env.DEBUG_FUNCS.split(',').indexOf(curFunc) > -1
-	else
-		return false
-
-# ---------------------------------------------------------------------------
-
 export debug = (lArgs...) ->
-	# --- either 1 or 2 args
+
+	# --- We want to allow item to be undef. Therefore, we need to
+	#     distinguish between 1 arg sent vs. 2+ args sent
+	nArgs = lArgs.length
+	if DEBUGDEBUG
+		LOG "debug() called with #{nArgs} args"
+	[label, item] = lArgs
 
 	# --- 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}"
-	str = lArgs[0]
-
-	# --- str must always be a string
-	#     if 2 args, then str is meant to be a label for the item
-
-	assert isString(str),
-			"debug(): 1st arg #{oneline(str)} should be a string"
-
-	if (nArgs==2)
-		item = lArgs[1]
+	assert isString(label),
+			"debug(): 1st arg #{oneline(label)} should be a string"
 
 	# --- determine if we're entering or returning from a function
 	entering = returning = false
 	curFunc = undef
-	if (lMatches = str.match(///^
+	if (lMatches = label.match(///^
 			\s*
 			enter
 			\s+
@@ -157,8 +136,10 @@ export debug = (lArgs...) ->
 		entering = true
 		curFunc = lMatches[1]
 		stack.call(curFunc, curEnv())
-		debugging = envSaysDebug(curFunc) || shouldDebug(curFunc, debugging)
-	else if (lMatches = str.match(///^
+		debugging = shouldDebugFunc(curFunc)
+		if DEBUGDEBUG
+			LOG "ENTER #{curFunc}, debugging = #{debugging}"
+	else if (lMatches = label.match(///^
 			\s*
 			return
 			.+
@@ -169,31 +150,32 @@ export debug = (lArgs...) ->
 		returning = true
 		curFunc = lMatches[1]
 		hInfo = stack.returnFrom(curFunc)
+		if DEBUGDEBUG
+			LOG "RETURN FROM #{curFunc}, debugging = #{hInfo.debugging}"
 
-	if shouldLog(str)
-
+	if shouldLogString(label)
 		# --- set the prefix, i.e. indentation to use
 		if returning
 			if (debugLevel==0)
 				prefix = arrow
 			else
-				prefix = indent.repeat(debugLevel-1) + arrow
+				prefix = getPrefix(debugLevel, true)   # with arrow
 		else
-			prefix = indent.repeat(debugLevel)
+			prefix = getPrefix(debugLevel, false)   # no arrow
 
 		if (nArgs==1)
-			logger str, {
-				prefix: prefix
-				}
+			log label, {prefix}
 		else
-			itemPrefix = prefix.replace(arrow, '    ')
-			logger item, {
-				label: str
-				prefix: prefix
+			itemPrefix = removeArrow(prefix, false)
+			log item, {
+				label
+				prefix
 				itemPrefix
 				}
+	else if DEBUGDEBUG
+		LOG "shouldLogString('#{label}') returned FALSE"
 
-	# --- Adjust debug level
+	# --- Adjust debug level & contents of hInfo
 	if returning
 		if debugLevel > 0
 			debugLevel -= 1
@@ -236,15 +218,15 @@ export checkTrace = (block) ->
 			funcName = lMatches[1]
 			len = lStack.length
 			if (len == 0)
-				logger "return from #{funcName} with empty stack"
+				log "return from #{funcName} with empty stack"
 			else if (lStack[len-1] == funcName)
 				lStack.pop()
 			else if (lStack[len-2] == funcName)
-				logger "missing return from #{lStack[len-2]}"
+				log "missing return from #{lStack[len-2]}"
 				lStack.pop()
 				lStack.pop()
 			else
-				logger "return from #{funcName} - not found on stack"
+				log "return from #{funcName} - not found on stack"
 	return
 
 # ---------------------------------------------------------------------------

package/src/debug_utils.js

@@ -1,9 +1,10 @@
 // Generated by CoffeeScript 2.6.1
 // debug_utils.coffee
-var arrow, arrowhead, corner, curEnv, debugLevel, envSaysDebug, getPrefix, hbar, indent, logger, reMethod, setEnv, shouldDebug, shouldLog, stack, undef, vbar;
+var DEBUGDEBUG, curEnv, debugLevel, reMethod, setEnv, shouldDebugFunc, shouldLogString, stack;
 
 import {
   assert,
+  undef,
   error,
   croak,
   warn,
@@ -35,23 +36,16 @@ import {
 
 import {
   log,
+  LOG,
   setStringifier,
   orderedStringify
 } from '@jdeighan/coffee-utils/log';
 
-undef = void 0;
-
-vbar = '│'; // unicode 2502
-
-hbar = '─'; // unicode 2500
-
-corner = '└'; // unicode 2514
-
-arrowhead = '>';
-
-indent = vbar + '   ';
-
-arrow = corner + hbar + arrowhead + ' ';
+import {
+  getPrefix,
+  arrow,
+  removeArrow
+} from '@jdeighan/coffee-utils/arrow';
 
 debugLevel = 0; // controls amount of indentation - we ensure it's never < 0
 
@@ -59,20 +53,37 @@ debugLevel = 0; // controls amount of indentation - we ensure it's never < 0
 // --- These are saved/restored on the call stack
 export var debugging = false;
 
-shouldDebug = shouldLog = undef;
+// --- By default, when entering a function, keep the debugging flag
+//     as it was
+shouldDebugFunc = function(func) {
+  return debugging;
+};
+
+// --- By default, log everything when debugging flag is on
+shouldLogString = function(str) {
+  return debugging;
+};
 
 stack = new CallStack();
 
+DEBUGDEBUG = false;
+
+// ---------------------------------------------------------------------------
+export var setDEBUGDEBUG = function(flag = true) {
+  DEBUGDEBUG = flag;
+  console.log(`DEBUGDEBUG = ${flag}`);
+};
+
 // ---------------------------------------------------------------------------
 export var resetDebugging = function(funcDoDebug = undef, funcDoLog = undef) {
   debugging = false;
   debugLevel = 0;
   stack.reset();
-  shouldDebug = function(funcName, curDebugging) {
-    return curDebugging;
+  shouldDebugFunc = function(func) {
+    return debugging;
   };
-  shouldLog = function(str) {
-    return debugging || process.env.DEBUG;
+  shouldLogString = function(str) {
+    return debugging;
   };
   if (funcDoDebug) {
     setDebugging(funcDoDebug, funcDoLog);
@@ -83,22 +94,31 @@ export var resetDebugging = function(funcDoDebug = undef, funcDoLog = undef) {
 export var setDebugging = function(funcDoDebug = undef, funcDoLog = undef) {
   var lFuncNames;
   if (isBoolean(funcDoDebug)) {
+    if (DEBUGDEBUG) {
+      console.log(`setDebugging ${funcDoDebug}`);
+    }
     debugging = funcDoDebug;
   } else if (isString(funcDoDebug)) {
     debugging = false;
     lFuncNames = words(funcDoDebug);
     assert(isArray(lFuncNames), `words('${funcDoDebug}') returned non-array`);
-    shouldDebug = function(funcName, curDebugging) {
-      return curDebugging || funcMatch(funcName, lFuncNames);
+    shouldDebugFunc = function(funcName) {
+      return funcMatch(funcName, lFuncNames);
     };
+    if (DEBUGDEBUG) {
+      console.log(`setDebugging FUNCS: ${lFuncNames.join(',')}`);
+    }
   } else if (isFunction(funcDoDebug)) {
-    shouldDebug = funcDoDebug;
+    shouldDebugFunc = funcDoDebug;
+    if (DEBUGDEBUG) {
+      console.log("setDebugging to custom func");
+    }
   } else {
     croak(`setDebugging(): bad parameter ${oneline(funcDoDebug)}`);
   }
   if (funcDoLog) {
     assert(isFunction(funcDoLog), "setDebugging: arg 2 not a function");
-    shouldLog = funcDoLog;
+    shouldLogString = funcDoLog;
   }
 };
 
@@ -119,97 +139,68 @@ export var funcMatch = function(curFunc, lFuncNames) {
 
 // ---------------------------------------------------------------------------
 curEnv = function() {
-  return {debugging, shouldDebug, shouldLog};
+  return {debugging, shouldDebugFunc, shouldLogString};
 };
 
 // ---------------------------------------------------------------------------
 setEnv = function(hEnv) {
-  ({debugging, shouldDebug, shouldLog} = hEnv);
-};
-
-// ---------------------------------------------------------------------------
-// --- 2 possible signatures:
-//        (item) - just log out the string
-//        (item, hOptions) - log out the object, with a label
-logger = function(item, hOptions = undef) {
-  log(item, hOptions);
-};
-
-// ---------------------------------------------------------------------------
-getPrefix = function(level) {
-  if (level < 0) {
-    warn("You have mismatched debug 'enter'/'return' somewhere!");
-    return '';
-  }
-  return '   '.repeat(level);
-};
-
-// ---------------------------------------------------------------------------
-envSaysDebug = function(curFunc) {
-  if (process.env.DEBUG_FUNC != null) {
-    return curFunc === process.env.DEBUG_FUNC;
-  } else if (process.env.DEBUG_FUNCS != null) {
-    return process.env.DEBUG_FUNCS.split(',').indexOf(curFunc) > -1;
-  } else {
-    return false;
-  }
+  ({debugging, shouldDebugFunc, shouldLogString} = hEnv);
 };
 
 // ---------------------------------------------------------------------------
 export var debug = function(...lArgs) {
-  var curFunc, entering, hInfo, item, itemPrefix, lMatches, nArgs, prefix, returning, str;
-  // --- either 1 or 2 args
-
+  var curFunc, entering, hInfo, item, itemPrefix, lMatches, label, nArgs, prefix, returning;
+  // --- We want to allow item to be undef. Therefore, we need to
+  //     distinguish between 1 arg sent vs. 2+ args sent
+  nArgs = lArgs.length;
+  if (DEBUGDEBUG) {
+    LOG(`debug() called with ${nArgs} args`);
+  }
+  [label, item] = lArgs;
   // --- 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}`);
-  str = lArgs[0];
-  // --- str must always be a string
-  //     if 2 args, then str is meant to be a label for the item
-  assert(isString(str), `debug(): 1st arg ${oneline(str)} should be a string`);
-  if (nArgs === 2) {
-    item = lArgs[1];
-  }
+  assert(isString(label), `debug(): 1st arg ${oneline(label)} should be a string`);
   // --- determine if we're entering or returning from a function
   entering = returning = false;
   curFunc = undef;
-  if ((lMatches = str.match(/^\s*enter\s+([A-Za-z_][A-Za-z0-9_\.]*)/))) {
+  if ((lMatches = label.match(/^\s*enter\s+([A-Za-z_][A-Za-z0-9_\.]*)/))) {
     entering = true;
     curFunc = lMatches[1];
     stack.call(curFunc, curEnv());
-    debugging = envSaysDebug(curFunc) || shouldDebug(curFunc, debugging);
-  } else if ((lMatches = str.match(/^\s*return.+from\s+([A-Za-z_][A-Za-z0-9_\.]*)/))) {
+    debugging = shouldDebugFunc(curFunc);
+    if (DEBUGDEBUG) {
+      LOG(`ENTER ${curFunc}, debugging = ${debugging}`);
+    }
+  } else if ((lMatches = label.match(/^\s*return.+from\s+([A-Za-z_][A-Za-z0-9_\.]*)/))) {
     returning = true;
     curFunc = lMatches[1];
     hInfo = stack.returnFrom(curFunc);
+    if (DEBUGDEBUG) {
+      LOG(`RETURN FROM ${curFunc}, debugging = ${hInfo.debugging}`);
+    }
   }
-  if (shouldLog(str)) {
+  if (shouldLogString(label)) {
     // --- set the prefix, i.e. indentation to use
     if (returning) {
       if (debugLevel === 0) {
         prefix = arrow;
       } else {
-        prefix = indent.repeat(debugLevel - 1) + arrow;
+        prefix = getPrefix(debugLevel, true); // with arrow
       }
     } else {
-      prefix = indent.repeat(debugLevel);
+      prefix = getPrefix(debugLevel, false); // no arrow
     }
     if (nArgs === 1) {
-      logger(str, {
-        prefix: prefix
-      });
+      log(label, {prefix});
     } else {
-      itemPrefix = prefix.replace(arrow, '    ');
-      logger(item, {
-        label: str,
-        prefix: prefix,
-        itemPrefix
-      });
+      itemPrefix = removeArrow(prefix, false);
+      log(item, {label, prefix, itemPrefix});
     }
+  } else if (DEBUGDEBUG) {
+    LOG(`shouldLogString('${label}') returned FALSE`);
   }
-  // --- Adjust debug level
+  // --- Adjust debug level & contents of hInfo
   if (returning) {
     if (debugLevel > 0) {
       debugLevel -= 1;
@@ -240,15 +231,15 @@ export var checkTrace = function(block) {
       funcName = lMatches[1];
       len = lStack.length;
       if (len === 0) {
-        logger(`return from ${funcName} with empty stack`);
+        log(`return from ${funcName} with empty stack`);
       } else if (lStack[len - 1] === funcName) {
         lStack.pop();
       } else if (lStack[len - 2] === funcName) {
-        logger(`missing return from ${lStack[len - 2]}`);
+        log(`missing return from ${lStack[len - 2]}`);
         lStack.pop();
         lStack.pop();
       } else {
-        logger(`return from ${funcName} - not found on stack`);
+        log(`return from ${funcName} - not found on stack`);
       }
     }
   }

package/src/fs_utils.coffee

@@ -3,12 +3,13 @@
 import pathlib from 'path'
 import urllib from 'url'
 import fs from 'fs'
+import NReadLines from 'n-readlines'
 
 import {
 	assert, undef, pass, rtrim, error, nonEmpty,
 	isString, isRegExp, isFunction, croak,
 	} from '@jdeighan/coffee-utils'
-import {log} from '@jdeighan/coffee-utils/log'
+import {log, LOG} from '@jdeighan/coffee-utils/log'
 import {debug} from '@jdeighan/coffee-utils/debug'
 
 # ---------------------------------------------------------------------------
@@ -98,14 +99,36 @@ export backup = (file, from, to, report=false) ->
 	else
 		fs.copyFileSync(src, dest)
 
+# ---------------------------------------------------------------------------
+
+export forEachLineInFile = (filepath, func) ->
+
+	reader = new NReadLines(filepath)
+	nLines = 0
+
+	while (buffer = reader.next())
+		nLines += 1
+		# --- text is split on \n chars, we also need to remove \r chars
+		line = buffer.toString().replace(/\r/g, '')
+		if func(line, nLines) == 'EOF'
+			reader.close()   # allow premature termination
+	return
+
 # ---------------------------------------------------------------------------
 #   slurp - read an entire file into a string
 
-export slurp = (filepath) ->
+export slurp = (filepath, maxLines=undef) ->
 
 	debug "enter slurp('#{filepath}')"
-	filepath = filepath.replace(/\//g, "\\")
-	contents = fs.readFileSync(filepath, 'utf8').toString()
+	if maxLines?
+		lLines = []
+		forEachLineInFile filepath, (line, nLines) ->
+			lLines.push line
+			return if nLines >= maxLines then 'EOF' else undef
+		contents = lLines.join("\n")
+	else
+		filepath = filepath.replace(/\//g, "\\")
+		contents = fs.readFileSync(filepath, 'utf8').toString()
 	debug "return from slurp()", contents
 	return contents
 

package/src/fs_utils.js

@@ -6,6 +6,8 @@ import urllib from 'url';
 
 import fs from 'fs';
 
+import NReadLines from 'n-readlines';
+
 import {
   assert,
   undef,
@@ -20,7 +22,8 @@ import {
 } from '@jdeighan/coffee-utils';
 
 import {
-  log
+  log,
+  LOG
 } from '@jdeighan/coffee-utils/log';
 
 import {
@@ -117,13 +120,41 @@ export var backup = function(file, from, to, report = false) {
   }
 };
 
+// ---------------------------------------------------------------------------
+export var forEachLineInFile = function(filepath, func) {
+  var buffer, line, nLines, reader;
+  reader = new NReadLines(filepath);
+  nLines = 0;
+  while ((buffer = reader.next())) {
+    nLines += 1;
+    // --- text is split on \n chars, we also need to remove \r chars
+    line = buffer.toString().replace(/\r/g, '');
+    if (func(line, nLines) === 'EOF') {
+      reader.close(); // allow premature termination
+    }
+  }
+};
+
 // ---------------------------------------------------------------------------
 //   slurp - read an entire file into a string
-export var slurp = function(filepath) {
-  var contents;
+export var slurp = function(filepath, maxLines = undef) {
+  var contents, lLines;
   debug(`enter slurp('${filepath}')`);
-  filepath = filepath.replace(/\//g, "\\");
-  contents = fs.readFileSync(filepath, 'utf8').toString();
+  if (maxLines != null) {
+    lLines = [];
+    forEachLineInFile(filepath, function(line, nLines) {
+      lLines.push(line);
+      if (nLines >= maxLines) {
+        return 'EOF';
+      } else {
+        return undef;
+      }
+    });
+    contents = lLines.join("\n");
+  } else {
+    filepath = filepath.replace(/\//g, "\\");
+    contents = fs.readFileSync(filepath, 'utf8').toString();
+  }
   debug("return from slurp()", contents);
   return contents;
 };

package/src/indent_utils.coffee

@@ -133,7 +133,7 @@ export tabify = (str, numSpaces=undef) ->
 # ---------------------------------------------------------------------------
 #    untabify - convert leading TABs to spaces
 
-export untabify = (str, numSpaces=3) ->
+untabify_old = (str, numSpaces=3) ->
 
 	oneIndent = ' '.repeat(numSpaces)
 	lLines = []
@@ -145,3 +145,10 @@ export untabify = (str, numSpaces=3) ->
 		else
 			lLines.push oneIndent.repeat(prefix.length) + theRest
 	return arrayToBlock(lLines)
+
+# ---------------------------------------------------------------------------
+#    untabify - convert ALL TABs to spaces
+
+export untabify = (str, numSpaces=3) ->
+
+	return str.replace(/\t/g, ' '.repeat(numSpaces))

package/src/indent_utils.js

@@ -1,5 +1,7 @@
 // Generated by CoffeeScript 2.6.1
-  // indent_utils.coffee
+// indent_utils.coffee
+var untabify_old;
+
 import {
   assert,
   undef,
@@ -162,7 +164,7 @@ export var tabify = function(str, numSpaces = undef) {
 
 // ---------------------------------------------------------------------------
 //    untabify - convert leading TABs to spaces
-export var untabify = function(str, numSpaces = 3) {
+untabify_old = function(str, numSpaces = 3) {
   var _, i, lLines, lMatches, len, oneIndent, prefix, ref, theRest;
   oneIndent = ' '.repeat(numSpaces);
   lLines = [];
@@ -179,3 +181,9 @@ export var untabify = function(str, numSpaces = 3) {
   }
   return arrayToBlock(lLines);
 };
+
+// ---------------------------------------------------------------------------
+//    untabify - convert ALL TABs to spaces
+export var untabify = function(str, numSpaces = 3) {
+  return str.replace(/\t/g, ' '.repeat(numSpaces));
+};

package/src/log_utils.coffee

@@ -7,23 +7,29 @@ import {
 	escapeStr, sep_eq, sep_dash
 	} from '@jdeighan/coffee-utils'
 import {blockToArray} from '@jdeighan/coffee-utils/block'
-import {tabify, untabify} from '@jdeighan/coffee-utils/indent'
+import {tabify, untabify, indentation} from '@jdeighan/coffee-utils/indent'
+import {arrow, hasArrow, removeArrow} from '@jdeighan/coffee-utils/arrow'
 
 # --- This logger only ever gets passed a single string argument
-logger = undef
+putstr = undef
+
 export stringify = undef
-export id = 42
+objSep = '-'.repeat(42)
 
 # ---------------------------------------------------------------------------
 # This is useful for debugging and easy to remove after debugging
 
-export LOG = (label, item, ch='=') ->
+export LOG = (lArgs...) ->
 
-	if item
-		console.log ch.repeat(42)
-		console.log "[#{label}]:"
-		console.log untabify(orderedStringify(item))
-		console.log ch.repeat(42)
+	[label, item] = lArgs
+	if lArgs.length > 1
+		console.log objSep
+		if item?
+			console.log "#{label}:"
+			console.log untabify(orderedStringify(item))
+		else
+			console.log "[#{label}]: UNDEFINED"
+		console.log objSep
 	else
 		console.log label
 	return
@@ -47,9 +53,9 @@ export resetStringifier = () ->
 
 export setLogger = (func) ->
 
-	orgLogger = logger
 	assert isFunction(func), "setLogger() arg is not a function"
-	logger = func
+	orgLogger = putstr
+	putstr = func
 	return orgLogger
 
 # ---------------------------------------------------------------------------
@@ -99,55 +105,61 @@ maxOneLine = 32
 
 # ---------------------------------------------------------------------------
 
-export log = (item, hOptions=undef) ->
+export log = (item, hOptions={}) ->
 	# --- valid options:
-	#        label
-	#        prefix
-	#        escape
-
-	assert isFunction(logger), "logger not properly set"
-	prefix = itemPrefix = label = ''
-	if hOptions?
-		if isString(hOptions)
-			label = hOptions
-		else
-			assert isHash(hOptions), "log(): 2nd arg must be a string or hash"
-			if hOptions.prefix?
-				prefix = hOptions.prefix
-			if hOptions.itemPrefix?
-				itemPrefix = hOptions.itemPrefix
-			else
-				itemPrefix = prefix
-			if hOptions.label?
-				label = hOptions.label
+	#   label
+	#   prefix
+	#   itemPrefix
+	#   escape
+
+	assert isFunction(putstr), "putstr not properly set"
+	if isString(hOptions)
+		label = hOptions
+		prefix = itemPrefix = ''
+	else
+		assert isHash(hOptions), "log(): 2nd arg must be a string or hash"
+		label = hOptions.label || ''
+		prefix = hOptions.prefix ||  ''
+		itemPrefix = hOptions.itemPrefix || prefix || ''
+
+	# --- If putstr is console.log, we'll convert TAB char to 3 spaces
+	if putstr == console.log
+		label = untabify(label)
+		prefix = untabify(prefix)
+		itemPrefix = untabify(itemPrefix)
 
 	if isString(item) && (label == '')
-		if hOptions? && hOptions.escape
-			logger "#{prefix}#{escapeStr(item)}"
+		if hOptions.escape
+			putstr "#{prefix}#{escapeStr(item)}"
 		else
-			logger "#{prefix}#{item}"
+			putstr "#{prefix}#{item}"
 		return
 
 	if (label == '')
 		label = 'ITEM'
 
 	if (item == undef)
-		logger "#{prefix}#{label} = undef"
+		putstr "#{prefix}#{label} = undef"
 	else if isString(item)
 		if (item.length <= maxOneLine)
-			logger "#{prefix}#{label} = '#{escapeStr(item)}'"
+			putstr "#{prefix}#{label} = '#{escapeStr(item)}'"
 		else
-			logger "#{prefix}#{label}:"
-			logger "#{itemPrefix}#{sep_eq}"
+			putstr "#{prefix}#{label}:"
+			putstr "#{itemPrefix}#{sep_eq}"
 			for line in blockToArray(item)
-				logger "#{itemPrefix}#{escapeStr(line)}"
-			logger "#{itemPrefix}#{sep_eq}"
+				putstr "#{itemPrefix}#{escapeStr(line)}"
+			putstr "#{itemPrefix}#{sep_eq}"
 	else if isNumber(item)
-		logger "#{prefix}#{label} = #{item}"
+		putstr "#{prefix}#{label} = #{item}"
 	else
-		logger "#{prefix}#{label}:"
+		putstr "#{removeArrow(prefix, true)}#{objSep}"
+		putstr "#{prefix}#{label}:"
 		for str in blockToArray(stringify(item, true))
-			logger "#{itemPrefix}\t#{str}"
+			if putstr == console.log
+				putstr "#{itemPrefix}   #{untabify(str)}"
+			else
+				putstr "#{itemPrefix}#{indentation(1)}#{str}"
+		putstr "#{removeArrow(prefix, false)}#{objSep}"
 	return
 
 # ---------------------------------------------------------------------------

package/src/log_utils.js

@@ -1,6 +1,6 @@
 // Generated by CoffeeScript 2.6.1
 // log_utils.coffee
-var escReplacer, loaded, logger, maxOneLine;
+var escReplacer, loaded, maxOneLine, objSep, putstr;
 
 import yaml from 'js-yaml';
 
@@ -23,24 +23,37 @@ import {
 
 import {
   tabify,
-  untabify
+  untabify,
+  indentation
 } from '@jdeighan/coffee-utils/indent';
 
+import {
+  arrow,
+  hasArrow,
+  removeArrow
+} from '@jdeighan/coffee-utils/arrow';
+
 // --- This logger only ever gets passed a single string argument
-logger = undef;
+putstr = undef;
 
 export var stringify = undef;
 
-export var id = 42;
+objSep = '-'.repeat(42);
 
 // ---------------------------------------------------------------------------
 // This is useful for debugging and easy to remove after debugging
-export var LOG = function(label, item, ch = '=') {
-  if (item) {
-    console.log(ch.repeat(42));
-    console.log(`[${label}]:`);
-    console.log(untabify(orderedStringify(item)));
-    console.log(ch.repeat(42));
+export var LOG = function(...lArgs) {
+  var item, label;
+  [label, item] = lArgs;
+  if (lArgs.length > 1) {
+    console.log(objSep);
+    if (item != null) {
+      console.log(`${label}:`);
+      console.log(untabify(orderedStringify(item)));
+    } else {
+      console.log(`[${label}]: UNDEFINED`);
+    }
+    console.log(objSep);
   } else {
     console.log(label);
   }
@@ -63,9 +76,9 @@ export var resetStringifier = function() {
 // ---------------------------------------------------------------------------
 export var setLogger = function(func) {
   var orgLogger;
-  orgLogger = logger;
   assert(isFunction(func), "setLogger() arg is not a function");
-  logger = func;
+  orgLogger = putstr;
+  putstr = func;
   return orgLogger;
 };
 
@@ -116,37 +129,34 @@ export var orderedStringify = function(obj, escape = false) {
 maxOneLine = 32;
 
 // ---------------------------------------------------------------------------
-export var log = function(item, hOptions = undef) {
+export var log = function(item, hOptions = {}) {
   var i, itemPrefix, j, label, len, len1, line, prefix, ref, ref1, str;
   // --- valid options:
-  //        label
-  //        prefix
-  //        escape
-  assert(isFunction(logger), "logger not properly set");
-  prefix = itemPrefix = label = '';
-  if (hOptions != null) {
-    if (isString(hOptions)) {
-      label = hOptions;
-    } else {
-      assert(isHash(hOptions), "log(): 2nd arg must be a string or hash");
-      if (hOptions.prefix != null) {
-        prefix = hOptions.prefix;
-      }
-      if (hOptions.itemPrefix != null) {
-        itemPrefix = hOptions.itemPrefix;
-      } else {
-        itemPrefix = prefix;
-      }
-      if (hOptions.label != null) {
-        label = hOptions.label;
-      }
-    }
+  //   label
+  //   prefix
+  //   itemPrefix
+  //   escape
+  assert(isFunction(putstr), "putstr not properly set");
+  if (isString(hOptions)) {
+    label = hOptions;
+    prefix = itemPrefix = '';
+  } else {
+    assert(isHash(hOptions), "log(): 2nd arg must be a string or hash");
+    label = hOptions.label || '';
+    prefix = hOptions.prefix || '';
+    itemPrefix = hOptions.itemPrefix || prefix || '';
+  }
+  // --- If putstr is console.log, we'll convert TAB char to 3 spaces
+  if (putstr === console.log) {
+    label = untabify(label);
+    prefix = untabify(prefix);
+    itemPrefix = untabify(itemPrefix);
   }
   if (isString(item) && (label === '')) {
-    if ((hOptions != null) && hOptions.escape) {
-      logger(`${prefix}${escapeStr(item)}`);
+    if (hOptions.escape) {
+      putstr(`${prefix}${escapeStr(item)}`);
     } else {
-      logger(`${prefix}${item}`);
+      putstr(`${prefix}${item}`);
     }
     return;
   }
@@ -154,29 +164,35 @@ export var log = function(item, hOptions = undef) {
     label = 'ITEM';
   }
   if (item === undef) {
-    logger(`${prefix}${label} = undef`);
+    putstr(`${prefix}${label} = undef`);
   } else if (isString(item)) {
     if (item.length <= maxOneLine) {
-      logger(`${prefix}${label} = '${escapeStr(item)}'`);
+      putstr(`${prefix}${label} = '${escapeStr(item)}'`);
     } else {
-      logger(`${prefix}${label}:`);
-      logger(`${itemPrefix}${sep_eq}`);
+      putstr(`${prefix}${label}:`);
+      putstr(`${itemPrefix}${sep_eq}`);
       ref = blockToArray(item);
       for (i = 0, len = ref.length; i < len; i++) {
         line = ref[i];
-        logger(`${itemPrefix}${escapeStr(line)}`);
+        putstr(`${itemPrefix}${escapeStr(line)}`);
       }
-      logger(`${itemPrefix}${sep_eq}`);
+      putstr(`${itemPrefix}${sep_eq}`);
     }
   } else if (isNumber(item)) {
-    logger(`${prefix}${label} = ${item}`);
+    putstr(`${prefix}${label} = ${item}`);
   } else {
-    logger(`${prefix}${label}:`);
+    putstr(`${removeArrow(prefix, true)}${objSep}`);
+    putstr(`${prefix}${label}:`);
     ref1 = blockToArray(stringify(item, true));
     for (j = 0, len1 = ref1.length; j < len1; j++) {
       str = ref1[j];
-      logger(`${itemPrefix}\t${str}`);
+      if (putstr === console.log) {
+        putstr(`${itemPrefix}   ${untabify(str)}`);
+      } else {
+        putstr(`${itemPrefix}${indentation(1)}${str}`);
+      }
     }
+    putstr(`${removeArrow(prefix, false)}${objSep}`);
   }
 };