@jdeighan/coffee-utils 4.1.7 → 4.1.11

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "4.1.7",
+	"version": "4.1.11",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -20,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,10 @@ export joinBlocks = (lBlocks...) ->
 
 	lNonEmptyBlocks = []
 	for block in lBlocks
+		if ! isString(block)
+			log "NOT A BLOCK"
+			log 'bad block', block
+			process.exit()
 		if nonEmpty(block)
 			lNonEmptyBlocks.push block
 	return lNonEmptyBlocks.join('\n')

package/src/block_utils.js

@@ -110,6 +110,11 @@ export var joinBlocks = function(...lBlocks) {
   lNonEmptyBlocks = [];
   for (i = 0, len1 = lBlocks.length; i < len1; i++) {
     block = lBlocks[i];
+    if (!isString(block)) {
+      log("NOT A BLOCK");
+      log('bad block', block);
+      process.exit();
+    }
     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
@@ -135,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 {
@@ -154,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/.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",
-			]
-	)()

package/.save/block.test.js

@@ -1,129 +0,0 @@
-// Generated by CoffeeScript 2.6.1
-// block.test.coffee
-var simple;
-
-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`);
-
-// ---------------------------------------------------------------------------
-(function() {
-  var str;
-  str = joinBlocks('import me', '', 'do this\ndo that');
-  return 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');
-
-// ---------------------------------------------------------------------------
-(function() {
-  var lBlocks, str;
-  lBlocks = ["import {say} from '@jdeighan/coffee-utils'", "", "<script>\n\tx = 42\n</script>", ""];
-  str = joinBlocks(...lBlocks);
-  return simple.equal(34, str, `import {say} from '@jdeighan/coffee-utils'
-<script>
-	x = 42
-</script>`);
-})();
-
-// ---------------------------------------------------------------------------
-(function() {
-  var code, lImports, str;
-  lImports = ["import {say} from '@jdeighan/coffee-utils'"];
-  code = `if (x==42)
-	log "line 2 in unit test"`;
-  str = joinBlocks(...lImports, code);
-  return simple.equal(34, str, `
-import {say} from '@jdeighan/coffee-utils'
-if (x==42)
-	log "line 2 in unit test"`);
-})();
-
-// ---------------------------------------------------------------------------
-// test forEachLine()
-(async function() {
-  var callback, filepath, lLines;
-  lLines = [];
-  callback = function(line) {
-    lLines.push(line);
-  };
-  filepath = "c:/Users/johnd/coffee-utils/test/data/file2.txt";
-  await forEachLine(filepath, callback);
-  return simple.equal(55, lLines, ["abc", "def", "ghi", "jkl"]);
-})();
-
-// ---------------------------------------------------------------------------
-// test forEachBlock()
-(async function() {
-  var callback, filepath, lBlocks;
-  lBlocks = [];
-  callback = function(block) {
-    lBlocks.push(block);
-  };
-  filepath = "c:/Users/johnd/coffee-utils/test/data/file3.txt";
-  await forEachBlock(filepath, callback);
-  return simple.equal(76, lBlocks, ["abc\ndef", "abc\ndef\nghi", "abc\ndef\nghi\njkl"]);
-})();

package/.save/block2.test.coffee

@@ -1,47 +0,0 @@
-# block2.test.coffee
-
-import assert from 'assert'
-import test from 'ava'
-
-import {
-	undef, say, isString, isHash, isEmpty, nonEmpty,
-	} from '@jdeighan/coffee-utils'
-import {mydir, mkpath} from '@jdeighan/coffee-utils/fs'
-import {UnitTester} from '@jdeighan/coffee-utils/test'
-import {
-	forEachLine, forEachBlock, forEachSetOfBlocks,
-	} from '@jdeighan/coffee-utils/block'
-
-testDir = mydir(`import.meta.url`)
-simple = new UnitTester()
-
-filepath = mkpath(testDir, 'code2.test.txt')
-
-# ----------------------------------------------------------------------------
-
-(() ->
-	lFirstBlocks = undef
-	callback = (lBlocks) ->
-		lFirstBlocks = lBlocks
-		return true   # we're only interested in the first set
-
-	test "line 29", (t) ->
-		await forEachSetOfBlocks filepath, callback
-		t.deepEqual lFirstBlocks, ["f()", "f"]
-	)()
-
-# ----------------------------------------------------------------------------
-
-(() ->
-	lAllBlockSets = []
-	callback = (lBlocks) ->
-		lAllBlockSets.push(lBlocks)
-		return
-
-	test "line 44", (t) ->
-		await forEachSetOfBlocks filepath, callback
-		t.deepEqual lAllBlockSets, [
-				["f()", "f"],
-				["f = (key=undef) ->\n\tswitch key\n\t\twhen 'ok'\n\t\t\tsay 'all is OK'", "f,say,mkpath"],
-				]
-	)()