Merge pull request #90 from NCMBianchi/fix/issue-81

Author: AlexanderGrooff

README.md

@@ -162,6 +162,42 @@ $ mermaid-ascii -f ./test.mermaid
 │         │          
 └─────────┘          
 
+# Other edge types
+Besides the default `-->` arrow, flowchart edges also accept `-.->` (dotted), `==>` (thick), `---` (open, no arrowhead), `--o` (circle head), and `--x` (cross head):
+$ cat test.mermaid
+graph TD
+A -.-> B
+A ==> C
+B --- C
+B --o|example| D
+D --x C
+$ mermaid-ascii -f ./test.mermaid
+┌──────────┐          
+│          │          
+│    A     │━━━━━━━┓  
+│          │       ┃  
+└─────┬────┘       ┃  
+      ┆            ┃  
+      ┆            ┃  
+      ┆            ┃  
+      ┆            ┃  
+      ▼            ▼  
+┌──────────┐     ┌───┐
+│          │     │   │
+│    B     ├─────┤ C │
+│          │     │   │
+└─────┬────┘     └───┘
+      │            ✕  
+      │            │  
+   example         │  
+      │            │  
+      ●            │  
+┌──────────┐       │  
+│          │       │  
+│    D     ├───────┘  
+│          │          
+└──────────┘          
+
 # Read from stdin
 $ cat test.mermaid | mermaid-ascii
 ┌───┐     ┌───┐     ┌───┐

cmd/arrow.go

@@ -111,14 +111,28 @@ func (g *graph) drawArrow(from gridCoord, to gridCoord, e *edge) (*drawing, *dra
 	}
 	log.Debugf("Drawing arrow from %v to %v with path %v", from, to, e.path)
 	dLabel := g.drawArrowLabel(e)
-	dPath, linesDrawn, lineDirs := g.drawPath(e.path)
-	dBoxStart := g.drawBoxStart(e.path, linesDrawn[0])
-	dArrowHead := g.drawArrowHead(linesDrawn[len(linesDrawn)-1], lineDirs[len(lineDirs)-1])
-	if e.isBidirectional && len(linesDrawn) > 0 {
-		dStartArrowHead := g.drawArrowHead(reverseDrawingLine(linesDrawn[0]), lineDirs[0].getOpposite())
+	dPath, linesDrawn, lineDirs := g.drawPath(e.path, e.stroke)
+	dBoxStart := g.drawBoxStart(e.path, linesDrawn[0], e.stroke)
+	skipHead := e.head == headNone
+	if skipHead && len(linesDrawn) > 0 {
+		// headNone (open links like ---) has no arrowhead glyph to mark the
+		// connection at the destination, unlike every other head; touch up
+		// the destination box's own border the same way drawBoxStart does
+		// for the source, so the join is visible there too.
+		dBoxEnd := g.drawBoxEnd(linesDrawn[len(linesDrawn)-1], lineDirs[len(lineDirs)-1], e.stroke)
+		dBoxStart = g.mergeDrawings(dBoxStart, drawingCoord{0, 0}, dBoxEnd)
+	}
+	var dArrowHead *drawing
+	if skipHead {
+		dArrowHead = copyCanvas(g.drawing)
+	} else {
+		dArrowHead = g.drawArrowHead(linesDrawn[len(linesDrawn)-1], lineDirs[len(lineDirs)-1], e.head)
+	}
+	if e.isBidirectional && !skipHead && len(linesDrawn) > 0 {
+		dStartArrowHead := g.drawArrowHead(reverseDrawingLine(linesDrawn[0]), lineDirs[0].getOpposite(), e.head)
 		dArrowHead = g.mergeDrawings(dArrowHead, drawingCoord{0, 0}, dStartArrowHead)
 	}
-	dCorners := g.drawCorners(e.path)
+	dCorners := g.drawCorners(e.path, e.stroke)
 	return dPath, dBoxStart, dArrowHead, dCorners, dLabel
 }
 
@@ -160,7 +174,7 @@ func mergePath(path []gridCoord) []gridCoord {
 	return newPath
 }
 
-func (g *graph) drawPath(path []gridCoord) (*drawing, [][]drawingCoord, []direction) {
+func (g *graph) drawPath(path []gridCoord, stroke edgeStroke) (*drawing, [][]drawingCoord, []direction) {
 	d := copyCanvas(g.drawing)
 	previousCoord := path[0]
 	linesDrawn := make([][]drawingCoord, 0)
@@ -174,7 +188,7 @@ func (g *graph) drawPath(path []gridCoord) (*drawing, [][]drawingCoord, []direct
 			continue
 		}
 		dir := determineDirection(genericCoord(previousCoord), genericCoord(nextCoord))
-		s := g.drawLine(d, previousDrawingCoord, nextDrawingCoord, 1, -1)
+		s := g.drawLine(d, previousDrawingCoord, nextDrawingCoord, 1, -1, stroke)
 		if len(s) == 0 {
 			// drawLine may return no coords if offsets collapse the line. Use at least one point so arrow and junction logic
 			// can still infer a direction.
@@ -187,7 +201,7 @@ func (g *graph) drawPath(path []gridCoord) (*drawing, [][]drawingCoord, []direct
 	return d, linesDrawn, lineDirs
 }
 
-func (g *graph) drawBoxStart(path []gridCoord, firstLine []drawingCoord) *drawing {
+func (g *graph) drawBoxStart(path []gridCoord, firstLine []drawingCoord, stroke edgeStroke) *drawing {
 	d := *(copyCanvas(g.drawing))
 	from := firstLine[0]
 	dir := determineDirection(genericCoord(path[0]), genericCoord(path[1]))
@@ -197,6 +211,13 @@ func (g *graph) drawBoxStart(path []gridCoord, firstLine []drawingCoord) *drawin
 		return &d
 	}
 
+	// A heavy line meeting a light box border looks mismatched through a
+	// light T-junction glyph (e.g. "├"); leave the box's own light border
+	// character in place instead.
+	if stroke == strokeThick {
+		return &d
+	}
+
 	switch dir {
 	case Up:
 		d[from.x][from.y+1] = "┴"
@@ -210,7 +231,32 @@ func (g *graph) drawBoxStart(path []gridCoord, firstLine []drawingCoord) *drawin
 	return &d
 }
 
-func (g *graph) drawArrowHead(line []drawingCoord, fallback direction) *drawing {
+// drawBoxEnd is drawBoxStart's mirror for the destination end of a path.
+func (g *graph) drawBoxEnd(lastLine []drawingCoord, dir direction, stroke edgeStroke) *drawing {
+	d := *(copyCanvas(g.drawing))
+	if len(lastLine) == 0 {
+		return &d
+	}
+	to := lastLine[len(lastLine)-1]
+
+	if g.useAscii || stroke == strokeThick {
+		return &d
+	}
+
+	switch dir {
+	case Up:
+		d[to.x][to.y-1] = "┬"
+	case Down:
+		d[to.x][to.y+1] = "┴"
+	case Left:
+		d[to.x-1][to.y] = "├"
+	case Right:
+		d[to.x+1][to.y] = "┤"
+	}
+	return &d
+}
+
+func (g *graph) drawArrowHead(line []drawingCoord, fallback direction, head edgeHead) *drawing {
 	d := *(copyCanvas(g.drawing))
 	if len(line) == 0 {
 		return &d
@@ -222,6 +268,22 @@ func (g *graph) drawArrowHead(line []drawingCoord, fallback direction) *drawing
 		dir = fallback
 	}
 
+	// Circle and cross heads are a single glyph regardless of travel direction.
+	if head == headCircle || head == headCross {
+		char := "o"
+		if head == headCross {
+			char = "x"
+		}
+		if !g.useAscii {
+			char = "●"
+			if head == headCross {
+				char = "✕"
+			}
+		}
+		d[lastPos.x][lastPos.y] = char
+		return &d
+	}
+
 	var char string
 	if !g.useAscii {
 		switch dir {
@@ -293,8 +355,12 @@ func (g *graph) drawArrowHead(line []drawingCoord, fallback direction) *drawing
 	return &d
 }
 
-func (g *graph) drawCorners(path []gridCoord) *drawing {
+func (g *graph) drawCorners(path []gridCoord, stroke edgeStroke) *drawing {
 	d := copyCanvas(g.drawing)
+	// Thick edges get the heavy box-drawing corner glyphs to match their
+	// heavy line/arrowhead; ASCII has no distinct "thick corner" (still
+	// "+"), and dotted corners are left as plain light corners.
+	thick := !g.useAscii && stroke == strokeThick
 	for idx, coord := range path {
 		// Skip the first and last step
 		if idx == 0 || idx == len(path)-1 {
@@ -310,12 +376,24 @@ func (g *graph) drawCorners(path []gridCoord) *drawing {
 			switch {
 			case (prevDir == Right && nextDir == Down) || (prevDir == Up && nextDir == Left):
 				corner = "┐"
+				if thick {
+					corner = "┓"
+				}
 			case (prevDir == Right && nextDir == Up) || (prevDir == Down && nextDir == Left):
 				corner = "┘"
+				if thick {
+					corner = "┛"
+				}
 			case (prevDir == Left && nextDir == Down) || (prevDir == Up && nextDir == Right):
 				corner = "┌"
+				if thick {
+					corner = "┏"
+				}
 			case (prevDir == Left && nextDir == Up) || (prevDir == Down && nextDir == Right):
 				corner = "└"
+				if thick {
+					corner = "┗"
+				}
 			default:
 				corner = "+"
 			}
@@ -353,7 +431,7 @@ func insetLine(line []drawingCoord, insetStart, insetEnd int) []drawingCoord {
 	}
 	endInset := insetEnd
 	if insetEnd > 0 {
-			endInset = insetEnd - 1 // shift label right ~1 char so the start dash survives the centered placement
+		endInset = insetEnd - 1 // shift label right ~1 char so the start dash survives the centered placement
 	}
 	dir := determineDirection(genericCoord(line[0]), genericCoord(line[1]))
 	a, b := line[0], line[1]

cmd/draw.go

@@ -66,32 +66,48 @@ func (d *drawing) drawText(start drawingCoord, text string) {
 	}
 }
 
-func (g *graph) drawLine(d *drawing, from drawingCoord, to drawingCoord, offsetFrom int, offsetTo int) []drawingCoord {
+func (g *graph) drawLine(d *drawing, from drawingCoord, to drawingCoord, offsetFrom int, offsetTo int, stroke edgeStroke) []drawingCoord {
 	// Offset determines how far from the actual coord the line should start/stop.
 	direction := determineDirection(genericCoord(from), genericCoord(to))
 	drawnCoords := make([]drawingCoord, 0)
-	log.Debug("Drawing line from ", from, " to ", to, " direction: ", direction, " offsetFrom: ", offsetFrom, " offsetTo: ", offsetTo)
+	log.Debug("Drawing line from ", from, " to ", to, " direction: ", direction, " offsetFrom: ", offsetFrom, " offsetTo: ", offsetTo, " stroke: ", stroke)
 	if !g.useAscii {
+		// Vertical glyph: solid "│", dotted "┆", thick "┃" - Unicode's own
+		// dedicated dashed/heavy box-drawing glyphs, so (unlike ASCII) no
+		// skip-cell pattern is needed for dotted; the glyph is dashed on its
+		// own. Horizontal glyph: solid "─", dotted "┄", thick "━".
+		vertical := "│"
+		if stroke == strokeThick {
+			vertical = "┃"
+		} else if stroke == strokeDotted {
+			vertical = "┆"
+		}
+		horizontal := "─"
+		if stroke == strokeThick {
+			horizontal = "━"
+		} else if stroke == strokeDotted {
+			horizontal = "┄"
+		}
 		switch direction {
 		case Up:
 			for y := from.y - offsetFrom; y >= to.y-offsetTo; y-- {
 				drawnCoords = append(drawnCoords, drawingCoord{from.x, y})
-				(*d)[from.x][y] = "│"
+				(*d)[from.x][y] = vertical
 			}
 		case Down:
 			for y := from.y + offsetFrom; y <= to.y+offsetTo; y++ {
 				drawnCoords = append(drawnCoords, drawingCoord{from.x, y})
-				(*d)[from.x][y] = "│"
+				(*d)[from.x][y] = vertical
 			}
 		case Left:
 			for x := from.x - offsetFrom; x >= to.x-offsetTo; x-- {
 				drawnCoords = append(drawnCoords, drawingCoord{x, from.y})
-				(*d)[x][from.y] = "─"
+				(*d)[x][from.y] = horizontal
 			}
 		case Right:
 			for x := from.x + offsetFrom; x <= to.x+offsetTo; x++ {
 				drawnCoords = append(drawnCoords, drawingCoord{x, from.y})
-				(*d)[x][from.y] = "─"
+				(*d)[x][from.y] = horizontal
 			}
 		case UpperLeft:
 			for x, y := from.x, from.y-offsetFrom; x >= to.x-offsetTo && y >= to.y-offsetTo; x, y = x-1, y-1 {
@@ -115,26 +131,45 @@ func (g *graph) drawLine(d *drawing, from drawingCoord, to drawingCoord, offsetF
 			}
 		}
 	} else {
+		// Vertical glyphs: solid "|", dotted ":" (every row - ASCII has no
+		// dashed-vertical glyph to space out), thick "I" (a plain, dot-less
+		// stroke; ASCII has no true double-width vertical). Horizontal
+		// glyph: solid/dotted share "-" (dotted skips every other cell
+		// below), thick "=".
+		vertical := "|"
+		if stroke == strokeThick {
+			vertical = "I"
+		} else if stroke == strokeDotted {
+			vertical = ":"
+		}
+		horizontal := "-"
+		if stroke == strokeThick {
+			horizontal = "="
+		}
 		switch direction {
 		case Up:
 			for y := from.y - offsetFrom; y >= to.y-offsetTo; y-- {
 				drawnCoords = append(drawnCoords, drawingCoord{from.x, y})
-				(*d)[from.x][y] = "|"
+				(*d)[from.x][y] = vertical
 			}
 		case Down:
 			for y := from.y + offsetFrom; y <= to.y+offsetTo; y++ {
 				drawnCoords = append(drawnCoords, drawingCoord{from.x, y})
-				(*d)[from.x][y] = "|"
+				(*d)[from.x][y] = vertical
 			}
 		case Left:
-			for x := from.x - offsetFrom; x >= to.x-offsetTo; x-- {
+			for i, x := 0, from.x-offsetFrom; x >= to.x-offsetTo; i, x = i+1, x-1 {
 				drawnCoords = append(drawnCoords, drawingCoord{x, from.y})
-				(*d)[x][from.y] = "-"
+				if stroke != strokeDotted || i%2 == 0 {
+					(*d)[x][from.y] = horizontal
+				}
 			}
 		case Right:
-			for x := from.x + offsetFrom; x <= to.x+offsetTo; x++ {
+			for i, x := 0, from.x+offsetFrom; x <= to.x+offsetTo; i, x = i+1, x+1 {
 				drawnCoords = append(drawnCoords, drawingCoord{x, from.y})
-				(*d)[x][from.y] = "-"
+				if stroke != strokeDotted || i%2 == 0 {
+					(*d)[x][from.y] = horizontal
+				}
 			}
 		case UpperLeft:
 			for x, y := from.x, from.y-offsetFrom; x >= to.x-offsetTo && y >= to.y-offsetTo; x, y = x-1, y-1 {

cmd/graph.go

@@ -106,6 +106,8 @@ func mkGraph(data *orderedmap.OrderedMap[string, []textEdge], nodeSpecs map[stri
 				to:              childNode,
 				text:            textEdge.label,
 				isBidirectional: textEdge.isBidirectional,
+				stroke:          textEdge.stroke,
+				head:            textEdge.head,
 			}
 			g.edges = append(g.edges, &e)
 		}

cmd/mapping_edge.go

@@ -6,11 +6,36 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
+// edgeStroke is the line style drawn along an edge's path. Only ASCII
+// output (g.useAscii) currently distinguishes them; Unicode output always
+// renders a solid line regardless of stroke.
+type edgeStroke int
+
+const (
+	strokeSolid edgeStroke = iota
+	strokeDotted
+	strokeThick
+)
+
+// edgeHead is the glyph drawn at an edge's arrowhead end. headNone means no
+// glyph is drawn at all (an open link like ---). Only ASCII output currently
+// distinguishes them; Unicode output always draws a directional arrowhead.
+type edgeHead int
+
+const (
+	headArrow edgeHead = iota
+	headCircle
+	headCross
+	headNone
+)
+
 type edge struct {
 	from            *node
 	to              *node
 	text            string
 	isBidirectional bool
+	stroke          edgeStroke
+	head            edgeHead
 	path            []gridCoord
 	labelLine       []gridCoord
 	startDir        direction