Merge pull request #58 from PeronGH/master

Author: AlexanderGrooff

cmd/diagram.go

@@ -82,6 +82,9 @@ func (gd *GraphDiagram) Render(config *diagram.Config) (string, error) {
 	if styleType == "" {
 		styleType = "cli"
 	}
+	gd.properties.boxBorderPadding = config.BoxBorderPadding
+	gd.properties.paddingX = config.PaddingBetweenX
+	gd.properties.paddingY = config.PaddingBetweenY
 	gd.properties.styleType = styleType
 	gd.properties.useAscii = config.UseAscii
 

cmd/direction.go

@@ -45,23 +45,23 @@ func (c drawingCoord) Direction(dir direction) drawingCoord {
 	return drawingCoord{x: c.x + dir.x, y: c.y + dir.y}
 }
 
-func selfReferenceDirection(e *edge) (direction, direction, direction, direction) {
-	if graphDirection == "LR" {
+func (g graph) selfReferenceDirection() (direction, direction, direction, direction) {
+	if g.graphDirection == "LR" {
 		return Right, Down, Down, Right
 	}
 	return Down, Right, Right, Down
 }
 
-func determineStartAndEndDir(e *edge) (direction, direction, direction, direction) {
+func (g graph) determineStartAndEndDir(e *edge) (direction, direction, direction, direction) {
 	if e.from == e.to {
-		return selfReferenceDirection(e)
+		return g.selfReferenceDirection()
 	}
 	d := determineDirection(genericCoord(*e.from.gridCoord), genericCoord(*e.to.gridCoord))
 	var preferredDir, preferredOppositeDir, alternativeDir, alternativeOppositeDir direction
 
 	// Check if this is a backwards flowing edge
 	isBackwards := false
-	if graphDirection == "LR" {
+	if g.graphDirection == "LR" {
 		// In LR mode, backwards flow is when edge goes from right to left (Left direction)
 		isBackwards = (d == Left || d == UpperLeft || d == LowerLeft)
 	} else { // TD mode
@@ -75,7 +75,7 @@ func determineStartAndEndDir(e *edge) (direction, direction, direction, directio
 	// For backwards edges, use special start positions: Down in LR mode, Right in TD mode
 	switch d {
 	case LowerRight:
-		if graphDirection == "LR" {
+		if g.graphDirection == "LR" {
 			preferredDir = Down
 			preferredOppositeDir = Left
 			alternativeDir = Right
@@ -87,7 +87,7 @@ func determineStartAndEndDir(e *edge) (direction, direction, direction, directio
 			alternativeOppositeDir = Left
 		}
 	case UpperRight:
-		if graphDirection == "LR" {
+		if g.graphDirection == "LR" {
 			preferredDir = Up
 			preferredOppositeDir = Left
 			alternativeDir = Right
@@ -99,7 +99,7 @@ func determineStartAndEndDir(e *edge) (direction, direction, direction, directio
 			alternativeOppositeDir = Left
 		}
 	case LowerLeft:
-		if graphDirection == "LR" {
+		if g.graphDirection == "LR" {
 			// Backwards flow in LR mode - start from Down, arrive at Down
 			preferredDir = Down
 			preferredOppositeDir = Down // Edge goes to bottom of destination
@@ -112,7 +112,7 @@ func determineStartAndEndDir(e *edge) (direction, direction, direction, directio
 			alternativeOppositeDir = Right
 		}
 	case UpperLeft:
-		if graphDirection == "LR" {
+		if g.graphDirection == "LR" {
 			// Backwards flow in LR mode - start from Down, arrive at Down
 			preferredDir = Down
 			preferredOppositeDir = Down // Edge goes to bottom of destination
@@ -128,13 +128,13 @@ func determineStartAndEndDir(e *edge) (direction, direction, direction, directio
 	default:
 		// Handle direct backwards flow cases
 		if isBackwards {
-			if graphDirection == "LR" && d == Left {
+			if g.graphDirection == "LR" && d == Left {
 				// Direct left flow in LR mode - start from Down, arrive at Down
 				preferredDir = Down
 				preferredOppositeDir = Down // Edge goes to bottom of destination
 				alternativeDir = Left
 				alternativeOppositeDir = Right
-			} else if graphDirection == "TD" && d == Up {
+			} else if g.graphDirection == "TD" && d == Up {
 				// Direct up flow in TD mode - start from Right, arrive at Right
 				preferredDir = Right
 				preferredOppositeDir = Right // Edge goes to right of destination

cmd/draw.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"github.com/gookit/color"
+	"github.com/mattn/go-runewidth"
 	log "github.com/sirupsen/logrus"
 )
 
@@ -151,7 +152,7 @@ func (g *graph) drawLine(d *drawing, from drawingCoord, to drawingCoord, offsetF
 }
 
 func drawMap(properties *graphProperties) string {
-	g := mkGraph(properties.data)
+	g := mkGraph(properties.data, properties.nodeSpecs)
 	g.setStyleClasses(properties)
 	g.paddingX = properties.paddingX
 	g.paddingY = properties.paddingY
@@ -227,11 +228,22 @@ func drawBox(n *node, g graph) *drawing {
 		boxDrawing[from.x][to.y] = "+"   // Bottom left corner
 		boxDrawing[to.x][to.y] = "+"     // Bottom right corner
 	}
-	// Draw text
-	textY := from.y + h/2
-	textX := from.x + w/2 - CeilDiv(len(n.name), 2) + 1
-	for x := 0; x < len(n.name); x++ {
-		boxDrawing[textX+x][textY] = wrapTextInColor(string(n.name[x]), n.styleClass.styles["color"], g.styleType)
+	// Draw label lines inside the padded content area.
+	innerTop := from.y + 1
+	innerHeight := h - 1
+	contentTop := innerTop + (innerHeight-n.label.contentHeight())/2
+	for lineIdx, line := range n.label.lines {
+		textY := contentTop + lineIdx*(graphLabelLineGap+1)
+		textWidth := runewidth.StringWidth(line)
+		textX := from.x + w/2 - CeilDiv(textWidth, 2) + 1
+		for _, r := range line {
+			runeWidth := Max(runewidth.RuneWidth(r), 1)
+			boxDrawing[textX][textY] = wrapTextInColor(string(r), n.styleClass.styles["color"], g.styleType)
+			for offset := 1; offset < runeWidth; offset++ {
+				boxDrawing[textX+offset][textY] = ""
+			}
+			textX += runeWidth
+		}
 	}
 
 	return &boxDrawing
@@ -316,15 +328,22 @@ func drawSubgraphLabel(sg *subgraph, g graph) (*drawing, drawingCoord) {
 	to := drawingCoord{width, height}
 	labelDrawing := *(mkDrawing(width, height))
 
-	// Draw label centered at top
-	labelY := from.y + 1
-	labelX := from.x + width/2 - len(sg.name)/2
-	if labelX < from.x+1 {
-		labelX = from.x + 1
-	}
-	for i, char := range sg.name {
-		if labelX+i < to.x {
-			labelDrawing[labelX+i][labelY] = string(char)
+	// Draw label centered at top.
+	for lineIdx, line := range sg.label.lines {
+		labelY := from.y + 1 + lineIdx*(graphLabelLineGap+1)
+		labelX := from.x + width/2 - runewidth.StringWidth(line)/2
+		if labelX < from.x+1 {
+			labelX = from.x + 1
+		}
+		for _, char := range line {
+			runeWidth := Max(runewidth.RuneWidth(char), 1)
+			if labelX < to.x {
+				labelDrawing[labelX][labelY] = string(char)
+			}
+			for offset := 1; offset < runeWidth && labelX+offset < to.x; offset++ {
+				labelDrawing[labelX+offset][labelY] = ""
+			}
+			labelX += runeWidth
 		}
 	}
 

cmd/graph.go

@@ -30,24 +30,40 @@ func (g graph) lineToDrawing(line []gridCoord) []drawingCoord {
 }
 
 type graph struct {
-	nodes        []*node
-	edges        []*edge
-	drawing      *drawing
-	grid         map[gridCoord]*node
-	columnWidth  map[int]int
-	rowHeight    map[int]int
-	styleClasses map[string]styleClass
-	styleType    string
-	paddingX     int
-	paddingY     int
-	subgraphs    []*subgraph
-	offsetX      int
-	offsetY      int
-	useAscii     bool
+	nodes            []*node
+	edges            []*edge
+	drawing          *drawing
+	grid             map[gridCoord]*node
+	edgeCounts       map[edgePair]int
+	columnWidth      map[int]int
+	rowHeight        map[int]int
+	styleClasses     map[string]styleClass
+	styleType        string
+	boxBorderPadding int
+	graphDirection   string
+	paddingX         int
+	paddingY         int
+	subgraphs        []*subgraph
+	offsetX          int
+	offsetY          int
+	useAscii         bool
+}
+
+type edgePair struct {
+	from int
+	to   int
+}
+
+func newEdgePair(from, to int) edgePair {
+	if from < to {
+		return edgePair{from: from, to: to}
+	}
+	return edgePair{from: to, to: from}
 }
 
 type subgraph struct {
 	name     string
+	label    graphLabel
 	nodes    []*node
 	parent   *subgraph
 	children []*subgraph
@@ -58,28 +74,30 @@ type subgraph struct {
 	maxY int
 }
 
-func mkGraph(data *orderedmap.OrderedMap[string, []textEdge]) graph {
+func mkGraph(data *orderedmap.OrderedMap[string, []textEdge], nodeSpecs map[string]graphNodeSpec) graph {
 	g := graph{drawing: mkDrawing(0, 0)}
 	g.grid = make(map[gridCoord]*node)
+	g.edgeCounts = make(map[edgePair]int)
 	g.columnWidth = make(map[int]int)
 	g.rowHeight = make(map[int]int)
 	g.styleClasses = make(map[string]styleClass)
 	index := 0
 	for el := data.Front(); el != nil; el = el.Next() {
 		nodeName := el.Key
 		children := el.Value
+		spec := nodeSpecs[nodeName]
 		// Get or create parent node
 		parentNode, err := g.getNode(nodeName)
 		if err != nil {
-			parentNode = &node{name: nodeName, index: index, styleClassName: ""}
+			parentNode = &node{name: nodeName, label: spec.label, index: index, styleClassName: spec.styleClass}
 			g.appendNode(parentNode)
 			index += 1
 		}
 		for _, textEdge := range children {
+			childSpec := nodeSpecs[textEdge.child.name]
 			childNode, err := g.getNode(textEdge.child.name)
 			if err != nil {
-				childNode = &node{name: textEdge.child.name, index: index, styleClassName: textEdge.child.styleClass}
-				parentNode.styleClassName = textEdge.parent.styleClass
+				childNode = &node{name: textEdge.child.name, label: childSpec.label, index: index, styleClassName: childSpec.styleClass}
 				g.appendNode(childNode)
 				index += 1
 			}
@@ -94,6 +112,8 @@ func (g *graph) setStyleClasses(properties *graphProperties) {
 	log.Debugf("Setting style classes to %v", properties.styleClasses)
 	g.styleClasses = *properties.styleClasses
 	g.styleType = properties.styleType
+	g.boxBorderPadding = properties.boxBorderPadding
+	g.graphDirection = properties.graphDirection
 	g.paddingX = properties.paddingX
 	g.paddingY = properties.paddingY
 	for _, n := range g.nodes {
@@ -111,6 +131,7 @@ func (g *graph) setSubgraphs(textSubgraphs []*textSubgraph) {
 	for _, tsg := range textSubgraphs {
 		sg := &subgraph{
 			name:     tsg.name,
+			label:    tsg.label,
 			nodes:    []*node{},
 			children: []*subgraph{},
 		}
@@ -194,7 +215,7 @@ func (g *graph) createMapping() {
 
 	// Separate root nodes by whether they're in subgraphs, but only if we have both types
 	// AND there are edges in subgraphs (indicating intentional layout structure)
-	shouldSeparate := graphDirection == "LR" && hasExternalRoots && hasSubgraphRootsWithEdges
+	shouldSeparate := g.graphDirection == "LR" && hasExternalRoots && hasSubgraphRootsWithEdges
 
 	externalRootNodes := []*node{}
 	subgraphRootNodes := []*node{}
@@ -214,7 +235,7 @@ func (g *graph) createMapping() {
 	// Place external root nodes first at level 0
 	for _, n := range externalRootNodes {
 		var mappingCoord *gridCoord
-		if graphDirection == "LR" {
+		if g.graphDirection == "LR" {
 			mappingCoord = g.reserveSpotInGrid(g.nodes[n.index], &gridCoord{x: 0, y: highestPositionPerLevel[0]})
 		} else {
 			mappingCoord = g.reserveSpotInGrid(g.nodes[n.index], &gridCoord{x: highestPositionPerLevel[0], y: 0})
@@ -230,7 +251,7 @@ func (g *graph) createMapping() {
 		subgraphLevel := 4
 		for _, n := range subgraphRootNodes {
 			var mappingCoord *gridCoord
-			if graphDirection == "LR" {
+			if g.graphDirection == "LR" {
 				mappingCoord = g.reserveSpotInGrid(g.nodes[n.index], &gridCoord{x: subgraphLevel, y: highestPositionPerLevel[subgraphLevel]})
 			} else {
 				mappingCoord = g.reserveSpotInGrid(g.nodes[n.index], &gridCoord{x: highestPositionPerLevel[subgraphLevel], y: subgraphLevel})
@@ -245,7 +266,7 @@ func (g *graph) createMapping() {
 		log.Debugf("Creating mapping for node %s at %v", n.name, n.gridCoord)
 		var childLevel int
 		// Next column is 4 coords further. This is because every node is 3 coords wide + 1 coord inbetween.
-		if graphDirection == "LR" {
+		if g.graphDirection == "LR" {
 			childLevel = n.gridCoord.x + 4
 		} else {
 			childLevel = n.gridCoord.y + 4
@@ -258,7 +279,7 @@ func (g *graph) createMapping() {
 			}
 
 			var mappingCoord *gridCoord
-			if graphDirection == "LR" {
+			if g.graphDirection == "LR" {
 				mappingCoord = g.reserveSpotInGrid(g.nodes[child.index], &gridCoord{x: childLevel, y: highestPosition})
 			} else {
 				mappingCoord = g.reserveSpotInGrid(g.nodes[child.index], &gridCoord{x: highestPosition, y: childLevel})
@@ -471,9 +492,18 @@ func (g *graph) calculateSubgraphBoundingBox(sg *subgraph) {
 		maxY = Max(maxY, nodeMaxY)
 	}
 
+	// Ensure the title fits inside the frame after padding is applied.
+	currentWidth := maxX - minX
+	currentInnerWidth := currentWidth + 3
+	if currentInnerWidth < sg.label.width {
+		extraWidth := sg.label.width - currentInnerWidth
+		minX -= extraWidth / 2
+		maxX += extraWidth - (extraWidth / 2)
+	}
+
 	// Add padding (allow negative coordinates, we'll offset later)
 	const subgraphPadding = 2
-	const subgraphLabelSpace = 2 // Extra space for label at top
+	subgraphLabelSpace := sg.label.contentHeight() + 1
 	sg.minX = minX - subgraphPadding
 	sg.minY = minY - subgraphPadding - subgraphLabelSpace
 	sg.maxX = maxX + subgraphPadding

cmd/label.go

@@ -0,0 +1,48 @@
+package cmd
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/mattn/go-runewidth"
+)
+
+var htmlBreakPattern = regexp.MustCompile(`(?i)<br\s*/?>`)
+
+const graphLabelLineGap = 1
+
+type graphLabel struct {
+	lines []string
+	width int
+}
+
+func newGraphLabel(raw string) graphLabel {
+	normalized := htmlBreakPattern.ReplaceAllString(raw, "\n")
+	normalized = strings.ReplaceAll(normalized, `\n`, "\n")
+
+	lines := strings.Split(normalized, "\n")
+	if len(lines) == 0 {
+		lines = []string{""}
+	}
+
+	width := 0
+	for _, line := range lines {
+		width = Max(width, runewidth.StringWidth(line))
+	}
+
+	return graphLabel{
+		lines: lines,
+		width: width,
+	}
+}
+
+func (l graphLabel) height() int {
+	return len(l.lines)
+}
+
+func (l graphLabel) contentHeight() int {
+	if len(l.lines) == 0 {
+		return 0
+	}
+	return len(l.lines) + (len(l.lines)-1)*graphLabelLineGap
+}