@jdeighan/coffee-utils 15.0.0 → 16.0.0

package/package.json

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

package/src/indent.coffee

@@ -34,15 +34,6 @@ export splitLine = (line, oneIndent=undef) =>
 	[prefix, str] = splitPrefix(line)
 	return [indentLevel(prefix, oneIndent), str]
 
-# ---------------------------------------------------------------------------
-#   indentation - return appropriate indentation string for given level
-#   export only to allow unit testing
-
-export indentation = (level, oneIndent="\t") =>
-
-	assert (level >= 0), "indentation(): negative level"
-	return oneIndent.repeat(level)
-
 # ---------------------------------------------------------------------------
 #   indentLevel - determine indent level of a string
 #                 it's OK if the string is ONLY indentation
@@ -59,28 +50,56 @@ export indentLevel = (line, oneIndent=undef) =>
 	if (prefixLen == 0)
 		return 0
 
-	if defined(oneIndent)
-		# --- prefix must be some multiple of oneIndent
-		len = oneIndent.length
-		assert (prefixLen % len == 0),
-			"prefix #{OL(prefix)} not a mult of #{OL(oneIndent)}"
-
-		level = prefixLen / len
+	# --- Match \t* followed by \x20* (error if no match)
+	if lMatches = prefix.match(/(\t*)(\x20*)/)
+		nTabs = lMatches[1].length
+		nSpaces = lMatches[2].length
 	else
-		ch = prefix.substring(0, 1)
-		if (ch == "\t")
-			oneIndent = "\t"
-			level = prefixLen
-		else if (ch == ' ')
-			oneIndent = ' '.repeat(prefixLen)
-			level = 1
+		croak "Invalid mix of TABs and spaces"
+
+	# --- oneIndent must be one of:
+	#        undef
+	#        a single TAB character
+	#        some number of space characters
+
+	switch oneIndent
+		when undef
+			if (nTabs > 0)
+				level = nTabs     # there may also be spaces, but we ignore them
+				oneIndent = "\t"  # may be used at end
+			else
+				assert (nSpaces > 0), "There must be TABS or spaces"
+				level = 1
+				oneIndent = ' '.repeat(nSpaces) # may be used at end
+		when "\t"
+			assert (nTabs > 0), "Expecting TAB indentation, found spaces"
+			# --- NOTE: there may be spaces, but they're not indentation
+			level = nTabs
 		else
-			croak "Bad Indentation in #{OL(line)}"
-
-	assert (prefix == oneIndent.repeat(level)),
-		"prefix #{OL(prefix)} not a mult of #{OL(oneIndent)}"
+			# --- oneIndent must be all space chars
+			assert (nTabs == 0),
+					"Indentation has TABs but oneIndent = #{OL(oneIndent)}"
+			assert (nSpaces % oneIndent.length == 0),
+				"prefix #{OL(prefix)} not a mult of #{OL(oneIndent)}"
+			level = nSpaces / oneIndent.length
+
+	# --- If a block, i.e. multi-line string, then all lines must be
+	#     at least at this level
+	if (line.indexOf("\n") >= 0)
+		for str in toArray(line)
+			assert (indentLevel(str, oneIndent) >= level),
+					"indentLevel of #{OL(line)} can't be found"
 	return level
 
+# ---------------------------------------------------------------------------
+#   indentation - return appropriate indentation string for given level
+#   export only to allow unit testing
+
+export indentation = (level, oneIndent="\t") =>
+
+	assert (level >= 0), "indentation(): negative level"
+	return oneIndent.repeat(level)
+
 # ---------------------------------------------------------------------------
 #   isUndented - true iff indentLevel(line) == 0
 
@@ -127,27 +146,22 @@ export indented = (input, level=1, oneIndent="\t") =>
 # ---------------------------------------------------------------------------
 #   undented - string with 1st line indentation removed for each line
 #            - ignore leading empty lines
-#            - unless level is set, in which case exactly that
-#              indentation is removed
 #            - returns same type as text, i.e. either string or array
 
-export undented = (input, level=undef, oneIndent="\t") =>
-
-	if defined(level) && (level==0)
-		return input
+export undented = (input) =>
 
-	# --- Remove any leading blank lines, set lLines
+	# --- If a string, convert to an array
 	if isString(input)
-		if lMatches = input.match(///^ [\r\n]+ (.*) $///s)
-			input = lMatches[1]
 		lLines = toArray(input)
 	else if isArray(input)
 		lLines = input
-		while (lLines.length > 0) && isEmpty(lLines[0])
-			lLines.shift()
 	else
 		croak "input not a string or array"
 
+	# --- Remove leading blank lines
+	while (lLines.length > 0) && isEmpty(lLines[0])
+		lLines.shift()   # remove
+
 	if (lLines.length == 0)
 		if isString(input)
 			return ''
@@ -155,27 +169,23 @@ export undented = (input, level=undef, oneIndent="\t") =>
 			return []
 
 	# --- determine what to remove from beginning of each line
-	if defined(level)
-		assert isInteger(level), "level must be an integer"
-		toRemove = indentation(level, oneIndent)
-	else
-		lMatches = lLines[0].match(/^\s*/)
-		toRemove = lMatches[0]
-	nToRemove = indentLevel(toRemove)
-
-	lNewLines = []
-	for line in lLines
-		if isEmpty(line)
-			lNewLines.push('')
-		else
-			if (line.indexOf(toRemove) != 0)
-				throw new Error("remove #{OL(toRemove)} from #{OL(line)}")
-			lNewLines.push(line.substr(nToRemove))
+	lMatches = lLines[0].match(/^\s*/)
+	toRemove = lMatches[0]
+	nToRemove = toRemove.length
+	if (nToRemove > 0)
+		lLines = lLines.map( (line) =>
+			if isEmpty(line)
+				return ''
+			else
+				assert (line.indexOf(toRemove)==0),
+					"can't remove #{OL(toRemove)} from #{OL(line)}"
+				return line.substr(nToRemove)
+			)
 
 	if isString(input)
-		return toBlock(lNewLines)
+		return toBlock(lLines)
 	else
-		return lNewLines
+		return lLines
 
 # ---------------------------------------------------------------------------
 #    enclose - indent text, surround with pre and post

package/src/indent.js

@@ -48,19 +48,11 @@ export var splitLine = (line, oneIndent = undef) => {
   return [indentLevel(prefix, oneIndent), str];
 };
 
-// ---------------------------------------------------------------------------
-//   indentation - return appropriate indentation string for given level
-//   export only to allow unit testing
-export var indentation = (level, oneIndent = "\t") => {
-  assert(level >= 0, "indentation(): negative level");
-  return oneIndent.repeat(level);
-};
-
 // ---------------------------------------------------------------------------
 //   indentLevel - determine indent level of a string
 //                 it's OK if the string is ONLY indentation
 export var indentLevel = (line, oneIndent = undef) => {
-  var ch, lMatches, len, level, prefix, prefixLen;
+  var i, lMatches, len, level, nSpaces, nTabs, prefix, prefixLen, ref, str;
   assert(isString(line), "not a string");
   // --- This will always match, and it's greedy
   if (lMatches = line.match(/^\s*/)) {
@@ -70,27 +62,59 @@ export var indentLevel = (line, oneIndent = undef) => {
   if (prefixLen === 0) {
     return 0;
   }
-  if (defined(oneIndent)) {
-    // --- prefix must be some multiple of oneIndent
-    len = oneIndent.length;
-    assert(prefixLen % len === 0, `prefix ${OL(prefix)} not a mult of ${OL(oneIndent)}`);
-    level = prefixLen / len;
+  // --- Match \t* followed by \x20* (error if no match)
+  if (lMatches = prefix.match(/(\t*)(\x20*)/)) {
+    nTabs = lMatches[1].length;
+    nSpaces = lMatches[2].length;
   } else {
-    ch = prefix.substring(0, 1);
-    if (ch === "\t") {
-      oneIndent = "\t";
-      level = prefixLen;
-    } else if (ch === ' ') {
-      oneIndent = ' '.repeat(prefixLen);
-      level = 1;
-    } else {
-      croak(`Bad Indentation in ${OL(line)}`);
+    croak("Invalid mix of TABs and spaces");
+  }
+  // --- oneIndent must be one of:
+  //        undef
+  //        a single TAB character
+  //        some number of space characters
+  switch (oneIndent) {
+    case undef:
+      if (nTabs > 0) {
+        level = nTabs; // there may also be spaces, but we ignore them
+        oneIndent = "\t"; // may be used at end
+      } else {
+        assert(nSpaces > 0, "There must be TABS or spaces");
+        level = 1;
+        oneIndent = ' '.repeat(nSpaces); // may be used at end
+      }
+      break;
+    case "\t":
+      assert(nTabs > 0, "Expecting TAB indentation, found spaces");
+      // --- NOTE: there may be spaces, but they're not indentation
+      level = nTabs;
+      break;
+    default:
+      // --- oneIndent must be all space chars
+      assert(nTabs === 0, `Indentation has TABs but oneIndent = ${OL(oneIndent)}`);
+      assert(nSpaces % oneIndent.length === 0, `prefix ${OL(prefix)} not a mult of ${OL(oneIndent)}`);
+      level = nSpaces / oneIndent.length;
+  }
+  // --- If a block, i.e. multi-line string, then all lines must be
+  //     at least at this level
+  if (line.indexOf("\n") >= 0) {
+    ref = toArray(line);
+    for (i = 0, len = ref.length; i < len; i++) {
+      str = ref[i];
+      assert(indentLevel(str, oneIndent) >= level, `indentLevel of ${OL(line)} can't be found`);
     }
   }
-  assert(prefix === oneIndent.repeat(level), `prefix ${OL(prefix)} not a mult of ${OL(oneIndent)}`);
   return level;
 };
 
+// ---------------------------------------------------------------------------
+//   indentation - return appropriate indentation string for given level
+//   export only to allow unit testing
+export var indentation = (level, oneIndent = "\t") => {
+  assert(level >= 0, "indentation(): negative level");
+  return oneIndent.repeat(level);
+};
+
 // ---------------------------------------------------------------------------
 //   isUndented - true iff indentLevel(line) == 0
 export var isUndented = (line) => {
@@ -102,7 +126,7 @@ export var isUndented = (line) => {
 //   indented - add indentation to each string in a block or array
 //            - returns the same type as input, i.e. array or string
 export var indented = (input, level = 1, oneIndent = "\t") => {
-  var i, lLines, len1, line, ref, toAdd;
+  var i, lLines, len, line, ref, toAdd;
   // --- level can be a string, in which case it is
   //     pre-pended to each line of input
   if (isString(level)) {
@@ -123,7 +147,7 @@ export var indented = (input, level = 1, oneIndent = "\t") => {
   //           else it splits the string into an array of lines
   lLines = [];
   ref = toArray(input);
-  for (i = 0, len1 = ref.length; i < len1; i++) {
+  for (i = 0, len = ref.length; i < len; i++) {
     line = ref[i];
     if (isEmpty(line)) {
       lLines.push('');
@@ -142,28 +166,21 @@ export var indented = (input, level = 1, oneIndent = "\t") => {
 // ---------------------------------------------------------------------------
 //   undented - string with 1st line indentation removed for each line
 //            - ignore leading empty lines
-//            - 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 = (input, level = undef, oneIndent = "\t") => {
-  var i, lLines, lMatches, lNewLines, len1, line, nToRemove, toRemove;
-  if (defined(level) && (level === 0)) {
-    return input;
-  }
-  // --- Remove any leading blank lines, set lLines
+export var undented = (input) => {
+  var lLines, lMatches, nToRemove, toRemove;
+  // --- If a string, convert to an array
   if (isString(input)) {
-    if (lMatches = input.match(/^[\r\n]+(.*)$/s)) {
-      input = lMatches[1];
-    }
     lLines = toArray(input);
   } else if (isArray(input)) {
     lLines = input;
-    while ((lLines.length > 0) && isEmpty(lLines[0])) {
-      lLines.shift();
-    }
   } else {
     croak("input not a string or array");
   }
+  // --- Remove leading blank lines
+  while ((lLines.length > 0) && isEmpty(lLines[0])) {
+    lLines.shift(); // remove
+  }
   if (lLines.length === 0) {
     if (isString(input)) {
       return '';
@@ -172,30 +189,23 @@ export var undented = (input, level = undef, oneIndent = "\t") => {
     }
   }
   // --- determine what to remove from beginning of each line
-  if (defined(level)) {
-    assert(isInteger(level), "level must be an integer");
-    toRemove = indentation(level, oneIndent);
-  } else {
-    lMatches = lLines[0].match(/^\s*/);
-    toRemove = lMatches[0];
-  }
-  nToRemove = indentLevel(toRemove);
-  lNewLines = [];
-  for (i = 0, len1 = lLines.length; i < len1; i++) {
-    line = lLines[i];
-    if (isEmpty(line)) {
-      lNewLines.push('');
-    } else {
-      if (line.indexOf(toRemove) !== 0) {
-        throw new Error(`remove ${OL(toRemove)} from ${OL(line)}`);
+  lMatches = lLines[0].match(/^\s*/);
+  toRemove = lMatches[0];
+  nToRemove = toRemove.length;
+  if (nToRemove > 0) {
+    lLines = lLines.map((line) => {
+      if (isEmpty(line)) {
+        return '';
+      } else {
+        assert(line.indexOf(toRemove) === 0, `can't remove ${OL(toRemove)} from ${OL(line)}`);
+        return line.substr(nToRemove);
       }
-      lNewLines.push(line.substr(nToRemove));
-    }
+    });
   }
   if (isString(input)) {
-    return toBlock(lNewLines);
+    return toBlock(lLines);
   } else {
-    return lNewLines;
+    return lLines;
   }
 };