@jdeighan/coffee-utils 4.1.6 → 4.1.10

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "4.1.6",
+	"version": "4.1.10",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -13,7 +13,6 @@
 		"./debug": "./src/debug_utils.js",
 		"./svelte": "./src/svelte_utils.js",
 		"./test": "./src/UnitTester.js",
-		"./privenv": "./src/private_env.js",
 		"./package.json": "./package.json"
 	},
 	"engines": {
@@ -21,7 +20,8 @@
 	},
 	"scripts": {
 		"build": "cls && rm -f ./src/*.js && coffee -c ./src",
-		"pretest": "npm run build && rm -f ./test/*.js && rm -f ./test/*.coffee && cielo -fq ./test",
+		"old_pretest": "npm run build && rm -f ./test/*.js && rm -f ./test/*.coffee && cielo -fq ./test",
+		"pretest": "cls && coffee -c .",
 		"test": "ava ./test/*.test.js",
 		"prefinaltest": "npm run pretest",
 		"finaltest": "cross-env FINALTEST=yes ava ./test/*.test.js"

package/src/block_utils.coffee

@@ -86,6 +86,7 @@ export joinBlocks = (lBlocks...) ->
 
 	lNonEmptyBlocks = []
 	for block in lBlocks
+		assert isString(block), "joinBlocks(): block #{block} is not a string"
 		if nonEmpty(block)
 			lNonEmptyBlocks.push block
 	return lNonEmptyBlocks.join('\n')

package/src/block_utils.js

@@ -110,6 +110,7 @@ export var joinBlocks = function(...lBlocks) {
   lNonEmptyBlocks = [];
   for (i = 0, len1 = lBlocks.length; i < len1; i++) {
     block = lBlocks[i];
+    assert(isString(block), `joinBlocks(): block ${block} is not a string`);
     if (nonEmpty(block)) {
       lNonEmptyBlocks.push(block);
     }

package/src/coffee_utils.coffee

@@ -100,6 +100,14 @@ export isHash = (x) ->
 
 	return (getClassName(x) == 'Object')
 
+# ---------------------------------------------------------------------------
+
+export hashHasKey = (x, key) ->
+
+	assert isHash(x), "hashHasKey(): not a hash"
+	assert isString(key), "hashHasKey(): key not a string"
+	return x.hasOwnProperty(key)
+
 # ---------------------------------------------------------------------------
 #   isEmpty
 #      - string is whitespace, array has no elements, hash has no keys
@@ -149,6 +157,7 @@ export setCommentRegexp = (regexp) ->
 
 export isComment = (str) ->
 
+	assert isString(str), "isComment(): not a string"
 	return if str.match(commentRegExp) then true else false
 
 # ---------------------------------------------------------------------------
@@ -264,6 +273,7 @@ export titleLine = (title, char='=', padding=2, linelen=42) ->
 
 export rtrim = (line) ->
 
+	assert isString(line), "rtrim(): line is not a string"
 	lMatches = line.match(/\s+$/)
 	if lMatches?
 		n = lMatches[0].length   # num chars to remove
@@ -357,3 +367,21 @@ export extractMatches = (line, regexp, convertFunc=undef) ->
 		return lStrings
 
 # ---------------------------------------------------------------------------
+
+export envVarsWithPrefix = (prefix, hOptions={}) ->
+	# --- valid options:
+	#        stripPrefix
+
+	assert prefix, "envVarsWithPrefix: empty prefix!"
+	plen = prefix.length
+	h = {}
+	for key in Object.keys(process.env)
+		if key.indexOf(prefix) == 0
+			if hOptions.stripPrefix
+				h[key.substr(plen)] = process.env[key]
+			else
+				h[key] = process.env[key]
+	return h
+
+# ---------------------------------------------------------------------------
+

package/src/coffee_utils.js

@@ -97,6 +97,13 @@ export var isHash = function(x) {
   return getClassName(x) === 'Object';
 };
 
+// ---------------------------------------------------------------------------
+export var hashHasKey = function(x, key) {
+  assert(isHash(x), "hashHasKey(): not a hash");
+  assert(isString(key), "hashHasKey(): key not a string");
+  return x.hasOwnProperty(key);
+};
+
 // ---------------------------------------------------------------------------
 //   isEmpty
 //      - string is whitespace, array has no elements, hash has no keys
@@ -147,6 +154,7 @@ export var setCommentRegexp = function(regexp) {
 
 // ---------------------------------------------------------------------------
 export var isComment = function(str) {
+  assert(isString(str), "isComment(): not a string");
   if (str.match(commentRegExp)) {
     return true;
   } else {
@@ -266,6 +274,7 @@ export var titleLine = function(title, char = '=', padding = 2, linelen = 42) {
 //   rtrim - strip trailing whitespace
 export var rtrim = function(line) {
   var lMatches, n;
+  assert(isString(line), "rtrim(): line is not a string");
   lMatches = line.match(/\s+$/);
   if (lMatches != null) {
     n = lMatches[0].length; // num chars to remove
@@ -392,3 +401,25 @@ export var extractMatches = function(line, regexp, convertFunc = undef) {
 };
 
 // ---------------------------------------------------------------------------
+export var envVarsWithPrefix = function(prefix, hOptions = {}) {
+  var h, i, key, len, plen, ref;
+  // --- valid options:
+  //        stripPrefix
+  assert(prefix, "envVarsWithPrefix: empty prefix!");
+  plen = prefix.length;
+  h = {};
+  ref = Object.keys(process.env);
+  for (i = 0, len = ref.length; i < len; i++) {
+    key = ref[i];
+    if (key.indexOf(prefix) === 0) {
+      if (hOptions.stripPrefix) {
+        h[key.substr(plen)] = process.env[key];
+      } else {
+        h[key] = process.env[key];
+      }
+    }
+  }
+  return h;
+};
+
+// ---------------------------------------------------------------------------

package/src/debug_utils.coffee

@@ -209,6 +209,7 @@ reMethod = ///^
 
 export funcMatch = (curFunc) ->
 
+	assert isString(curFunc), "funcMatch(): not a string"
 	if lDebugFuncs.includes(curFunc)
 		return true
 	else if (lMatches = curFunc.match(reMethod)) \

package/src/debug_utils.js

@@ -204,6 +204,7 @@ reMethod = /^([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/;
 // --- export only to allow unit tests
 export var funcMatch = function(curFunc) {
   var _, cls, lMatches, meth;
+  assert(isString(curFunc), "funcMatch(): not a string");
   if (lDebugFuncs.includes(curFunc)) {
     return true;
   } else if ((lMatches = curFunc.match(reMethod)) && ([_, cls, meth] = lMatches) && lDebugFuncs.includes(meth)) {

package/src/fs_utils.coffee

@@ -6,7 +6,7 @@ import fs from 'fs'
 
 import {
 	assert, undef, pass, rtrim, error, nonEmpty,
-	isRegExp, isFunction, croak,
+	isString, isRegExp, isFunction, croak,
 	} from '@jdeighan/coffee-utils'
 import {log} from '@jdeighan/coffee-utils/log'
 import {debug} from '@jdeighan/coffee-utils/debug'
@@ -34,6 +34,7 @@ export isSimpleFileName = (path) ->
 
 export fileExt = (path) ->
 
+	assert isString(path), "fileExt(): path not a string"
 	if lMatches = path.match(/\.[A-Za-z0-9_]+$/)
 		return lMatches[0]
 	else
@@ -45,8 +46,14 @@ export fileExt = (path) ->
 
 export mydir = (url) ->
 
-	dir = pathlib.dirname(urllib.fileURLToPath(url))
-	return mkpath(dir)
+	debug "url = #{url}"
+	path = urllib.fileURLToPath(url)
+	debug "path = #{path}"
+	dir = pathlib.dirname(path)
+	debug "dir = #{dir}"
+	final = mkpath(dir)
+	debug "final = #{final}"
+	return final
 
 # ---------------------------------------------------------------------------
 
@@ -129,6 +136,25 @@ export withExt = (path, newExt, hOptions={}) ->
 		name = name.substr(1)
 	return mkpath(dir, "#{name}#{newExt}")
 
+# ---------------------------------------------------------------------------
+#   removeFileWithExt - remove file with different ext
+
+export removeFileWithExt = (path, newExt, hOptions={}) ->
+	# --- Valid options:
+	#        doLog
+	#        removeLeadingUnderScore
+
+	fullpath = withExt(path, newExt, hOptions)
+	try
+		fs.unlinkSync fullpath
+		if hOptions.doLog
+			log "   unlink #{filename}"
+		success = true
+	catch err
+		log "   UNLINK FAILED: #{err.message}"
+		success = false
+	return success
+
 # ---------------------------------------------------------------------------
 #   withUnderScore - add '_' to file name
 

package/src/fs_utils.js

@@ -13,6 +13,7 @@ import {
   rtrim,
   error,
   nonEmpty,
+  isString,
   isRegExp,
   isFunction,
   croak
@@ -46,6 +47,7 @@ export var isSimpleFileName = function(path) {
 // ---------------------------------------------------------------------------
 export var fileExt = function(path) {
   var lMatches;
+  assert(isString(path), "fileExt(): path not a string");
   if (lMatches = path.match(/\.[A-Za-z0-9_]+$/)) {
     return lMatches[0];
   } else {
@@ -57,9 +59,15 @@ export var fileExt = function(path) {
 //    mydir() - pass argument `import.meta.url` and it will return
 //              the directory your file is in
 export var mydir = function(url) {
-  var dir;
-  dir = pathlib.dirname(urllib.fileURLToPath(url));
-  return mkpath(dir);
+  var dir, final, path;
+  debug(`url = ${url}`);
+  path = urllib.fileURLToPath(url);
+  debug(`path = ${path}`);
+  dir = pathlib.dirname(path);
+  debug(`dir = ${dir}`);
+  final = mkpath(dir);
+  debug(`final = ${final}`);
+  return final;
 };
 
 // ---------------------------------------------------------------------------
@@ -148,6 +156,28 @@ export var withExt = function(path, newExt, hOptions = {}) {
   return mkpath(dir, `${name}${newExt}`);
 };
 
+// ---------------------------------------------------------------------------
+//   removeFileWithExt - remove file with different ext
+export var removeFileWithExt = function(path, newExt, hOptions = {}) {
+  var err, fullpath, success;
+  // --- Valid options:
+  //        doLog
+  //        removeLeadingUnderScore
+  fullpath = withExt(path, newExt, hOptions);
+  try {
+    fs.unlinkSync(fullpath);
+    if (hOptions.doLog) {
+      log(`   unlink ${filename}`);
+    }
+    success = true;
+  } catch (error1) {
+    err = error1;
+    log(`   UNLINK FAILED: ${err.message}`);
+    success = false;
+  }
+  return success;
+};
+
 // ---------------------------------------------------------------------------
 //   withUnderScore - add '_' to file name
 export var withUnderScore = function(path) {

package/src/indent_utils.coffee

@@ -14,7 +14,7 @@ import {arrayToBlock, blockToArray} from '@jdeighan/coffee-utils/block'
 export splitLine = (line) ->
 
 	assert line?, "splitLine(): line is undef"
-	assert (typeof line == 'string'), "splitLine(): line is not a string"
+	assert isString(line), "splitLine(): line is not a string"
 	line = rtrim(line)
 	lMatches = line.match(/^(\s*)(.*)$/)
 	return [lMatches[1].length, lMatches[2]]
@@ -34,6 +34,7 @@ export indentation = (level) ->
 
 export indentLevel = (str) ->
 
+	assert isString(str), "indentLevel(): not a string"
 	lMatches = str.match(/^\t*/)
 	return lMatches[0].length
 
@@ -76,6 +77,8 @@ export undented = (text, level=undef) ->
 			return ''
 	else if isArray(text)
 		lLines = text
+		for line in lLines
+			assert isString(line), "undented(): input array is not all strings"
 		if (lLines.length == 0)
 			return []
 	else

package/src/indent_utils.js

@@ -25,7 +25,7 @@ import {
 export var splitLine = function(line) {
   var lMatches;
   assert(line != null, "splitLine(): line is undef");
-  assert(typeof line === 'string', "splitLine(): line is not a string");
+  assert(isString(line), "splitLine(): line is not a string");
   line = rtrim(line);
   lMatches = line.match(/^(\s*)(.*)$/);
   return [lMatches[1].length, lMatches[2]];
@@ -44,6 +44,7 @@ export var indentation = function(level) {
 //                 it's OK if the string is ONLY indentation
 export var indentLevel = function(str) {
   var lMatches;
+  assert(isString(str), "indentLevel(): not a string");
   lMatches = str.match(/^\t*/);
   return lMatches[0].length;
 };
@@ -84,7 +85,7 @@ export var indented = function(input, level = 0) {
 //              indentation is removed
 //            - returns same type as text, i.e. either string or array
 export var undented = function(text, level = undef) {
-  var i, lLines, lMatches, lNewLines, len, line, nToRemove, toRemove;
+  var i, j, lLines, lMatches, lNewLines, len, len1, line, nToRemove, toRemove;
   if ((level != null) && (level === 0)) {
     return text;
   }
@@ -95,6 +96,10 @@ export var undented = function(text, level = undef) {
     }
   } else if (isArray(text)) {
     lLines = text;
+    for (i = 0, len = lLines.length; i < len; i++) {
+      line = lLines[i];
+      assert(isString(line), "undented(): input array is not all strings");
+    }
     if (lLines.length === 0) {
       return [];
     }
@@ -111,8 +116,8 @@ export var undented = function(text, level = undef) {
   }
   nToRemove = toRemove.length;
   lNewLines = [];
-  for (i = 0, len = lLines.length; i < len; i++) {
-    line = lLines[i];
+  for (j = 0, len1 = lLines.length; j < len1; j++) {
+    line = lLines[j];
     if (isEmpty(line)) {
       lNewLines.push('');
     } else {

package/temp.js

@@ -1,16 +1,26 @@
 // Generated by CoffeeScript 2.6.1
 // temp.coffee
-var str;
+var dir;
 
 import {
-  hashToStr
+  say
 } from '@jdeighan/coffee-utils';
 
-// ---------------------------------------------------------------------------
-str = hashToStr({
-  c: 3,
-  b: 2,
-  a: 1
-});
+import {
+  log
+} from '@jdeighan/coffee-utils/log';
+
+import {
+  setDebugging
+} from '@jdeighan/coffee-utils/debug';
+
+import {
+  mydir,
+  mkpath
+} from '@jdeighan/coffee-utils/fs';
+
+setDebugging(true);
+
+dir = mydir(import.meta.url);
 
-console.log(str);
+say(`dir = ${dir}`);

package/.save/block.test.coffee

@@ -1,185 +0,0 @@
-# block.test.coffee
-
-import assert from 'assert'
-
-import {UnitTester} from '@jdeighan/coffee-utils/test'
-import {
-	blockToArray, arrayToBlock, firstLine, remainingLines,
-	normalizeBlock, truncateBlock,
-	joinBlocks, forEachLine, forEachBlock, forEachSetOfBlocks,
-	} from '@jdeighan/coffee-utils/block'
-
-simple = new UnitTester()
-
-# ---------------------------------------------------------------------------
-
-simple.equal 108, blockToArray("abc\nxyz\n"), [
-	'abc'
-	'xyz'
-	]
-
-simple.equal 113, blockToArray("abc\nxyz\n\n\n\n"), [
-	'abc'
-	'xyz'
-	]
-
-simple.equal 118, blockToArray("abc\n\nxyz\n"), [
-	'abc'
-	''
-	'xyz'
-	]
-
-# ---------------------------------------------------------------------------
-
-simple.equal 126, arrayToBlock(['a','b','c']), "a\nb\nc\n"
-
-# ---------------------------------------------------------------------------
-
-simple.equal 225, firstLine("""
-		#starbucks
-		do this
-		do that
-		"""), '#starbucks'
-
-# ---------------------------------------------------------------------------
-
-simple.equal 225, remainingLines("""
-		#starbucks
-		do this
-		do that
-		"""), """
-		do this
-		do that
-		"""
-
-# ---------------------------------------------------------------------------
-
-(() ->
-	str = joinBlocks('import me', '', 'do this\ndo that')
-	simple.equal 17, str, """
-			import me
-			do this
-			do that
-			"""
-	)()
-
-# ---------------------------------------------------------------------------
-
-simple.equal 49, normalizeBlock("""
-			line 1
-			line 2
-			"""), """
-			line 1
-			line 2
-			""" + '\n'
-
-simple.equal 57, normalizeBlock("""
-			line 1
-
-			line 2
-			"""), """
-			line 1
-			line 2
-			""" + '\n'
-
-simple.equal 66, normalizeBlock("""
-
-			line 1
-
-			line 2
-
-
-			"""), """
-			line 1
-			line 2
-			""" + '\n'
-
-# ---------------------------------------------------------------------------
-
-simple.equal 96, truncateBlock("""
-			line 1
-			line 2
-			line 3
-			line 4
-			""", 2), """
-			line 1
-			line 2
-			""" + '\n'
-
-# ---------------------------------------------------------------------------
-
-(() ->
-	lBlocks = [
-		"import {say} from '@jdeighan/coffee-utils'",
-		"",
-		"<script>\n\tx = 42\n</script>",
-		"",
-		]
-	str = joinBlocks(lBlocks...)
-	simple.equal 34, str, """
-			import {say} from '@jdeighan/coffee-utils'
-			<script>
-				x = 42
-			</script>
-			"""
-	)()
-
-# ---------------------------------------------------------------------------
-
-(() ->
-	lImports = [
-		"import {say} from '@jdeighan/coffee-utils'",
-		]
-	code = """
-		if (x==42)
-			log "line 2 in unit test"
-		"""
-	str = joinBlocks(lImports..., code)
-	simple.equal 34, str, """
-
-			import {say} from '@jdeighan/coffee-utils'
-			if (x==42)
-				log "line 2 in unit test"
-			"""
-	)()
-
-# ---------------------------------------------------------------------------
-# test forEachLine()
-
-(() ->
-	lLines = []
-
-	callback = (line) ->
-		lLines.push line
-		return
-
-	filepath = "c:/Users/johnd/coffee-utils/test/data/file2.txt"
-	await forEachLine filepath, callback
-
-	simple.equal 55, lLines, [
-			"abc",
-			"def",
-			"ghi",
-			"jkl",
-			]
-	)()
-
-# ---------------------------------------------------------------------------
-# test forEachBlock()
-
-(() ->
-	lBlocks = []
-
-	callback = (block) ->
-		lBlocks.push block
-		return
-
-	filepath = "c:/Users/johnd/coffee-utils/test/data/file3.txt"
-	await forEachBlock filepath, callback
-
-	simple.equal 76, lBlocks, [
-			"abc\ndef",
-			"abc\ndef\nghi",
-			"abc\ndef\nghi\njkl",
-			]
-	)()