@jdeighan/coffee-utils 9.0.4 → 9.0.5

package/package.json

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

package/src/block_utils.coffee

@@ -25,6 +25,23 @@ export blockToArray = (block) ->
 			len -= 1
 		return lLines
 
+# ---------------------------------------------------------------------------
+#   toArray - split a block or array into lines w/o newlines
+
+export toArray = (item) ->
+
+	if isString(item)
+		return item.split(/\r?\n/)
+	else if isArray(item)
+		# --- We still need to ensure that no strings contain newlines
+		lLines = []
+		for str in item
+			for substr in toArray(str)
+				lLines.push substr
+		return lLines
+	else
+		croak "Not a string or array"
+
 # ---------------------------------------------------------------------------
 #   arrayToBlock - block will have no trailing whitespace
 
@@ -39,6 +56,21 @@ export arrayToBlock = (lLines) ->
 	else
 		return rtrim(lLines.join('\n'))
 
+# ---------------------------------------------------------------------------
+#   toBlock - block may have trailing whitespace
+#             but undef items are ignored
+
+export toBlock = (lLines) ->
+
+	if (lLines == undef)
+		return undef
+	assert isArray(lLines), "lLines is not an array"
+	lLines = lLines.filter((line) => defined(line));
+	if lLines.length == 0
+		return undef
+	else
+		return lLines.join('\n')
+
 # ---------------------------------------------------------------------------
 
 export splitBlock = (block) ->

package/src/block_utils.js

@@ -37,6 +37,29 @@ export var blockToArray = function(block) {
   }
 };
 
+// ---------------------------------------------------------------------------
+//   toArray - split a block or array into lines w/o newlines
+export var toArray = function(item) {
+  var i, j, lLines, len1, len2, ref, str, substr;
+  if (isString(item)) {
+    return item.split(/\r?\n/);
+  } else if (isArray(item)) {
+    // --- We still need to ensure that no strings contain newlines
+    lLines = [];
+    for (i = 0, len1 = item.length; i < len1; i++) {
+      str = item[i];
+      ref = toArray(str);
+      for (j = 0, len2 = ref.length; j < len2; j++) {
+        substr = ref[j];
+        lLines.push(substr);
+      }
+    }
+    return lLines;
+  } else {
+    return croak("Not a string or array");
+  }
+};
+
 // ---------------------------------------------------------------------------
 //   arrayToBlock - block will have no trailing whitespace
 export var arrayToBlock = function(lLines) {
@@ -54,6 +77,24 @@ export var arrayToBlock = function(lLines) {
   }
 };
 
+// ---------------------------------------------------------------------------
+//   toBlock - block may have trailing whitespace
+//             but undef items are ignored
+export var toBlock = function(lLines) {
+  if (lLines === undef) {
+    return undef;
+  }
+  assert(isArray(lLines), "lLines is not an array");
+  lLines = lLines.filter((line) => {
+    return defined(line);
+  });
+  if (lLines.length === 0) {
+    return undef;
+  } else {
+    return lLines.join('\n');
+  }
+};
+
 // ---------------------------------------------------------------------------
 export var splitBlock = function(block) {
   var pos;

package/src/indent_utils.coffee

@@ -5,7 +5,9 @@ import {
 	undef, escapeStr, defined,
 	OL, isInteger, isString, isArray, isEmpty, rtrim,
 	} from '@jdeighan/coffee-utils'
-import {arrayToBlock, blockToArray} from '@jdeighan/coffee-utils/block'
+import {
+	arrayToBlock, blockToArray, toArray, toBlock,
+	} from '@jdeighan/coffee-utils/block'
 
 # ---------------------------------------------------------------------------
 
@@ -71,14 +73,11 @@ export isUndented = (line) ->
 export indented = (input, level=1, oneIndent="\t") ->
 
 	assert (level >= 0), "indented(): negative level"
-	if level == 0
+	if (level == 0)
 		return input
 
 	toAdd = indentation(level, oneIndent)
-	if isArray(input)
-		lInputLines = input
-	else
-		lInputLines = blockToArray(input)
+	lInputLines = toArray(input)
 
 	lLines = for line in lInputLines
 		if isEmpty(line)
@@ -93,27 +92,18 @@ export indented = (input, level=1, oneIndent="\t") ->
 #              indentation is removed
 #            - returns same type as text, i.e. either string or array
 
-export undented = (text, level=undef, oneIndent="\t") ->
+export undented = (input, level=undef, oneIndent="\t") ->
 
 	if defined(level) && (level==0)
-		return text
-
-	if isString(text)
-		lLines = blockToArray(text)
-		if (lLines.length == 0)
-			return ''
-	else if isArray(text)
-		lLines = text
-		for line in lLines
-			assert isString(line), "undented(): array not all strings"
-		if (lLines.length == 0)
-			return []
-	else
-		error "undented(): Not an array or string: #{OL(text)}"
+		return input
+
+	lLines = toArray(input)
+	if (lLines.length == 0)
+		return ''
 
 	# --- determine what to remove from beginning of each line
 	if defined(level)
-		assert isInteger(level), "undented(): level must be an integer"
+		assert isInteger(level), "level must be an integer"
 		toRemove = indentation(level, oneIndent)
 	else
 		lMatches = lLines[0].match(/^\s*/)
@@ -129,8 +119,8 @@ export undented = (text, level=undef, oneIndent="\t") ->
 				throw new Error("remove #{OL(toRemove)} from #{OL(text)}")
 			lNewLines.push(line.substr(nToRemove))
 
-	if isString(text)
-		return arrayToBlock(lNewLines)
+	if isString(input)
+		return toBlock(lNewLines)
 	else
 		return lNewLines
 

package/src/indent_utils.js

@@ -19,7 +19,9 @@ import {
 
 import {
   arrayToBlock,
-  blockToArray
+  blockToArray,
+  toArray,
+  toBlock
 } from '@jdeighan/coffee-utils/block';
 
 // ---------------------------------------------------------------------------
@@ -87,11 +89,7 @@ export var indented = function(input, level = 1, oneIndent = "\t") {
     return input;
   }
   toAdd = indentation(level, oneIndent);
-  if (isArray(input)) {
-    lInputLines = input;
-  } else {
-    lInputLines = blockToArray(input);
-  }
+  lInputLines = toArray(input);
   lLines = (function() {
     var i, len1, results;
     results = [];
@@ -113,31 +111,18 @@ export var indented = function(input, level = 1, oneIndent = "\t") {
 //            - unless level is set, in which case exactly that
 //              indentation is removed
 //            - returns same type as text, i.e. either string or array
-export var undented = function(text, level = undef, oneIndent = "\t") {
-  var i, j, lLines, lMatches, lNewLines, len1, len2, line, nToRemove, toRemove;
+export var undented = function(input, level = undef, oneIndent = "\t") {
+  var i, lLines, lMatches, lNewLines, len1, line, nToRemove, toRemove;
   if (defined(level) && (level === 0)) {
-    return text;
+    return input;
   }
-  if (isString(text)) {
-    lLines = blockToArray(text);
-    if (lLines.length === 0) {
-      return '';
-    }
-  } else if (isArray(text)) {
-    lLines = text;
-    for (i = 0, len1 = lLines.length; i < len1; i++) {
-      line = lLines[i];
-      assert(isString(line), "undented(): array not all strings");
-    }
-    if (lLines.length === 0) {
-      return [];
-    }
-  } else {
-    error(`undented(): Not an array or string: ${OL(text)}`);
+  lLines = toArray(input);
+  if (lLines.length === 0) {
+    return '';
   }
   // --- determine what to remove from beginning of each line
   if (defined(level)) {
-    assert(isInteger(level), "undented(): level must be an integer");
+    assert(isInteger(level), "level must be an integer");
     toRemove = indentation(level, oneIndent);
   } else {
     lMatches = lLines[0].match(/^\s*/);
@@ -145,8 +130,8 @@ export var undented = function(text, level = undef, oneIndent = "\t") {
   }
   nToRemove = indentLevel(toRemove);
   lNewLines = [];
-  for (j = 0, len2 = lLines.length; j < len2; j++) {
-    line = lLines[j];
+  for (i = 0, len1 = lLines.length; i < len1; i++) {
+    line = lLines[i];
     if (isEmpty(line)) {
       lNewLines.push('');
     } else {
@@ -156,8 +141,8 @@ export var undented = function(text, level = undef, oneIndent = "\t") {
       lNewLines.push(line.substr(nToRemove));
     }
   }
-  if (isString(text)) {
-    return arrayToBlock(lNewLines);
+  if (isString(input)) {
+    return toBlock(lNewLines);
   } else {
     return lNewLines;
   }