Complete IsLeaf() method & tests, clean up GoDoc

Author: mramshaw

README.md

@@ -108,7 +108,7 @@ a high level - what the tests ***were***. But my experience - in practice - is t
 still gets very cluttered quite quickly, so that this high-level overview is not really possible.
 
 I still think this approach is great - but I'd probably reserve it for lower-level components, rather
-than for system-wise testing.
+than for system testing.
 
 ## To Do
 

node.go

@@ -4,36 +4,38 @@ import (
 //"fmt"
 )
 
-type node struct {
+// Node is a radix trie node (which may also be a leaf).
+type Node struct {
 	value      string
-	children   []*node
+	children   []*Node
 	childCount int
 }
 
-func (n *node) IsLeaf() bool {
+// IsLeaf may be called to determine of the current node is a leaf.
+func (n *Node) IsLeaf() bool {
 	return n.childCount == 0
 }
 
-func (n *node) makeChildNode(s string) *node {
+func (n *Node) makeChildNode(s string) *Node {
 	//fmt.Printf("makingChildNode: %s\n", s)
 	child := makeNode(s)
 	n.childCount++
 	if n.children == nil {
-		n.children = []*node{&child}
+		n.children = []*Node{&child}
 	} else {
 		n.children = append(n.children, &child)
 	}
 	return &child
 }
 
-func (n *node) setChildNode(newNode *node) bool {
+func (n *Node) setChildNode(newNode *Node) bool {
 	//fmt.Printf("settingChildNode: %v\n", newNode)
 	n.childCount = 1
-	n.children = []*node{newNode}
+	n.children = []*Node{newNode}
 	return true
 }
 
-func makeNode(s string) node {
+func makeNode(s string) Node {
 	//fmt.Printf("makingNode: %s\n", s)
-	return node{value: s, childCount: 0}
+	return Node{value: s, childCount: 0}
 }

trie.go

@@ -1,3 +1,4 @@
+// Package trie provides primitives for processing radix tries.
 package trie
 
 import (
@@ -7,16 +8,16 @@ import (
 
 // Trie is a radix trie implementation.
 type Trie struct {
-	child []*node
+	child []*Node
 	count int
 }
 
-// NewTrie is used to create a new Trie.
+// NewTrie is used to create a new radix trie.
 func NewTrie() *Trie {
 	return &Trie{}
 }
 
-// Count returns the number of nodes in the Trie.
+// Count returns the number of nodes in the trie.
 func (t *Trie) Count() int {
 	return t.count
 }
@@ -25,7 +26,9 @@ func (t *Trie) isEmpty() bool {
 	return t.count == 0
 }
 
-// Insert is used to add a new term to the Trie.
+// Insert is used to add a new term to the trie.
+// If successful, this will create one or more child
+// nodes.
 func (t *Trie) Insert(s string) bool {
 
 	// remove leading & trailing whitespace
@@ -59,7 +62,7 @@ func (t *Trie) Insert(s string) bool {
 	return true
 }
 
-func (t *Trie) insertRuneNode(parent *node, n *node, s string) bool {
+func (t *Trie) insertRuneNode(parent *Node, n *Node, s string) bool {
 
 	for _, c := range n.children {
 		index := t.findRuneMatch(c.value, s)
@@ -95,27 +98,28 @@ func (t *Trie) insertRuneNode(parent *node, n *node, s string) bool {
 func (t *Trie) makeRuneNode(s string) {
 	rootRune := makeNode(s[:1])
 	rootChild := makeNode(s[1:])
-	rootRune.children = []*node{&rootChild}
+	rootRune.children = []*Node{&rootChild}
 	rootRune.childCount = 1
-	t.child = []*node{&rootRune}
+	t.child = []*Node{&rootRune}
 	t.count++
 }
 
-// Find is used to search for a specific term in the Trie.
-func (t *Trie) Find(s string) bool {
+// Find is used to search for a specific term in the trie.
+func (t *Trie) Find(s string) (bool, *Node) {
 
 	// Remove leading & trailing whitespace
 	trimmed := strings.TrimSpace(s)
 
 	// Sanity check (should catch empty strings too)
 	if len(s) < 2 {
-		return false
+		return false, nil
 	}
 
-	return t.findNode(trimmed) != nil
+	n := t.findNode(trimmed)
+	return n != nil, n
 }
 
-func (t *Trie) findNode(s string) *node {
+func (t *Trie) findNode(s string) *Node {
 
 	for _, c := range t.child {
 		if c.value == s[:1] {
@@ -129,7 +133,7 @@ func (t *Trie) findNode(s string) *node {
 	return nil
 }
 
-func (t *Trie) findRuneNode(n *node, s string) *node {
+func (t *Trie) findRuneNode(n *Node, s string) *Node {
 
 	for _, c := range n.children {
 		index := t.findRuneMatch(c.value, s)