@jdeighan/coffee-utils 10.0.11 → 10.0.14

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "10.0.11",
+	"version": "10.0.14",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {
@@ -22,6 +22,7 @@
 		"./placeholders": "./src/placeholders.js",
 		"./section": "./src/Section.js",
 		"./sectionmap": "./src/SectionMap.js",
+		"./fsa": "./src/fsa.js",
 		"./package.json": "./package.json"
 	},
 	"engines": {

package/src/block_utils.coffee

@@ -6,6 +6,7 @@ import readline from 'readline'
 import {assert, error, croak} from '@jdeighan/unit-tester/utils'
 import {
 	undef, pass, defined, isEmpty, isString, isArray, nonEmpty, rtrim,
+	escapeStr,
 	} from '@jdeighan/coffee-utils'
 
 # ---------------------------------------------------------------------------

package/src/block_utils.js

@@ -18,7 +18,8 @@ import {
   isString,
   isArray,
   nonEmpty,
-  rtrim
+  rtrim,
+  escapeStr
 } from '@jdeighan/coffee-utils';
 
 // ---------------------------------------------------------------------------

package/src/coffee_utils.coffee

@@ -21,6 +21,30 @@ export isComment = (line) ->
 
 # ---------------------------------------------------------------------------
 
+export chomp = (str) ->
+
+	len = str.length
+	if (len == 0)
+		return ''
+	else if (len == 1)
+		if (str == "\r") || (str == "\n")
+			return ''
+		else
+			return str
+	else
+		# --- check the last 2 characters
+		tail = str.substring(len-2)
+		if (tail == "\r\n")
+			return str.substring(0, len-2)
+		else
+			tail = str.substring(len-1)
+			if (tail == "\n")
+				return str.substring(0, len-1)
+			else
+				return str
+
+# ---------------------------------------------------------------------------
+
 export isSubclassOf = (subClass, superClass) ->
 
 	return (subClass == superClass) \
@@ -61,6 +85,12 @@ export charCount = (str, ch) ->
 
 # ---------------------------------------------------------------------------
 
+export oneof = (word, lWords...) ->
+
+	return (lWords.indexOf(word) >= 0)
+
+# ---------------------------------------------------------------------------
+
 export isConstructor = (f) ->
 
 	try
@@ -241,7 +271,10 @@ export pushCond = (lItems, item, doPush=notInArray) ->
 
 export words = (str) ->
 
-	return str.trim().split(/\s+/)
+	str = str.trim()
+	if (str == '')
+		return []
+	return str.split(/\s+/)
 
 # ---------------------------------------------------------------------------
 

package/src/coffee_utils.js

@@ -27,6 +27,34 @@ export var isComment = function(line) {
   return defined(lMatches);
 };
 
+// ---------------------------------------------------------------------------
+export var chomp = function(str) {
+  var len, tail;
+  len = str.length;
+  if (len === 0) {
+    return '';
+  } else if (len === 1) {
+    if ((str === "\r") || (str === "\n")) {
+      return '';
+    } else {
+      return str;
+    }
+  } else {
+    // --- check the last 2 characters
+    tail = str.substring(len - 2);
+    if (tail === "\r\n") {
+      return str.substring(0, len - 2);
+    } else {
+      tail = str.substring(len - 1);
+      if (tail === "\n") {
+        return str.substring(0, len - 1);
+      } else {
+        return str;
+      }
+    }
+  }
+};
+
 // ---------------------------------------------------------------------------
 export var isSubclassOf = function(subClass, superClass) {
   return (subClass === superClass) || (subClass.prototype instanceof superClass);
@@ -65,6 +93,11 @@ export var charCount = function(str, ch) {
   return count;
 };
 
+// ---------------------------------------------------------------------------
+export var oneof = function(word, ...lWords) {
+  return lWords.indexOf(word) >= 0;
+};
+
 // ---------------------------------------------------------------------------
 export var isConstructor = function(f) {
   var err;
@@ -168,13 +201,13 @@ export var isNonEmptyArray = function(x) {
 
 // ---------------------------------------------------------------------------
 export var isHash = function(x, lKeys) {
-  var i, key, len;
+  var i, key, len1;
   if (!x || (getClassName(x) !== 'Object')) {
     return false;
   }
   if (defined(lKeys)) {
     assert(isArray(lKeys), "isHash(): lKeys not an array");
-    for (i = 0, len = lKeys.length; i < len; i++) {
+    for (i = 0, len1 = lKeys.length; i < len1; i++) {
       key = lKeys[i];
       if (!x.hasOwnProperty(key)) {
         return false;
@@ -253,16 +286,20 @@ export var pushCond = function(lItems, item, doPush = notInArray) {
 
 // ---------------------------------------------------------------------------
 export var words = function(str) {
-  return str.trim().split(/\s+/);
+  str = str.trim();
+  if (str === '') {
+    return [];
+  }
+  return str.split(/\s+/);
 };
 
 // ---------------------------------------------------------------------------
 export var isArrayOfHashes = function(lItems) {
-  var i, item, len;
+  var i, item, len1;
   if (!isArray(lItems)) {
     return false;
   }
-  for (i = 0, len = lItems.length; i < len; i++) {
+  for (i = 0, len1 = lItems.length; i < len1; i++) {
     item = lItems[i];
     if (!isHash(item)) {
       return false;
@@ -273,11 +310,11 @@ export var isArrayOfHashes = function(lItems) {
 
 // ---------------------------------------------------------------------------
 export var isArrayOfStrings = function(lItems) {
-  var i, item, len;
+  var i, item, len1;
   if (!isArray(lItems)) {
     return false;
   }
-  for (i = 0, len = lItems.length; i < len; i++) {
+  for (i = 0, len1 = lItems.length; i < len1; i++) {
     item = lItems[i];
     if (!isString(item)) {
       return false;
@@ -336,7 +373,7 @@ export var isInteger = function(x, hOptions = {}) {
 
 // ---------------------------------------------------------------------------
 export var isUniqueList = function(lItems, func = undef) {
-  var h, i, item, len;
+  var h, i, item, len1;
   if (lItems == null) {
     return true; // empty list is unique
   }
@@ -344,7 +381,7 @@ export var isUniqueList = function(lItems, func = undef) {
     assert(isFunction(func), `Not a function: ${OL(func)}`);
   }
   h = {};
-  for (i = 0, len = lItems.length; i < len; i++) {
+  for (i = 0, len1 = lItems.length; i < len1; i++) {
     item = lItems[i];
     if (defined(func) && !func(item)) {
       return false;
@@ -359,14 +396,14 @@ export var isUniqueList = function(lItems, func = undef) {
 
 // ---------------------------------------------------------------------------
 export var isUniqueTree = function(lItems, func = undef, hFound = {}) {
-  var i, item, len;
+  var i, item, len1;
   if (isEmpty(lItems)) {
     return true; // empty list is unique
   }
   if (defined(func)) {
     assert(isFunction(func), `Not a function: ${OL(func)}`);
   }
-  for (i = 0, len = lItems.length; i < len; i++) {
+  for (i = 0, len1 = lItems.length; i < len1; i++) {
     item = lItems[i];
     if (isArray(item)) {
       if (!isUniqueTree(item, func, hFound)) {
@@ -483,10 +520,10 @@ export var escapeStr = function(str, hEscape = hDefEsc) {
   var ch, lParts;
   assert(isString(str), "escapeStr(): not a string");
   lParts = (function() {
-    var i, len, ref, results;
+    var i, len1, ref, results;
     ref = str.split('');
     results = [];
-    for (i = 0, len = ref.length; i < len; i++) {
+    for (i = 0, len1 = ref.length; i < len1; i++) {
       ch = ref[i];
       if (hEscape[ch] != null) {
         results.push(hEscape[ch]);
@@ -530,9 +567,9 @@ export var extractMatches = function(line, regexp, convertFunc = undef) {
   var lConverted, lStrings, str;
   lStrings = [...line.matchAll(regexp)];
   lStrings = (function() {
-    var i, len, results;
+    var i, len1, results;
     results = [];
-    for (i = 0, len = lStrings.length; i < len; i++) {
+    for (i = 0, len1 = lStrings.length; i < len1; i++) {
       str = lStrings[i];
       results.push(str[0]);
     }
@@ -540,9 +577,9 @@ export var extractMatches = function(line, regexp, convertFunc = undef) {
   })();
   if (convertFunc != null) {
     lConverted = (function() {
-      var i, len, results;
+      var i, len1, results;
       results = [];
-      for (i = 0, len = lStrings.length; i < len; i++) {
+      for (i = 0, len1 = lStrings.length; i < len1; i++) {
         str = lStrings[i];
         results.push(convertFunc(str));
       }
@@ -556,14 +593,14 @@ export var extractMatches = function(line, regexp, convertFunc = undef) {
 
 // ---------------------------------------------------------------------------
 export var envVarsWithPrefix = function(prefix, hOptions = {}) {
-  var h, i, key, len, plen, ref;
+  var h, i, key, len1, 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++) {
+  for (i = 0, len1 = ref.length; i < len1; i++) {
     key = ref[i];
     if (key.indexOf(prefix) === 0) {
       if (hOptions.stripPrefix) {
@@ -594,9 +631,9 @@ export var getDateStr = function(date = undef) {
 
 // ---------------------------------------------------------------------------
 export var strcat = function(...lItems) {
-  var i, item, len, str;
+  var i, item, len1, str;
   str = '';
-  for (i = 0, len = lItems.length; i < len; i++) {
+  for (i = 0, len1 = lItems.length; i < len1; i++) {
     item = lItems[i];
     str += item.toString();
   }

package/src/fsa.coffee

@@ -0,0 +1,83 @@
+# fsa.coffee
+
+import {assert, croak} from '@jdeighan/unit-tester/utils'
+import {
+	undef, defined, notdefined, words, isEmpty, nonEmpty,
+	isString, OL,
+	} from '@jdeighan/coffee-utils'
+import {toArray} from '@jdeighan/coffee-utils/block'
+import {LOG} from '@jdeighan/coffee-utils/log'
+import {debug} from '@jdeighan/coffee-utils/debug'
+
+# ---------------------------------------------------------------------------
+
+export class FSA
+
+	constructor: (block) ->
+
+		debug "enter FSA()"
+		assert isString(block), "block not a string"
+		@hTransitions = {}
+		lLines = toArray(block, 'noEmptyLines')
+		debug 'lLines', lLines
+		for line,i in lLines
+			debug "LINE #{i}", line
+			lWords = words(line)
+			if (lWords.length == 3)
+				[bState, token, eState] = lWords
+				output = undef
+			else if (lWords.length == 4)
+				[bState, token, eState, output] = lWords
+			else
+				croak "Invalid desc: #{OL(line)}"
+			debug "LINE #{i}: #{OL(bState)} #{OL(token)} #{OL(eState)} #{OL(output)}"
+			assert nonEmpty(eState), "Invalid FSA description #{i}"
+
+			# --- tokens may be quoted (but may not contain whitespace),
+			#     but the quotes are stripped
+			if (i == 0)
+				assert (bState == 'start'), "Invalid FSA description #{i}"
+			token = @fixToken(token)
+			debug 'token', token
+			if isEmpty(output)
+				output = undef
+			hTrans = @hTransitions[bState]
+			if notdefined(hTrans)
+				hTrans = @hTransitions[bState] = {}
+			assert notdefined(hTrans[token]), "Duplicate transition"
+			hTrans[token] = [eState, output]
+		debug 'hTransitions', @hTransitions
+		@curState = 'start'
+		debug "return from FSA()"
+
+	# ..........................................................
+
+	fixToken: (token) ->
+
+		if lMatches = token.match(/^\'(.*)\'$/)
+			return lMatches[1]
+		else if lMatches = token.match(/^\"(.*)\"$/)
+			return lMatches[1]
+		else
+			return token
+
+	# ..........................................................
+
+	got: (token) ->
+		# --- returns pair [newState, output]
+
+		hTrans = @hTransitions[@curState]
+		if notdefined(hTrans)
+			return [undef, undef]
+		result = hTrans[token]
+		if notdefined(result)
+			return [undef, undef]
+		[newState, output] = result
+		assert nonEmpty(newState), "Failed: #{@curState} -> #{token}"
+		@curState = newState
+		return result
+
+	# ..........................................................
+
+	state: () ->
+		return @curState

package/src/fsa.js

@@ -0,0 +1,111 @@
+// Generated by CoffeeScript 2.7.0
+  // fsa.coffee
+import {
+  assert,
+  croak
+} from '@jdeighan/unit-tester/utils';
+
+import {
+  undef,
+  defined,
+  notdefined,
+  words,
+  isEmpty,
+  nonEmpty,
+  isString,
+  OL
+} from '@jdeighan/coffee-utils';
+
+import {
+  toArray
+} from '@jdeighan/coffee-utils/block';
+
+import {
+  LOG
+} from '@jdeighan/coffee-utils/log';
+
+import {
+  debug
+} from '@jdeighan/coffee-utils/debug';
+
+// ---------------------------------------------------------------------------
+export var FSA = class FSA {
+  constructor(block) {
+    var bState, eState, hTrans, i, j, lLines, lWords, len, line, output, token;
+    debug("enter FSA()");
+    assert(isString(block), "block not a string");
+    this.hTransitions = {};
+    lLines = toArray(block, 'noEmptyLines');
+    debug('lLines', lLines);
+    for (i = j = 0, len = lLines.length; j < len; i = ++j) {
+      line = lLines[i];
+      debug(`LINE ${i}`, line);
+      lWords = words(line);
+      if (lWords.length === 3) {
+        [bState, token, eState] = lWords;
+        output = undef;
+      } else if (lWords.length === 4) {
+        [bState, token, eState, output] = lWords;
+      } else {
+        croak(`Invalid desc: ${OL(line)}`);
+      }
+      debug(`LINE ${i}: ${OL(bState)} ${OL(token)} ${OL(eState)} ${OL(output)}`);
+      assert(nonEmpty(eState), `Invalid FSA description ${i}`);
+      // --- tokens may be quoted (but may not contain whitespace),
+      //     but the quotes are stripped
+      if (i === 0) {
+        assert(bState === 'start', `Invalid FSA description ${i}`);
+      }
+      token = this.fixToken(token);
+      debug('token', token);
+      if (isEmpty(output)) {
+        output = undef;
+      }
+      hTrans = this.hTransitions[bState];
+      if (notdefined(hTrans)) {
+        hTrans = this.hTransitions[bState] = {};
+      }
+      assert(notdefined(hTrans[token]), "Duplicate transition");
+      hTrans[token] = [eState, output];
+    }
+    debug('hTransitions', this.hTransitions);
+    this.curState = 'start';
+    debug("return from FSA()");
+  }
+
+  // ..........................................................
+  fixToken(token) {
+    var lMatches;
+    if (lMatches = token.match(/^\'(.*)\'$/)) {
+      return lMatches[1];
+    } else if (lMatches = token.match(/^\"(.*)\"$/)) {
+      return lMatches[1];
+    } else {
+      return token;
+    }
+  }
+
+  // ..........................................................
+  got(token) {
+    var hTrans, newState, output, result;
+    // --- returns pair [newState, output]
+    hTrans = this.hTransitions[this.curState];
+    if (notdefined(hTrans)) {
+      return [undef, undef];
+    }
+    result = hTrans[token];
+    if (notdefined(result)) {
+      return [undef, undef];
+    }
+    [newState, output] = result;
+    assert(nonEmpty(newState), `Failed: ${this.curState} -> ${token}`);
+    this.curState = newState;
+    return result;
+  }
+
+  // ..........................................................
+  state() {
+    return this.curState;
+  }
+
+};

package/src/log_utils.coffee

@@ -173,7 +173,10 @@ export logItem = (label, item, pre='', itemPre=undef) ->
 		LOG "pre = #{OL(pre)}"
 		LOG "itemPre = #{OL(itemPre)}"
 
-	labelStr = if label then "#{label} = " else ""
+	if label
+		labelStr = "#{label} = "
+	else
+		labelStr = ""
 
 	if (item == undef)
 		putstr "#{pre}#{labelStr}undef"

package/src/log_utils.js

@@ -198,7 +198,11 @@ export var logItem = function(label, item, pre = '', itemPre = undef) {
     LOG(`pre = ${OL(pre)}`);
     LOG(`itemPre = ${OL(itemPre)}`);
   }
-  labelStr = label ? `${label} = ` : "";
+  if (label) {
+    labelStr = `${label} = `;
+  } else {
+    labelStr = "";
+  }
   if (item === undef) {
     putstr(`${pre}${labelStr}undef`);
   } else if (item === null) {

package/src/taml.coffee

@@ -4,7 +4,7 @@ import yaml from 'js-yaml'
 
 import {assert, error, croak} from '@jdeighan/unit-tester/utils'
 import {
-	undef, oneline, isString,
+	undef, oneline, isString, chomp,
 	} from '@jdeighan/coffee-utils'
 import {untabify, tabify, splitLine} from '@jdeighan/coffee-utils/indent'
 import {slurp} from '@jdeighan/coffee-utils/fs'
@@ -58,6 +58,19 @@ export taml = (text) ->
 	debug "return from taml()"
 	return yaml.load(arrayToBlock(lLines), {skipInvalid: true})
 
+# ---------------------------------------------------------------------------
+
+export fromTAML = taml
+
+# ---------------------------------------------------------------------------
+
+export toTAML = (x, useTabs=false) ->
+
+	str = yaml.dump(x, {indent:3})
+	if useTabs
+		str = str.replace(/   /g, "\t")
+	return "---\n" + chomp(str)
+
 # ---------------------------------------------------------------------------
 #   slurpTAML - read TAML from a file
 

package/src/taml.js

@@ -13,7 +13,8 @@ import {
 import {
   undef,
   oneline,
-  isString
+  isString,
+  chomp
 } from '@jdeighan/coffee-utils';
 
 import {
@@ -84,6 +85,21 @@ export var taml = function(text) {
   });
 };
 
+// ---------------------------------------------------------------------------
+export var fromTAML = taml;
+
+// ---------------------------------------------------------------------------
+export var toTAML = function(x, useTabs = false) {
+  var str;
+  str = yaml.dump(x, {
+    indent: 3
+  });
+  if (useTabs) {
+    str = str.replace(/   /g, "\t");
+  }
+  return "---\n" + chomp(str);
+};
+
 // ---------------------------------------------------------------------------
 //   slurpTAML - read TAML from a file
 export var slurpTAML = function(filepath) {