205 lines
6.4 KiB
Go
205 lines
6.4 KiB
Go
package tui
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
"github.com/charmbracelet/lipgloss"
|
|
"github.com/charmbracelet/x/ansi"
|
|
)
|
|
|
|
// Each visit is a separate node, preserving cycles. Only recorded routes are drawn.
|
|
func (m Model) runPathGraph() protocol.Graph {
|
|
r := m.runDetail
|
|
if r == nil {
|
|
return protocol.Graph{}
|
|
}
|
|
graph := protocol.Graph{}
|
|
for i, step := range r.Steps {
|
|
node := protocol.Stage{Key: m.runVisitKey(i), Edges: map[string]string{}}
|
|
if step.Target != "" && step.Outcome != "" {
|
|
if protocol.IsTerminal(step.Target) {
|
|
node.Edges[step.Outcome] = step.Target
|
|
} else if i+1 < len(r.Steps) && r.Steps[i+1].Stage == step.Target {
|
|
node.Edges[step.Outcome] = m.runVisitKey(i + 1)
|
|
}
|
|
}
|
|
graph.Stages = append(graph.Stages, node)
|
|
}
|
|
return graph
|
|
}
|
|
|
|
func (m Model) runVisitKey(index int) string {
|
|
step := m.runDetail.Steps[index]
|
|
return fmt.Sprintf("%d. %s (%s)", step.Sequence, step.Stage, m.stepProgressStatus(step))
|
|
}
|
|
|
|
func (m Model) runGraphLines(_ int) []string {
|
|
graph, selected, appearance := m.runGraphState()
|
|
if len(graph.Stages) == 0 {
|
|
return []string{"Waiting for the first stage…"}
|
|
}
|
|
return renderGraphAppearance(graph, selected, appearance)
|
|
}
|
|
|
|
func (m Model) runGraphState() (protocol.Graph, string, *graphAppearance) {
|
|
if m.runDetail == nil {
|
|
return protocol.Graph{}, "", nil
|
|
}
|
|
r := m.runDetail
|
|
graph := r.Graph
|
|
// Older servers may omit the graph. Never substitute a different version.
|
|
if len(graph.Stages) == 0 && m.detail != nil && m.detail.ID == r.PipelineID && m.detail.Version == r.Version {
|
|
graph = m.detail.Graph
|
|
}
|
|
index := len(r.Steps) - 1
|
|
if m.runStepIndex > 0 && m.runStepIndex <= len(r.Steps) {
|
|
index = m.runStepIndex - 1
|
|
}
|
|
if len(graph.Stages) == 0 {
|
|
graph = m.runPathGraph()
|
|
selected := ""
|
|
if index >= 0 {
|
|
selected = graph.Stages[index].Key
|
|
}
|
|
return graph, selected, nil
|
|
}
|
|
appearance := &graphAppearance{nodes: map[string]bool{}, routes: map[graphRoute]bool{}, labels: map[string]string{}}
|
|
for _, stage := range graph.Stages {
|
|
appearance.labels[stage.Key] = stage.Key + " · ○ pending"
|
|
}
|
|
for _, step := range r.Steps {
|
|
appearance.nodes[step.Stage] = true
|
|
appearance.labels[step.Stage] = step.Stage + " · " + ansi.Strip(m.progress(m.stepProgressStatus(step)))
|
|
if step.Target != "" && step.Outcome != "" {
|
|
target := protocol.ResolveTarget(step.Outcome, step.Target)
|
|
appearance.routes[graphRoute{step.Stage, step.Outcome, target}] = true
|
|
if protocol.IsTerminal(target) {
|
|
appearance.nodes[target] = true
|
|
}
|
|
}
|
|
}
|
|
selected := r.CurrentStage
|
|
if index >= 0 {
|
|
selected = r.Steps[index].Stage
|
|
}
|
|
return graph, selected, appearance
|
|
}
|
|
|
|
func (m Model) runsView(height int) string {
|
|
if m.runDetail == nil || height < 14 {
|
|
return m.runsDetailsView(height)
|
|
}
|
|
graphHeight := height / 2
|
|
top, pan := m.runGraphTop, m.runGraphPan
|
|
if !m.runGraphFocus {
|
|
top, pan = m.runGraphFollow()
|
|
}
|
|
graph := m.runGraphPanel(graphHeight, top, pan)
|
|
details := m.runsDetailsView(height - graphHeight)
|
|
return fitBlock(strings.Split(graph+"\n"+details, "\n"), m.width, height)
|
|
}
|
|
|
|
func (m Model) runGraphTitle() string {
|
|
r := m.runDetail
|
|
if r == nil {
|
|
return "Run graph"
|
|
}
|
|
durationLabel := "elapsed"
|
|
if r.FinishedAt != "" {
|
|
durationLabel = "duration"
|
|
}
|
|
title := "Run graph · " + durationLabel + " " + runDuration(r.CreatedAt, r.FinishedAt) + " · started " + dateLabel(r.CreatedAt)
|
|
if m.runGraphFocus {
|
|
title = "▸ " + title
|
|
}
|
|
if r.FinishedAt != "" {
|
|
title += " · finished " + dateLabel(r.FinishedAt)
|
|
}
|
|
return title
|
|
}
|
|
|
|
func (m Model) runGraphFollow() (int, int) {
|
|
graph, selected, appearance := m.runGraphState()
|
|
if len(graph.Stages) == 0 {
|
|
return 0, 0
|
|
}
|
|
rows := max(1, (m.height-4)/2-5)
|
|
lines, compact := m.fittedRunGraph(max(1, m.width-4), rows)
|
|
if compact {
|
|
for i, line := range lines {
|
|
if strings.HasPrefix(ansi.Strip(line), "▸ ") {
|
|
return max(0, i-rows/2), 0
|
|
}
|
|
}
|
|
return 0, 0
|
|
}
|
|
layout := layoutGraphAppearance(graph, appearance)
|
|
for _, node := range layout.nodes {
|
|
if node.key == selected {
|
|
return max(0, node.y-rows/2), max(0, node.x-(m.width-4-node.width)/2)
|
|
}
|
|
}
|
|
return 0, 0
|
|
}
|
|
|
|
func (m Model) fittedRunGraph(width, rows int) ([]string, bool) {
|
|
lines := m.runGraphLines(width)
|
|
widest := 0
|
|
for _, line := range lines {
|
|
widest = max(widest, ansi.StringWidth(line))
|
|
}
|
|
if widest <= width && len(lines) <= rows {
|
|
return lines, false
|
|
}
|
|
graph, selected, appearance := m.runGraphState()
|
|
if appearance == nil {
|
|
return lines, false
|
|
}
|
|
// Dense overview preserves every declared branch, rather than hiding nodes
|
|
// or scaling terminal text into unreadable glyphs.
|
|
lines = nil
|
|
for _, stage := range graph.Stages {
|
|
prefix := " "
|
|
if stage.Key == selected {
|
|
prefix = "▸ "
|
|
}
|
|
line := prefix + appearance.title(stage.Key, appearance.label(stage.Key), stage.Key == selected, graph)
|
|
for _, outcome := range outcomes(stage) {
|
|
target := protocol.ResolveTarget(outcome, stage.Edges[outcome])
|
|
color, bold := appearance.edgeStyle(graphEdge{source: stage.Key, outcome: outcome, target: target})
|
|
line += " " + lipgloss.NewStyle().Foreground(color).Bold(bold).Render(outcome+" → "+nodeLabel(target))
|
|
}
|
|
lines = append(lines, strings.Split(ansi.Wrap(line, max(1, width), ""), "\n")...)
|
|
}
|
|
lines = append(lines, appearance.title(protocol.SuccessEnd, "SUCCESS", false, graph)+" "+appearance.title(protocol.FailureEnd, "FAILURE", false, graph))
|
|
return lines, true
|
|
}
|
|
|
|
func (m Model) runGraphPanel(height, top, pan int) string {
|
|
width, rows := max(1, m.width-4), max(0, height-5)
|
|
lines, compact := m.fittedRunGraph(width, rows)
|
|
widest := 0
|
|
for _, line := range lines {
|
|
widest = max(widest, ansi.StringWidth(line))
|
|
}
|
|
pan = max(0, min(pan, max(0, widest-width)))
|
|
top = max(0, min(top, max(0, len(lines)-rows)))
|
|
leftPad, topPad := max(0, (width-widest)/2), max(0, (rows-len(lines))/2)
|
|
body := make([]string, topPad)
|
|
for _, line := range lines[top:min(len(lines), top+rows-topPad)] {
|
|
body = append(body, strings.Repeat(" ", leftPad)+ansi.Cut(line, pan, pan+width-leftPad))
|
|
}
|
|
label := m.runGraphTitle()
|
|
if compact {
|
|
label += " · compact"
|
|
}
|
|
footer := "Tab pane · n/p stage · dim = not executed"
|
|
if widest > width || len(lines) > rows {
|
|
footer = "h/j/k/l pan · c center · Tab pane · n/p stage"
|
|
}
|
|
header := runPaneTitle(strings.TrimPrefix(label, "▸ "), "", width, m.runGraphFocus)
|
|
return panel(m.width, height, []string{header, ""}, body, footer, m.runGraphFocus)
|
|
}
|