@jdeighan/coffee-utils 14.0.35 → 14.0.37

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "14.0.35",
+	"version": "14.0.37",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -45,14 +45,14 @@
 	},
 	"homepage": "https://github.com/johndeighan/coffee-utils#readme",
 	"dependencies": {
-		"@jdeighan/base-utils": "^4.0.21",
+		"@jdeighan/base-utils": "^4.0.26",
 		"cross-env": "^7.0.3",
 		"n-readlines": "^1.0.1",
 		"readline-sync": "^1.4.10",
-		"svelte": "^3.55.1"
+		"svelte": "^3.58.0"
 	},
 	"devDependencies": {
-		"@jdeighan/unit-tester": "^3.0.42",
+		"@jdeighan/unit-tester": "^3.0.44",
 		"ava": "^5.2.0"
 	}
 }

package/src/fs.coffee

@@ -3,6 +3,10 @@
 import pathlib from 'path'
 import urllib from 'url'
 import fs from 'fs'
+import {
+	readFile, writeFile, rm,
+	} from 'node:fs/promises'
+import {execSync} from 'node:child_process'
 import readline from 'readline'
 import NReadLines from 'n-readlines'
 
@@ -16,6 +20,102 @@ import {LOG, LOGVALUE} from '@jdeighan/base-utils/log'
 import {dbg, dbgEnter, dbgReturn} from '@jdeighan/base-utils/debug'
 import {fromTAML} from '@jdeighan/base-utils/taml'
 
+# ---------------------------------------------------------------------------
+
+export mkpath = (lParts...) =>
+
+	# --- Ignore empty parts
+	lNewParts = []
+	for part in lParts
+		if nonEmpty(part)
+			lNewParts.push part
+
+	newPath = lNewParts.join('/').replace(/\\/g, '/')
+	if lMatches = newPath.match(/^([A-Z])\:(.*)$/)
+		[_, drive, rest] = lMatches
+		return "#{drive.toLowerCase()}:#{rest}"
+	else
+		return newPath
+
+# ---------------------------------------------------------------------------
+
+export mkdir = (dirpath) =>
+
+	try
+		fs.mkdirSync dirpath
+	catch err
+		if (err.code == 'EEXIST')
+			console.log 'Directory exists. Please choose another name'
+		else
+			console.log err
+		process.exit 1
+	return
+
+# ---------------------------------------------------------------------------
+
+export mkfile = (filepath, contents='') =>
+
+	await writeFile filepath, contents
+	return
+
+# ---------------------------------------------------------------------------
+
+export rmdir = (dirpath) =>
+
+	await rm dirpath, {recursive: true}
+	return
+
+# ---------------------------------------------------------------------------
+
+export rmfile = (filepath) =>
+
+	await rm filepath
+	return
+
+# ---------------------------------------------------------------------------
+
+export cdTo = (dirpath) =>
+
+	process.chdir dirpath
+	return process.cwd()
+
+# ---------------------------------------------------------------------------
+
+export cdToUserDir = (lSubDirs...) =>
+
+	return cd(mkpath('~', lSubDirs...))
+
+# --------------------------------------------------------------------------
+
+export execCmd = (cmdLine) =>
+
+	execSync cmdLine, {}, (error, stdout, stderr) =>
+		if (error)
+			LOG "ERROR in #{cmdLine}: #{error.code}"
+			process.exit 1
+	return stdout
+
+# ---------------------------------------------------------------------------
+
+export cloneRepo = (user, repo, dir) =>
+
+	git_repo = "https://github.com/#{user}/#{repo}.git"
+	return execCmd "git clone #{git_repo} #{dir}"
+
+# ---------------------------------------------------------------------------
+
+export getPkgJson = (filepath) =>
+
+	jsonTxt = fs.readFileSync(filepath, {encoding: 'utf8'})
+	hJson = JSON.parse jsonTxt
+	return
+
+# ---------------------------------------------------------------------------
+
+export putPkgJson = (filepath, hJson) =>
+
+	return
+
 # ---------------------------------------------------------------------------
 #    mydir() - pass argument import.meta.url and it will return
 #              the directory your file is in
@@ -108,23 +208,6 @@ export fileExt = (path) =>
 
 # ---------------------------------------------------------------------------
 
-export mkpath = (lParts...) =>
-
-	# --- Ignore empty parts
-	lNewParts = []
-	for part in lParts
-		if nonEmpty(part)
-			lNewParts.push part
-
-	newPath = lNewParts.join('/').replace(/\\/g, '/')
-	if lMatches = newPath.match(/^([A-Z])\:(.*)$/)
-		[_, drive, rest] = lMatches
-		return "#{drive.toLowerCase()}:#{rest}"
-	else
-		return newPath
-
-# ---------------------------------------------------------------------------
-
 export getFullPath = (filepath) =>
 
 	return mkpath(pathlib.resolve(filepath))
@@ -230,10 +313,11 @@ export forEachSetOfBlocks = (filepath, func,
 	return
 
 # ---------------------------------------------------------------------------
-#   slurp - read an entire file into a string
+#   slurp - read a file into a string
 
-export slurp = (filepath, maxLines=undef) =>
+export slurp = (filepath, hOptions={}) =>
 
+	{maxLines, format} = getOptions(hOptions)
 	if defined(maxLines)
 		lLines = []
 		forEachLineInFile filepath, (line, nLines) ->
@@ -243,20 +327,33 @@ export slurp = (filepath, maxLines=undef) =>
 	else
 		filepath = filepath.replace(/\//g, "\\")
 		contents = fs.readFileSync(filepath, 'utf8').toString()
-	return contents
+	switch format
+		when 'TAML'
+			return fromTAML(contents)
+		when 'JSON'
+			return JSON.parse(contents)
+		else
+			assert notdefined(format), "Unknown format: #{format}"
+			return contents
 
 # ---------------------------------------------------------------------------
 #   barf - write a string to a file
 
-export barf = (filepath, contents) =>
+export barf = (filepath, contents='', hOptions={}) =>
 
-	if isEmpty(contents)
-		return
-	if isArray(contents)
-		contents = toBlock(contents)
-	else if ! isString(contents)
-		croak "barf(): Invalid contents"
-	contents = rtrim(contents) + "\n"
+	{format} = getOptions(hOptions)
+	switch format
+		when 'TAML'
+			contents = toTAML(contents)
+		when 'JSON'
+			contents = JSON.stringify(contents, null, 3)
+		else
+			assert notdefined(format), "Unknown format: #{format}"
+			if isArray(contents)
+				contents = toBlock(contents)
+			else if ! isString(contents)
+				croak "barf(): Invalid contents"
+			contents = rtrim(contents) + "\n"
 	fs.writeFileSync(filepath, contents, {encoding: 'utf8'})
 	return
 
@@ -499,5 +596,4 @@ export parseSource = (source) =>
 
 export slurpTAML = (filepath) =>
 
-	contents = slurp(filepath)
-	return fromTAML(contents)
+	return slurp(filepath, {format: 'TAML'})

package/src/fs.js

@@ -8,6 +8,16 @@ import urllib from 'url';
 
 import fs from 'fs';
 
+import {
+  readFile,
+  writeFile,
+  rm
+} from 'node:fs/promises';
+
+import {
+  execSync
+} from 'node:child_process';
+
 import readline from 'readline';
 
 import NReadLines from 'n-readlines';
@@ -51,6 +61,100 @@ import {
   fromTAML
 } from '@jdeighan/base-utils/taml';
 
+// ---------------------------------------------------------------------------
+export var mkpath = (...lParts) => {
+  var _, drive, i, lMatches, lNewParts, len, newPath, part, rest;
+  // --- Ignore empty parts
+  lNewParts = [];
+  for (i = 0, len = lParts.length; i < len; i++) {
+    part = lParts[i];
+    if (nonEmpty(part)) {
+      lNewParts.push(part);
+    }
+  }
+  newPath = lNewParts.join('/').replace(/\\/g, '/');
+  if (lMatches = newPath.match(/^([A-Z])\:(.*)$/)) {
+    [_, drive, rest] = lMatches;
+    return `${drive.toLowerCase()}:${rest}`;
+  } else {
+    return newPath;
+  }
+};
+
+// ---------------------------------------------------------------------------
+export var mkdir = (dirpath) => {
+  var err;
+  try {
+    fs.mkdirSync(dirpath);
+  } catch (error1) {
+    err = error1;
+    if (err.code === 'EEXIST') {
+      console.log('Directory exists. Please choose another name');
+    } else {
+      console.log(err);
+    }
+    process.exit(1);
+  }
+};
+
+// ---------------------------------------------------------------------------
+export var mkfile = async(filepath, contents = '') => {
+  await writeFile(filepath, contents);
+};
+
+// ---------------------------------------------------------------------------
+export var rmdir = async(dirpath) => {
+  await rm(dirpath, {
+    recursive: true
+  });
+};
+
+// ---------------------------------------------------------------------------
+export var rmfile = async(filepath) => {
+  await rm(filepath);
+};
+
+// ---------------------------------------------------------------------------
+export var cdTo = (dirpath) => {
+  process.chdir(dirpath);
+  return process.cwd();
+};
+
+// ---------------------------------------------------------------------------
+export var cdToUserDir = (...lSubDirs) => {
+  return cd(mkpath('~', ...lSubDirs));
+};
+
+// --------------------------------------------------------------------------
+export var execCmd = (cmdLine) => {
+  execSync(cmdLine, {}, (error, stdout, stderr) => {
+    if (error) {
+      LOG(`ERROR in ${cmdLine}: ${error.code}`);
+      return process.exit(1);
+    }
+  });
+  return stdout;
+};
+
+// ---------------------------------------------------------------------------
+export var cloneRepo = (user, repo, dir) => {
+  var git_repo;
+  git_repo = `https://github.com/${user}/${repo}.git`;
+  return execCmd(`git clone ${git_repo} ${dir}`);
+};
+
+// ---------------------------------------------------------------------------
+export var getPkgJson = (filepath) => {
+  var hJson, jsonTxt;
+  jsonTxt = fs.readFileSync(filepath, {
+    encoding: 'utf8'
+  });
+  hJson = JSON.parse(jsonTxt);
+};
+
+// ---------------------------------------------------------------------------
+export var putPkgJson = (filepath, hJson) => {};
+
 // ---------------------------------------------------------------------------
 //    mydir() - pass argument import.meta.url and it will return
 //              the directory your file is in
@@ -99,7 +203,7 @@ export var getStats = (fullpath) => {
 export var isFile = (fullpath) => {
   try {
     return getStats(fullpath).isFile();
-  } catch (error) {
+  } catch (error1) {
     return false;
   }
 };
@@ -108,7 +212,7 @@ export var isFile = (fullpath) => {
 export var isDir = (fullpath) => {
   try {
     return getStats(fullpath).isDirectory();
-  } catch (error) {
+  } catch (error1) {
     return false;
   }
 };
@@ -142,26 +246,6 @@ export var fileExt = (path) => {
   }
 };
 
-// ---------------------------------------------------------------------------
-export var mkpath = (...lParts) => {
-  var _, drive, i, lMatches, lNewParts, len, newPath, part, rest;
-  // --- Ignore empty parts
-  lNewParts = [];
-  for (i = 0, len = lParts.length; i < len; i++) {
-    part = lParts[i];
-    if (nonEmpty(part)) {
-      lNewParts.push(part);
-    }
-  }
-  newPath = lNewParts.join('/').replace(/\\/g, '/');
-  if (lMatches = newPath.match(/^([A-Z])\:(.*)$/)) {
-    [_, drive, rest] = lMatches;
-    return `${drive.toLowerCase()}:${rest}`;
-  } else {
-    return newPath;
-  }
-};
-
 // ---------------------------------------------------------------------------
 export var getFullPath = (filepath) => {
   return mkpath(pathlib.resolve(filepath));
@@ -273,9 +357,10 @@ export var forEachSetOfBlocks = (filepath, func, block_regexp = /^-{16,}$/, set_
 };
 
 // ---------------------------------------------------------------------------
-//   slurp - read an entire file into a string
-export var slurp = (filepath, maxLines = undef) => {
-  var contents, lLines;
+//   slurp - read a file into a string
+export var slurp = (filepath, hOptions = {}) => {
+  var contents, format, lLines, maxLines;
+  ({maxLines, format} = getOptions(hOptions));
   if (defined(maxLines)) {
     lLines = [];
     forEachLineInFile(filepath, function(line, nLines) {
@@ -287,21 +372,38 @@ export var slurp = (filepath, maxLines = undef) => {
     filepath = filepath.replace(/\//g, "\\");
     contents = fs.readFileSync(filepath, 'utf8').toString();
   }
-  return contents;
+  switch (format) {
+    case 'TAML':
+      return fromTAML(contents);
+    case 'JSON':
+      return JSON.parse(contents);
+    default:
+      assert(notdefined(format), `Unknown format: ${format}`);
+      return contents;
+  }
 };
 
 // ---------------------------------------------------------------------------
 //   barf - write a string to a file
-export var barf = (filepath, contents) => {
-  if (isEmpty(contents)) {
-    return;
-  }
-  if (isArray(contents)) {
-    contents = toBlock(contents);
-  } else if (!isString(contents)) {
-    croak("barf(): Invalid contents");
+export var barf = (filepath, contents = '', hOptions = {}) => {
+  var format;
+  ({format} = getOptions(hOptions));
+  switch (format) {
+    case 'TAML':
+      contents = toTAML(contents);
+      break;
+    case 'JSON':
+      contents = JSON.stringify(contents, null, 3);
+      break;
+    default:
+      assert(notdefined(format), `Unknown format: ${format}`);
+      if (isArray(contents)) {
+        contents = toBlock(contents);
+      } else if (!isString(contents)) {
+        croak("barf(): Invalid contents");
+      }
+      contents = rtrim(contents) + "\n";
   }
-  contents = rtrim(contents) + "\n";
   fs.writeFileSync(filepath, contents, {
     encoding: 'utf8'
   });
@@ -333,8 +435,8 @@ export var removeFileWithExt = (path, newExt, hOptions = {}) => {
       LOG(`   unlink ${filename}`);
     }
     success = true;
-  } catch (error) {
-    err = error;
+  } catch (error1) {
+    err = error1;
     LOG(`   UNLINK FAILED: ${err.message}`);
     success = false;
   }
@@ -576,7 +678,7 @@ export var parseSource = (source) => {
 // ---------------------------------------------------------------------------
 //   slurpTAML - read TAML from a file
 export var slurpTAML = (filepath) => {
-  var contents;
-  contents = slurp(filepath);
-  return fromTAML(contents);
+  return slurp(filepath, {
+    format: 'TAML'
+  });
 };