@jdeighan/coffee-utils 8.0.4 → 8.0.5

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jdeighan/coffee-utils",
 	"type": "module",
-	"version": "8.0.4",
+	"version": "8.0.5",
 	"description": "A set of utility functions for CoffeeScript",
 	"main": "coffee_utils.js",
 	"exports": {

package/src/Section.coffee

@@ -10,7 +10,7 @@ import {indented} from '@jdeighan/coffee-utils/indent'
 
 export class Section
 
-	constructor: () ->
+	constructor: (@name) ->
 
 		@lLines = []
 

package/src/Section.js

@@ -19,7 +19,8 @@ import {
 
 // ---------------------------------------------------------------------------
 export var Section = class Section {
-  constructor() {
+  constructor(name) {
+    this.name = name;
     this.lLines = [];
   }
 

package/src/SectionMap.coffee

@@ -5,6 +5,7 @@ import {
 	isString, isHash, isArray, isUniqueTree, isNonEmptyString,
 	} from '@jdeighan/coffee-utils'
 import {arrayToBlock} from '@jdeighan/coffee-utils/block'
+import {indented} from '@jdeighan/coffee-utils/indent'
 import {debug} from '@jdeighan/coffee-utils/debug'
 import {Section} from '@jdeighan/coffee-utils/section'
 
@@ -12,110 +13,125 @@ import {Section} from '@jdeighan/coffee-utils/section'
 
 isSectionName = (name) ->
 
-	assert isString(name), "not a string"
-	return name.match(/^[a-z][a-z0-9]*/)
+	return isString(name) && name.match(/^[a-z][a-z0-9]*/)
 
 # ---------------------------------------------------------------------------
 
 isSetName = (name) ->
 
-	assert isString(name), "not a string"
-	return name.match(/^[A-Z][a-z0-9]*/)
+	return isString(name) && name.match(/^[A-Z][a-z0-9]*/)
 
 # ---------------------------------------------------------------------------
 
 export class SectionMap
 
-	constructor: (lSections) ->
-		# --- lSections is a tree of section names
+	constructor: (lSectionTree) ->
+		# --- lSectionTree is a tree of section names
 
-		debug "enter SectionMap()", lSections
-		@lSections = lSections   # a tree of section names
+		debug "enter SectionMap()", lSectionTree
+		@lSectionTree = lSectionTree   # a tree of section names
 		@hSets = {}
 		@hSections = {}
-		@addSections lSections
+		@addSections lSectionTree
 		debug "return from SectionMap()", @hSections
 
 	# ..........................................................
 
-	# --- TODO: Allow array to start with a set name ---
-
 	addSections: (desc) ->
+		# --- returns a flat array of sections that were added
 
 		if isString(desc)
 			assert nonEmpty(desc), "empty section name"
-			assert desc.match(/^[a-z][a-z0-9]*$/), "bad section name #{OL(desc)}"
+			assert isSectionName(desc), "bad section name #{OL(desc)}"
 			assert (@hSections[desc] == undef), "duplicate section #{OL(desc)}"
-			@hSections[desc] = new Section()
+			@hSections[desc] = new Section(desc)
+			return [desc]
 		else
 			assert isArray(desc), "not an array or string #{OL(desc)}"
-			for item in desc
-				@addSections item
-		return
-
-	# ..........................................................
-	# --- a generator - yield order is not guaranteed
-
-	allSections: (desc) ->
-
-		debug "enter allSections()"
-		if (desc == undef)
-			# --- We want to return all sections
-			debug "yield all sections"
-			for _,sect of @hSections
-				yield sect
-		else if isString(desc)
-			if isSectionName(desc)
-				debug "yield section #{OL(desc)}"
-				yield @section(desc)
-			else if isSetName(desc)
-				debug "expand set #{OL(desc)}"
-				debug 'hSets', @hSets
-				lNames = @hSets[desc]
-				assert defined(lNames), "no set named #{OL(desc)}"
-				debug "set #{desc}", lNames
-				for name in lNames
-					debug "yield section #{OL(desc)}"
-					yield @section(name)
-			else
-				croak "bad name #{OL(desc)}"
-		else
-			assert isArray(desc), "not an array"
-			for name in desc
-				debug "yield section #{OL(name)}"
-				assert isString(name), "not a string #{OL(name)}"
-				if isSectionName(name)
-					yield @section(name)
-				else if isSetName(name)
-					for _,sect of @hSets[name]
-						yield sect
+			name = undef
+			lParts = []
+			for item,i in desc
+				if (i==0) && isSetName(item)
+					name = item
 				else
-					croak "bad name #{OL(name)}"
-		debug "return from allSections()"
+					lAdded = @addSections item
+					for item in lAdded
+						lParts.push item
+			if defined(name)
+				@addSet name, lParts
+			return lParts
 		return
 
 	# ..........................................................
 
-	addSet: (name, lSections) ->
+	addSet: (name, lSectionTree) ->
 
-		debug "enter addSet()", name, lSections
+		debug "enter addSet()", name, lSectionTree
 
 		# --- check the name
 		assert isSetName(name), "not a valid set name #{OL(name)}"
 
-		# --- check lSections
-		assert isArray(lSections), "arg 2 not an array"
-		for secName in lSections
+		# --- check lSectionTree
+		assert isArray(lSectionTree), "arg 2 not an array"
+		for secName in lSectionTree
 			assert isNonEmptyString(secName),
 					"not a non-empty string #{OL(secName)}"
 			assert defined(@hSections[secName]),
 					"not a section name #{OL(secName)}"
 
-		@hSets[name] = lSections
+		@hSets[name] = lSectionTree
 		debug 'hSets', @hSets
 		debug "return from addSet()"
 		return
 
+	# ..........................................................
+	# --- sections returned in depth-first order from section tree
+	#     Set names are simply skipped
+	#     yields: [<level>, <section>]
+
+	allSections: (desc=undef, level=0) ->
+
+		debug "enter allSections()", desc, level
+		if (desc == undef)
+			desc = @lSectionTree
+		if isArray(desc)
+			for item in desc
+				if isSectionName(item)
+					result = [level, @section(item)]
+					debug 'yield', result
+					yield result
+				else if isSetName(item)
+					pass
+				else
+					assert isArray(item), "not an array #{OL(item)}"
+					yield from @allSections(item, level+1)
+		else if isSectionName(desc)
+			result = [level, @section(desc)]
+			debug 'yield', result
+			yield result
+		else if isSetName(desc)
+			lTree = @hSets[desc]
+			assert defined(lTree), "Not a Set: #{OL(desc)}"
+			yield from @allSections(lTree, level)
+		else
+			croak "Bad item: #{OL(desc)}"
+		debug "return from allSections()"
+		return
+
+	# ..........................................................
+
+	getBlock: () ->
+
+		debug "enter getBlock()"
+		lParts = []
+		for [_, sect] from @allSections()
+			if sect.nonEmpty()
+				lParts.push sect.getBlock()
+		debug 'lParts', lParts
+		result = arrayToBlock(lParts)
+		debug "return from getBlock()", result
+		return result
+
 	# ..........................................................
 
 	section: (name) ->
@@ -129,27 +145,27 @@ export class SectionMap
 	firstSection: (name) ->
 
 		assert isSetName(name), "bad set name #{OL(name)}"
-		lSections = @hSets[name]
-		assert defined(lSections), "no such set #{OL(name)}"
-		assert nonEmpty(lSections), "empty section #{OL(name)}"
-		return @section(lSections[0])
+		lSectionTree = @hSets[name]
+		assert defined(lSectionTree), "no such set #{OL(name)}"
+		assert nonEmpty(lSectionTree), "empty section #{OL(name)}"
+		return @section(lSectionTree[0])
 
 	# ..........................................................
 
 	lastSection: (name) ->
 
 		assert isSetName(name), "bad set name #{OL(name)}"
-		lSections = @hSets[name]
-		assert defined(lSections), "no such set #{OL(name)}"
-		assert nonEmpty(lSections), "empty section #{OL(name)}"
-		return @section(lSections[lSections.length - 1])
+		lSectionTree = @hSets[name]
+		assert defined(lSectionTree), "no such set #{OL(name)}"
+		assert nonEmpty(lSectionTree), "empty section #{OL(name)}"
+		return @section(lSectionTree[lSectionTree.length - 1])
 
 	# ..........................................................
 
 	length: (desc=undef) ->
 
 		result = 0
-		for sect from @allSections(desc)
+		for [_, sect] from @allSections(desc)
 			result += sect.length()
 		return result
 
@@ -169,7 +185,7 @@ export class SectionMap
 
 	indent: (desc=undef, level=1) ->
 
-		for sect from @allSections(desc)
+		for [_, sect] from @allSections(desc)
 			sect.indent(level)
 		return
 
@@ -194,28 +210,12 @@ export class SectionMap
 
 	# ..........................................................
 
-	getBlock: () ->
+	getShape: () ->
 
-		debug "enter getBlock()"
-		@lAllBlocks = []
-		debug 'lSections', @lSections
-		@accumBlock @lSections
-		debug 'lAllBlocks', @lAllBlocks
-		result = arrayToBlock(@lAllBlocks)
-		debug "return from getBlock()", result
+		debug "enter getShape()"
+		lParts = []
+		for [level, sect] from @allSections()
+			lParts.push indented(sect.name, level)
+		result = arrayToBlock(lParts)
+		debug "return from getShape()", result
 		return result
-
-	# ..........................................................
-
-	accumBlock: (tree) ->
-
-		if isString(tree)
-			debug "accumBlock #{OL(tree)}"
-			block = @section(tree).getBlock()
-			if nonEmpty(block)
-				@lAllBlocks.push block
-		else
-			assert isArray(tree), "not an array"
-			for subtree in tree
-				@accumBlock subtree
-		return

package/src/SectionMap.js

@@ -22,6 +22,10 @@ import {
   arrayToBlock
 } from '@jdeighan/coffee-utils/block';
 
+import {
+  indented
+} from '@jdeighan/coffee-utils/indent';
+
 import {
   debug
 } from '@jdeighan/coffee-utils/debug';
@@ -32,116 +36,131 @@ import {
 
 // ---------------------------------------------------------------------------
 isSectionName = function(name) {
-  assert(isString(name), "not a string");
-  return name.match(/^[a-z][a-z0-9]*/);
+  return isString(name) && name.match(/^[a-z][a-z0-9]*/);
 };
 
 // ---------------------------------------------------------------------------
 isSetName = function(name) {
-  assert(isString(name), "not a string");
-  return name.match(/^[A-Z][a-z0-9]*/);
+  return isString(name) && name.match(/^[A-Z][a-z0-9]*/);
 };
 
 // ---------------------------------------------------------------------------
 export var SectionMap = class SectionMap {
-  constructor(lSections) {
-    // --- lSections is a tree of section names
-    debug("enter SectionMap()", lSections);
-    this.lSections = lSections; // a tree of section names
+  constructor(lSectionTree) {
+    // --- lSectionTree is a tree of section names
+    debug("enter SectionMap()", lSectionTree);
+    this.lSectionTree = lSectionTree; // a tree of section names
     this.hSets = {};
     this.hSections = {};
-    this.addSections(lSections);
+    this.addSections(lSectionTree);
     debug("return from SectionMap()", this.hSections);
   }
 
   // ..........................................................
-
-    // --- TODO: Allow array to start with a set name ---
   addSections(desc) {
-    var i, item, len;
+    var i, item, j, k, lAdded, lParts, len, len1, name;
+    // --- returns a flat array of sections that were added
     if (isString(desc)) {
       assert(nonEmpty(desc), "empty section name");
-      assert(desc.match(/^[a-z][a-z0-9]*$/), `bad section name ${OL(desc)}`);
+      assert(isSectionName(desc), `bad section name ${OL(desc)}`);
       assert(this.hSections[desc] === undef, `duplicate section ${OL(desc)}`);
-      this.hSections[desc] = new Section();
+      this.hSections[desc] = new Section(desc);
+      return [desc];
     } else {
       assert(isArray(desc), `not an array or string ${OL(desc)}`);
-      for (i = 0, len = desc.length; i < len; i++) {
+      name = undef;
+      lParts = [];
+      for (i = j = 0, len = desc.length; j < len; i = ++j) {
         item = desc[i];
-        this.addSections(item);
+        if ((i === 0) && isSetName(item)) {
+          name = item;
+        } else {
+          lAdded = this.addSections(item);
+          for (k = 0, len1 = lAdded.length; k < len1; k++) {
+            item = lAdded[k];
+            lParts.push(item);
+          }
+        }
       }
+      if (defined(name)) {
+        this.addSet(name, lParts);
+      }
+      return lParts;
+    }
+  }
+
+  // ..........................................................
+  addSet(name, lSectionTree) {
+    var j, len, secName;
+    debug("enter addSet()", name, lSectionTree);
+    // --- check the name
+    assert(isSetName(name), `not a valid set name ${OL(name)}`);
+    // --- check lSectionTree
+    assert(isArray(lSectionTree), "arg 2 not an array");
+    for (j = 0, len = lSectionTree.length; j < len; j++) {
+      secName = lSectionTree[j];
+      assert(isNonEmptyString(secName), `not a non-empty string ${OL(secName)}`);
+      assert(defined(this.hSections[secName]), `not a section name ${OL(secName)}`);
     }
+    this.hSets[name] = lSectionTree;
+    debug('hSets', this.hSets);
+    debug("return from addSet()");
   }
 
   // ..........................................................
-  // --- a generator - yield order is not guaranteed
-  * allSections(desc) {
-    var _, i, j, lNames, len, len1, name, ref, ref1, sect;
-    debug("enter allSections()");
+  // --- sections returned in depth-first order from section tree
+  //     Set names are simply skipped
+  //     yields: [<level>, <section>]
+  * allSections(desc = undef, level = 0) {
+    var item, j, lTree, len, result;
+    debug("enter allSections()", desc, level);
     if (desc === undef) {
-      // --- We want to return all sections
-      debug("yield all sections");
-      ref = this.hSections;
-      for (_ in ref) {
-        sect = ref[_];
-        yield sect;
-      }
-    } else if (isString(desc)) {
-      if (isSectionName(desc)) {
-        debug(`yield section ${OL(desc)}`);
-        yield this.section(desc);
-      } else if (isSetName(desc)) {
-        debug(`expand set ${OL(desc)}`);
-        debug('hSets', this.hSets);
-        lNames = this.hSets[desc];
-        assert(defined(lNames), `no set named ${OL(desc)}`);
-        debug(`set ${desc}`, lNames);
-        for (i = 0, len = lNames.length; i < len; i++) {
-          name = lNames[i];
-          debug(`yield section ${OL(desc)}`);
-          yield this.section(name);
-        }
-      } else {
-        croak(`bad name ${OL(desc)}`);
-      }
-    } else {
-      assert(isArray(desc), "not an array");
-      for (j = 0, len1 = desc.length; j < len1; j++) {
-        name = desc[j];
-        debug(`yield section ${OL(name)}`);
-        assert(isString(name), `not a string ${OL(name)}`);
-        if (isSectionName(name)) {
-          yield this.section(name);
-        } else if (isSetName(name)) {
-          ref1 = this.hSets[name];
-          for (_ in ref1) {
-            sect = ref1[_];
-            yield sect;
-          }
+      desc = this.lSectionTree;
+    }
+    if (isArray(desc)) {
+      for (j = 0, len = desc.length; j < len; j++) {
+        item = desc[j];
+        if (isSectionName(item)) {
+          result = [level, this.section(item)];
+          debug('yield', result);
+          yield result;
+        } else if (isSetName(item)) {
+          pass;
         } else {
-          croak(`bad name ${OL(name)}`);
+          assert(isArray(item), `not an array ${OL(item)}`);
+          yield* this.allSections(item, level + 1);
         }
       }
+    } else if (isSectionName(desc)) {
+      result = [level, this.section(desc)];
+      debug('yield', result);
+      yield result;
+    } else if (isSetName(desc)) {
+      lTree = this.hSets[desc];
+      assert(defined(lTree), `Not a Set: ${OL(desc)}`);
+      yield* this.allSections(lTree, level);
+    } else {
+      croak(`Bad item: ${OL(desc)}`);
     }
     debug("return from allSections()");
   }
 
   // ..........................................................
-  addSet(name, lSections) {
-    var i, len, secName;
-    debug("enter addSet()", name, lSections);
-    // --- check the name
-    assert(isSetName(name), `not a valid set name ${OL(name)}`);
-    // --- check lSections
-    assert(isArray(lSections), "arg 2 not an array");
-    for (i = 0, len = lSections.length; i < len; i++) {
-      secName = lSections[i];
-      assert(isNonEmptyString(secName), `not a non-empty string ${OL(secName)}`);
-      assert(defined(this.hSections[secName]), `not a section name ${OL(secName)}`);
+  getBlock() {
+    var _, lParts, ref, result, sect, x;
+    debug("enter getBlock()");
+    lParts = [];
+    ref = this.allSections();
+    for (x of ref) {
+      [_, sect] = x;
+      if (sect.nonEmpty()) {
+        lParts.push(sect.getBlock());
+      }
     }
-    this.hSets[name] = lSections;
-    debug('hSets', this.hSets);
-    debug("return from addSet()");
+    debug('lParts', lParts);
+    result = arrayToBlock(lParts);
+    debug("return from getBlock()", result);
+    return result;
   }
 
   // ..........................................................
@@ -154,30 +173,31 @@ export var SectionMap = class SectionMap {
 
   // ..........................................................
   firstSection(name) {
-    var lSections;
+    var lSectionTree;
     assert(isSetName(name), `bad set name ${OL(name)}`);
-    lSections = this.hSets[name];
-    assert(defined(lSections), `no such set ${OL(name)}`);
-    assert(nonEmpty(lSections), `empty section ${OL(name)}`);
-    return this.section(lSections[0]);
+    lSectionTree = this.hSets[name];
+    assert(defined(lSectionTree), `no such set ${OL(name)}`);
+    assert(nonEmpty(lSectionTree), `empty section ${OL(name)}`);
+    return this.section(lSectionTree[0]);
   }
 
   // ..........................................................
   lastSection(name) {
-    var lSections;
+    var lSectionTree;
     assert(isSetName(name), `bad set name ${OL(name)}`);
-    lSections = this.hSets[name];
-    assert(defined(lSections), `no such set ${OL(name)}`);
-    assert(nonEmpty(lSections), `empty section ${OL(name)}`);
-    return this.section(lSections[lSections.length - 1]);
+    lSectionTree = this.hSets[name];
+    assert(defined(lSectionTree), `no such set ${OL(name)}`);
+    assert(nonEmpty(lSectionTree), `empty section ${OL(name)}`);
+    return this.section(lSectionTree[lSectionTree.length - 1]);
   }
 
   // ..........................................................
   length(desc = undef) {
-    var ref, result, sect;
+    var _, ref, result, sect, x;
     result = 0;
     ref = this.allSections(desc);
-    for (sect of ref) {
+    for (x of ref) {
+      [_, sect] = x;
       result += sect.length();
     }
     return result;
@@ -195,9 +215,10 @@ export var SectionMap = class SectionMap {
 
   // ..........................................................
   indent(desc = undef, level = 1) {
-    var ref, sect;
+    var _, ref, sect, x;
     ref = this.allSections(desc);
-    for (sect of ref) {
+    for (x of ref) {
+      [_, sect] = x;
       sect.indent(level);
     }
   }
@@ -224,34 +245,18 @@ export var SectionMap = class SectionMap {
   }
 
   // ..........................................................
-  getBlock() {
-    var result;
-    debug("enter getBlock()");
-    this.lAllBlocks = [];
-    debug('lSections', this.lSections);
-    this.accumBlock(this.lSections);
-    debug('lAllBlocks', this.lAllBlocks);
-    result = arrayToBlock(this.lAllBlocks);
-    debug("return from getBlock()", result);
-    return result;
-  }
-
-  // ..........................................................
-  accumBlock(tree) {
-    var block, i, len, subtree;
-    if (isString(tree)) {
-      debug(`accumBlock ${OL(tree)}`);
-      block = this.section(tree).getBlock();
-      if (nonEmpty(block)) {
-        this.lAllBlocks.push(block);
-      }
-    } else {
-      assert(isArray(tree), "not an array");
-      for (i = 0, len = tree.length; i < len; i++) {
-        subtree = tree[i];
-        this.accumBlock(subtree);
-      }
+  getShape() {
+    var lParts, level, ref, result, sect, x;
+    debug("enter getShape()");
+    lParts = [];
+    ref = this.allSections();
+    for (x of ref) {
+      [level, sect] = x;
+      lParts.push(indented(sect.name, level));
     }
+    result = arrayToBlock(lParts);
+    debug("return from getShape()", result);
+    return result;
   }
 
 };

package/src/block_utils.coffee

@@ -30,19 +30,31 @@ export blockToArray = (block) ->
 export arrayToBlock = (lLines) ->
 
 	if (lLines == undef)
-		return ''
+		return undef
 	assert isArray(lLines), "lLines is not an array"
 	lLines = lLines.filter((line) => defined(line));
 	if lLines.length == 0
-		return ''
+		return undef
 	else
 		return rtrim(lLines.join('\n'))
 
 # ---------------------------------------------------------------------------
 
+export splitBlock = (block) ->
+
+	assert isString(block), "not a string"
+	pos = block.indexOf('\n')
+	if (pos == -1)
+		return [block, undef]
+	else
+		return [block.substring(0, pos), block.substring(pos+1)]
+
+
+# ---------------------------------------------------------------------------
+
 export firstLine = (block) ->
 
-	assert isString(block), "firstLine(): string expected"
+	assert isString(block), "not a string"
 	pos = block.indexOf('\n')
 	if (pos == -1)
 		return block
@@ -53,10 +65,10 @@ export firstLine = (block) ->
 
 export remainingLines = (block) ->
 
-	assert isString(block), "remainingLines(): string expected"
+	assert isString(block), "not a string"
 	pos = block.indexOf('\n')
 	if (pos == -1)
-		return ''
+		return undef
 	else
 		return block.substring(pos+1)
 

package/src/block_utils.js

@@ -38,23 +38,35 @@ export var blockToArray = function(block) {
 //   arrayToBlock - block will have no trailing whitespace
 export var arrayToBlock = function(lLines) {
   if (lLines === undef) {
-    return '';
+    return undef;
   }
   assert(isArray(lLines), "lLines is not an array");
   lLines = lLines.filter((line) => {
     return defined(line);
   });
   if (lLines.length === 0) {
-    return '';
+    return undef;
   } else {
     return rtrim(lLines.join('\n'));
   }
 };
 
+// ---------------------------------------------------------------------------
+export var splitBlock = function(block) {
+  var pos;
+  assert(isString(block), "not a string");
+  pos = block.indexOf('\n');
+  if (pos === -1) {
+    return [block, undef];
+  } else {
+    return [block.substring(0, pos), block.substring(pos + 1)];
+  }
+};
+
 // ---------------------------------------------------------------------------
 export var firstLine = function(block) {
   var pos;
-  assert(isString(block), "firstLine(): string expected");
+  assert(isString(block), "not a string");
   pos = block.indexOf('\n');
   if (pos === -1) {
     return block;
@@ -66,10 +78,10 @@ export var firstLine = function(block) {
 // ---------------------------------------------------------------------------
 export var remainingLines = function(block) {
   var pos;
-  assert(isString(block), "remainingLines(): string expected");
+  assert(isString(block), "not a string");
   pos = block.indexOf('\n');
   if (pos === -1) {
-    return '';
+    return undef;
   } else {
     return block.substring(pos + 1);
   }