Improve the implementation of the smart tree printer

It now correctly indents lines with branches status

pkg/tree.go

@@ -86,7 +86,9 @@ func BuildTree(root string, repos []*Repo) *Node {
 	return tree
 }
 
-// RenderTree returns a string representation of repos tree.
+// RenderSmartTree returns a string representation of repos tree.
+// It's "smart" because it automatically folds branches which only have a single child and indents branches with many children.
+//
 // It recursively traverses the tree and prints its nodes.
 // If a node contains multiple children, they are be printed in new lines and indented.
 // If a node contains only a single child, it is printed in the same line using path separator.
@@ -106,12 +108,35 @@ func BuildTree(root string, repos []*Repo) *Node {
 //           repo2
 //       another/repo
 //
-func RenderTree(node *Node) string {
+func RenderSmartTree(node *Node) string {
 	if node.children == nil {
 		// If node is a leaf, print repo name and its status and finish processing this node.
-		return node.val + " " + renderWorktreeStatus(node.repo)
+		value := node.val
+
+		// TODO: Ugly
+		// If this is called from tests the repo will be nil and we should return just the name without the status.
+		if node.repo.repo == nil {
+			return value
+		}
+
+		value += " " + renderWorktreeStatus(node.repo)
+
+		// Print the status of each branch on a new line, indented to match the position of the current branch name.
+		indent := "\n" + strings.Repeat(" ", length+len(node.val))
+		for _, branch := range node.repo.Status.Branches {
+			// Don't print the status of the current branch. It was already printed above.
+			if branch.Name == node.repo.Status.CurrentBranch {
+				continue
+			}
+
+			value += indent + renderBranchStatus(branch)
+		}
+
+		return value
 	}
 
+	val := node.val + string(filepath.Separator)
+
 	shift := ""
 	if node.parent == nil {
 		// If node is a root, print its children on a new line without indentation.
@@ -121,17 +146,25 @@ func RenderTree(node *Node) string {
 		// Setting node's depth to the same as parent's ensures that its children will be indented only once even if
 		// node's path has multiple levels above.
 		node.depth = node.parent.depth
+
+		length += len(val)
 	} else {
 		// If node has multiple children, print each of them on a new line
 		// and indent them once relative to the parent
 		node.depth = node.parent.depth + 1
-		shift = "\n" + strings.Repeat("\t", node.depth)
+		shift = "\n" + strings.Repeat("    ", node.depth)
+		length = 0
 	}
 
-	val := node.val + string(filepath.Separator)
 	for _, child := range node.children {
-		val += shift + RenderTree(child)
+		length += len(shift)
+		val += shift + RenderSmartTree(child)
+		length = 0
 	}
 
 	return val
 }
+
+// lenght is the size (number of chars) of the currently processed line.
+// It's used to correctly indent the lines with branches status.
+var length int