@jdeighan/coffee-utils 2.1.2 → 2.1.6

package/package.json

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

package/src/coffee_utils.coffee

@@ -188,6 +188,12 @@ export isFunction = (x) ->
 
 # ---------------------------------------------------------------------------
 
+export isRegExp = (x) ->
+
+	return x instanceof RegExp
+
+# ---------------------------------------------------------------------------
+
 export isInteger = (x) ->
 
 	if (typeof x == 'number')

package/src/coffee_utils.js

@@ -195,6 +195,11 @@ export var isFunction = function(x) {
   return typeof x === 'function';
 };
 
+// ---------------------------------------------------------------------------
+export var isRegExp = function(x) {
+  return x instanceof RegExp;
+};
+
 // ---------------------------------------------------------------------------
 export var isInteger = function(x) {
   if (typeof x === 'number') {

package/src/debug_utils.coffee

@@ -17,13 +17,12 @@ arrow = corner + hbar + arrowhead + ' '
 
 debugLevel = 0   # controls amount of indentation - we ensure it's never < 0
 
-export debugging = false
-
-ifMatches = undefined
+lDebugStack = []
 
-# --- turn debugging on when in one of these functions
-#     when returning from one of these functions, restore previous setting
-lDebugFuncs = undefined
+# --- These are saved/restored in lDebugStack
+export debugging = false
+ifMatches = undef
+lDebugFuncs = undef
 
 # ---------------------------------------------------------------------------
 
@@ -34,37 +33,43 @@ export debugIfLineMatches = (regexp=undef) ->
 
 # ---------------------------------------------------------------------------
 
-lDebugStack = []
-
 saveDebugEnv = () ->
 
-	lDebugStack.push(debugging)
+	lDebugStack.push({
+		debugging,
+		ifMatches,
+		lDebugFuncs,
+		})
 	return
 
 restoreDebugEnv = () ->
 
 	if (lDebugStack.length == 0)
 		debugging = false
+		ifMatches = undef
+		lDebugFuncs = undef
 	else
-		debugging = lDebugStack.pop()
+		h = lDebugStack.pop()
+		{debugging, ifMatches, lDebugFuncs} = h
+
 	return
 
 # ---------------------------------------------------------------------------
 
 export setDebugging = (x) ->
 
-	if (x==true)
-		# --- save current setting
-		saveDebugEnv()
-		debugging = true
-	else if (x==false)
+	if (x==false)
 		restoreDebugEnv()
-	else if isString(x)
-		lDebugFuncs = words(x)
-	else if isArray(x)
-		lDebugFuncs = x
 	else
-		croak "setDebugging(): bad parameter #{oneline(x)}"
+		# --- save current setting
+		saveDebugEnv()
+		if (x==true)
+			debugging = true
+		else if isString(x)
+			debugging = false
+			lDebugFuncs = words(x)
+		else
+			croak "setDebugging(): bad parameter #{oneline(x)}"
 	return
 
 # ---------------------------------------------------------------------------
@@ -78,6 +83,17 @@ getPrefix = (level) ->
 
 # ---------------------------------------------------------------------------
 
+export resetDebugging = () ->
+
+	debugging = false
+	debugLevel = 0
+	ifMatches = undef
+	lDebugFuncs = undef
+	lDebugStack = []
+	return
+
+# ---------------------------------------------------------------------------
+
 export debug = (lArgs...) ->
 	# --- either 1 or 2 args
 
@@ -100,7 +116,7 @@ export debug = (lArgs...) ->
 	# --- determine if we're entering or returning from a function
 	entering = exiting = false
 	curFunction = undef
-	if (lMatches=str.match(///^
+	if (lMatches = str.match(///^
 			\s*
 			enter
 			\s+
@@ -108,7 +124,7 @@ export debug = (lArgs...) ->
 			///))
 		entering = true
 		curFunction = lMatches[1]
-	else if (lMatches=str.match(///^
+	else if (lMatches = str.match(///^
 			\s*
 			return
 			.*
@@ -119,9 +135,8 @@ export debug = (lArgs...) ->
 		exiting = true
 		curFunction = lMatches[1]
 
-	if curFunction && lDebugFuncs && lDebugFuncs.includes(curFunction)
-		if entering
-			setDebugging true
+	if entering && lDebugFuncs && lDebugFuncs.includes(curFunction)
+		setDebugging true
 
 	if debugging && (not ifMatches? || str.match(ifMatches))
 
@@ -139,12 +154,12 @@ export debug = (lArgs...) ->
 		else
 			log str, item, {prefix, logItem: true}
 
-	if curFunction && lDebugFuncs && lDebugFuncs.includes(curFunction)
-		if exiting
-			setDebugging false # revert to previous setting - might still be on
+	if exiting && lDebugFuncs && lDebugFuncs.includes(curFunction)
+		setDebugging false    # revert to previous setting - might still be on
 
-	if entering
-		debugLevel += 1
-	if exiting && (debugLevel > 0)
-		debugLevel -= 1
+	if debugging
+		if entering
+			debugLevel += 1
+		if exiting && (debugLevel > 0)
+			debugLevel -= 1
 	return

package/src/debug_utils.js

@@ -39,13 +39,14 @@ arrow = corner + hbar + arrowhead + ' ';
 
 debugLevel = 0; // controls amount of indentation - we ensure it's never < 0
 
+lDebugStack = [];
+
+// --- These are saved/restored in lDebugStack
 export var debugging = false;
 
-ifMatches = void 0;
+ifMatches = undef;
 
-// --- turn debugging on when in one of these functions
-//     when returning from one of these functions, restore previous setting
-lDebugFuncs = void 0;
+lDebugFuncs = undef;
 
 // ---------------------------------------------------------------------------
 export var debugIfLineMatches = function(regexp = undef) {
@@ -53,34 +54,37 @@ export var debugIfLineMatches = function(regexp = undef) {
 };
 
 // ---------------------------------------------------------------------------
-lDebugStack = [];
-
 saveDebugEnv = function() {
-  lDebugStack.push(debugging);
+  lDebugStack.push({debugging, ifMatches, lDebugFuncs});
 };
 
 restoreDebugEnv = function() {
+  var h;
   if (lDebugStack.length === 0) {
     debugging = false;
+    ifMatches = undef;
+    lDebugFuncs = undef;
   } else {
-    debugging = lDebugStack.pop();
+    h = lDebugStack.pop();
+    ({debugging, ifMatches, lDebugFuncs} = h);
   }
 };
 
 // ---------------------------------------------------------------------------
 export var setDebugging = function(x) {
-  if (x === true) {
-    // --- save current setting
-    saveDebugEnv();
-    debugging = true;
-  } else if (x === false) {
+  if (x === false) {
     restoreDebugEnv();
-  } else if (isString(x)) {
-    lDebugFuncs = words(x);
-  } else if (isArray(x)) {
-    lDebugFuncs = x;
   } else {
-    croak(`setDebugging(): bad parameter ${oneline(x)}`);
+    // --- save current setting
+    saveDebugEnv();
+    if (x === true) {
+      debugging = true;
+    } else if (isString(x)) {
+      debugging = false;
+      lDebugFuncs = words(x);
+    } else {
+      croak(`setDebugging(): bad parameter ${oneline(x)}`);
+    }
   }
 };
 
@@ -93,6 +97,15 @@ getPrefix = function(level) {
   return '   '.repeat(level);
 };
 
+// ---------------------------------------------------------------------------
+export var resetDebugging = function() {
+  debugging = false;
+  debugLevel = 0;
+  ifMatches = undef;
+  lDebugFuncs = undef;
+  lDebugStack = [];
+};
+
 // ---------------------------------------------------------------------------
 export var debug = function(...lArgs) {
   var curFunction, entering, exiting, item, lMatches, nArgs, prefix, str;
@@ -119,10 +132,8 @@ export var debug = function(...lArgs) {
     exiting = true;
     curFunction = lMatches[1];
   }
-  if (curFunction && lDebugFuncs && lDebugFuncs.includes(curFunction)) {
-    if (entering) {
-      setDebugging(true);
-    }
+  if (entering && lDebugFuncs && lDebugFuncs.includes(curFunction)) {
+    setDebugging(true);
   }
   if (debugging && ((ifMatches == null) || str.match(ifMatches))) {
     // --- set the prefix, i.e. indentation to use
@@ -144,15 +155,15 @@ export var debug = function(...lArgs) {
       });
     }
   }
-  if (curFunction && lDebugFuncs && lDebugFuncs.includes(curFunction)) {
-    if (exiting) {
-      setDebugging(false); // revert to previous setting - might still be on
-    }
-  }
-  if (entering) {
-    debugLevel += 1;
+  if (exiting && lDebugFuncs && lDebugFuncs.includes(curFunction)) {
+    setDebugging(false); // revert to previous setting - might still be on
   }
-  if (exiting && (debugLevel > 0)) {
-    debugLevel -= 1;
+  if (debugging) {
+    if (entering) {
+      debugLevel += 1;
+    }
+    if (exiting && (debugLevel > 0)) {
+      debugLevel -= 1;
+    }
   }
 };

package/src/fs_utils.coffee

@@ -11,7 +11,8 @@ import {
 	} from 'fs'
 
 import {
-	undef, pass, firstLine, rtrim, error,
+	undef, pass, firstLine, rtrim, error, nonEmpty,
+	isRegExp, isFunction, croak,
 	} from '@jdeighan/coffee-utils'
 import {log} from '@jdeighan/coffee-utils/log'
 import {debug} from '@jdeighan/coffee-utils/debug'
@@ -117,6 +118,33 @@ export getParentDir = (dir) ->
 
 # ---------------------------------------------------------------------------
 
+export forEachFile = (dir, cb, filt=undef, level=0) ->
+	# --- filt can be a regular expression or a function that gets:
+	#        (filename, dir, level)
+	#     callback will get parms (filename, dir, level)
+
+	lSubDirectories = []
+	for ent in readdirSync(dir, {withFileTypes: true})
+		if ent.isDirectory()
+			lSubDirectories.push ent
+		else if ent.isFile()
+			if not filt?
+				cb(ent.name, dir, level)
+			else if isRegExp(filt)
+				if ent.name.match(filt)
+					cb(ent.name, dir, level)
+				else if isFunction(filt)
+					if filt(ent.name, dir, level)
+						cb(ent.name, dir, level)
+			else
+				croak "forEachFile(): bad filter", 'filter', filt
+	if nonEmpty(lSubDirectories)
+		for subdir in lSubDirectories.sort()
+			forEachFile(mkpath(dir, subdir.name), cb, filt, level+1)
+	return
+
+# ---------------------------------------------------------------------------
+
 export pathTo = (fname, dir, direction="down") ->
 
 	debug "enter pathTo('#{fname}','#{dir}','#{direction}')"

package/src/fs_utils.js

@@ -28,7 +28,11 @@ import {
   pass,
   firstLine,
   rtrim,
-  error
+  error,
+  nonEmpty,
+  isRegExp,
+  isFunction,
+  croak
 } from '@jdeighan/coffee-utils';
 
 import {
@@ -145,6 +149,45 @@ export var getParentDir = function(dir) {
   return mkpath(resolve(dir, '..'));
 };
 
+// ---------------------------------------------------------------------------
+export var forEachFile = function(dir, cb, filt = undef, level = 0) {
+  var ent, i, j, lSubDirectories, len, len1, ref, ref1, subdir;
+  // --- filt can be a regular expression or a function that gets:
+  //        (filename, dir, level)
+  //     callback will get parms (filename, dir, level)
+  lSubDirectories = [];
+  ref = readdirSync(dir, {
+    withFileTypes: true
+  });
+  for (i = 0, len = ref.length; i < len; i++) {
+    ent = ref[i];
+    if (ent.isDirectory()) {
+      lSubDirectories.push(ent);
+    } else if (ent.isFile()) {
+      if (filt == null) {
+        cb(ent.name, dir, level);
+      } else if (isRegExp(filt)) {
+        if (ent.name.match(filt)) {
+          cb(ent.name, dir, level);
+        } else if (isFunction(filt)) {
+          if (filt(ent.name, dir, level)) {
+            cb(ent.name, dir, level);
+          }
+        }
+      } else {
+        croak("forEachFile(): bad filter", 'filter', filt);
+      }
+    }
+  }
+  if (nonEmpty(lSubDirectories)) {
+    ref1 = lSubDirectories.sort();
+    for (j = 0, len1 = ref1.length; j < len1; j++) {
+      subdir = ref1[j];
+      forEachFile(mkpath(dir, subdir.name), cb, filt, level + 1);
+    }
+  }
+};
+
 // ---------------------------------------------------------------------------
 export var pathTo = function(fname, dir, direction = "down") {
   var fpath, i, len, ref, subdir;

package/src/indent_utils.coffee

@@ -3,7 +3,7 @@
 import {strict as assert} from 'assert'
 import {
 	undef, error, arrayToString, stringToArray, escapeStr,
-	oneline, isInteger, isString, isArray, isEmpty,
+	oneline, isInteger, isString, isArray, isEmpty, rtrim,
 	} from '@jdeighan/coffee-utils'
 
 # ---------------------------------------------------------------------------
@@ -15,8 +15,9 @@ export splitLine = (line) ->
 
 	assert line?, "splitLine(): line is undef"
 	assert (typeof line == 'string'), "splitLine(): line is not a string"
+	line = rtrim(line)
 	lMatches = line.match(/^(\s*)(.*)$/)
-	return [lMatches[1].length, lMatches[2].trim()]
+	return [lMatches[1].length, lMatches[2]]
 
 # ---------------------------------------------------------------------------
 #   indentation - return appropriate indentation string for given level
@@ -129,15 +130,13 @@ export tabify = (str, numSpaces=undef) ->
 
 export untabify = (str, numSpaces=3) ->
 
+	oneIndent = ' '.repeat(numSpaces)
 	lLines = []
 	for str in stringToArray(str)
-		lMatches = str.match(/^(\s*)(.*)$/)
+		lMatches = str.match(/^(\t*)(.*)$/)
 		[_, prefix, theRest] = lMatches
 		if prefix == ''
 			lLines.push theRest
 		else
-			n = prefix.length
-			if (prefix != '\t'.repeat(n))
-				error "untabify(): not all TABs: prefix='#{escapeStr(prefix)}'"
-			lLines.push ' '.repeat(n * numSpaces) + theRest
+			lLines.push oneIndent.repeat(prefix.length) + theRest
 	return arrayToString(lLines)

package/src/indent_utils.js

@@ -14,7 +14,8 @@ import {
   isInteger,
   isString,
   isArray,
-  isEmpty
+  isEmpty,
+  rtrim
 } from '@jdeighan/coffee-utils';
 
 // ---------------------------------------------------------------------------
@@ -25,8 +26,9 @@ export var splitLine = function(line) {
   var lMatches;
   assert(line != null, "splitLine(): line is undef");
   assert(typeof line === 'string', "splitLine(): line is not a string");
+  line = rtrim(line);
   lMatches = line.match(/^(\s*)(.*)$/);
-  return [lMatches[1].length, lMatches[2].trim()];
+  return [lMatches[1].length, lMatches[2]];
 };
 
 // ---------------------------------------------------------------------------
@@ -163,21 +165,18 @@ export var tabify = function(str, numSpaces = undef) {
 // ---------------------------------------------------------------------------
 //    untabify - convert leading TABs to spaces
 export var untabify = function(str, numSpaces = 3) {
-  var _, i, lLines, lMatches, len, n, prefix, ref, theRest;
+  var _, i, lLines, lMatches, len, oneIndent, prefix, ref, theRest;
+  oneIndent = ' '.repeat(numSpaces);
   lLines = [];
   ref = stringToArray(str);
   for (i = 0, len = ref.length; i < len; i++) {
     str = ref[i];
-    lMatches = str.match(/^(\s*)(.*)$/);
+    lMatches = str.match(/^(\t*)(.*)$/);
     [_, prefix, theRest] = lMatches;
     if (prefix === '') {
       lLines.push(theRest);
     } else {
-      n = prefix.length;
-      if (prefix !== '\t'.repeat(n)) {
-        error(`untabify(): not all TABs: prefix='${escapeStr(prefix)}'`);
-      }
-      lLines.push(' '.repeat(n * numSpaces) + theRest);
+      lLines.push(oneIndent.repeat(prefix.length) + theRest);
     }
   }
   return arrayToString(lLines);