chore: adapt graph

internal/graph/graph.go

@@ -14,7 +14,7 @@ type NodeParser[T any] interface {
 	Deps(node *node.Node[T]) []string
 }
 
-func makeGraph[T any](
+func makeNodes[T any](
 	entrypoint string,
 	parser NodeParser[T],
 	seen map[string]*node.Node[T],
@@ -31,7 +31,7 @@ func makeGraph[T any](
 
 	deps := parser.Deps(root)
 	for _, dep := range deps {
-		child, err := makeGraph(dep, parser, seen)
+		child, err := makeNodes(dep, parser, seen)
 		if err != nil {
 			return nil, err
 		}
@@ -45,59 +45,63 @@ type graphNode[T any] struct {
 	level int
 }
 
-func renderGraph[T any](
-	root *node.Node[T],
-	parser NodeParser[T],
-	rootId string,
-) (string, error) {
+func sortNodes[T any](root *node.Node[T]) []graphNode[T] {
 	ctx := context.Background()
 	allNodes := root.Flatten()
 
-	nodesWithLevel := make([]graphNode[T], 0)
-	maxLevel := 0
-	maxSize := 0
+	result := make([]graphNode[T], 0)
 	for _, k := range allNodes.Keys() {
 		n, _ := allNodes.Get(k)
 		var level int
-		ctx, level = n.Level(ctx, rootId)
-		if level > maxLevel {
-			maxLevel = level
-		}
-		display := parser.Display(n)
-		if len(display) > maxSize {
-			maxSize = len(display)
-		}
-		nodesWithLevel = append(nodesWithLevel, graphNode[T]{node: n, level: level})
+		ctx, level = n.Level(ctx, root.Id)
+		result = append(result, graphNode[T]{node: n, level: level})
 	}
 
-	sort.SliceStable(nodesWithLevel, func(i, j int) bool {
-		if nodesWithLevel[i].level == nodesWithLevel[j].level {
-			return nodesWithLevel[i].node.Id < nodesWithLevel[j].node.Id
+	sort.SliceStable(result, func(i, j int) bool {
+		if result[i].level == result[j].level {
+			return result[i].node.Id < result[j].node.Id
 		} else {
-			return nodesWithLevel[i].level < nodesWithLevel[j].level
+			return result[i].level < result[j].level
 		}
 	})
+	return result
+}
 
-	board := render.MakeBoard(render.BoardOptions{
-		Indent: 2,
-	})
+const indent = 4
+
+func renderGraph[T any](
+	parser NodeParser[T],
+	nodes []graphNode[T],
+) (string, error) {
+	board := render.MakeBoard()
+
+	lastLevel := -1
+	yOffset := 0
+	for i, n := range nodes {
+		if n.level == lastLevel {
+			if nodes[i-1].node.Children.Len() > 0 {
+				yOffset++
+			}
+		} else {
+			lastLevel = n.level
+		}
 
-	for i, nodeWithLevel := range nodesWithLevel {
 		err := board.AddBlock(
-			nodeWithLevel.node.Id,
-			parser.Display(nodeWithLevel.node),
-			nodeWithLevel.level,
-			i,
+			n.node.Id,
+			parser.Display(n.node),
+			indent*n.level,
+			i+yOffset,
 		)
 		if err != nil {
 			return "", err
 		}
 	}
 
-	for _, nodeWithLevel := range nodesWithLevel {
-		for _, childId := range nodeWithLevel.node.Children.Keys() {
-			child, _ := nodeWithLevel.node.Children.Get(childId)
-			err := board.AddConnector(nodeWithLevel.node.Id, child.Id)
+	for i := range nodes {
+		n := nodes[len(nodes)-1-i]
+		for _, childId := range n.node.Children.Keys() {
+			child, _ := n.node.Children.Get(childId)
+			err := board.AddConnector(n.node.Id, child.Id)
 			if err != nil {
 				return "", err
 			}
@@ -111,9 +115,10 @@ func RenderGraph[T any](
 	entrypoint string,
 	parser NodeParser[T],
 ) (string, error) {
-	root, err := makeGraph(entrypoint, parser, map[string]*node.Node[T]{})
+	root, err := makeNodes(entrypoint, parser, map[string]*node.Node[T]{})
 	if err != nil {
 		return "", err
 	}
-	return renderGraph(root, parser, root.Id)
+	nodes := sortNodes(root)
+	return renderGraph(parser, nodes)
 }

internal/render/block.go

@@ -38,16 +38,13 @@ func (b *Block) Render(matrix *graphics.Matrix) error {
 func (b *Board) AddBlock(
 	id string,
 	label string,
-	column int,
-	row int,
+	x int,
+	y int,
 ) error {
 	if _, ok := b.blocks.Get(id); ok {
 		return fmt.Errorf("block %s is already present", id)
 	}
 
-	x := column * b.options.Indent
-	y := row
-
 	newW := x + len(label)
 	newH := y + 1
 

internal/render/board.go

@@ -4,26 +4,17 @@ import (
 	"github.com/elliotchance/orderedmap/v2"
 
 	"dep-tree/internal/render/graphics"
-	"dep-tree/internal/utils"
 )
 
-type BoardOptions struct {
-	Indent int
-}
-
 type Board struct {
 	w          int
 	h          int
-	options    BoardOptions
 	blocks     *orderedmap.OrderedMap[string, *Block]
 	connectors *orderedmap.OrderedMap[string, *Connector]
 }
 
-func MakeBoard(options BoardOptions) *Board {
+func MakeBoard() *Board {
 	return &Board{
-		options: BoardOptions{
-			Indent: utils.Clamp(2, options.Indent, 8),
-		},
 		blocks:     orderedmap.NewOrderedMap[string, *Block](),
 		connectors: orderedmap.NewOrderedMap[string, *Connector](),
 	}

internal/render/connector.go

@@ -5,7 +5,6 @@ import (
 
 	"dep-tree/internal/render/graphics"
 	"dep-tree/internal/utils"
-	"dep-tree/internal/vector"
 )
 
 const (
@@ -21,7 +20,6 @@ func (c *Connector) Render(matrix *graphics.Matrix) error {
 	reverseX := c.to.Position.X < c.from.Position.X
 	reverseY := c.to.Position.Y < c.from.Position.Y
 
-	dir := vector.Vec(utils.Bool2Int(!reverseX), utils.Bool2Int(!reverseY))
 	// 1. If the line is going upwards, start at the end of the block.
 	from := c.from.Position
 	if reverseY {
@@ -63,17 +61,17 @@ func (c *Connector) Render(matrix *graphics.Matrix) error {
 	}
 
 	// 3. displacing vertically until aligned...
-	for dir.Y*cur.Y < dir.Y*c.to.Position.Y {
+	for cur.Y != c.to.Position.Y {
 		cur = tracer.MoveVertical(reverseY)
 		matrix.Cell(cur).Tag(noCrossOwnership, c.from.Id)
 	}
 
 	// 4. moving horizontally until meeting target node...
 	stopBefore := 1
-	if dir.X < 0 {
+	if reverseX {
 		stopBefore = len(c.to.Label)
 	}
-	for dir.X*cur.X < dir.X*c.to.Position.X-stopBefore {
+	for cur.X != c.to.Position.X-stopBefore {
 		cur = tracer.MoveHorizontal(reverseX)
 	}
 	err := tracer.Dump(matrix)

internal/render/graphics/stack.go

@@ -6,7 +6,7 @@ type CellStack struct {
 }
 
 func (c *CellStack) add(cell *Cell) {
-	c.cells = append([]*Cell{cell}, c.cells...)
+	c.cells = append(c.cells, cell)
 }
 
 func (c *CellStack) Tag(key string, value string) {