Files

350 lines
9.7 KiB
Go

package tui
import (
"fmt"
"sort"
"strings"
"git.a-wan.net/alan/pipelines/internal/protocol"
"github.com/charmbracelet/lipgloss"
"github.com/charmbracelet/x/ansi"
)
func outcomes(stage protocol.Stage) []string {
keys := make([]string, 0, len(stage.Edges))
for key := range stage.Edges {
keys = append(keys, key)
}
sort.Slice(keys, func(i, j int) bool {
priority := func(k string) int {
if k == "success" {
return 0
}
if k == "error" {
return 2
}
return 1
}
if a, b := priority(keys[i]), priority(keys[j]); a != b {
return a < b
}
return keys[i] < keys[j]
})
return keys
}
func compactGraph(graph protocol.Graph) bool {
edges := 0
for _, stage := range graph.Stages {
edges += len(stage.Edges)
}
return len(graph.Stages) > 200 || edges > 500
}
type graphPoint struct{ x, y int }
type graphEdge struct {
id int
source, target, outcome, label string
from, to, lane, x int
left bool
path []graphPoint
topEntry bool
bottomExit bool
}
type graphNode struct {
key string
x, y, width, height int
}
type graphLayout struct {
nodes []graphNode
edges []graphEdge
nodeX, nodeWidth, width, height int
positions map[string]int
}
func graphEdges(graph protocol.Graph) []graphEdge {
index := map[string]int{protocol.SuccessEnd: len(graph.Stages), protocol.FailureEnd: len(graph.Stages) + 1}
for i, s := range graph.Stages {
index[s.Key] = i
}
var edges []graphEdge
for i, stage := range graph.Stages {
for _, outcome := range outcomes(stage) {
label := outcome
if outcome == "error" && stage.FallbackError {
label += "*"
}
target := protocol.ResolveTarget(outcome, stage.Edges[outcome])
edges = append(edges, graphEdge{id: len(edges) + 1, source: stage.Key, target: target, outcome: outcome, label: label, left: index[target] <= i})
}
}
return edges
}
func graphStageRow(graph protocol.Graph, key string) int {
if !compactGraph(graph) {
return layoutGraph(graph).positions[key]
}
row := 0
for _, stage := range graph.Stages {
if stage.Key == key {
return row
}
row += len(stage.Edges) + 1
}
return 0
}
func renderGraph(graph protocol.Graph, selection ...string) []string {
selected := ""
if len(selection) > 0 {
selected = selection[0]
}
return renderGraphAppearance(graph, selected, nil)
}
// A nil appearance is the normal definition view. Run views dim all nodes and
// routes not present in the audit, without removing any definition branches.
type graphAppearance struct {
nodes map[string]bool
routes map[graphRoute]bool
labels map[string]string
}
func (a *graphAppearance) label(key string) string {
if a != nil && a.labels[key] != "" {
return a.labels[key]
}
return nodeLabel(key)
}
func layoutGraphAppearance(graph protocol.Graph, appearance *graphAppearance) graphLayout {
if appearance == nil || len(appearance.labels) == 0 {
return layoutGraph(graph)
}
display := protocol.Graph{}
keys := map[string]string{}
label := func(key string) string {
if protocol.IsTerminal(key) {
return key
}
return appearance.label(key)
}
for _, stage := range graph.Stages {
copy := stage
copy.Key = label(stage.Key)
keys[copy.Key] = stage.Key
copy.Edges = map[string]string{}
for outcome, target := range stage.Edges {
copy.Edges[outcome] = label(protocol.ResolveTarget(outcome, target))
}
display.Stages = append(display.Stages, copy)
}
layout := layoutGraph(display)
for i, node := range layout.nodes {
if key, ok := keys[node.key]; ok {
layout.nodes[i].key = key
}
}
for i, edge := range layout.edges {
if key, ok := keys[edge.source]; ok {
layout.edges[i].source = key
}
if key, ok := keys[edge.target]; ok {
layout.edges[i].target = key
}
}
return layout
}
type graphRoute struct{ source, outcome, target string }
func (a *graphAppearance) nodeColor(key string, graph protocol.Graph) lipgloss.Color {
if a != nil && !a.nodes[key] {
return themeMuted
}
return stageColor(key, graph)
}
func (a *graphAppearance) title(key, label string, selected bool, graph protocol.Graph) string {
if a == nil {
return stageTitle(key, label, selected, graph)
}
s := lipgloss.NewStyle().Foreground(a.nodeColor(key, graph)).Bold(a.nodes[key])
if selected {
s = s.Background(themeSelection)
}
return s.Render(label)
}
func (a *graphAppearance) edgeStyle(edge graphEdge) (lipgloss.Color, bool) {
if a != nil && !a.routes[graphRoute{edge.source, edge.outcome, edge.target}] {
return themeMuted, false
}
return outcomeColor(edge.outcome), true
}
func renderGraphAppearance(graph protocol.Graph, selected string, appearance *graphAppearance) []string {
if len(graph.Stages) == 0 {
return []string{"(empty graph)"}
}
if compactGraph(graph) {
var lines []string
edges, index := graphEdges(graph), 0
for _, stage := range graph.Stages {
lines = append(lines, appearance.title(stage.Key, "["+appearance.label(stage.Key)+"]", stage.Key == selected, graph))
for range outcomes(stage) {
e := edges[index]
index++
color, bold := appearance.edgeStyle(e)
label := lipgloss.NewStyle().Foreground(color).Bold(bold).Render(fmt.Sprintf("└─ %s [%d] → ", e.label, e.id))
lines = append(lines, " "+label+appearance.title(e.target, "["+nodeLabel(e.target)+"]", false, graph))
}
}
return append(lines, appearance.title(protocol.FailureEnd, "[FAILURE]", false, graph)+" "+appearance.title(protocol.SuccessEnd, "[SUCCESS]", false, graph))
}
layout := layoutGraphAppearance(graph, appearance)
type cell struct {
glyph rune
color lipgloss.Color
bold bool
}
canvas := make([][]cell, layout.height)
for row := range canvas {
canvas[row] = make([]cell, layout.width)
for x := range canvas[row] {
canvas[row][x].glyph = ' '
}
}
put := func(x, y int, r rune, color lipgloss.Color, bold bool) { canvas[y][x] = cell{r, color, bold} }
text := func(x, y int, s string, color lipgloss.Color, bold bool) {
for _, r := range s {
put(x, y, r, color, bold)
x++
}
}
nodes := map[string]graphNode{}
for _, node := range layout.nodes {
nodes[node.key] = node
x, w, y, h := node.x, node.width, node.y, node.height
color := appearance.nodeColor(node.key, graph)
active := node.key == selected
top, bottom, vertical := "╭"+strings.Repeat("─", w-2)+"╮", "╰"+strings.Repeat("─", w-2)+"╯", '│'
if active {
top = "╔" + strings.Repeat("═", w-2) + "╗"
bottom = "╚" + strings.Repeat("═", w-2) + "╝"
vertical = '║'
}
text(x, y, top, color, active)
for row := y + 1; row < y+h-1; row++ {
put(x, row, vertical, color, active)
put(x+w-1, row, vertical, color, active)
}
text(x, y+h-1, bottom, color, active)
}
line := func(p graphPoint, r rune, color lipgloss.Color) {
// Edges are drawn in stable ID order. The earlier route stays intact at
// every crossing, including its color; never invent a joining glyph.
if canvas[p.y][p.x].glyph == ' ' {
put(p.x, p.y, r, color, false)
}
}
for _, edge := range layout.edges {
color, bold := appearance.edgeStyle(edge)
path := []graphPoint{}
for i := 1; i < len(edge.path); i++ {
a, b := edge.path[i-1], edge.path[i]
dx, dy := 0, 0
if b.x > a.x {
dx = 1
} else if b.x < a.x {
dx = -1
}
if b.y > a.y {
dy = 1
} else if b.y < a.y {
dy = -1
}
if len(path) == 0 {
path = append(path, a)
}
for a != b {
a.x += dx
a.y += dy
path = append(path, a)
}
}
for i := 1; i < len(path)-1; i++ {
p, a, b := path[i], path[i-1], path[i+1]
glyph := '─'
if a.x == b.x {
glyph = '│'
} else if a.y != b.y {
left, right, up, down := a.x < p.x || b.x < p.x, a.x > p.x || b.x > p.x, a.y < p.y || b.y < p.y, a.y > p.y || b.y > p.y
switch {
case right && down:
glyph = '┌'
case left && down:
glyph = '┐'
case right && up:
glyph = '└'
case left && up:
glyph = '┘'
}
}
line(p, glyph, color)
}
start, end := path[0], path[len(path)-1]
if edge.bottomExit {
put(start.x, start.y, '▼', color, bold)
} else {
put(start.x, start.y, '├', color, false)
put(start.x+1, start.y, '→', color, false)
}
if edge.topEntry {
put(end.x, end.y, '▼', color, bold)
text(end.x-1, end.y-1, fmt.Sprintf("[%d]", edge.id), color, bold)
} else {
put(end.x, end.y, '▶', color, bold)
target := nodes[edge.target]
text(target.x+2, edge.to, fmt.Sprintf("[%d]", edge.id), color, bold)
}
source := nodes[edge.source]
label := fmt.Sprintf("%s [%d]", edge.label, edge.id)
text(source.x+source.width-2-len(label), edge.from, label, color, bold)
}
result := make([]string, layout.height)
for row, cells := range canvas {
var b strings.Builder
end := len(cells)
for end > 0 && cells[end-1].glyph == ' ' {
end--
}
for x := 0; x < end; {
current, next := cells[x], x+1
for next < end && cells[next].color == current.color && cells[next].bold == current.bold {
next++
}
var run strings.Builder
for i := x; i < next; i++ {
run.WriteRune(cells[i].glyph)
}
style := lipgloss.NewStyle().Bold(current.bold)
if current.color != "" {
style = style.Foreground(current.color)
}
b.WriteString(style.Render(run.String()))
x = next
}
result[row] = b.String()
}
for _, node := range layout.nodes {
label, row := appearance.label(node.key), node.y+1
left := ansi.Cut(result[row], 0, node.x+1)
title := " " + label + strings.Repeat(" ", node.width-3-ansi.StringWidth(label))
right := ansi.Cut(result[row], node.x+node.width-1, layout.width)
result[row] = left + appearance.title(node.key, title, node.key == selected, graph) + right
}
return result
}