@jdeighan/coffee-utils 7.0.64 → 7.0.67

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "7.0.64",
+	"version": "7.0.67",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -18,6 +18,7 @@
 		"./svelte": "./src/svelte_utils.js",
 		"./store": "./src/DataStores.js",
 		"./taml": "./src/taml.js",
+		"./placeholders": "./src/placeholders.js",
 		"./package.json": "./package.json"
 	},
 	"engines": {
@@ -52,6 +53,6 @@
 		"svelte": "^3.48.0"
 	},
 	"devDependencies": {
-		"@jdeighan/unit-tester": "^2.0.7"
+		"@jdeighan/unit-tester": "^2.0.8"
 	}
 }

package/src/debug_utils.coffee

@@ -25,12 +25,26 @@ strFuncList = undef     # original string
 
 # ---------------------------------------------------------------------------
 
+export interp = (label) ->
+
+	return label.replace(/// \$ (\@)? ([A-Za-z_][A-Za-z0-9_]*) ///g,
+			(_, atSign, varName) ->
+				if atSign
+					return "\#{OL(@#{varName})\}"
+				else
+					return "\#{OL(#{varName})\}"
+			)
+
+# ---------------------------------------------------------------------------
+
 export debug = (orgLabel, lObjects...) ->
 
 	assert isString(orgLabel), "1st arg #{OL(orgLabel)} should be a string"
 
 	[type, funcName] = getType(orgLabel, lObjects)
 	label = shouldLog(orgLabel, type, funcName, callStack)
+	if defined(label)
+		label = interp(label)
 
 	switch type
 
@@ -243,22 +257,25 @@ export getType = (str, lObjects) ->
 
 	if lMatches = str.match(///^
 			\s*
-			enter
+			( enter | (?: return .+ from ) )
 			\s+
-			([A-Za-z_][A-Za-z0-9_\.]*)
+			([A-Za-z_][A-Za-z0-9_]*)
+			(?:
+				\.
+				([A-Za-z_][A-Za-z0-9_]*)
+				)?
 			///)
+		[_, type, ident1, ident2] = lMatches
 
-		# --- We are entering function curFunc
-		return ['enter', lMatches[1]]
-	else if lMatches = str.match(///^
-			\s*
-			return
-			.+
-			from
-			\s+
-			([A-Za-z_][A-Za-z0-9_\.]*)
-			///)
-		return ['return', lMatches[1]]
+		if ident2
+			funcName = ident2
+		else
+			funcName = ident1
+
+		if (type == 'enter')
+			return ['enter', funcName]
+		else
+			return ['return', funcName]
 	else
 		return ['string', undef]
 

package/src/debug_utils.js

@@ -65,12 +65,26 @@ lFuncList = []; // names of functions being debugged
 strFuncList = undef; // original string
 
 
+// ---------------------------------------------------------------------------
+export var interp = function(label) {
+  return label.replace(/\$(\@)?([A-Za-z_][A-Za-z0-9_]*)/g, function(_, atSign, varName) {
+    if (atSign) {
+      return `\#{OL(@${varName})\}`;
+    } else {
+      return `\#{OL(${varName})\}`;
+    }
+  });
+};
+
 // ---------------------------------------------------------------------------
 export var debug = function(orgLabel, ...lObjects) {
   var funcName, label, type;
   assert(isString(orgLabel), `1st arg ${OL(orgLabel)} should be a string`);
   [type, funcName] = getType(orgLabel, lObjects);
   label = shouldLog(orgLabel, type, funcName, callStack);
+  if (defined(label)) {
+    label = interp(label);
+  }
   switch (type) {
     case 'enter':
       if (defined(label)) {
@@ -292,12 +306,19 @@ export var funcMatch = function(funcName) {
 // ---------------------------------------------------------------------------
 // --- type is one of: 'enter', 'return', 'string'
 export var getType = function(str, lObjects) {
-  var lMatches;
-  if (lMatches = str.match(/^\s*enter\s+([A-Za-z_][A-Za-z0-9_\.]*)/)) {
-    // --- We are entering function curFunc
-    return ['enter', lMatches[1]];
-  } else if (lMatches = str.match(/^\s*return.+from\s+([A-Za-z_][A-Za-z0-9_\.]*)/)) {
-    return ['return', lMatches[1]];
+  var _, funcName, ident1, ident2, lMatches, type;
+  if (lMatches = str.match(/^\s*(enter|(?:return.+from))\s+([A-Za-z_][A-Za-z0-9_]*)(?:\.([A-Za-z_][A-Za-z0-9_]*))?/)) {
+    [_, type, ident1, ident2] = lMatches;
+    if (ident2) {
+      funcName = ident2;
+    } else {
+      funcName = ident1;
+    }
+    if (type === 'enter') {
+      return ['enter', funcName];
+    } else {
+      return ['return', funcName];
+    }
   } else {
     return ['string', undef];
   }

package/src/fs_utils.coffee

@@ -6,7 +6,7 @@ import fs from 'fs'
 import NReadLines from 'n-readlines'
 
 import {
-	assert, undef, pass, rtrim, error, isEmpty, nonEmpty,
+	assert, undef, pass, defined, rtrim, error, isEmpty, nonEmpty,
 	isString, isArray, isRegExp, isFunction, croak, OL,
 	} from '@jdeighan/coffee-utils'
 import {log, LOG} from '@jdeighan/coffee-utils/log'
@@ -270,30 +270,33 @@ export forEachFile = (dir, cb, filt=undef, level=0) ->
 
 export pathTo = (fname, searchDir, direction="down") ->
 
-	debug "enter pathTo('#{fname}','#{searchDir}','#{direction}')"
+	debug "enter pathTo()", fname, searchDir, direction
 	if ! searchDir
 		searchDir = process.cwd()
-	assert fs.existsSync(searchDir), "Directory #{searchDir} does not exist"
+	assert fs.existsSync(searchDir), "Dir #{searchDir} does not exist"
 	filepath = mkpath(searchDir, fname)
 	if fs.existsSync(filepath)
-		debug "return from pathTo: #{filepath} - file exists"
+		debug "return from pathTo() - file exists", filepath
 		return filepath
-	else if (direction == 'down')
+
+	if (direction == 'down')
 		# --- Search all directories in this directory
 		#     getSubDirs() returns dirs sorted alphabetically
 		for subdir in getSubDirs(searchDir)
 			dirpath = mkpath(searchDir, subdir)
-			debug "check #{dirpath}"
-			if fpath = pathTo(fname, dirpath)
-				debug "return from pathTo: #{fpath}"
+			debug "check #{subdir}"
+			if defined(fpath = pathTo(fname, dirpath))
+				debug "return from pathTo()", fpath
 				return fpath
 	else if (direction == 'up')
-		while dirpath = getParentDir(searchDir)
-			debug "check #{dirpath}"
-			filepath = mkpath(dirpath, fname)
+		while defined(dirPath = getParentDir(searchDir))
+			debug "check #{dirPath}"
+			filepath = mkpath(dirPath, fname)
+			debug "check for #{filepath}"
 			if fs.existsSync(filepath)
-				debug "return from pathTo(): #{filepath}"
+				debug "return from pathTo()", filepath
 				return filepath
+			searchDir = dirPath
 	else
 		error "pathTo(): Invalid direction '#{direction}'"
 	debug "return undef from pathTo - file not found"

package/src/fs_utils.js

@@ -14,6 +14,7 @@ import {
   assert,
   undef,
   pass,
+  defined,
   rtrim,
   error,
   isEmpty,
@@ -326,37 +327,40 @@ export var forEachFile = function(dir, cb, filt = undef, level = 0) {
 
 // ---------------------------------------------------------------------------
 export var pathTo = function(fname, searchDir, direction = "down") {
-  var dirpath, filepath, fpath, i, len, ref, subdir;
-  debug(`enter pathTo('${fname}','${searchDir}','${direction}')`);
+  var dirPath, dirpath, filepath, fpath, i, len, ref, subdir;
+  debug("enter pathTo()", fname, searchDir, direction);
   if (!searchDir) {
     searchDir = process.cwd();
   }
-  assert(fs.existsSync(searchDir), `Directory ${searchDir} does not exist`);
+  assert(fs.existsSync(searchDir), `Dir ${searchDir} does not exist`);
   filepath = mkpath(searchDir, fname);
   if (fs.existsSync(filepath)) {
-    debug(`return from pathTo: ${filepath} - file exists`);
+    debug("return from pathTo() - file exists", filepath);
     return filepath;
-  } else if (direction === 'down') {
+  }
+  if (direction === 'down') {
     ref = getSubDirs(searchDir);
     // --- Search all directories in this directory
     //     getSubDirs() returns dirs sorted alphabetically
     for (i = 0, len = ref.length; i < len; i++) {
       subdir = ref[i];
       dirpath = mkpath(searchDir, subdir);
-      debug(`check ${dirpath}`);
-      if (fpath = pathTo(fname, dirpath)) {
-        debug(`return from pathTo: ${fpath}`);
+      debug(`check ${subdir}`);
+      if (defined(fpath = pathTo(fname, dirpath))) {
+        debug("return from pathTo()", fpath);
         return fpath;
       }
     }
   } else if (direction === 'up') {
-    while (dirpath = getParentDir(searchDir)) {
-      debug(`check ${dirpath}`);
-      filepath = mkpath(dirpath, fname);
+    while (defined(dirPath = getParentDir(searchDir))) {
+      debug(`check ${dirPath}`);
+      filepath = mkpath(dirPath, fname);
+      debug(`check for ${filepath}`);
       if (fs.existsSync(filepath)) {
-        debug(`return from pathTo(): ${filepath}`);
+        debug("return from pathTo()", filepath);
         return filepath;
       }
+      searchDir = dirPath;
     }
   } else {
     error(`pathTo(): Invalid direction '${direction}'`);

package/src/indent_utils.coffee

@@ -131,13 +131,14 @@ export tabify = (str, numSpaces=undef) ->
 		if prefixLen == 0
 			lLines.push theRest
 		else
-			if (prefix.indexOf('\t') != -1)
-				error "tabify(): leading TAB characters not allowed"
+			assert (prefix.indexOf('\t') == -1), "found TAB"
 			if numSpaces == undef
 				numSpaces = prefixLen
 			assert (prefixLen % numSpaces == 0), "Bad prefix"
-			lLines.push '\t'.repeat(prefixLen) + theRest
-	return arrayToBlock(lLines)
+			level = prefixLen / numSpaces
+			lLines.push '\t'.repeat(level) + theRest
+	result = arrayToBlock(lLines)
+	return result
 
 # ---------------------------------------------------------------------------
 #    untabify - convert ALL TABs to spaces

package/src/indent_utils.js

@@ -147,7 +147,7 @@ export var undented = function(text, level = undef) {
 //             if numSpaces is not defined, then the first line
 //             that contains at least one space sets it
 export var tabify = function(str, numSpaces = undef) {
-  var _, i, lLines, len, prefix, prefixLen, ref, theRest;
+  var _, i, lLines, len, level, prefix, prefixLen, ref, result, theRest;
   lLines = [];
   ref = blockToArray(str);
   for (i = 0, len = ref.length; i < len; i++) {
@@ -157,17 +157,17 @@ export var tabify = function(str, numSpaces = undef) {
     if (prefixLen === 0) {
       lLines.push(theRest);
     } else {
-      if (prefix.indexOf('\t') !== -1) {
-        error("tabify(): leading TAB characters not allowed");
-      }
+      assert(prefix.indexOf('\t') === -1, "found TAB");
       if (numSpaces === undef) {
         numSpaces = prefixLen;
       }
       assert(prefixLen % numSpaces === 0, "Bad prefix");
-      lLines.push('\t'.repeat(prefixLen) + theRest);
+      level = prefixLen / numSpaces;
+      lLines.push('\t'.repeat(level) + theRest);
     }
   }
-  return arrayToBlock(lLines);
+  result = arrayToBlock(lLines);
+  return result;
 };
 
 // ---------------------------------------------------------------------------

package/src/placeholders.coffee

@@ -0,0 +1,25 @@
+# placeholders.coffee
+
+import {assert, undef, defined, croak} from '@jdeighan/coffee-utils'
+
+hDefOptions = {
+	pre:  '__'
+	post: '__'
+	}
+
+# ---------------------------------------------------------------------------
+
+export phStr = (name, hOptions=hDefOptions) ->
+
+	{pre, post} = hOptions
+	return "#{pre}#{name}#{post}"
+
+# ---------------------------------------------------------------------------
+
+export phReplace = (str, hValues, hOptions=hDefOptions) ->
+
+	{pre, post} = hOptions
+	return str.replace(
+			/// #{pre} ([A-Za-z_][A-Za-z0-9_]*) #{post} ///g,
+			(_, name) -> hValues[name]
+			)

package/src/placeholders.js

@@ -0,0 +1,31 @@
+// Generated by CoffeeScript 2.7.0
+// placeholders.coffee
+var hDefOptions;
+
+import {
+  assert,
+  undef,
+  defined,
+  croak
+} from '@jdeighan/coffee-utils';
+
+hDefOptions = {
+  pre: '__',
+  post: '__'
+};
+
+// ---------------------------------------------------------------------------
+export var phStr = function(name, hOptions = hDefOptions) {
+  var post, pre;
+  ({pre, post} = hOptions);
+  return `${pre}${name}${post}`;
+};
+
+// ---------------------------------------------------------------------------
+export var phReplace = function(str, hValues, hOptions = hDefOptions) {
+  var post, pre;
+  ({pre, post} = hOptions);
+  return str.replace(RegExp(`${pre}([A-Za-z_][A-Za-z0-9_]*)${post}`, "g"), function(_, name) {
+    return hValues[name];
+  });
+};