@jdeighan/coffee-utils 4.1.34 → 5.0.1

package/src/log_utils.coffee

@@ -3,82 +3,81 @@
 import yaml from 'js-yaml'
 
 import {
-	assert, undef, isNumber, isString, isHash, isFunction,
+	assert, undef, isNumber, isInteger, isString, isHash, isFunction,
 	escapeStr, sep_eq,
 	} from '@jdeighan/coffee-utils'
 import {blockToArray} from '@jdeighan/coffee-utils/block'
-import {tabify} from '@jdeighan/coffee-utils/indent'
+import {tabify, untabify} from '@jdeighan/coffee-utils/indent'
 
 # --- This logger only ever gets passed a single string argument
-logger = console.log          # for strings
+logger = undef
+export stringify = undef
+export id = 42
+
+# ---------------------------------------------------------------------------
+
+export setStringifier = (func) ->
+
+	orgStringifier = stringify
+	assert isFunction(func), "setStringifier() arg is not a function"
+	stringify = func
+	return orgStringifier
+
+# ---------------------------------------------------------------------------
+
+export resetStringifier = () ->
+
+	setStringifier orderedStringify
 
 # ---------------------------------------------------------------------------
 
 export setLogger = (func) ->
 
 	orgLogger = logger
-	if func?
-		assert isFunction(func), "setLogger() not a function"
-		logger = func
-	else
-		logger = console.log
+	assert isFunction(func), "setLogger() arg is not a function"
+	logger = func
 	return orgLogger
 
 # ---------------------------------------------------------------------------
 
-export tamlStringify = (obj) ->
+export resetLogger = () ->
+
+	setLogger console.log
+
+# ---------------------------------------------------------------------------
+
+escReplacer = (name, value) ->
+
+	if ! isString(value)
+		return value
+	return escapeStr(value)
+
+# ---------------------------------------------------------------------------
+
+export tamlStringify = (obj, escape=false) ->
 
 	str = yaml.dump(obj, {
 		skipInvalid: true
 		indent: 1
 		sortKeys: false
 		lineWidth: -1
+		replacer: if escape then escReplacer else (name,value) -> value
 		})
-	str = "---\n" + tabify(str)
-	str = str.replace(/\t/g, '   ')  # fr***ing Windows Terminal
-	return str
+	return "---\n" + tabify(str, 1)
 
 # ---------------------------------------------------------------------------
-# the default stringifier
 
-export orderedStringify = (obj) ->
+export orderedStringify = (obj, escape=false) ->
 
 	str = yaml.dump(obj, {
 		skipInvalid: true
 		indent: 1
 		sortKeys: true
 		lineWidth: -1
+		replacer: if escape then escReplacer else (name,value) -> value
 		})
-	str = "---\n" + tabify(str)
-	str = str.replace(/\t/g, '   ')  # fr***ing Windows Terminal
-	return str
-
-# ---------------------------------------------------------------------------
-
-export stringify = orderedStringify # for non-strings
-
-# ---------------------------------------------------------------------------
 
-export setStringifier = (func) ->
-
-	if func?
-		assert isFunction(func), "setStringifier() not a function"
-		stringify = func
-	else
-		stringify = orderedStringify
-	return
-
-# ---------------------------------------------------------------------------
-
-export currentLogger = () ->
-
-	return logger
-
-# ---------------------------------------------------------------------------
-
-export currentStringifier = () ->
-
-	return stringify
+	return "---\n" + tabify(str, 1)
 
 # ---------------------------------------------------------------------------
 
@@ -86,67 +85,60 @@ maxOneLine = 32
 
 # ---------------------------------------------------------------------------
 
-export log = (lArgs...) ->
-	# --- (str, item, hOptions)
-	#     valid options:
-	#        logItem
+export log = (item, hOptions=undef) ->
+	# --- valid options:
+	#        label
 	#        prefix
-	#        itemPrefix
-
-	if (lArgs.length==0)
-		return
-	str = lArgs[0]
-	switch lArgs.length
-		when 1
-			logItem = false
-		when 2
-			item = lArgs[1]
-			logItem = true
-		else
-			item = lArgs[1]      # might not be logged, though
-			hOptions = lArgs[2]
-			assert isHash(hOptions), "log(): 3rd arg must be a hash"
-			if hOptions.logItem?
-				logItem = hOptions.logItem
+	#        escape
 
+	assert isFunction(logger), "logger not properly set"
+	prefix = itemPrefix = label = ''
 	if hOptions?
-		if hOptions.prefix?
-			prefix = hOptions.prefix
+		if isString(hOptions)
+			label = hOptions
 		else
-			prefix = ''
-
-		if hOptions.itemPrefix?
-			itemPrefix = hOptions.itemPrefix
+			assert isHash(hOptions), "log(): 2nd arg must be a string or hash"
+			if hOptions.prefix?
+				prefix = hOptions.prefix
+			if hOptions.itemPrefix?
+				itemPrefix = hOptions.itemPrefix
+			else
+				itemPrefix = prefix
+			if hOptions.label?
+				label = hOptions.label
+
+	if isString(item) && (label == '')
+		if hOptions? && hOptions.escape
+			logger "#{prefix}#{escapeStr(item)}"
 		else
-			itemPrefix = ''
-	else
-		prefix = itemPrefix = ''
+			logger "#{prefix}#{item}"
+		return
 
-	if (! logItem)
-		logger "#{prefix}#{str}"
-	else if ! item?
-		logger "#{prefix}#{str} = undef"
-	else if isNumber(item)
-		logger "#{prefix}#{str} = #{item}"
+	if (label == '')
+		label = 'ITEM'
+
+	if (item == undef)
+		logger "#{prefix}#{label} = undef"
 	else if isString(item)
-		esc = escapeStr(item)
-		if (esc.length <= maxOneLine)
-			logger "#{prefix}#{str} = '#{esc}'"
+		if (item.length <= maxOneLine)
+			logger "#{prefix}#{label} = '#{escapeStr(item)}'"
 		else
-			logger "#{prefix}#{str}:"
+			logger "#{prefix}#{label}:"
 			logger "#{itemPrefix}#{sep_eq}"
 			for line in blockToArray(item)
 				logger "#{itemPrefix}#{escapeStr(line)}"
 			logger "#{itemPrefix}#{sep_eq}"
+	else if isNumber(item)
+		logger "#{prefix}#{label} = #{item}"
 	else
-		# --- It's some type of object
-		json = JSON.stringify(item)
-		if (json.length <= maxOneLine)
-			logger "#{prefix}#{str} = #{json}"
-		else
-			logger "#{prefix}#{str}:"
-			for str in blockToArray(stringify(item))
-				logger "#{itemPrefix}   #{str}"
+		logger "#{prefix}#{label}:"
+		for str in blockToArray(stringify(item, true))
+			logger "#{itemPrefix}\t#{str}"
 	return
 
 # ---------------------------------------------------------------------------
+
+if ! loaded
+	setStringifier orderedStringify
+	resetLogger()
+loaded = true

package/src/log_utils.js

@@ -1,6 +1,6 @@
 // Generated by CoffeeScript 2.6.1
 // log_utils.coffee
-var logger, maxOneLine;
+var escReplacer, loaded, logger, maxOneLine;
 
 import yaml from 'js-yaml';
 
@@ -8,6 +8,7 @@ import {
   assert,
   undef,
   isNumber,
+  isInteger,
   isString,
   isHash,
   isFunction,
@@ -20,136 +21,131 @@ import {
 } from '@jdeighan/coffee-utils/block';
 
 import {
-  tabify
+  tabify,
+  untabify
 } from '@jdeighan/coffee-utils/indent';
 
 // --- This logger only ever gets passed a single string argument
-logger = console.log; // for strings
+logger = undef;
 
+export var stringify = undef;
+
+export var id = 42;
+
+// ---------------------------------------------------------------------------
+export var setStringifier = function(func) {
+  var orgStringifier;
+  orgStringifier = stringify;
+  assert(isFunction(func), "setStringifier() arg is not a function");
+  stringify = func;
+  return orgStringifier;
+};
+
+// ---------------------------------------------------------------------------
+export var resetStringifier = function() {
+  return setStringifier(orderedStringify);
+};
 
 // ---------------------------------------------------------------------------
 export var setLogger = function(func) {
   var orgLogger;
   orgLogger = logger;
-  if (func != null) {
-    assert(isFunction(func), "setLogger() not a function");
-    logger = func;
-  } else {
-    logger = console.log;
-  }
+  assert(isFunction(func), "setLogger() arg is not a function");
+  logger = func;
   return orgLogger;
 };
 
 // ---------------------------------------------------------------------------
-export var tamlStringify = function(obj) {
+export var resetLogger = function() {
+  return setLogger(console.log);
+};
+
+// ---------------------------------------------------------------------------
+escReplacer = function(name, value) {
+  if (!isString(value)) {
+    return value;
+  }
+  return escapeStr(value);
+};
+
+// ---------------------------------------------------------------------------
+export var tamlStringify = function(obj, escape = false) {
   var str;
   str = yaml.dump(obj, {
     skipInvalid: true,
     indent: 1,
     sortKeys: false,
-    lineWidth: -1
+    lineWidth: -1,
+    replacer: escape ? escReplacer : function(name, value) {
+      return value;
+    }
   });
-  str = "---\n" + tabify(str);
-  str = str.replace(/\t/g, '   '); // fr***ing Windows Terminal
-  return str;
+  return "---\n" + tabify(str, 1);
 };
 
 // ---------------------------------------------------------------------------
-// the default stringifier
-export var orderedStringify = function(obj) {
+export var orderedStringify = function(obj, escape = false) {
   var str;
   str = yaml.dump(obj, {
     skipInvalid: true,
     indent: 1,
     sortKeys: true,
-    lineWidth: -1
+    lineWidth: -1,
+    replacer: escape ? escReplacer : function(name, value) {
+      return value;
+    }
   });
-  str = "---\n" + tabify(str);
-  str = str.replace(/\t/g, '   '); // fr***ing Windows Terminal
-  return str;
-};
-
-// ---------------------------------------------------------------------------
-export var stringify = orderedStringify; // for non-strings
-
-
-// ---------------------------------------------------------------------------
-export var setStringifier = function(func) {
-  if (func != null) {
-    assert(isFunction(func), "setStringifier() not a function");
-    stringify = func;
-  } else {
-    stringify = orderedStringify;
-  }
-};
-
-// ---------------------------------------------------------------------------
-export var currentLogger = function() {
-  return logger;
-};
-
-// ---------------------------------------------------------------------------
-export var currentStringifier = function() {
-  return stringify;
+  return "---\n" + tabify(str, 1);
 };
 
 // ---------------------------------------------------------------------------
 maxOneLine = 32;
 
 // ---------------------------------------------------------------------------
-export var log = function(...lArgs) {
-  var esc, hOptions, i, item, itemPrefix, j, json, len, len1, line, logItem, prefix, ref, ref1, str;
-  // --- (str, item, hOptions)
-  //     valid options:
-  //        logItem
+export var log = function(item, hOptions = undef) {
+  var i, itemPrefix, j, label, len, len1, line, prefix, ref, ref1, str;
+  // --- valid options:
+  //        label
   //        prefix
-  //        itemPrefix
-  if (lArgs.length === 0) {
-    return;
-  }
-  str = lArgs[0];
-  switch (lArgs.length) {
-    case 1:
-      logItem = false;
-      break;
-    case 2:
-      item = lArgs[1];
-      logItem = true;
-      break;
-    default:
-      item = lArgs[1];
-      hOptions = lArgs[2];
-      assert(isHash(hOptions), "log(): 3rd arg must be a hash");
-      if (hOptions.logItem != null) {
-        logItem = hOptions.logItem;
-      }
-  }
+  //        escape
+  assert(isFunction(logger), "logger not properly set");
+  prefix = itemPrefix = label = '';
   if (hOptions != null) {
-    if (hOptions.prefix != null) {
-      prefix = hOptions.prefix;
+    if (isString(hOptions)) {
+      label = hOptions;
     } else {
-      prefix = '';
+      assert(isHash(hOptions), "log(): 2nd arg must be a string or hash");
+      if (hOptions.prefix != null) {
+        prefix = hOptions.prefix;
+      }
+      if (hOptions.itemPrefix != null) {
+        itemPrefix = hOptions.itemPrefix;
+      } else {
+        itemPrefix = prefix;
+      }
+      if (hOptions.label != null) {
+        label = hOptions.label;
+      }
     }
-    if (hOptions.itemPrefix != null) {
-      itemPrefix = hOptions.itemPrefix;
+  }
+  if (isString(item) && (label === '')) {
+    if ((hOptions != null) && hOptions.escape) {
+      logger(`${prefix}${escapeStr(item)}`);
     } else {
-      itemPrefix = '';
+      logger(`${prefix}${item}`);
     }
-  } else {
-    prefix = itemPrefix = '';
+    return;
   }
-  if (!logItem) {
-    logger(`${prefix}${str}`);
-  } else if (item == null) {
-    logger(`${prefix}${str} = undef`);
-  } else if (isNumber(item)) {
-    logger(`${prefix}${str} = ${item}`);
+  if (label === '') {
+    label = 'ITEM';
+  }
+  if (item === undef) {
+    logger(`${prefix}${label} = undef`);
   } else if (isString(item)) {
-    esc = escapeStr(item);
-    if (esc.length <= maxOneLine) {
-      logger(`${prefix}${str} = '${esc}'`);
+    if (item.length <= maxOneLine) {
+      logger(`${prefix}${label} = '${escapeStr(item)}'`);
     } else {
-      logger(`${prefix}${str}:`);
+      logger(`${prefix}${label}:`);
       logger(`${itemPrefix}${sep_eq}`);
       ref = blockToArray(item);
       for (i = 0, len = ref.length; i < len; i++) {
@@ -158,20 +154,21 @@ export var log = function(...lArgs) {
       }
       logger(`${itemPrefix}${sep_eq}`);
     }
+  } else if (isNumber(item)) {
+    logger(`${prefix}${label} = ${item}`);
   } else {
-    // --- It's some type of object
-    json = JSON.stringify(item);
-    if (json.length <= maxOneLine) {
-      logger(`${prefix}${str} = ${json}`);
-    } else {
-      logger(`${prefix}${str}:`);
-      ref1 = blockToArray(stringify(item));
-      for (j = 0, len1 = ref1.length; j < len1; j++) {
-        str = ref1[j];
-        logger(`${itemPrefix}   ${str}`);
-      }
+    logger(`${prefix}${label}:`);
+    ref1 = blockToArray(stringify(item, true));
+    for (j = 0, len1 = ref1.length; j < len1; j++) {
+      str = ref1[j];
+      logger(`${itemPrefix}\t${str}`);
     }
   }
 };
 
-// ---------------------------------------------------------------------------
+if (!loaded) {
+  setStringifier(orderedStringify);
+  resetLogger();
+}
+
+loaded = true;