@jdeighan/coffee-utils 2.1.11 → 3.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "2.1.11",
+	"version": "3.0.0",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {

package/src/UnitTester.coffee

@@ -4,9 +4,10 @@ import {strict as assert} from 'assert'
 import test from 'ava'
 
 import {
-	undef, error, stringToArray,
+	undef, pass, error,
 	isString, isFunction, isInteger, isArray,
 	} from '@jdeighan/coffee-utils'
+import {blockToArray} from '@jdeighan/coffee-utils/block'
 import {log, currentLogger, setLogger} from '@jdeighan/coffee-utils/log'
 import {
 	debug, debugging, setDebugging,
@@ -25,6 +26,12 @@ export class UnitTester
 
 	# ........................................................................
 
+	initialize: () ->     # override to do any initialization
+
+		pass
+
+	# ........................................................................
+
 	justshow: (flag) ->
 
 		@justshow = flag
@@ -67,10 +74,7 @@ export class UnitTester
 	# ........................................................................
 
 	equal: (lineNum, input, expected) ->
-		if isString(input) && isString(expected)
-			@setWhichTest 'is'
-		else
-			@setWhichTest 'deepEqual'
+		@setWhichTest 'deepEqual'
 		@test lineNum, input, expected
 		return
 
@@ -160,7 +164,7 @@ export class UnitTester
 		#     Remove empty lines
 
 		if isString(input)
-			lLines = for line in stringToArray(input)
+			lLines = for line in blockToArray(input)
 				line = line.trim()
 				line.replace(/\s+/g, ' ')
 			lLines = lLines.filter (line) -> line != ''
@@ -172,6 +176,7 @@ export class UnitTester
 
 	test: (lineNum, input, expected) ->
 
+		@initialize()
 		@lineNum = lineNum    # set an object property
 
 		if (lineNum < 0) && process.env.FINALTEST

package/src/UnitTester.js

@@ -8,14 +8,18 @@ import test from 'ava';
 
 import {
   undef,
+  pass,
   error,
-  stringToArray,
   isString,
   isFunction,
   isInteger,
   isArray
 } from '@jdeighan/coffee-utils';
 
+import {
+  blockToArray
+} from '@jdeighan/coffee-utils/block';
+
 import {
   log,
   currentLogger,
@@ -39,6 +43,11 @@ export var UnitTester = class UnitTester {
     this.maxLineNum = undef;
   }
 
+  // ........................................................................
+  initialize() { // override to do any initialization
+    return pass;
+  }
+
   // ........................................................................
   justshow(flag) {
     this.justshow = flag;
@@ -73,11 +82,7 @@ export var UnitTester = class UnitTester {
 
   // ........................................................................
   equal(lineNum, input, expected) {
-    if (isString(input) && isString(expected)) {
-      this.setWhichTest('is');
-    } else {
-      this.setWhichTest('deepEqual');
-    }
+    this.setWhichTest('deepEqual');
     this.test(lineNum, input, expected);
   }
 
@@ -161,7 +166,7 @@ export var UnitTester = class UnitTester {
     if (isString(input)) {
       lLines = (function() {
         var i, len, ref, results;
-        ref = stringToArray(input);
+        ref = blockToArray(input);
         results = [];
         for (i = 0, len = ref.length; i < len; i++) {
           line = ref[i];
@@ -182,6 +187,7 @@ export var UnitTester = class UnitTester {
   // ........................................................................
   test(lineNum, input, expected) {
     var err, errMsg, got, whichTest;
+    this.initialize();
     this.lineNum = lineNum; // set an object property
     if ((lineNum < 0) && process.env.FINALTEST) {
       error("Negative line numbers not allowed in FINALTEST");

package/src/block_utils.coffee

@@ -6,10 +6,60 @@ import {
 import {createInterface} from 'readline'
 
 import {
-	isEmpty, nonEmpty, error, isComment,
+	isEmpty, nonEmpty, error, isComment, rtrim,
 	} from '@jdeighan/coffee-utils'
 import {log} from '@jdeighan/coffee-utils/log'
 
+# ---------------------------------------------------------------------------
+#   blockToArray - split a block into lines
+
+export blockToArray = (block) ->
+
+	if isEmpty(block)
+		return []
+	else
+		lLines = block.split(/\r?\n/)
+
+		# --- remove trailing empty lines
+		len = lLines.length
+		while (len > 0) && isEmpty(lLines[len-1])
+			lLines.pop()
+			len -= 1
+		return lLines
+
+# ---------------------------------------------------------------------------
+#   arrayToBlock - block will have no trailing whitespace
+
+export arrayToBlock = (lLines) ->
+
+	if lLines.length == 0
+		return ''
+	else
+		return rtrim(lLines.join('\n'))
+
+# ---------------------------------------------------------------------------
+#   normalizeBlock - remove blank lines, trim each line
+#                  - collapse internal whitespace to ' '
+
+export normalizeBlock = (content) ->
+
+	if typeof content != 'string'
+		throw new Error("normalizeBlock(): not a string")
+	lLines = for line in blockToArray(content)
+		line = line.trim()
+		line.replace(/\s+/g, ' ')
+	lLines = lLines.filter (line) -> line != ''
+	return lLines.join('\n')
+
+# ---------------------------------------------------------------------------
+# truncateBlock - limit block to a certain number of lines
+
+export truncateBlock = (str, numLines) ->
+
+	lLines = blockToArray str
+	lLines.length = numLines
+	return arrayToBlock lLines
+
 # ---------------------------------------------------------------------------
 
 export joinBlocks = (lBlocks...) ->

package/src/block_utils.js

@@ -14,18 +14,81 @@ import {
   isEmpty,
   nonEmpty,
   error,
-  isComment
+  isComment,
+  rtrim
 } from '@jdeighan/coffee-utils';
 
 import {
   log
 } from '@jdeighan/coffee-utils/log';
 
+// ---------------------------------------------------------------------------
+//   blockToArray - split a block into lines
+export var blockToArray = function(block) {
+  var lLines, len;
+  if (isEmpty(block)) {
+    return [];
+  } else {
+    lLines = block.split(/\r?\n/);
+    // --- remove trailing empty lines
+    len = lLines.length;
+    while ((len > 0) && isEmpty(lLines[len - 1])) {
+      lLines.pop();
+      len -= 1;
+    }
+    return lLines;
+  }
+};
+
+// ---------------------------------------------------------------------------
+//   arrayToBlock - block will have no trailing whitespace
+export var arrayToBlock = function(lLines) {
+  if (lLines.length === 0) {
+    return '';
+  } else {
+    return rtrim(lLines.join('\n'));
+  }
+};
+
+// ---------------------------------------------------------------------------
+//   normalizeBlock - remove blank lines, trim each line
+//                  - collapse internal whitespace to ' '
+export var normalizeBlock = function(content) {
+  var lLines, line;
+  if (typeof content !== 'string') {
+    throw new Error("normalizeBlock(): not a string");
+  }
+  lLines = (function() {
+    var i, len1, ref, results;
+    ref = blockToArray(content);
+    results = [];
+    for (i = 0, len1 = ref.length; i < len1; i++) {
+      line = ref[i];
+      line = line.trim();
+      results.push(line.replace(/\s+/g, ' '));
+    }
+    return results;
+  })();
+  lLines = lLines.filter(function(line) {
+    return line !== '';
+  });
+  return lLines.join('\n');
+};
+
+// ---------------------------------------------------------------------------
+// truncateBlock - limit block to a certain number of lines
+export var truncateBlock = function(str, numLines) {
+  var lLines;
+  lLines = blockToArray(str);
+  lLines.length = numLines;
+  return arrayToBlock(lLines);
+};
+
 // ---------------------------------------------------------------------------
 export var joinBlocks = function(...lBlocks) {
-  var blk, i, len, str;
+  var blk, i, len1, str;
   str = '';
-  for (i = 0, len = lBlocks.length; i < len; i++) {
+  for (i = 0, len1 = lBlocks.length; i < len1; i++) {
     blk = lBlocks[i];
     if (nonEmpty(blk)) {
       str += "\n" + blk;

package/src/coffee_utils.coffee

@@ -233,45 +233,6 @@ export firstLine = (input) ->
 	else
 		return input.substring(0, pos)
 
-# ---------------------------------------------------------------------------
-#   stringToArray - split a string into lines
-
-export stringToArray = (str) ->
-
-	if isEmpty(str)
-		return []
-	else
-		lLines = str.split(/\r?\n/)
-		len = lLines.length
-		while (len > 0) && isEmpty(lLines[len-1])
-			lLines.pop()
-			len -= 1
-		return lLines
-
-# ---------------------------------------------------------------------------
-#   arrayToString - every line has trailing newline
-
-export arrayToString = (lLines) ->
-
-	if lLines.length == 0
-		return ''
-	else
-		return rtrim(lLines.join('\n'))
-
-# ---------------------------------------------------------------------------
-#   normalize - remove blank lines, trim each line
-#             - collapse internal whitespace to ' '
-
-export normalize = (content) ->
-
-	if typeof content != 'string'
-		throw new Error("normalize(): not a string")
-	lLines = for line in stringToArray(content)
-		line = line.trim()
-		line.replace(/\s+/g, ' ')
-	lLines = lLines.filter (line) -> line != ''
-	return lLines.join('\n')
-
 # ---------------------------------------------------------------------------
 
 export titleLine = (title, char='=', padding=2, linelen=42) ->
@@ -353,15 +314,6 @@ export oneline = (obj) ->
 
 export OL = oneline
 
-# ---------------------------------------------------------------------------
-# truncateBlock - limit block to a certain number of lines
-
-export truncateBlock = (str, numLines) ->
-
-	lLines = stringToArray str
-	lLines.length = numLines
-	return arrayToString lLines
-
 # ---------------------------------------------------------------------------
 
 export removeCR = (block) ->

package/src/coffee_utils.js

@@ -162,11 +162,11 @@ export var words = function(str) {
 
 // ---------------------------------------------------------------------------
 export var isArrayOfHashes = function(lItems) {
-  var i, item, len1;
+  var i, item, len;
   if (!isArray(lItems)) {
     return false;
   }
-  for (i = 0, len1 = lItems.length; i < len1; i++) {
+  for (i = 0, len = lItems.length; i < len; i++) {
     item = lItems[i];
     if (!isHash(item)) {
       return false;
@@ -177,11 +177,11 @@ export var isArrayOfHashes = function(lItems) {
 
 // ---------------------------------------------------------------------------
 export var isArrayOfStrings = function(lItems) {
-  var i, item, len1;
+  var i, item, len;
   if (!isArray(lItems)) {
     return false;
   }
-  for (i = 0, len1 = lItems.length; i < len1; i++) {
+  for (i = 0, len = lItems.length; i < len; i++) {
     item = lItems[i];
     if (!isString(item)) {
       return false;
@@ -242,58 +242,6 @@ export var firstLine = function(input) {
   }
 };
 
-// ---------------------------------------------------------------------------
-//   stringToArray - split a string into lines
-export var stringToArray = function(str) {
-  var lLines, len;
-  if (isEmpty(str)) {
-    return [];
-  } else {
-    lLines = str.split(/\r?\n/);
-    len = lLines.length;
-    while ((len > 0) && isEmpty(lLines[len - 1])) {
-      lLines.pop();
-      len -= 1;
-    }
-    return lLines;
-  }
-};
-
-// ---------------------------------------------------------------------------
-//   arrayToString - every line has trailing newline
-export var arrayToString = function(lLines) {
-  if (lLines.length === 0) {
-    return '';
-  } else {
-    return rtrim(lLines.join('\n'));
-  }
-};
-
-// ---------------------------------------------------------------------------
-//   normalize - remove blank lines, trim each line
-//             - collapse internal whitespace to ' '
-export var normalize = function(content) {
-  var lLines, line;
-  if (typeof content !== 'string') {
-    throw new Error("normalize(): not a string");
-  }
-  lLines = (function() {
-    var i, len1, ref, results;
-    ref = stringToArray(content);
-    results = [];
-    for (i = 0, len1 = ref.length; i < len1; i++) {
-      line = ref[i];
-      line = line.trim();
-      results.push(line.replace(/\s+/g, ' '));
-    }
-    return results;
-  })();
-  lLines = lLines.filter(function(line) {
-    return line !== '';
-  });
-  return lLines.join('\n');
-};
-
 // ---------------------------------------------------------------------------
 export var titleLine = function(title, char = '=', padding = 2, linelen = 42) {
   var nLeft, nRight, strLeft, strMiddle, strRight, titleLen;
@@ -352,10 +300,10 @@ export var escapeStr = function(str) {
     croak("escapeStr(): not a string", str, 'STRING');
   }
   lParts = (function() {
-    var i, len1, ref, results;
+    var i, len, ref, results;
     ref = str.split('');
     results = [];
-    for (i = 0, len1 = ref.length; i < len1; i++) {
+    for (i = 0, len = ref.length; i < len; i++) {
       ch = ref[i];
       if (ch === '\n') {
         results.push('\\n');
@@ -385,15 +333,6 @@ export var oneline = function(obj) {
 
 export var OL = oneline;
 
-// ---------------------------------------------------------------------------
-// truncateBlock - limit block to a certain number of lines
-export var truncateBlock = function(str, numLines) {
-  var lLines;
-  lLines = stringToArray(str);
-  lLines.length = numLines;
-  return arrayToString(lLines);
-};
-
 // ---------------------------------------------------------------------------
 export var removeCR = function(block) {
   return block.replace(/\r/g, '');

package/src/debug_utils.coffee

@@ -3,9 +3,11 @@
 import {strict as assert} from 'assert'
 import {
 	undef, error, croak, warn, words, isString, isFunction,
-	stringToArray, oneline, escapeStr, isNumber, isArray,
+	oneline, escapeStr, isNumber, isArray,
 	} from '@jdeighan/coffee-utils'
+import {blockToArray} from '@jdeighan/coffee-utils/block'
 import {log} from '@jdeighan/coffee-utils/log'
+import {slurp} from '@jdeighan/coffee-utils/fs'
 
 vbar = '│'       # unicode 2502
 hbar = '─'       # unicode 2500
@@ -103,8 +105,9 @@ export resetDebugging = () ->
 export debug = (lArgs...) ->
 	# --- either 1 or 2 args
 
-	if not debugging && not lDebugFuncs?
-		return
+	# --- 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}"
@@ -126,7 +129,7 @@ export debug = (lArgs...) ->
 			\s*
 			enter
 			\s+
-			([A-Za-z_][A-Za-z0-9_]*)
+			([A-Za-z_][A-Za-z0-9_\.]*)
 			///))
 		entering = true
 		curFunc = lMatches[1]
@@ -136,7 +139,7 @@ export debug = (lArgs...) ->
 			.*
 			from
 			\s+
-			([A-Za-z_][A-Za-z0-9_]*)
+			([A-Za-z_][A-Za-z0-9_\.]*)
 			///))
 		returning = true
 		curFunc = lMatches[1]
@@ -163,15 +166,14 @@ 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
-		if entering
-			debugLevel += 1
-		if returning && (debugLevel > 0)
-			debugLevel -= 1
+	if debugging && entering
+		debugLevel += 1
 	return
 
 # ---------------------------------------------------------------------------
@@ -195,3 +197,45 @@ export funcMatch = (curFunc) ->
 		return true
 	else
 		return false
+
+# ---------------------------------------------------------------------------
+
+export checkTrace = (block) ->
+
+	lStack = []
+
+	for line in blockToArray(block)
+		if lMatches = line.match(///
+				enter
+				\s+
+				([A-Za-z_][A-Za-z0-9_\.]*)
+				///)
+			funcName = lMatches[1]
+			lStack.push funcName
+		else if lMatches = line.match(///
+				return
+				.*
+				from
+				\s+
+				([A-Za-z_][A-Za-z0-9_\.]*)
+				///)
+			funcName = lMatches[1]
+			len = lStack.length
+			if (len == 0)
+				log "return from #{funcName} with empty stack"
+			else if (lStack[len-1] == funcName)
+				lStack.pop()
+			else if (lStack[len-2] == funcName)
+				log "missing return from #{lStack[len-2]}"
+				lStack.pop()
+				lStack.pop()
+			else
+				log "return from #{funcName} - not found on stack"
+	return
+
+# ---------------------------------------------------------------------------
+
+export checkTraceFile = (filepath) ->
+
+	checkTrace(slurp(filepath))
+	return

package/src/debug_utils.js

@@ -14,17 +14,24 @@ import {
   words,
   isString,
   isFunction,
-  stringToArray,
   oneline,
   escapeStr,
   isNumber,
   isArray
 } from '@jdeighan/coffee-utils';
 
+import {
+  blockToArray
+} from '@jdeighan/coffee-utils/block';
+
 import {
   log
 } from '@jdeighan/coffee-utils/log';
 
+import {
+  slurp
+} from '@jdeighan/coffee-utils/fs';
+
 vbar = '│'; // unicode 2502
 
 hbar = '─'; // unicode 2500
@@ -115,9 +122,10 @@ export var resetDebugging = function() {
 export var debug = function(...lArgs) {
   var curFunc, entering, item, lMatches, nArgs, prefix, returning, str;
   // --- either 1 or 2 args
-  if (!debugging && (lDebugFuncs == null)) {
-    return;
-  }
+
+  // --- 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];
@@ -130,10 +138,10 @@ export var debug = function(...lArgs) {
   // --- 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 = str.match(/^\s*enter\s+([A-Za-z_][A-Za-z0-9_\.]*)/))) {
     entering = true;
     curFunc = lMatches[1];
-  } else if ((lMatches = str.match(/^\s*return.*from\s+([A-Za-z_][A-Za-z0-9_]*)/))) {
+  } else if ((lMatches = str.match(/^\s*return.*from\s+([A-Za-z_][A-Za-z0-9_\.]*)/))) {
     returning = true;
     curFunc = lMatches[1];
   }
@@ -160,17 +168,15 @@ export var debug = function(...lArgs) {
         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) {
-    if (entering) {
-      debugLevel += 1;
-    }
-    if (returning && (debugLevel > 0)) {
-      debugLevel -= 1;
-    }
+  if (debugging && entering) {
+    debugLevel += 1;
   }
 };
 
@@ -189,3 +195,36 @@ export var funcMatch = function(curFunc) {
     return false;
   }
 };
+
+// ---------------------------------------------------------------------------
+export var checkTrace = function(block) {
+  var funcName, i, lMatches, lStack, len, len1, line, ref;
+  lStack = [];
+  ref = blockToArray(block);
+  for (i = 0, len1 = ref.length; i < len1; i++) {
+    line = ref[i];
+    if (lMatches = line.match(/enter\s+([A-Za-z_][A-Za-z0-9_\.]*)/)) {
+      funcName = lMatches[1];
+      lStack.push(funcName);
+    } else if (lMatches = line.match(/return.*from\s+([A-Za-z_][A-Za-z0-9_\.]*)/)) {
+      funcName = lMatches[1];
+      len = lStack.length;
+      if (len === 0) {
+        log(`return from ${funcName} with empty stack`);
+      } else if (lStack[len - 1] === funcName) {
+        lStack.pop();
+      } else if (lStack[len - 2] === funcName) {
+        log(`missing return from ${lStack[len - 2]}`);
+        lStack.pop();
+        lStack.pop();
+      } else {
+        log(`return from ${funcName} - not found on stack`);
+      }
+    }
+  }
+};
+
+// ---------------------------------------------------------------------------
+export var checkTraceFile = function(filepath) {
+  checkTrace(slurp(filepath));
+};

package/src/indent_utils.coffee

@@ -2,9 +2,10 @@
 
 import {strict as assert} from 'assert'
 import {
-	undef, error, arrayToString, stringToArray, escapeStr,
+	undef, error, escapeStr,
 	oneline, isInteger, isString, isArray, isEmpty, rtrim,
 	} from '@jdeighan/coffee-utils'
+import {arrayToBlock, blockToArray} from '@jdeighan/coffee-utils/block'
 
 # ---------------------------------------------------------------------------
 #        NOTE: Currently, only TAB indentation is supported
@@ -30,6 +31,7 @@ export indentation = (level) ->
 
 # ---------------------------------------------------------------------------
 #   indentLevel - determine indent level of a string
+#                 it's OK if the string is ONLY indentation
 
 export indentLevel = (str) ->
 
@@ -51,9 +53,9 @@ export indented = (input, level=0) ->
 			"#{toAdd}#{line}"
 		return lLines
 	else
-		lLines = for line in stringToArray(input)
+		lLines = for line in blockToArray(input)
 			"#{toAdd}#{line}"
-		return arrayToString(lLines)
+		return arrayToBlock(lLines)
 
 # ---------------------------------------------------------------------------
 #   undented - string with 1st line indentation removed for each line
@@ -67,7 +69,7 @@ export undented = (text, level=undef) ->
 		return text
 
 	if isString(text)
-		lLines = stringToArray(text)
+		lLines = blockToArray(text)
 		if (lLines.length == 0)
 			return ''
 	else if isArray(text)
@@ -97,7 +99,7 @@ export undented = (text, level=undef) ->
 			lNewLines.push(line.substr(nToRemove))
 
 	if isString(text)
-		return arrayToString(lNewLines)
+		return arrayToBlock(lNewLines)
 	else
 		return lNewLines
 
@@ -109,7 +111,7 @@ export undented = (text, level=undef) ->
 export tabify = (str, numSpaces=undef) ->
 
 	lLines = []
-	for str in stringToArray(str)
+	for str in blockToArray(str)
 		lMatches = str.match(/^(\s*)(.*)$/)
 		[_, prefix, theRest] = lMatches
 		if prefix == ''
@@ -123,7 +125,7 @@ export tabify = (str, numSpaces=undef) ->
 			if (n % numSpaces != 0)
 				error "tabify(): Invalid # of leading space chars"
 			lLines.push '\t'.repeat(n / numSpaces) + theRest
-	return arrayToString(lLines)
+	return arrayToBlock(lLines)
 
 # ---------------------------------------------------------------------------
 #    untabify - convert leading TABs to spaces
@@ -132,11 +134,11 @@ export untabify = (str, numSpaces=3) ->
 
 	oneIndent = ' '.repeat(numSpaces)
 	lLines = []
-	for str in stringToArray(str)
+	for str in blockToArray(str)
 		lMatches = str.match(/^(\t*)(.*)$/)
 		[_, prefix, theRest] = lMatches
 		if prefix == ''
 			lLines.push theRest
 		else
 			lLines.push oneIndent.repeat(prefix.length) + theRest
-	return arrayToString(lLines)
+	return arrayToBlock(lLines)

package/src/indent_utils.js

@@ -7,8 +7,6 @@ import {
 import {
   undef,
   error,
-  arrayToString,
-  stringToArray,
   escapeStr,
   oneline,
   isInteger,
@@ -18,6 +16,11 @@ import {
   rtrim
 } from '@jdeighan/coffee-utils';
 
+import {
+  arrayToBlock,
+  blockToArray
+} from '@jdeighan/coffee-utils/block';
+
 // ---------------------------------------------------------------------------
 //        NOTE: Currently, only TAB indentation is supported
 // ---------------------------------------------------------------------------
@@ -41,6 +44,7 @@ export var indentation = function(level) {
 
 // ---------------------------------------------------------------------------
 //   indentLevel - determine indent level of a string
+//                 it's OK if the string is ONLY indentation
 export var indentLevel = function(str) {
   var lMatches;
   lMatches = str.match(/^\t*/);
@@ -70,7 +74,7 @@ export var indented = function(input, level = 0) {
   } else {
     lLines = (function() {
       var i, len, ref, results;
-      ref = stringToArray(input);
+      ref = blockToArray(input);
       results = [];
       for (i = 0, len = ref.length; i < len; i++) {
         line = ref[i];
@@ -78,7 +82,7 @@ export var indented = function(input, level = 0) {
       }
       return results;
     })();
-    return arrayToString(lLines);
+    return arrayToBlock(lLines);
   }
 };
 
@@ -93,7 +97,7 @@ export var undented = function(text, level = undef) {
     return text;
   }
   if (isString(text)) {
-    lLines = stringToArray(text);
+    lLines = blockToArray(text);
     if (lLines.length === 0) {
       return '';
     }
@@ -125,7 +129,7 @@ export var undented = function(text, level = undef) {
     }
   }
   if (isString(text)) {
-    return arrayToString(lNewLines);
+    return arrayToBlock(lNewLines);
   } else {
     return lNewLines;
   }
@@ -138,7 +142,7 @@ export var undented = function(text, level = undef) {
 export var tabify = function(str, numSpaces = undef) {
   var _, i, lLines, lMatches, len, n, prefix, ref, theRest;
   lLines = [];
-  ref = stringToArray(str);
+  ref = blockToArray(str);
   for (i = 0, len = ref.length; i < len; i++) {
     str = ref[i];
     lMatches = str.match(/^(\s*)(.*)$/);
@@ -159,7 +163,7 @@ export var tabify = function(str, numSpaces = undef) {
       lLines.push('\t'.repeat(n / numSpaces) + theRest);
     }
   }
-  return arrayToString(lLines);
+  return arrayToBlock(lLines);
 };
 
 // ---------------------------------------------------------------------------
@@ -168,7 +172,7 @@ export var untabify = function(str, numSpaces = 3) {
   var _, i, lLines, lMatches, len, oneIndent, prefix, ref, theRest;
   oneIndent = ' '.repeat(numSpaces);
   lLines = [];
-  ref = stringToArray(str);
+  ref = blockToArray(str);
   for (i = 0, len = ref.length; i < len; i++) {
     str = ref[i];
     lMatches = str.match(/^(\t*)(.*)$/);
@@ -179,5 +183,5 @@ export var untabify = function(str, numSpaces = 3) {
       lLines.push(oneIndent.repeat(prefix.length) + theRest);
     }
   }
-  return arrayToString(lLines);
+  return arrayToBlock(lLines);
 };

package/src/log_utils.coffee

@@ -4,9 +4,9 @@ import {strict as assert} from 'assert'
 import yaml from 'js-yaml'
 
 import {
-	undef, isNumber, isString, isHash, isFunction,
-	escapeStr, stringToArray,
+	undef, isNumber, isString, isHash, isFunction, escapeStr,
 	} from '@jdeighan/coffee-utils'
+import {blockToArray} from '@jdeighan/coffee-utils/block'
 import {tabify} from '@jdeighan/coffee-utils/indent'
 
 logger = console.log          # for strings
@@ -120,7 +120,7 @@ export log = (lArgs...) ->
 			logger "#{prefix}#{str} = '#{esc}'"
 		else
 			logger "#{prefix}#{str}:"
-			for line in stringToArray(item)
+			for line in blockToArray(item)
 				logger "#{itemPrefix}   #{escapeStr(line)}"
 	else
 		# --- It's some type of object
@@ -129,7 +129,7 @@ export log = (lArgs...) ->
 			logger "#{prefix}#{str} = #{json}"
 		else
 			logger "#{prefix}#{str}:"
-			for str in stringToArray(stringify(item))
+			for str in blockToArray(stringify(item))
 				logger "#{itemPrefix}   #{str}"
 	return
 

package/src/log_utils.js

@@ -14,10 +14,13 @@ import {
   isString,
   isHash,
   isFunction,
-  escapeStr,
-  stringToArray
+  escapeStr
 } from '@jdeighan/coffee-utils';
 
+import {
+  blockToArray
+} from '@jdeighan/coffee-utils/block';
+
 import {
   tabify
 } from '@jdeighan/coffee-utils/indent';
@@ -133,7 +136,7 @@ export var log = function(...lArgs) {
       logger(`${prefix}${str} = '${esc}'`);
     } else {
       logger(`${prefix}${str}:`);
-      ref = stringToArray(item);
+      ref = blockToArray(item);
       for (i = 0, len = ref.length; i < len; i++) {
         line = ref[i];
         logger(`${itemPrefix}   ${escapeStr(line)}`);
@@ -146,7 +149,7 @@ export var log = function(...lArgs) {
       logger(`${prefix}${str} = ${json}`);
     } else {
       logger(`${prefix}${str}:`);
-      ref1 = stringToArray(stringify(item));
+      ref1 = blockToArray(stringify(item));
       for (j = 0, len1 = ref1.length; j < len1; j++) {
         str = ref1[j];
         logger(`${itemPrefix}   ${str}`);