@jdeighan/coffee-utils 7.0.74 → 8.0.1

package/package.json

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

package/src/block_utils.coffee

@@ -4,7 +4,7 @@ import fs from 'fs'
 import readline from 'readline'
 
 import {
-	assert, defined, isEmpty, isString, nonEmpty, error, rtrim,
+	undef, assert, defined, isEmpty, isString, isArray, nonEmpty, error, rtrim,
 	} from '@jdeighan/coffee-utils'
 
 # ---------------------------------------------------------------------------
@@ -29,6 +29,9 @@ export blockToArray = (block) ->
 
 export arrayToBlock = (lLines) ->
 
+	if (lLines == undef)
+		return ''
+	assert isArray(lLines), "lLines is not an array"
 	lLines = lLines.filter((line) => defined(line));
 	if lLines.length == 0
 		return ''

package/src/block_utils.js

@@ -5,10 +5,12 @@ import fs from 'fs';
 import readline from 'readline';
 
 import {
+  undef,
   assert,
   defined,
   isEmpty,
   isString,
+  isArray,
   nonEmpty,
   error,
   rtrim
@@ -35,6 +37,10 @@ export var blockToArray = function(block) {
 // ---------------------------------------------------------------------------
 //   arrayToBlock - block will have no trailing whitespace
 export var arrayToBlock = function(lLines) {
+  if (lLines === undef) {
+    return '';
+  }
+  assert(isArray(lLines), "lLines is not an array");
   lLines = lLines.filter((line) => {
     return defined(line);
   });

package/src/coffee_utils.coffee

@@ -135,6 +135,16 @@ export isString = (x) ->
 
 # ---------------------------------------------------------------------------
 
+export isNonEmptyString = (x) ->
+
+	if typeof x != 'string' && x ! instanceof String
+		return false
+	if x.match(/^\s*$/)
+		return false
+	return true
+
+# ---------------------------------------------------------------------------
+
 export isBoolean = (x) ->
 
 	return typeof x == 'boolean'
@@ -269,13 +279,17 @@ export isInteger = (x) ->
 
 # ---------------------------------------------------------------------------
 
-export isUniqueList = (lItems) ->
+export isUniqueList = (lItems, func=undef) ->
 
 	if ! lItems?
 		return true     # empty list is unique
+	if defined(func)
+		assert isFunction(func), "Not a function: #{OL(func)}"
 	h = {}
 	for item in lItems
-		if h[item]
+		if defined(func) && !func(item)
+			return false
+		if defined(h[item])
 			return false
 		h[item] = 1
 	return true

package/src/coffee_utils.js

@@ -128,6 +128,17 @@ export var isString = function(x) {
   return typeof x === 'string' || x instanceof String;
 };
 
+// ---------------------------------------------------------------------------
+export var isNonEmptyString = function(x) {
+  if (typeof x !== 'string' && !(x instanceof String)) {
+    return false;
+  }
+  if (x.match(/^\s*$/)) {
+    return false;
+  }
+  return true;
+};
+
 // ---------------------------------------------------------------------------
 export var isBoolean = function(x) {
   return typeof x === 'boolean';
@@ -270,15 +281,21 @@ export var isInteger = function(x) {
 };
 
 // ---------------------------------------------------------------------------
-export var isUniqueList = function(lItems) {
+export var isUniqueList = function(lItems, func = undef) {
   var h, i, item, len;
   if (lItems == null) {
     return true; // empty list is unique
   }
+  if (defined(func)) {
+    assert(isFunction(func), `Not a function: ${OL(func)}`);
+  }
   h = {};
   for (i = 0, len = lItems.length; i < len; i++) {
     item = lItems[i];
-    if (h[item]) {
+    if (defined(func) && !func(item)) {
+      return false;
+    }
+    if (defined(h[item])) {
       return false;
     }
     h[item] = 1;

package/src/fs_utils.coffee

@@ -7,7 +7,7 @@ import NReadLines from 'n-readlines'
 
 import {
 	assert, undef, pass, defined, rtrim, error, isEmpty, nonEmpty,
-	isString, isArray, isRegExp, isFunction, croak, OL,
+	isString, isArray, isHash, isRegExp, isFunction, croak, OL,
 	} from '@jdeighan/coffee-utils'
 import {log, LOG} from '@jdeighan/coffee-utils/log'
 import {debug} from '@jdeighan/coffee-utils/debug'
@@ -268,7 +268,13 @@ export forEachFile = (dir, cb, filt=undef, level=0) ->
 
 # ---------------------------------------------------------------------------
 
-export pathTo = (fname, searchDir, direction="down") ->
+export pathTo = (fname, searchDir, hOptions={}) ->
+
+	{direction, relative} = hOptions
+	if isEmpty(direction)
+		direction = 'down'
+	if isEmpty(relative)
+		relative = false
 
 	debug "enter pathTo()", fname, searchDir, direction
 	if ! searchDir
@@ -276,6 +282,8 @@ export pathTo = (fname, searchDir, direction="down") ->
 	assert fs.existsSync(searchDir), "Dir #{searchDir} does not exist"
 	filepath = mkpath(searchDir, fname)
 	if fs.existsSync(filepath)
+		if relative
+			filepath = "./#{fname}"
 		debug "return from pathTo() - file exists", filepath
 		return filepath
 
@@ -285,17 +293,26 @@ export pathTo = (fname, searchDir, direction="down") ->
 		for subdir in getSubDirs(searchDir)
 			dirpath = mkpath(searchDir, subdir)
 			debug "check #{subdir}"
-			if defined(fpath = pathTo(fname, dirpath))
+			if defined(fpath = pathTo(fname, dirpath, hOptions))
+				if relative
+					fpath = fpath.replace('./', "./#{subdir}/")
 				debug "return from pathTo()", fpath
 				return fpath
 	else if (direction == 'up')
+		nLevels = 0
 		while defined(dirPath = getParentDir(searchDir))
+			nLevels += 1
 			debug "check #{dirPath}"
-			filepath = mkpath(dirPath, fname)
-			debug "check for #{filepath}"
-			if fs.existsSync(filepath)
-				debug "return from pathTo()", filepath
-				return filepath
+			fpath = mkpath(dirPath, fname)
+			debug "check for #{fpath}"
+			if fs.existsSync(fpath)
+				if relative
+					fpath = "../".repeat(nLevels) + fname
+					debug "return from pathTo()", fpath
+					return fpath
+				else
+					debug "return from pathTo()", fpath
+					return fpath
 			searchDir = dirPath
 	else
 		error "pathTo(): Invalid direction '#{direction}'"
@@ -309,12 +326,12 @@ export allPathsTo = (fname, searchDir) ->
 
 	if ! searchDir
 		searchDir = process.cwd()
-	path = pathTo(fname, searchDir, "up")
+	path = pathTo(fname, searchDir, {direction: "up"})
 	if path?
 		lPaths = [path]    # --- build an array of paths
 		# --- search upward for files, but return ordered top down
 		while (h = pathlib.parse(path)) \
-				&& (path = pathTo(fname, pathlib.resolve(h.dir, '..'), "up"))
+				&& (path = pathTo(fname, pathlib.resolve(h.dir, '..'), {direction: "up"}))
 			lPaths.unshift path
 		return lPaths
 	else

package/src/fs_utils.js

@@ -21,6 +21,7 @@ import {
   nonEmpty,
   isString,
   isArray,
+  isHash,
   isRegExp,
   isFunction,
   croak,
@@ -326,8 +327,15 @@ export var forEachFile = function(dir, cb, filt = undef, level = 0) {
 };
 
 // ---------------------------------------------------------------------------
-export var pathTo = function(fname, searchDir, direction = "down") {
-  var dirPath, dirpath, filepath, fpath, i, len, ref, subdir;
+export var pathTo = function(fname, searchDir, hOptions = {}) {
+  var dirPath, direction, dirpath, filepath, fpath, i, len, nLevels, ref, relative, subdir;
+  ({direction, relative} = hOptions);
+  if (isEmpty(direction)) {
+    direction = 'down';
+  }
+  if (isEmpty(relative)) {
+    relative = false;
+  }
   debug("enter pathTo()", fname, searchDir, direction);
   if (!searchDir) {
     searchDir = process.cwd();
@@ -335,6 +343,9 @@ export var pathTo = function(fname, searchDir, direction = "down") {
   assert(fs.existsSync(searchDir), `Dir ${searchDir} does not exist`);
   filepath = mkpath(searchDir, fname);
   if (fs.existsSync(filepath)) {
+    if (relative) {
+      filepath = `./${fname}`;
+    }
     debug("return from pathTo() - file exists", filepath);
     return filepath;
   }
@@ -346,19 +357,30 @@ export var pathTo = function(fname, searchDir, direction = "down") {
       subdir = ref[i];
       dirpath = mkpath(searchDir, subdir);
       debug(`check ${subdir}`);
-      if (defined(fpath = pathTo(fname, dirpath))) {
+      if (defined(fpath = pathTo(fname, dirpath, hOptions))) {
+        if (relative) {
+          fpath = fpath.replace('./', `./${subdir}/`);
+        }
         debug("return from pathTo()", fpath);
         return fpath;
       }
     }
   } else if (direction === 'up') {
+    nLevels = 0;
     while (defined(dirPath = getParentDir(searchDir))) {
+      nLevels += 1;
       debug(`check ${dirPath}`);
-      filepath = mkpath(dirPath, fname);
-      debug(`check for ${filepath}`);
-      if (fs.existsSync(filepath)) {
-        debug("return from pathTo()", filepath);
-        return filepath;
+      fpath = mkpath(dirPath, fname);
+      debug(`check for ${fpath}`);
+      if (fs.existsSync(fpath)) {
+        if (relative) {
+          fpath = "../".repeat(nLevels) + fname;
+          debug("return from pathTo()", fpath);
+          return fpath;
+        } else {
+          debug("return from pathTo()", fpath);
+          return fpath;
+        }
       }
       searchDir = dirPath;
     }
@@ -375,11 +397,15 @@ export var allPathsTo = function(fname, searchDir) {
   if (!searchDir) {
     searchDir = process.cwd();
   }
-  path = pathTo(fname, searchDir, "up");
+  path = pathTo(fname, searchDir, {
+    direction: "up"
+  });
   if (path != null) {
     lPaths = [path]; // --- build an array of paths
     // --- search upward for files, but return ordered top down
-    while ((h = pathlib.parse(path)) && (path = pathTo(fname, pathlib.resolve(h.dir, '..'), "up"))) {
+    while ((h = pathlib.parse(path)) && (path = pathTo(fname, pathlib.resolve(h.dir, '..'), {
+        direction: "up"
+      }))) {
       lPaths.unshift(path);
     }
     return lPaths;