@jdeighan/coffee-utils 9.0.2 → 9.0.5

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "9.0.2",
+	"version": "9.0.5",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -55,6 +55,6 @@
 		"svelte": "^3.49.0"
 	},
 	"devDependencies": {
-		"@jdeighan/unit-tester": "^2.0.20"
+		"@jdeighan/unit-tester": "^2.0.21"
 	}
 }

package/src/Section.coffee

@@ -23,10 +23,10 @@ export class Section
 
 	# ..........................................................
 
-	indent: (level=1) ->
+	indent: (level=1, oneIndent="\t") ->
 
 		lNewLines = for line in @lParts
-			indented(line, level)
+			indented(line, level, oneIndent)
 		@lParts = lNewLines
 		return
 

package/src/Section.js

@@ -34,7 +34,7 @@ export var Section = class Section {
   }
 
   // ..........................................................
-  indent(level = 1) {
+  indent(level = 1, oneIndent = "\t") {
     var lNewLines, line;
     lNewLines = (function() {
       var i, len, ref, results;
@@ -42,7 +42,7 @@ export var Section = class Section {
       results = [];
       for (i = 0, len = ref.length; i < len; i++) {
         line = ref[i];
-        results.push(indented(line, level));
+        results.push(indented(line, level, oneIndent));
       }
       return results;
     }).call(this);

package/src/SectionMap.coffee

@@ -121,10 +121,11 @@ export class SectionMap
 		return
 
 	# ..........................................................
-	# --- procFunc should be (name, block) ->
-	#        return processed block
+	# --- hProc should be <name> -> <function>
+	#     <function> should be <block> -> <block>
+	# --- lTree allows you to get just a section
 
-	getBlock: (procFunc=undef, lTree=undef) ->
+	getBlock: (hProc={}, lTree=undef) ->
 
 		debug "enter getBlock()"
 		if (lTree == undef)
@@ -135,22 +136,23 @@ export class SectionMap
 		lParts = []
 		for part in lTree
 			if isString(part)
-				text = @section(part).getBlock()
-				if nonEmpty(text) && defined(procFunc)
-					text = procFunc(part, text)
+				block = @section(part).getBlock()
+				if defined(hProc[part])
+					# --- called even if block is empty
+					block = hProc[part](block)
 			else if isNonEmptyArray(part)
 				if isSectionName(part[0])
-					text = @getBlock(procFunc, part)
+					block = @getBlock(hProc, part)
 				else if isSetName(part[0])
-					text = @getBlock(procFunc, part.slice(1))
-					if nonEmpty(text) && defined(procFunc)
-						text = procFunc(part[0], text)
+					block = @getBlock(hProc, part.slice(1))
+					if defined(hProc[part[0]])
+						block = hProc[part[0]](block)
 				else
 					croak "Bad part: #{OL(part)}"
 			else
 				croak "Bad part: #{OL(part)}"
-			if defined(text)
-				lParts.push text
+			if defined(block)
+				lParts.push block
 
 		debug 'lParts', lParts
 		result = arrayToBlock(lParts)

package/src/SectionMap.js

@@ -151,10 +151,11 @@ export var SectionMap = class SectionMap {
   }
 
   // ..........................................................
-  // --- procFunc should be (name, block) ->
-  //        return processed block
-  getBlock(procFunc = undef, lTree = undef) {
-    var j, lParts, len, part, result, text;
+  // --- hProc should be <name> -> <function>
+  //     <function> should be <block> -> <block>
+  // --- lTree allows you to get just a section
+  getBlock(hProc = {}, lTree = undef) {
+    var block, j, lParts, len, part, result;
     debug("enter getBlock()");
     if (lTree === undef) {
       lTree = this.lSectionTree;
@@ -165,17 +166,18 @@ export var SectionMap = class SectionMap {
     for (j = 0, len = lTree.length; j < len; j++) {
       part = lTree[j];
       if (isString(part)) {
-        text = this.section(part).getBlock();
-        if (nonEmpty(text) && defined(procFunc)) {
-          text = procFunc(part, text);
+        block = this.section(part).getBlock();
+        if (defined(hProc[part])) {
+          // --- called even if block is empty
+          block = hProc[part](block);
         }
       } else if (isNonEmptyArray(part)) {
         if (isSectionName(part[0])) {
-          text = this.getBlock(procFunc, part);
+          block = this.getBlock(hProc, part);
         } else if (isSetName(part[0])) {
-          text = this.getBlock(procFunc, part.slice(1));
-          if (nonEmpty(text) && defined(procFunc)) {
-            text = procFunc(part[0], text);
+          block = this.getBlock(hProc, part.slice(1));
+          if (defined(hProc[part[0]])) {
+            block = hProc[part[0]](block);
           }
         } else {
           croak(`Bad part: ${OL(part)}`);
@@ -183,8 +185,8 @@ export var SectionMap = class SectionMap {
       } else {
         croak(`Bad part: ${OL(part)}`);
       }
-      if (defined(text)) {
-        lParts.push(text);
+      if (defined(block)) {
+        lParts.push(block);
       }
     }
     debug('lParts', lParts);

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