@jdeighan/coffee-utils 2.1.14 → 3.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "2.1.14",
+	"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, pass, 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,
@@ -163,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 != ''

package/src/UnitTester.js

@@ -10,13 +10,16 @@ import {
   undef,
   pass,
   error,
-  stringToArray,
   isString,
   isFunction,
   isInteger,
   isArray
 } from '@jdeighan/coffee-utils';
 
+import {
+  blockToArray
+} from '@jdeighan/coffee-utils/block';
+
 import {
   log,
   currentLogger,
@@ -163,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];

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,8 +3,9 @@
 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'
 
@@ -203,7 +204,7 @@ export checkTrace = (block) ->
 
 	lStack = []
 
-	for line in stringToArray(block)
+	for line in blockToArray(block)
 		if lMatches = line.match(///
 				enter
 				\s+

package/src/debug_utils.js

@@ -14,13 +14,16 @@ 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';
@@ -197,7 +200,7 @@ export var funcMatch = function(curFunc) {
 export var checkTrace = function(block) {
   var funcName, i, lMatches, lStack, len, len1, line, ref;
   lStack = [];
-  ref = stringToArray(block);
+  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_\.]*)/)) {

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}`);