@jdeighan/coffee-utils 7.0.17 → 7.0.20

package/package.json

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

package/src/debug_utils.coffee

@@ -150,7 +150,7 @@ adjustStack = (str) ->
 export debug = (lArgs...) ->
 
 	# --- We want to allow item to be undef. Therefore, we need to
-	#     distinguish between 1 arg sent vs. 2+ args sent
+	#     distinguish between 1 arg sent vs. 2 args sent
 	nArgs = lArgs.length
 	assert (nArgs==1) || (nArgs==2), "debug(): #{nArgs} args"
 	[label, item] = lArgs
@@ -172,6 +172,7 @@ export debug = (lArgs...) ->
 		prefix: mainPre
 		itemPrefix: auxPre
 		}
+
 	switch type
 		when 'enter'
 			log label, hOptions
@@ -184,7 +185,7 @@ export debug = (lArgs...) ->
 				# --- don't repeat the label
 				logItem undef, item, hOptions
 		when 'string'
-			if item
+			if (nArgs==2)
 				logItem label, item, hOptions
 			else
 				log label, hOptions

package/src/debug_utils.js

@@ -163,7 +163,7 @@ adjustStack = function(str) {
 export var debug = function(...lArgs) {
   var auxPre, hEnv, hOptions, item, label, mainPre, nArgs, orgDebugging, trans, type;
   // --- We want to allow item to be undef. Therefore, we need to
-  //     distinguish between 1 arg sent vs. 2+ args sent
+  //     distinguish between 1 arg sent vs. 2 args sent
   nArgs = lArgs.length;
   assert((nArgs === 1) || (nArgs === 2), `debug(): ${nArgs} args`);
   [label, item] = lArgs;
@@ -199,7 +199,7 @@ export var debug = function(...lArgs) {
       }
       break;
     case 'string':
-      if (item) {
+      if (nArgs === 2) {
         logItem(label, item, hOptions);
       } else {
         log(label, hOptions);

package/src/fs_utils.coffee

@@ -14,7 +14,7 @@ import {debug} from '@jdeighan/coffee-utils/debug'
 import {arrayToBlock} from '@jdeighan/coffee-utils/block'
 
 # ---------------------------------------------------------------------------
-#    mydir() - pass argument `import.meta.url` and it will return
+#    mydir() - pass argument import.meta.url and it will return
 #              the directory your file is in
 
 export mydir = (url) ->
@@ -28,6 +28,30 @@ export mydir = (url) ->
 	debug "final = #{final}"
 	return final
 
+# ---------------------------------------------------------------------------
+#    myfile() - pass argument import.meta.url and it will return
+#               the name of your file
+
+export myfile = (url) ->
+
+	debug "url = #{url}"
+	path = urllib.fileURLToPath(url)
+	debug "path = #{path}"
+	filename = pathlib.parse(path).base
+	debug "filename = #{filename}"
+	return filename
+
+# ---------------------------------------------------------------------------
+#    myfullpath() - pass argument import.meta.url and it will return
+#                   the full path to your file
+
+export myfullpath = (url) ->
+
+	debug "url = #{url}"
+	path = urllib.fileURLToPath(url)
+	debug "path = #{path}"
+	return mkpath(path)
+
 # ---------------------------------------------------------------------------
 
 export isFile = (fullpath) ->
@@ -80,26 +104,6 @@ export getFullPath = (filepath) ->
 
 	return mkpath(pathlib.resolve(filepath))
 
-# ---------------------------------------------------------------------------
-#   backup - back up a file
-
-# --- If report is true, missing source files are not an error
-#     but both missing source files and successful copies
-#     are reported via LOG
-
-export backup = (file, from, to, report=false) ->
-	src = mkpath(from, file)
-	dest = mkpath(to, file)
-
-	if report
-		if fs.existsSync(src)
-			LOG "OK #{file}"
-			fs.copyFileSync(src, dest)
-		else
-			LOG "MISSING #{src}"
-	else
-		fs.copyFileSync(src, dest)
-
 # ---------------------------------------------------------------------------
 
 export forEachLineInFile = (filepath, func) ->
@@ -249,25 +253,27 @@ export forEachFile = (dir, cb, filt=undef, level=0) ->
 
 # ---------------------------------------------------------------------------
 
-export pathTo = (fname, dir, direction="down") ->
+export pathTo = (fname, searchDir, direction="down") ->
 
-	debug "enter pathTo('#{fname}','#{dir}','#{direction}')"
-	assert fs.existsSync(dir), "Directory #{dir} does not exist"
-	filepath = mkpath(dir, fname)
+	debug "enter pathTo('#{fname}','#{searchDir}','#{direction}')"
+	if ! searchDir
+		searchDir = process.cwd()
+	assert fs.existsSync(searchDir), "Directory #{searchDir} does not exist"
+	filepath = mkpath(searchDir, fname)
 	if fs.existsSync(filepath)
 		debug "return from pathTo: #{filepath} - file exists"
 		return filepath
 	else if (direction == 'down')
 		# --- Search all directories in this directory
 		#     getSubDirs() returns dirs sorted alphabetically
-		for subdir in getSubDirs(dir)
-			dirpath = mkpath(dir, subdir)
+		for subdir in getSubDirs(searchDir)
+			dirpath = mkpath(searchDir, subdir)
 			debug "check #{dirpath}"
 			if fpath = pathTo(fname, dirpath)
 				debug "return from pathTo: #{fpath}"
 				return fpath
 	else if (direction == 'up')
-		while dirpath = getParentDir(dir)
+		while dirpath = getParentDir(searchDir)
 			debug "check #{dirpath}"
 			filepath = mkpath(dirpath, fname)
 			if fs.existsSync(filepath)
@@ -283,6 +289,8 @@ export pathTo = (fname, dir, direction="down") ->
 export allPathsTo = (fname, searchDir) ->
 	# --- Only searches upward
 
+	if ! searchDir
+		searchDir = process.cwd()
 	path = pathTo(fname, searchDir, "up")
 	if path?
 		lPaths = [path]    # --- build an array of paths
@@ -334,43 +342,54 @@ export shortenPath = (path) ->
 export parseSource = (source) ->
 	# --- returns {
 	#        dir
-	#        filename   # only this is guaranteed to be set
+	#        filename
 	#        stub
 	#        ext
 	#        }
+	# --- NOTE: source may be a file URL, e.g. import.meta.url
 
 	debug "enter parseSource()"
+	assert isString(source), "parseSource(): source not a string"
 	if source == 'unit test'
+		croak "A source of 'unit test' is deprecated"
+	if source.match(/^file\:\/\//)
+		source = urllib.fileURLToPath(source)
+
+	hInfo = pathlib.parse(source)
+	if hInfo.dir
+		dir = mkpath(hInfo.dir)   # change \ to /
 		hSourceInfo = {
-			filename: 'unit test'
-			stub: 'unit test'
+			dir
+			fullpath: mkpath(dir, hInfo.base)
+			filename: hInfo.base
+			stub: hInfo.name
+			ext: hInfo.ext
 			}
-		debug "return from parseSource()", hSourceInfo
-		return hSourceInfo
-	try
-		hInfo = pathlib.parse(source)
-		if hInfo.dir
-			dir = mkpath(hInfo.dir)   # change \ to /
-			hSourceInfo = {
-				dir
-				fullpath: mkpath(dir, hInfo.base)
-				filename: hInfo.base
-				stub: hInfo.name
-				ext: hInfo.ext
-				}
-		else
-			hSourceInfo = {
-				filename: hInfo.base
-				stub: hInfo.name
-				ext: hInfo.ext
-				}
-		debug "return from parseSource()", hSourceInfo
-		return hSourceInfo
-	catch err
+	else
 		hSourceInfo = {
-			filename: source
-			stub: source
-			error: err.message
+			filename: hInfo.base
+			stub: hInfo.name
+			ext: hInfo.ext
 			}
-		debug "return '#{err.message} from parseSource()", hSourceInfo
-		return hSourceInfo
+	debug "return from parseSource()", hSourceInfo
+	return hSourceInfo
+
+# ---------------------------------------------------------------------------
+#   backup - back up a file
+
+# --- If report is true, missing source files are not an error
+#     but both missing source files and successful copies
+#     are reported via LOG
+
+export backup = (file, from, to, report=false) ->
+	src = mkpath(from, file)
+	dest = mkpath(to, file)
+
+	if report
+		if fs.existsSync(src)
+			LOG "OK #{file}"
+			fs.copyFileSync(src, dest)
+		else
+			LOG "MISSING #{src}"
+	else
+		fs.copyFileSync(src, dest)

package/src/fs_utils.js

@@ -39,7 +39,7 @@ import {
 } from '@jdeighan/coffee-utils/block';
 
 // ---------------------------------------------------------------------------
-//    mydir() - pass argument `import.meta.url` and it will return
+//    mydir() - pass argument import.meta.url and it will return
 //              the directory your file is in
 export var mydir = function(url) {
   var dir, final, path;
@@ -53,6 +53,30 @@ export var mydir = function(url) {
   return final;
 };
 
+// ---------------------------------------------------------------------------
+//    myfile() - pass argument import.meta.url and it will return
+//               the name of your file
+export var myfile = function(url) {
+  var filename, path;
+  debug(`url = ${url}`);
+  path = urllib.fileURLToPath(url);
+  debug(`path = ${path}`);
+  filename = pathlib.parse(path).base;
+  debug(`filename = ${filename}`);
+  return filename;
+};
+
+// ---------------------------------------------------------------------------
+//    myfullpath() - pass argument import.meta.url and it will return
+//                   the full path to your file
+export var myfullpath = function(url) {
+  var path;
+  debug(`url = ${url}`);
+  path = urllib.fileURLToPath(url);
+  debug(`path = ${path}`);
+  return mkpath(path);
+};
+
 // ---------------------------------------------------------------------------
 export var isFile = function(fullpath) {
   return fs.lstatSync(fullpath).isFile();
@@ -106,28 +130,6 @@ export var getFullPath = function(filepath) {
   return mkpath(pathlib.resolve(filepath));
 };
 
-// ---------------------------------------------------------------------------
-//   backup - back up a file
-
-// --- If report is true, missing source files are not an error
-//     but both missing source files and successful copies
-//     are reported via LOG
-export var backup = function(file, from, to, report = false) {
-  var dest, src;
-  src = mkpath(from, file);
-  dest = mkpath(to, file);
-  if (report) {
-    if (fs.existsSync(src)) {
-      LOG(`OK ${file}`);
-      return fs.copyFileSync(src, dest);
-    } else {
-      return LOG(`MISSING ${src}`);
-    }
-  } else {
-    return fs.copyFileSync(src, dest);
-  }
-};
-
 // ---------------------------------------------------------------------------
 export var forEachLineInFile = function(filepath, func) {
   var buffer, line, nLines, reader;
@@ -302,21 +304,24 @@ export var forEachFile = function(dir, cb, filt = undef, level = 0) {
 };
 
 // ---------------------------------------------------------------------------
-export var pathTo = function(fname, dir, direction = "down") {
+export var pathTo = function(fname, searchDir, direction = "down") {
   var dirpath, filepath, fpath, i, len, ref, subdir;
-  debug(`enter pathTo('${fname}','${dir}','${direction}')`);
-  assert(fs.existsSync(dir), `Directory ${dir} does not exist`);
-  filepath = mkpath(dir, fname);
+  debug(`enter pathTo('${fname}','${searchDir}','${direction}')`);
+  if (!searchDir) {
+    searchDir = process.cwd();
+  }
+  assert(fs.existsSync(searchDir), `Directory ${searchDir} does not exist`);
+  filepath = mkpath(searchDir, fname);
   if (fs.existsSync(filepath)) {
     debug(`return from pathTo: ${filepath} - file exists`);
     return filepath;
   } else if (direction === 'down') {
-    ref = getSubDirs(dir);
+    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(dir, subdir);
+      dirpath = mkpath(searchDir, subdir);
       debug(`check ${dirpath}`);
       if (fpath = pathTo(fname, dirpath)) {
         debug(`return from pathTo: ${fpath}`);
@@ -324,7 +329,7 @@ export var pathTo = function(fname, dir, direction = "down") {
       }
     }
   } else if (direction === 'up') {
-    while (dirpath = getParentDir(dir)) {
+    while (dirpath = getParentDir(searchDir)) {
       debug(`check ${dirpath}`);
       filepath = mkpath(dirpath, fname);
       if (fs.existsSync(filepath)) {
@@ -342,7 +347,9 @@ export var pathTo = function(fname, dir, direction = "down") {
 // ---------------------------------------------------------------------------
 export var allPathsTo = function(fname, searchDir) {
   var h, lPaths, path;
-  // --- Only searches upward
+  if (!searchDir) {
+    searchDir = process.cwd();
+  }
   path = pathTo(fname, searchDir, "up");
   if (path != null) {
     lPaths = [path]; // --- build an array of paths
@@ -394,50 +401,61 @@ export var shortenPath = function(path) {
 
 // ---------------------------------------------------------------------------
 export var parseSource = function(source) {
-  var dir, err, hInfo, hSourceInfo;
+  var dir, hInfo, hSourceInfo;
   // --- returns {
   //        dir
-  //        filename   # only this is guaranteed to be set
+  //        filename
   //        stub
   //        ext
   //        }
+  // --- NOTE: source may be a file URL, e.g. import.meta.url
   debug("enter parseSource()");
+  assert(isString(source), "parseSource(): source not a string");
   if (source === 'unit test') {
+    croak("A source of 'unit test' is deprecated");
+  }
+  if (source.match(/^file\:\/\//)) {
+    source = urllib.fileURLToPath(source);
+  }
+  hInfo = pathlib.parse(source);
+  if (hInfo.dir) {
+    dir = mkpath(hInfo.dir); // change \ to /
+    hSourceInfo = {
+      dir,
+      fullpath: mkpath(dir, hInfo.base),
+      filename: hInfo.base,
+      stub: hInfo.name,
+      ext: hInfo.ext
+    };
+  } else {
     hSourceInfo = {
-      filename: 'unit test',
-      stub: 'unit test'
+      filename: hInfo.base,
+      stub: hInfo.name,
+      ext: hInfo.ext
     };
-    debug("return from parseSource()", hSourceInfo);
-    return hSourceInfo;
   }
-  try {
-    hInfo = pathlib.parse(source);
-    if (hInfo.dir) {
-      dir = mkpath(hInfo.dir); // change \ to /
-      hSourceInfo = {
-        dir,
-        fullpath: mkpath(dir, hInfo.base),
-        filename: hInfo.base,
-        stub: hInfo.name,
-        ext: hInfo.ext
-      };
+  debug("return from parseSource()", hSourceInfo);
+  return hSourceInfo;
+};
+
+// ---------------------------------------------------------------------------
+//   backup - back up a file
+
+// --- If report is true, missing source files are not an error
+//     but both missing source files and successful copies
+//     are reported via LOG
+export var backup = function(file, from, to, report = false) {
+  var dest, src;
+  src = mkpath(from, file);
+  dest = mkpath(to, file);
+  if (report) {
+    if (fs.existsSync(src)) {
+      LOG(`OK ${file}`);
+      return fs.copyFileSync(src, dest);
     } else {
-      hSourceInfo = {
-        filename: hInfo.base,
-        stub: hInfo.name,
-        ext: hInfo.ext
-      };
+      return LOG(`MISSING ${src}`);
     }
-    debug("return from parseSource()", hSourceInfo);
-    return hSourceInfo;
-  } catch (error1) {
-    err = error1;
-    hSourceInfo = {
-      filename: source,
-      stub: source,
-      error: err.message
-    };
-    debug(`return '${err.message} from parseSource()`, hSourceInfo);
-    return hSourceInfo;
+  } else {
+    return fs.copyFileSync(src, dest);
   }
 };