@jdeighan/coffee-utils 14.0.38 → 15.0.1

package/package.json

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

package/src/fs.coffee

@@ -5,7 +5,7 @@ import pathlib from 'path'
 import urllib from 'url'
 import fs from 'fs'
 import {
-	readFile, writeFile, rm,
+	readFile, writeFile, rm, rmdir,   #  rmSync, rmdirSync,
 	} from 'node:fs/promises'
 import {execSync} from 'node:child_process'
 import readline from 'readline'
@@ -21,6 +21,15 @@ import {LOG, LOGVALUE} from '@jdeighan/base-utils/log'
 import {dbg, dbgEnter, dbgReturn} from '@jdeighan/base-utils/debug'
 import {fromTAML} from '@jdeighan/base-utils/taml'
 
+fix = true
+
+# ---------------------------------------------------------------------------
+
+export doFixOutput = (flag=true) =>
+
+	fix = flag
+	return
+
 # ---------------------------------------------------------------------------
 
 export mkpath = (lParts...) =>
@@ -40,7 +49,7 @@ export mkpath = (lParts...) =>
 
 # ---------------------------------------------------------------------------
 
-export mkdir = (dirpath) =>
+export mkdirSync = (dirpath) =>
 
 	try
 		fs.mkdirSync dirpath
@@ -54,21 +63,88 @@ export mkdir = (dirpath) =>
 
 # ---------------------------------------------------------------------------
 
-export rmdir = (dirpath) =>
+export rmDir = (dirpath) =>
+
+	await rmdir dirpath, {recursive: true}
+	return
+
+# ---------------------------------------------------------------------------
+
+export rmDirSync = (dirpath) =>
 
-	await rm dirpath, {recursive: true}
+	fs.rmdirSync dirpath, {recursive: true}
 	return
 
 # ---------------------------------------------------------------------------
 
-export rmfile = (filepath) =>
+export rmFile = (filepath) =>
 
 	await rm filepath
 	return
 
+# ---------------------------------------------------------------------------
+
+export rmFileSync = (filepath) =>
+
+	fs.rmSync filepath
+	return
+
+# --------------------------------------------------------------------------
+
+export fixOutput = (contents) =>
+
+	if fix
+		return rtrim(contents) + "\n"
+	else
+		return contents
+
+# --------------------------------------------------------------------------
+
+export fixFile = (filepath, func) =>
+
+	contents = await readFile(filepath, {encoding: 'utf8'})
+	output = func(contents) # returns modified contents
+	output = fixOutput(output)
+	await writeFile(filepath, output, {encoding: 'utf8'})
+	return
+
+# --------------------------------------------------------------------------
+
+export fixJson = (filepath, func) =>
+
+	contents = await readFile(filepath, {encoding: 'utf8'})
+	hJson = JSON.parse(contents)
+	func(hJson)   # modify in place
+	output = JSON.stringify(hJson, null, 3)
+	output = fixOutput(output)
+	await writeFile(filepath, output, {encoding: 'utf8'})
+	return
+
+# --------------------------------------------------------------------------
+
+export fixFileSync = (filepath, func) =>
+
+	contents = fs.readFileSync(filepath, {encoding: 'utf8'})
+	output = func(contents) # returns modified contents
+	output = fixOutput(output)
+	fs.writeFileSync(filepath, output, {encoding: 'utf8'})
+	return
+
+# --------------------------------------------------------------------------
+
+export fixJsonSync = (filepath, func) =>
+
+	contents = fs.readFileSync(filepath, {encoding: 'utf8'})
+	hJson = JSON.parse(contents)
+	func(hJson)   # modify in place
+	output = JSON.stringify(hJson, null, 3)
+	output = fixOutput(output)
+	fs.writeFileSync(filepath, output, {encoding: 'utf8'})
+	return
+
 # --------------------------------------------------------------------------
 
-export execCmd = (cmdLine) =>
+export execCmdSync = (cmdLine) =>
 
 	execSync cmdLine, {}, (error, stdout, stderr) =>
 		if (error)
@@ -326,7 +402,7 @@ export barf = (filepath, contents='', hOptions={}) =>
 				contents = toBlock(contents)
 			else if ! isString(contents)
 				croak "barf(): Invalid contents"
-			contents = rtrim(contents) + "\n"
+			contents = fixOutput(contents)
 	fs.writeFileSync(filepath, contents, {encoding: 'utf8'})
 	return
 

package/src/fs.js

@@ -1,6 +1,6 @@
 // Generated by CoffeeScript 2.7.0
 // fs.coffee
-var isSystemDir;
+var fix, isSystemDir;
 
 import os from 'os';
 
@@ -13,7 +13,8 @@ import fs from 'fs';
 import {
   readFile,
   writeFile,
-  rm
+  rm,
+  rmdir //  rmSync, rmdirSync,
 } from 'node:fs/promises';
 
 import {
@@ -63,6 +64,13 @@ import {
   fromTAML
 } from '@jdeighan/base-utils/taml';
 
+fix = true;
+
+// ---------------------------------------------------------------------------
+export var doFixOutput = (flag = true) => {
+  fix = flag;
+};
+
 // ---------------------------------------------------------------------------
 export var mkpath = (...lParts) => {
   var _, drive, i, lMatches, lNewParts, len, newPath, part, rest;
@@ -84,7 +92,7 @@ export var mkpath = (...lParts) => {
 };
 
 // ---------------------------------------------------------------------------
-export var mkdir = (dirpath) => {
+export var mkdirSync = (dirpath) => {
   var err;
   try {
     fs.mkdirSync(dirpath);
@@ -100,19 +108,96 @@ export var mkdir = (dirpath) => {
 };
 
 // ---------------------------------------------------------------------------
-export var rmdir = async(dirpath) => {
-  await rm(dirpath, {
+export var rmDir = async(dirpath) => {
+  await rmdir(dirpath, {
+    recursive: true
+  });
+};
+
+// ---------------------------------------------------------------------------
+export var rmDirSync = (dirpath) => {
+  fs.rmdirSync(dirpath, {
     recursive: true
   });
 };
 
 // ---------------------------------------------------------------------------
-export var rmfile = async(filepath) => {
+export var rmFile = async(filepath) => {
   await rm(filepath);
 };
 
+// ---------------------------------------------------------------------------
+export var rmFileSync = (filepath) => {
+  fs.rmSync(filepath);
+};
+
+// --------------------------------------------------------------------------
+export var fixOutput = (contents) => {
+  if (fix) {
+    return rtrim(contents) + "\n";
+  } else {
+    return contents;
+  }
+};
+
+// --------------------------------------------------------------------------
+export var fixFile = async(filepath, func) => {
+  var contents, output;
+  contents = (await readFile(filepath, {
+    encoding: 'utf8'
+  }));
+  output = func(contents); // returns modified contents
+  output = fixOutput(output);
+  await writeFile(filepath, output, {
+    encoding: 'utf8'
+  });
+};
+
+// --------------------------------------------------------------------------
+export var fixJson = async(filepath, func) => {
+  var contents, hJson, output;
+  contents = (await readFile(filepath, {
+    encoding: 'utf8'
+  }));
+  hJson = JSON.parse(contents);
+  func(hJson); // modify in place
+  output = JSON.stringify(hJson, null, 3);
+  output = fixOutput(output);
+  await writeFile(filepath, output, {
+    encoding: 'utf8'
+  });
+};
+
+// --------------------------------------------------------------------------
+export var fixFileSync = (filepath, func) => {
+  var contents, output;
+  contents = fs.readFileSync(filepath, {
+    encoding: 'utf8'
+  });
+  output = func(contents); // returns modified contents
+  output = fixOutput(output);
+  fs.writeFileSync(filepath, output, {
+    encoding: 'utf8'
+  });
+};
+
+// --------------------------------------------------------------------------
+export var fixJsonSync = (filepath, func) => {
+  var contents, hJson, output;
+  contents = fs.readFileSync(filepath, {
+    encoding: 'utf8'
+  });
+  hJson = JSON.parse(contents);
+  func(hJson); // modify in place
+  output = JSON.stringify(hJson, null, 3);
+  output = fixOutput(output);
+  fs.writeFileSync(filepath, output, {
+    encoding: 'utf8'
+  });
+};
+
 // --------------------------------------------------------------------------
-export var execCmd = (cmdLine) => {
+export var execCmdSync = (cmdLine) => {
   execSync(cmdLine, {}, (error, stdout, stderr) => {
     if (error) {
       LOG(`ERROR in ${cmdLine}: ${error.code}`);
@@ -381,7 +466,7 @@ export var barf = (filepath, contents = '', hOptions = {}) => {
       } else if (!isString(contents)) {
         croak("barf(): Invalid contents");
       }
-      contents = rtrim(contents) + "\n";
+      contents = fixOutput(contents);
   }
   fs.writeFileSync(filepath, contents, {
     encoding: 'utf8'

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
 

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('');
@@ -146,7 +170,7 @@ export var indented = (input, level = 1, oneIndent = "\t") => {
 //              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;
+  var i, lLines, lMatches, lNewLines, len, line, nToRemove, toRemove;
   if (defined(level) && (level === 0)) {
     return input;
   }
@@ -181,7 +205,7 @@ export var undented = (input, level = undef, oneIndent = "\t") => {
   }
   nToRemove = indentLevel(toRemove);
   lNewLines = [];
-  for (i = 0, len1 = lLines.length; i < len1; i++) {
+  for (i = 0, len = lLines.length; i < len; i++) {
     line = lLines[i];
     if (isEmpty(line)) {
       lNewLines.push('');