@jdeighan/coffee-utils 8.0.4 → 8.0.7

package/package.json

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

package/src/Section.coffee

@@ -10,36 +10,36 @@ import {indented} from '@jdeighan/coffee-utils/indent'
 
 export class Section
 
-	constructor: () ->
+	constructor: (@name) ->
 
-		@lLines = []
+		@lParts = []
 
 	# ..........................................................
 
 	length: () ->
 
-		return @lLines.length
+		return @lParts.length
 
 	# ..........................................................
 
 	indent: (level=1) ->
 
-		lNewLines = for line in @lLines
+		lNewLines = for line in @lParts
 			indented(line, level)
-		@lLines = lNewLines
+		@lParts = lNewLines
 		return
 
 	# ..........................................................
 
 	isEmpty: () ->
 
-		return (@lLines.length == 0)
+		return (@lParts.length == 0)
 
 	# ..........................................................
 
 	nonEmpty: () ->
 
-		return (@lLines.length > 0)
+		return (@lParts.length > 0)
 
 	# ..........................................................
 
@@ -47,9 +47,9 @@ export class Section
 
 		if isArray(data)
 			for line in data
-				@lLines.push line
+				@lParts.push line
 		else
-			@lLines.push data
+			@lParts.push data
 		return
 
 	# ..........................................................
@@ -57,13 +57,22 @@ export class Section
 	prepend: (data) ->
 
 		if isArray(data)
-			@lLines = [data..., @lLines...]
+			@lParts = [data..., @lParts...]
 		else
-			@lLines = [data, @lLines...]
+			@lParts = [data, @lParts...]
 		return
 
 	# ..........................................................
 
+	getParts: () ->
+
+		return @lParts
+
+	# ..........................................................
+
 	getBlock: () ->
 
-		return arrayToBlock(@lLines)
+		if (@lParts.length == 0)
+			return undef
+		else
+			return arrayToBlock(@lParts)

package/src/Section.js

@@ -19,13 +19,14 @@ import {
 
 // ---------------------------------------------------------------------------
 export var Section = class Section {
-  constructor() {
-    this.lLines = [];
+  constructor(name) {
+    this.name = name;
+    this.lParts = [];
   }
 
   // ..........................................................
   length() {
-    return this.lLines.length;
+    return this.lParts.length;
   }
 
   // ..........................................................
@@ -33,7 +34,7 @@ export var Section = class Section {
     var lNewLines, line;
     lNewLines = (function() {
       var i, len, ref, results;
-      ref = this.lLines;
+      ref = this.lParts;
       results = [];
       for (i = 0, len = ref.length; i < len; i++) {
         line = ref[i];
@@ -41,17 +42,17 @@ export var Section = class Section {
       }
       return results;
     }).call(this);
-    this.lLines = lNewLines;
+    this.lParts = lNewLines;
   }
 
   // ..........................................................
   isEmpty() {
-    return this.lLines.length === 0;
+    return this.lParts.length === 0;
   }
 
   // ..........................................................
   nonEmpty() {
-    return this.lLines.length > 0;
+    return this.lParts.length > 0;
   }
 
   // ..........................................................
@@ -60,25 +61,34 @@ export var Section = class Section {
     if (isArray(data)) {
       for (i = 0, len = data.length; i < len; i++) {
         line = data[i];
-        this.lLines.push(line);
+        this.lParts.push(line);
       }
     } else {
-      this.lLines.push(data);
+      this.lParts.push(data);
     }
   }
 
   // ..........................................................
   prepend(data) {
     if (isArray(data)) {
-      this.lLines = [...data, ...this.lLines];
+      this.lParts = [...data, ...this.lParts];
     } else {
-      this.lLines = [data, ...this.lLines];
+      this.lParts = [data, ...this.lParts];
     }
   }
 
+  // ..........................................................
+  getParts() {
+    return this.lParts;
+  }
+
   // ..........................................................
   getBlock() {
-    return arrayToBlock(this.lLines);
+    if (this.lParts.length === 0) {
+      return undef;
+    } else {
+      return arrayToBlock(this.lParts);
+    }
   }
 
 };

package/src/SectionMap.coffee

@@ -3,8 +3,10 @@
 import {
 	assert, pass, undef, defined, croak, OL, isEmpty, nonEmpty,
 	isString, isHash, isArray, isUniqueTree, isNonEmptyString,
+	isNonEmptyArray,
 	} 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 +14,148 @@ 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
+
+	# ..........................................................
+	# --- procFunc should be (name, block) ->
+	#        return processed block
+
+	getBlock: (procFunc=undef, lTree=undef) ->
+
+		debug "enter getBlock()"
+		if (lTree == undef)
+			lTree = @lSectionTree
+		else
+			assert isArray(lTree), "not an array #{OL(lTree)}"
+
+		lParts = []
+		for part in lTree
+			if isString(part)
+				text = @section(part).getBlock()
+				if nonEmpty(text) && defined(procFunc)
+					text = procFunc(part, text)
+			else if isNonEmptyArray(part)
+				if isSectionName(part[0])
+					text = @getBlock(procFunc, part)
+				else if isSetName(part[0])
+					text = @getBlock(procFunc, part.slice(1))
+					if nonEmpty(text) && defined(procFunc)
+						text = procFunc(part[0], text)
+				else
+					croak "Bad part: #{OL(part)}"
+			else
+				croak "Bad part: #{OL(part)}"
+			if defined(text)
+				lParts.push text
+
+		debug 'lParts', lParts
+		result = arrayToBlock(lParts)
+		debug "return from getBlock()", result
+		return result
+
 	# ..........................................................
 
 	section: (name) ->
@@ -129,27 +169,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
 
@@ -167,55 +207,12 @@ export class SectionMap
 
 	# ..........................................................
 
-	indent: (desc=undef, level=1) ->
+	getShape: () ->
 
-		for sect from @allSections(desc)
-			sect.indent(level)
-		return
-
-	# ..........................................................
-
-	enclose: (name, pre, post) ->
-
-		if isSectionName(name)
-			sect = @section(name)
-			if sect.nonEmpty()
-				sect.indent()
-				sect.prepend(pre)
-				sect.add(post)
-		else if isSetName(name)
-			if @nonEmpty(name)
-				@indent(name)
-				@firstSection(name).prepend(pre)
-				@lastSection(name).add(post)
-		else
-			croak "Bad name param #{OL(name)}"
-		return
-
-	# ..........................................................
-
-	getBlock: () ->
-
-		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

@@ -15,13 +15,18 @@ import {
   isHash,
   isArray,
   isUniqueTree,
-  isNonEmptyString
+  isNonEmptyString,
+  isNonEmptyArray
 } 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';
@@ -32,116 +37,156 @@ 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)}`);
+  // --- procFunc should be (name, block) ->
+  //        return processed block
+  getBlock(procFunc = undef, lTree = undef) {
+    var j, lParts, len, part, result, text;
+    debug("enter getBlock()");
+    if (lTree === undef) {
+      lTree = this.lSectionTree;
+    } else {
+      assert(isArray(lTree), `not an array ${OL(lTree)}`);
     }
-    this.hSets[name] = lSections;
-    debug('hSets', this.hSets);
-    debug("return from addSet()");
+    lParts = [];
+    for (j = 0, len = lTree.length; j < len; j++) {
+      part = lTree[j];
+      if (isString(part)) {
+        text = this.section(part).getBlock();
+        if (nonEmpty(text) && defined(procFunc)) {
+          text = procFunc(part, text);
+        }
+      } else if (isNonEmptyArray(part)) {
+        if (isSectionName(part[0])) {
+          text = this.getBlock(procFunc, part);
+        } else if (isSetName(part[0])) {
+          text = this.getBlock(procFunc, part.slice(1));
+          if (nonEmpty(text) && defined(procFunc)) {
+            text = procFunc(part[0], text);
+          }
+        } else {
+          croak(`Bad part: ${OL(part)}`);
+        }
+      } else {
+        croak(`Bad part: ${OL(part)}`);
+      }
+      if (defined(text)) {
+        lParts.push(text);
+      }
+    }
+    debug('lParts', lParts);
+    result = arrayToBlock(lParts);
+    debug("return from getBlock()", result);
+    return result;
   }
 
   // ..........................................................
@@ -154,30 +199,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;
@@ -194,64 +240,18 @@ export var SectionMap = class SectionMap {
   }
 
   // ..........................................................
-  indent(desc = undef, level = 1) {
-    var ref, sect;
-    ref = this.allSections(desc);
-    for (sect of ref) {
-      sect.indent(level);
-    }
-  }
-
-  // ..........................................................
-  enclose(name, pre, post) {
-    var sect;
-    if (isSectionName(name)) {
-      sect = this.section(name);
-      if (sect.nonEmpty()) {
-        sect.indent();
-        sect.prepend(pre);
-        sect.add(post);
-      }
-    } else if (isSetName(name)) {
-      if (this.nonEmpty(name)) {
-        this.indent(name);
-        this.firstSection(name).prepend(pre);
-        this.lastSection(name).add(post);
-      }
-    } else {
-      croak(`Bad name param ${OL(name)}`);
+  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));
     }
-  }
-
-  // ..........................................................
-  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);
+    result = arrayToBlock(lParts);
+    debug("return from getShape()", 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);
-      }
-    }
-  }
-
 };

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);
   }

package/src/coffee_utils.coffee

@@ -173,6 +173,12 @@ export isArray = (x) ->
 
 # ---------------------------------------------------------------------------
 
+export isNonEmptyArray = (x) ->
+
+	return isArray(x) && (x.length > 0)
+
+# ---------------------------------------------------------------------------
+
 export isHash = (x, lKeys) ->
 
 	if ! x || (getClassName(x) != 'Object')
@@ -186,6 +192,12 @@ export isHash = (x, lKeys) ->
 
 # ---------------------------------------------------------------------------
 
+export isNonEmptyHash = (x) ->
+
+	return isHash(x) && (Object.keys(x).length > 0)
+
+# ---------------------------------------------------------------------------
+
 export hashHasKey = (x, key) ->
 
 	assert isHash(x), "hashHasKey(): not a hash"

package/src/coffee_utils.js

@@ -159,6 +159,11 @@ export var isArray = function(x) {
   return Array.isArray(x);
 };
 
+// ---------------------------------------------------------------------------
+export var isNonEmptyArray = function(x) {
+  return isArray(x) && (x.length > 0);
+};
+
 // ---------------------------------------------------------------------------
 export var isHash = function(x, lKeys) {
   var i, key, len;
@@ -177,6 +182,11 @@ export var isHash = function(x, lKeys) {
   return true;
 };
 
+// ---------------------------------------------------------------------------
+export var isNonEmptyHash = function(x) {
+  return isHash(x) && (Object.keys(x).length > 0);
+};
+
 // ---------------------------------------------------------------------------
 export var hashHasKey = function(x, key) {
   assert(isHash(x), "hashHasKey(): not a hash");

package/src/indent_utils.coffee

@@ -146,3 +146,10 @@ export tabify = (str, numSpaces=undef) ->
 export untabify = (str, numSpaces=3) ->
 
 	return str.replace(/\t/g, ' '.repeat(numSpaces))
+
+# ---------------------------------------------------------------------------
+#    enclose - indent text, surround with pre and post
+
+export enclose = (text, pre, post) ->
+
+	return pre + "\n" + indented(text) + "\n" + post

package/src/indent_utils.js

@@ -175,3 +175,9 @@ export var tabify = function(str, numSpaces = undef) {
 export var untabify = function(str, numSpaces = 3) {
   return str.replace(/\t/g, ' '.repeat(numSpaces));
 };
+
+// ---------------------------------------------------------------------------
+//    enclose - indent text, surround with pre and post
+export var enclose = function(text, pre, post) {
+  return pre + "\n" + indented(text) + "\n" + post;
+};