diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailSheet.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailSheet.kt new file mode 100644 index 00000000..add13cff --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/StageDetailSheet.kt @@ -0,0 +1,270 @@ +package net.awan.pipelines.ui.graph + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.widthIn +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.BottomSheetDefaults +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.ModalBottomSheet +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.material3.rememberModalBottomSheetState +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.semantics.heading +import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.unit.dp +import net.awan.pipelines.data.protocol.Graph +import net.awan.pipelines.data.protocol.GraphSemantics +import net.awan.pipelines.data.protocol.Protocol +import net.awan.pipelines.data.protocol.RunStep +import net.awan.pipelines.data.protocol.Stage +import net.awan.pipelines.data.protocol.edges +import net.awan.pipelines.ui.components.CodeBlock +import net.awan.pipelines.ui.components.DETAIL_MAX_WIDTH_DP +import net.awan.pipelines.ui.components.KeyValueRow +import net.awan.pipelines.ui.formatDuration +import net.awan.pipelines.ui.theme.pipelinesText + +/** + * The effective stage type, mirroring internal/stage.EffectiveType: a blank type + * is the model stage. Kept pure so the sheet chip and the node description share + * one derivation. + */ +internal fun effectiveStageType(type: String?): String = + if (type.isNullOrBlank()) "model" else type + +/** One labelled row/block of stage detail, rendered by the sheet. */ +internal data class StageField( + val label: String, + val value: String, + val mono: Boolean = false, + val block: Boolean = false, +) + +/** + * The pure definition view of a [stage]: key + type title, prompt, output, edges + * with their outcomes and resolved terminals, configs, tools, limits and memory + * sources. Only non-blank fields are emitted, so the sheet never shows an empty + * row and no protocol field is invented. + */ +internal fun stageDefinitionFields(stage: Stage): List { + val fields = ArrayList() + fields += StageField("Type", effectiveStageType(stage.type)) + if (stage.prompt.isNotBlank()) fields += StageField("Prompt", stage.prompt, block = true) + if (stage.output.isNotBlank()) fields += StageField("Output", stage.output, block = true) + + val outcomes = GraphSemantics.outcomes(stage).map { outcome -> + val target = Protocol.resolveTarget(outcome, stage.edges[outcome] ?: "") + val label = GraphSemantics.nodeLabel(target) + val suffix = if (Protocol.isTerminal(target)) " (terminal)" else "" + "$outcome → $label$suffix" + } + if (outcomes.isNotEmpty()) { + fields += StageField("Outcomes", outcomes.joinToString("\n"), block = true) + } + + stage.configs.keys.sorted().forEach { key -> + val value = stage.configs.getValue(key) + if (value.isNotBlank()) fields += StageField(configLabel(key), value) + } + + stage.blocks?.get("tools")?.takeIf { it.isNotBlank() }?.let { + fields += StageField("Tools", it, block = true) + } + + stage.limits?.let { limits -> + if (limits.maxVisits > 0) fields += StageField("Max visits", limits.maxVisits.toString()) + val on = limits.on.orEmpty() + if (on.isNotEmpty()) fields += StageField("Limit on", on.joinToString(", ")) + } + + stage.memory?.takeIf { it.isNotEmpty() }?.let { memory -> + fields += StageField( + "Memory", + memory.entries.joinToString("\n") { "${it.key}: ${it.value}" }, + block = true, + ) + } + + stage.notify?.let { policy -> + if (policy.on.isNotEmpty()) fields += StageField("Notify on", policy.on.joinToString(", ")) + if (policy.destination.isNotBlank()) fields += StageField("Notify destination", policy.destination) + val artifacts = policy.artifacts.orEmpty() + if (artifacts.isNotEmpty()) fields += StageField("Notify artifacts", artifacts.joinToString(", ")) + } + return fields +} + +/** + * The pure run view of one [RunStep] for the selected stage: status, outcome, + * duration, visit against the control's max_visits, target, session id, + * diagnostic, transcript, a file-change summary and notification receipts. Blank + * fields are skipped. + */ +internal fun runStepFields(step: RunStep): List { + val fields = ArrayList() + if (step.status.isNotBlank()) fields += StageField("Status", step.status) + if (step.outcome.isNotBlank()) fields += StageField("Outcome", step.outcome) + formatDuration(step.startedAt, step.finishedAt)?.let { fields += StageField("Duration", it) } + step.control?.let { control -> + val suffix = if (control.limitReached) " (limit reached)" else "" + when { + control.maxVisits > 0 -> fields += StageField("Visit", "${control.visit} / ${control.maxVisits}$suffix") + control.visit > 0 -> fields += StageField("Visit", control.visit.toString()) + } + control.modelTarget?.takeIf { it.isNotBlank() }?.let { fields += StageField("Model target", it) } + } + if (step.target.isNotBlank()) fields += StageField("Target", step.target) + if (step.sessionId.isNotBlank()) fields += StageField("Session", step.sessionId, mono = true) + if (step.agentActive) fields += StageField("Agent", "active") + if (step.diagnostic.isNotBlank()) fields += StageField("Diagnostic", step.diagnostic, block = true) + if (step.transcript.isNotBlank()) fields += StageField("Transcript", step.transcript, block = true) + + step.fileChanges?.let { changes -> + val summary = buildString { + append(changes.status) + if (changes.files.isNotEmpty()) append(" (${changes.files.size} files)") + if (changes.skipped > 0) append(", ${changes.skipped} skipped") + }.trim().trimStart(',') + if (summary.isNotBlank()) fields += StageField("File changes", summary) + if (changes.files.isNotEmpty()) { + fields += StageField( + "Changed files", + changes.files.joinToString("\n") { file -> + "${file.kind} ${file.path}" + + (if (file.binary) " (binary)" else "") + + (if (file.truncated) " (truncated)" else "") + }, + block = true, + ) + } + } + + step.notifications.orEmpty().forEach { receipt -> + if (receipt.status.isNotBlank() || receipt.destination.isNotBlank()) { + fields += StageField( + "Notification", + "${receipt.status} → ${receipt.destination}" + + (receipt.diagnostic?.takeIf { it.isNotBlank() }?.let { " · $it" } ?: ""), + ) + } + } + return fields +} + +/** Incoming routes into a terminal node, for the sheet opened on a terminal. */ +internal fun terminalFields(graph: Graph, key: String): List { + val lines = graph.edges() + .filter { it.target == key } + .map { "${it.source} · ${it.label} → ${GraphSemantics.nodeLabel(key)}" } + return if (lines.isEmpty()) { + emptyList() + } else { + listOf(StageField("Incoming routes", lines.joinToString("\n"), block = true)) + } +} + +private fun configLabel(key: String): String = when (key) { + "provider" -> "Provider" + "model" -> "Model" + "retries" -> "Retries" + "timeout" -> "Timeout" + "budget_usd" -> "Budget (USD)" + "budget_tokens" -> "Budget (tokens)" + "harness" -> "Harness" + else -> key +} + +/** + * The one reusable stage-detail overlay, opened when a node in [WorkflowGraph] is + * tapped. It is a Material 3 [ModalBottomSheet] that opens near full height + * (`skipPartiallyExpanded`), is scrollable, and dismisses by swipe, back or + * tapping outside. On a wide window it reuses the screens' responsive centring + * (the shared [DETAIL_MAX_WIDTH_DP]) instead of stretching one narrow column. It + * is an overlay on the current screen; no navigation route is added. + */ +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun StageDetailSheet( + stageKey: String, + graph: Graph, + runStep: RunStep?, + onDismiss: () -> Unit, +) { + val text = pipelinesText() + val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true) + val stage = graph.stages.firstOrNull { it.key == stageKey } + val definition = stage?.let(::stageDefinitionFields) ?: terminalFields(graph, stageKey) + val run = runStep?.let(::runStepFields).orEmpty() + val typeLabel = if (stage != null) effectiveStageType(stage.type) else "terminal" + + ModalBottomSheet( + onDismissRequest = onDismiss, + sheetState = sheetState, + dragHandle = { BottomSheetDefaults.DragHandle() }, + ) { + Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.TopCenter) { + Column( + modifier = Modifier + .widthIn(max = DETAIL_MAX_WIDTH_DP.dp) + .fillMaxWidth() + .verticalScroll(rememberScrollState()) + .padding(horizontal = 16.dp, vertical = 8.dp), + verticalArrangement = Arrangement.spacedBy(4.dp), + ) { + Text( + GraphSemantics.nodeLabel(stageKey), + style = text.screenTitle, + modifier = Modifier.semantics { heading() }, + ) + TypeChip(typeLabel) + if (definition.isNotEmpty()) { + Text("Definition", style = text.sectionHeader, modifier = Modifier.padding(top = 8.dp)) + definition.forEach { field -> FieldRow(field) } + } + if (run.isNotEmpty()) { + Text("This run", style = text.sectionHeader, modifier = Modifier.padding(top = 8.dp)) + run.forEach { field -> FieldRow(field) } + } + if (definition.isEmpty() && run.isEmpty()) { + Text("No details recorded for this node.", style = text.meta) + } + } + } + } +} + +/** One field as either the shared code card (blocks) or a key/value row. */ +@Composable +private fun FieldRow(field: StageField) { + if (field.block) { + CodeBlock(field.label, field.value) + } else { + KeyValueRow(field.label, field.value, monospace = field.mono) + } +} + +/** A small rounded chip naming the stage type (model / ntfy / …). */ +@Composable +private fun TypeChip(label: String) { + Surface( + shape = RoundedCornerShape(50), + color = MaterialTheme.colorScheme.secondaryContainer, + ) { + Text( + text = label, + style = MaterialTheme.typography.labelMedium, + color = MaterialTheme.colorScheme.onSecondaryContainer, + modifier = Modifier.padding(horizontal = 10.dp, vertical = 4.dp), + ) + } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt index 48eef38b..01e0c8f6 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt @@ -3,12 +3,15 @@ package net.awan.pipelines.ui.graph import androidx.compose.foundation.Canvas import androidx.compose.foundation.ExperimentalFoundationApi import androidx.compose.foundation.background +import androidx.compose.foundation.gestures.detectTapGestures import androidx.compose.foundation.gestures.detectTransformGestures import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.offset import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size import androidx.compose.foundation.relocation.BringIntoViewRequester import androidx.compose.foundation.relocation.bringIntoViewRequester import androidx.compose.material.icons.Icons @@ -35,14 +38,19 @@ import androidx.compose.ui.geometry.Offset import androidx.compose.ui.geometry.Size import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.Path +import androidx.compose.ui.graphics.TransformOrigin import androidx.compose.ui.graphics.drawscope.DrawScope import androidx.compose.ui.graphics.drawscope.Stroke import androidx.compose.ui.graphics.drawscope.withTransform +import androidx.compose.ui.graphics.graphicsLayer import androidx.compose.ui.input.pointer.pointerInput import androidx.compose.ui.layout.onSizeChanged import androidx.compose.ui.platform.LocalConfiguration import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.semantics.Role import androidx.compose.ui.semantics.contentDescription +import androidx.compose.ui.semantics.onClick +import androidx.compose.ui.semantics.role import androidx.compose.ui.semantics.semantics import androidx.compose.ui.text.TextMeasurer import androidx.compose.ui.text.TextStyle @@ -50,10 +58,12 @@ import androidx.compose.ui.text.drawText import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.rememberTextMeasurer import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.IntOffset import androidx.compose.ui.unit.IntSize import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.sp import kotlin.math.abs +import kotlin.math.roundToInt import kotlinx.coroutines.launch import net.awan.pipelines.data.protocol.Graph import net.awan.pipelines.data.protocol.GraphEdge @@ -71,7 +81,11 @@ internal data class NodeLayout( val width: Float, val height: Float, val terminal: Boolean, -) +) { + /** The graph-space rect hit when a tap lands inside this node. */ + fun contains(point: Offset): Boolean = + point.x >= x && point.x <= x + width && point.y >= y && point.y <= y + height +} internal data class EdgeLayout( val edge: GraphEdge, @@ -85,10 +99,18 @@ internal data class EdgeLayout( val bottomExit: Boolean, val sourceRank: Int, val targetRank: Int, - // Index of this edge among the outgoing edges of its source plus how many - // there are, so each label can get its own row instead of overprinting. - val labelSlot: Int, - val labelCount: Int, + // True for a non-adjacent non-terminal route (a feedback or jump edge): it + // leaves the source, drops to its own lane, travels across and rises into the + // target's left edge, mirroring the TUI's arc/multi-run tracks. + val across: Boolean, + // The edge's own horizontal lane and the vertical track columns it uses, all + // allocated once by [layoutGraph] (stable edge-id order) so drawing and + // hit-testing share exactly one allocation and no two routes share a track. + val lane: Float, + val trackX: Float, + val leadX: Float, + // Where this edge's outcome label is drawn (on the edge's own lane/track). + val labelPoint: Offset, // The axis-aligned polyline this edge is drawn along, computed once by // [routePoints] during layout so drawing never re-routes per frame. val points: List = emptyList(), @@ -116,6 +138,10 @@ internal data class ZoomResult(val offset: Offset, val scale: Float) * the `error*` fallback marker, `#success`/`#failure` terminals and loop routes. * When [runState] is supplied, executed stages/routes are highlighted and the * rest dimmed; when it is null the full definition is shown. + * + * A tap that lands inside a node (stage or terminal) calls [onStageTap] with the + * node key; tapping empty space does nothing. Pan/zoom keep working because the + * tap detector is separate from the transform detector. */ @OptIn(ExperimentalFoundationApi::class) @Composable @@ -124,6 +150,7 @@ fun WorkflowGraph( modifier: Modifier = Modifier, runState: RunGraphState? = null, selectedStage: String? = null, + onStageTap: (String) -> Unit = {}, ) { val density = LocalDensity.current val configuration = LocalConfiguration.current @@ -222,6 +249,16 @@ fun WorkflowGraph( .background(MaterialTheme.colorScheme.surface) .semantics { contentDescription = description } .onSizeChanged { canvasSize = it } + // A tap is mapped through the current transform to graph space and + // hit-tested against the (single) layout allocation. It runs only on a + // tap, never per frame; empty space does nothing and pan/zoom are + // untouched because this is a separate detector. + .pointerInput(layout) { + detectTapGestures { position -> + val graphPoint = toGraphPoint(position, offset, scale) + hitTest(layout, graphPoint)?.let(onStageTap) + } + } .pointerInput(layout) { detectTransformGestures { centroid, pan, zoom, _ -> userAdjusted = true @@ -253,6 +290,39 @@ fun WorkflowGraph( drawNodes(layout, colors, runState, selectedStage, textMeasurer) } } + // Accessibility overlay: invisible nodes carrying a click action and a + // spoken label. It shares the canvas transform (graphicsLayer) and the + // layout's coordinates, so a screen reader reaches exactly the nodes that + // hit-testing reaches. It has no pointer handler, so it never steals the + // pan/zoom gestures from the Canvas below. + Box( + Modifier + .fillMaxSize() + .graphicsLayer( + translationX = offset.x, + translationY = offset.y, + scaleX = scale, + scaleY = scale, + transformOrigin = TransformOrigin(0f, 0f), + ), + ) { + layout.nodes.forEach { node -> + val nodeType = graph.stages.firstOrNull { it.key == node.key }?.type + Box( + Modifier + .offset { IntOffset(node.x.roundToInt(), node.y.roundToInt()) } + .size(with(density) { node.width.toDp() }, with(density) { node.height.toDp() }) + .semantics { + contentDescription = nodeDescription(node, nodeType) + role = Role.Button + onClick(label = "Open details for ${node.label}") { + onStageTap(node.key) + true + } + }, + ) + } + } Row( modifier = Modifier.align(Alignment.TopEnd).padding(4.dp), ) { @@ -305,6 +375,13 @@ private class GraphColors( val labelText: Color, ) +/** The accessibility label for one node, naming its type when it is a stage. */ +private fun nodeDescription(node: NodeLayout, type: String?): String { + if (node.terminal) return "Terminal ${node.label}, tap for details" + val typeLabel = effectiveStageType(type) + return "Stage ${node.label}, $typeLabel, tap for details" +} + /** * Uniform scale that fits [content] inside [viewport] with [padding] on every * side, never upscaling above 1:1. Degenerate (zero/negative) content or @@ -373,29 +450,169 @@ internal fun zoomAbout( return ZoomResult(anchored, newScale) } +/** + * The draw transform is `p * scale + offset`, so a tap in viewport space maps to + * graph space as `(tap - offset) / scale`. Pure, so hit-test mapping is unit + * tested without Compose; a degenerate scale returns [Offset.Zero] instead of + * dividing by zero. + */ +internal fun toGraphPoint(tap: Offset, offset: Offset, scale: Float): Offset { + if (!scale.isFinite() || scale == 0f) return Offset.Zero + return (tap - offset) / scale +} + +/** The key of the stage/terminal whose rect contains [graphPoint], else null. */ +internal fun hitTest(layout: GraphLayout, graphPoint: Offset): String? = + layout.nodes.firstOrNull { it.contains(graphPoint) }?.key + +/** + * A tiny one-dimensional allocator that places a run at the first position, + * starting from [desired] and stepping outward by `step`, that is at least `step` + * away from every already-placed run whose cross-interval overlaps. It is the + * single mechanism that keeps two edges off the same row/column: horizontal runs + * pass their x-interval, vertical runs their y-interval. Deterministic because + * callers allocate in stable edge-id order. + */ +private class SegmentAllocator(private val eps: Float) { + private val pos = ArrayList() + private val lo = ArrayList() + private val hi = ArrayList() + + fun allocate(desired: Float, from: Float, to: Float, min: Float, max: Float, step: Float): Float { + val start = desired.coerceIn(min, max) + val a = minOf(from, to) + val b = maxOf(from, to) + var k = 0 + while (k <= 512) { + val candidates = if (k == 0) listOf(start) else listOf(start + k * step, start - k * step) + for (candidate in candidates) { + if (candidate < min || candidate > max) continue + if (isFree(candidate, a, b)) { + record(candidate, a, b) + return candidate + } + } + k++ + } + record(start, a, b) + return start + } + + private fun isFree(candidate: Float, a: Float, b: Float): Boolean { + for (i in pos.indices) { + if (abs(pos[i] - candidate) < eps && lo[i] <= b && a <= hi[i]) return false + } + return true + } + + private fun record(candidate: Float, a: Float, b: Float) { + pos.add(candidate) + lo.add(a) + hi.add(b) + } +} + +/** + * A partially-routed edge. Routing runs in passes over these holders so the gap + * tracks are all placed before any under-node/terminal port vertical, which is + * what stops a later route being starved into sharing a column (the original + * overlap defect). Mutable only during layout. + */ +private class RouteParts( + val edge: GraphEdge, + val source: NodeLayout, + val target: NodeLayout, + val sourceRank: Int, + val targetRank: Int, + val forward: Boolean, + val bottomExit: Boolean, + val topEntry: Boolean, + val backEdge: Boolean, + val across: Boolean, + val lane: Float, +) { + var fromX = 0f + var fromY = 0f + var toX = 0f + var toY = 0f + var trackX = 0f + var leadX = 0f +} + +/** Centred fan for the k-th of n ports: 0, +s, -s, +2s, -2s, ... around centre. */ +private fun portOffset(index: Int, spacing: Float): Float { + if (index == 0) return 0f + val magnitude = ((index + 1) / 2).toFloat() + val sign = if (index % 2 == 1) 1f else -1f + return sign * magnitude * spacing +} + +/** True for an edge that goes to the immediately following stage. */ +private fun forwardAdjacent(edge: GraphEdge, rank: Map): Boolean = + !Protocol.isTerminal(edge.target) && + (rank[edge.target] ?: 0) == (rank[edge.source] ?: 0) + 1 + internal fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density): GraphLayout { if (graph.stages.isEmpty()) return GraphLayout(emptyList(), emptyList(), 0f, 0f) val nodeWidth = with(density) { 132.dp.toPx() } - val nodeHeight = with(density) { 56.dp.toPx() } - val hGap = with(density) { 88.dp.toPx() } + val portSpacing = with(density) { 12.dp.toPx() } + val hGap = with(density) { 132.dp.toPx() } val pad = with(density) { 32.dp.toPx() } - val terminalRowGap = with(density) { 72.dp.toPx() } + val laneSpacing = with(density) { 26.dp.toPx() } + val terminalGap = with(density) { 64.dp.toPx() } + val trackStep = with(density) { 18.dp.toPx() } + val minNodeHeight = with(density) { 56.dp.toPx() } val ranks = rankStages(graph) + val edges = graph.edges() val hasTerminal = graph.stages.any { stage -> stage.edges.values.any { Protocol.isTerminal(it) || it == "#" } } - // Stages occupy a single top row in declaration order, exactly like - // tui.layoutSingleRowGraph: x grows with the declared stage index and every - // stage shares the same y. + // Port demand per node, so the node grows tall enough to host one port per + // distinct edge leaving/entering it (the distinct-port requirement). + val outCount = HashMap() + val inCount = HashMap() + val bottomCount = HashMap() + for (edge in edges) { + val bottom = edge.outcome == "error" && edge.target == Protocol.FAILURE_END + val forward = forwardAdjacent(edge, ranks) + if (!bottom && !forward) outCount[edge.source] = (outCount[edge.source] ?: 0) + 1 + if (bottom) bottomCount[edge.source] = (bottomCount[edge.source] ?: 0) + 1 + if (!Protocol.isTerminal(edge.target) && !forward) { + inCount[edge.target] = (inCount[edge.target] ?: 0) + 1 + } + } + val terminalIn = HashMap() + if (hasTerminal) { + terminalIn[Protocol.FAILURE_END] = edges.count { it.target == Protocol.FAILURE_END } + terminalIn[Protocol.SUCCESS_END] = edges.count { it.target == Protocol.SUCCESS_END } + } + var maxPorts = 1 + (outCount.values + inCount.values + bottomCount.values + terminalIn.values).forEach { + maxPorts = maxOf(maxPorts, it) + } + val nodeHeight = maxOf(minNodeHeight, (maxPorts + 1) * portSpacing) + val portLo = pad + portSpacing * 0.5f + val portHi = pad + nodeHeight - portSpacing * 0.5f + + val stageCount = graph.stages.size + val contentLeft = pad + hGap + fun stageX(index: Int) = contentLeft + index * (nodeWidth + hGap) + fun gapBounds(gap: Int): Pair = when { + gap <= 0 -> pad to contentLeft + gap >= stageCount -> (stageX(stageCount - 1) + nodeWidth) to + (stageX(stageCount - 1) + nodeWidth + hGap) + else -> (stageX(gap - 1) + nodeWidth) to stageX(gap) + } + val positions = HashMap() graph.stages.forEachIndexed { index, stage -> positions[stage.key] = NodeLayout( key = stage.key, label = GraphSemantics.nodeLabel(stage.key), - x = pad + index * (nodeWidth + hGap), + x = stageX(index), y = pad, width = nodeWidth, height = nodeHeight, @@ -403,24 +620,38 @@ internal fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density ) } - val stageRowInner = graph.stages.size * nodeWidth + - (graph.stages.size - 1).coerceAtLeast(0) * hGap - val terminalPairInner = 2 * nodeWidth + hGap - val contentInner = if (hasTerminal) maxOf(stageRowInner, terminalPairInner) else stageRowInner - val width = pad * 2 + contentInner + val stageRowRight = stageX(stageCount - 1) + nodeWidth + val stageBottom = pad + nodeHeight + + // Every non-forward edge needs its own cross lane, stacked below the stage + // row in stable edge-id order; the terminal row sits below all of them. + val laneIds = edges.filterNot { forwardAdjacent(it, ranks) } + val laneIndexById = HashMap() + laneIds.forEachIndexed { index, edge -> laneIndexById[edge.id] = index } + fun laneY(edge: GraphEdge) = stageBottom + ((laneIndexById[edge.id] ?: 0) + 1) * laneSpacing + val terminalY = stageBottom + (laneIds.size + 1) * laneSpacing + terminalGap + + // Terminal widths grow with their incoming-edge count so every incoming route + // gets its own top port without crowding (mirroring the TUI's per-incoming + // terminal width). + val terminalWidthFor = { incoming: Int -> maxOf(nodeWidth, incoming * trackStep + 4 * portSpacing) } + val failureWidth = if (hasTerminal) terminalWidthFor(terminalIn[Protocol.FAILURE_END] ?: 0) else nodeWidth + val successWidth = if (hasTerminal) terminalWidthFor(terminalIn[Protocol.SUCCESS_END] ?: 0) else nodeWidth + val terminalPairInner = failureWidth + successWidth + hGap + val width = maxOf(stageRowRight + hGap + pad, terminalPairInner + 2 * pad) if (hasTerminal) { // Both terminals share one lower row, FAILURE left of SUCCESS, the pair // centred on the content width, so incoming arrows enter their top border. - val terminalY = pad + nodeHeight + terminalRowGap - val failureX = pad + (contentInner - terminalPairInner) / 2f - val successX = failureX + nodeWidth + hGap + val centre = width / 2f + val failureX = centre - terminalPairInner / 2f + val successX = failureX + failureWidth + hGap positions[Protocol.FAILURE_END] = NodeLayout( key = Protocol.FAILURE_END, label = GraphSemantics.nodeLabel(Protocol.FAILURE_END), x = failureX, y = terminalY, - width = nodeWidth, + width = failureWidth, height = nodeHeight, terminal = true, ) @@ -429,93 +660,282 @@ internal fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density label = GraphSemantics.nodeLabel(Protocol.SUCCESS_END), x = successX, y = terminalY, - width = nodeWidth, + width = successWidth, height = nodeHeight, terminal = true, ) } - val edges = graph.edges() - val countsBySource = edges.groupingBy { it.source }.eachCount() - val slotsBySource = HashMap() - val edgeLayouts = edges.mapNotNull { edge -> + // One shared allocator per axis so no two collinear runs overlap. Horizontal + // runs pass their x-interval, vertical runs their y-interval. + val horizontals = SegmentAllocator(eps = portSpacing) + val verticals = SegmentAllocator(eps = trackStep / 3f) + + // Forward edges are allocated first: a straight forward route keeps a single + // horizontal segment by sharing one y between its source and target ports. + val forwardEdges = edges.filter { forwardAdjacent(it, ranks) } + val forwardY = HashMap() + forwardEdges.forEachIndexed { index, edge -> + val source = positions[edge.source] ?: return@forEachIndexed + val target = positions[edge.target] ?: return@forEachIndexed + val y = source.y + source.height / 2f - + (forwardEdges.size - 1) / 2f * portSpacing + index * portSpacing + forwardY[edge.id] = horizontals.allocate( + desired = y, + from = source.x + source.width, + to = target.x, + min = portLo, + max = portHi, + step = portSpacing, + ) + } + + // Routing happens in three passes so a later allocation can never be starved + // by an earlier one: (1) horizontal port anchors, (2) the gap tracks, then + // (3) the bottom/terminal port verticals that live under the nodes. + val parts = edges.mapNotNull { edge -> val source = positions[edge.source] ?: return@mapNotNull null val target = positions[edge.target] ?: return@mapNotNull null val sourceRank = ranks[edge.source] ?: 0 val targetIsTerminal = Protocol.isTerminal(edge.target) val targetRank = if (targetIsTerminal) graph.stages.size else (ranks[edge.target] ?: 0) val bottomExit = edge.outcome == "error" && edge.target == Protocol.FAILURE_END - val labelSlot = slotsBySource.getOrDefault(edge.source, 0) - slotsBySource[edge.source] = labelSlot + 1 - EdgeLayout( + val forward = forwardAdjacent(edge, ranks) + // A terminal target is entered from the top (mirroring tui.graphEdge.topEntry), + // including an error->#failure route that leaves the source bottom. + val topEntry = targetIsTerminal + val backEdge = !targetIsTerminal && targetRank <= sourceRank + val across = !targetIsTerminal && !forward + val part = RouteParts( edge = edge, - from = if (bottomExit) { - Offset(source.x + source.width / 2f, source.y + source.height) - } else { - Offset(source.x + source.width, source.y + source.height / 2f) - }, - to = if (targetIsTerminal) { - Offset(target.x + target.width / 2f, target.y) - } else { - Offset(target.x, target.y + target.height / 2f) - }, - backEdge = !targetIsTerminal && targetRank <= sourceRank, - topEntry = targetIsTerminal, - bottomExit = bottomExit, + source = source, + target = target, sourceRank = sourceRank, targetRank = targetRank, - labelSlot = labelSlot, - labelCount = countsBySource[edge.source] ?: 1, - ).let { it.copy(points = routePoints(it)) } + forward = forward, + bottomExit = bottomExit, + topEntry = topEntry, + backEdge = backEdge, + across = across, + lane = laneY(edge), + ) + // Pass 1: horizontal anchors. + when { + bottomExit -> { + part.fromX = Float.NaN + part.fromY = source.y + source.height + } + forward -> { + part.fromX = source.x + source.width + part.fromY = forwardY[edge.id] ?: (source.y + source.height / 2f) + } + else -> { + val slot = edges.filter { + it.source == edge.source && !forwardAdjacent(it, ranks) && + !(it.outcome == "error" && it.target == Protocol.FAILURE_END) + }.indexOfFirst { it.id == edge.id } + part.fromX = source.x + source.width + part.fromY = horizontals.allocate( + desired = source.y + source.height / 2f + portOffset(slot, portSpacing), + from = source.x + source.width, + to = source.x + source.width + hGap, + min = portLo, + max = portHi, + step = portSpacing, + ) + } + } + when { + forward -> { + part.toX = target.x + part.toY = forwardY[edge.id] ?: (target.y + target.height / 2f) + } + targetIsTerminal -> { + part.toX = Float.NaN + part.toY = target.y + } + else -> { + val slot = edges.filter { + it.target == edge.target && !Protocol.isTerminal(it.target) && + !forwardAdjacent(it, ranks) + }.indexOfFirst { it.id == edge.id } + part.toX = target.x + part.toY = horizontals.allocate( + desired = target.y + target.height / 2f + portOffset(slot, portSpacing), + from = target.x - hGap, + to = target.x, + min = portLo, + max = portHi, + step = portSpacing, + ) + } + } + part } - val height = pad * 2 + nodeHeight + (if (hasTerminal) terminalRowGap + nodeHeight else 0f) + // Pass 2: the vertical tracks in the gaps. + for (part in parts) { + if (part.topEntry && !part.bottomExit) { + val (gapLo, gapHi) = gapBounds(part.sourceRank + 1) + part.trackX = verticals.allocate( + desired = gapLo + trackStep, + from = minOf(part.fromY, part.lane), + to = maxOf(part.fromY, part.lane), + min = gapLo + trackStep / 2f, + max = gapHi - trackStep / 2f, + step = trackStep, + ) + } else if (part.across) { + val (sourceGapLo, sourceGapHi) = gapBounds(part.sourceRank + 1) + part.trackX = verticals.allocate( + desired = sourceGapLo + trackStep, + from = minOf(part.fromY, part.lane), + to = maxOf(part.fromY, part.lane), + min = sourceGapLo + trackStep / 2f, + max = sourceGapHi - trackStep / 2f, + step = trackStep, + ) + val (targetGapLo, targetGapHi) = gapBounds(part.targetRank) + part.leadX = verticals.allocate( + desired = targetGapHi - trackStep, + from = minOf(part.lane, part.toY), + to = maxOf(part.lane, part.toY), + min = targetGapLo + trackStep / 2f, + max = targetGapHi - trackStep / 2f, + step = trackStep, + ) + } + } + + // Pass 3: the bottom-exit drop and the terminal top-drop. + for (part in parts) { + if (part.bottomExit) { + val bottomIndex = edges.filter { + it.outcome == "error" && it.target == Protocol.FAILURE_END && it.source == part.edge.source + }.indexOfFirst { it.id == part.edge.id } + part.fromX = verticals.allocate( + desired = part.source.x + part.source.width / 2f + portOffset(bottomIndex, portSpacing), + from = part.source.y + part.source.height, + to = part.lane, + min = part.source.x + portSpacing, + max = part.source.x + part.source.width - portSpacing, + step = trackStep, + ) + } + if (part.topEntry) { + val slot = edges.filter { it.target == part.edge.target }.indexOfFirst { it.id == part.edge.id } + part.toX = verticals.allocate( + desired = part.target.x + part.target.width / 2f + portOffset(slot, portSpacing), + from = part.lane, + to = part.target.y, + min = part.target.x + portSpacing, + max = part.target.x + part.target.width - portSpacing, + step = trackStep, + ) + } + } + + val edgeLayouts = parts.map { part -> + val layout = EdgeLayout( + edge = part.edge, + from = Offset(part.fromX, part.fromY), + to = Offset(part.toX, part.toY), + backEdge = part.backEdge, + topEntry = part.topEntry, + bottomExit = part.bottomExit, + sourceRank = part.sourceRank, + targetRank = part.targetRank, + across = part.across, + lane = part.lane, + trackX = part.trackX, + leadX = part.leadX, + labelPoint = Offset.Zero, + ) + val points = routePoints(layout) + layout.copy(points = points, labelPoint = labelPointFor(layout, points)) + } + + val height = pad * 2 + nodeHeight + (if (hasTerminal) { + (laneIds.size + 1) * laneSpacing + terminalGap + nodeHeight + } else { + 0f + }) return GraphLayout(positions.values.toList(), edgeLayouts, width, height) } +/** + * Where this edge's outcome label is drawn: the midpoint of its own lane run (or + * its single straight segment for a forward edge), so each label travels on that + * edge's own track instead of overprinting a neighbouring route. Pure, and the + * point is stored on [EdgeLayout] so drawing never recomputes it. + */ +private fun labelPointFor(edge: EdgeLayout, points: List): Offset { + if (points.size < 2) return edge.from + if (!edge.bottomExit && !edge.topEntry && !edge.across) { + return (points.first() + points.last()) / 2f + } + // The lane run is the widest horizontal segment of the route. + var best: Pair? = null + var bestWidth = -1f + for (i in 1 until points.size) { + val a = points[i - 1] + val b = points[i] + if (a.y == b.y && abs(b.x - a.x) > bestWidth) { + bestWidth = abs(b.x - a.x) + best = a to b + } + } + val (a, b) = best ?: return points.first() + return Offset((a.x + b.x) / 2f, a.y) +} + /** * The axis-aligned polyline an edge is drawn along: horizontal and vertical runs * joined at right angles, mirroring internal/tui/graph_layout.go (source track -> * lane -> target track). Pure and independent of drawing so tests can assert it - * and layout can precompute it once per edge. + * and layout can precompute it once per edge; it only reads the ports/lanes the + * allocator already fixed on [edge]. * - * - `bottomExit` (error -> #failure) drops out of the source's bottom, runs - * across above the terminal and drops into its top border. - * - `topEntry` (any other terminal) leaves the source's right edge, drops into a - * lane just above the lower terminal row, then drops into the terminal top. - * - `backEdge` (loop) dips below the stages, runs back horizontally and enters - * the target's left edge. - * - a forward edge is a single horizontal segment when source and target share a - * y, otherwise an L across a shared mid-x. + * - `bottomExit` (error -> #failure) drops out of the source's bottom port into + * its own lane and down into the terminal's own top port. + * - `topEntry` (any other terminal) leaves the source's right-edge port, uses + * its own vertical track and lane and drops into the terminal's own top port. + * - `across` (a loop or jump) uses its own bottom dip lane and its own lead + * column into the target's own left port. + * - a forward edge is a single horizontal segment when its ports share a y. * * Consecutive equal points are collapsed so no zero-length segment is produced. */ internal fun routePoints(edge: EdgeLayout): List { val raw = when { - edge.bottomExit -> { - val approachY = edge.to.y - BOTTOM_EXIT_APPROACH - listOf(edge.from, Offset(edge.from.x, approachY), Offset(edge.to.x, approachY), edge.to) - } - edge.topEntry -> { - val laneY = edge.to.y - LANE_APPROACH - listOf(edge.from, Offset(edge.from.x, laneY), Offset(edge.to.x, laneY), edge.to) - } - edge.backEdge -> { - val dipY = maxOf(edge.from.y, edge.to.y) + BACK_EDGE_DIP - val leadX = edge.to.x - BACK_EDGE_LEAD - listOf( - edge.from, - Offset(edge.from.x, dipY), - Offset(leadX, dipY), - Offset(leadX, edge.to.y), - edge.to, - ) - } + edge.bottomExit -> listOf( + edge.from, + Offset(edge.from.x, edge.lane), + Offset(edge.to.x, edge.lane), + edge.to, + ) + edge.topEntry -> listOf( + edge.from, + Offset(edge.trackX, edge.from.y), + Offset(edge.trackX, edge.lane), + Offset(edge.to.x, edge.lane), + edge.to, + ) + edge.across -> listOf( + edge.from, + Offset(edge.trackX, edge.from.y), + Offset(edge.trackX, edge.lane), + Offset(edge.leadX, edge.lane), + Offset(edge.leadX, edge.to.y), + edge.to, + ) edge.from.y == edge.to.y -> listOf(edge.from, edge.to) - else -> { - val midX = (edge.from.x + edge.to.x) / 2f - listOf(edge.from, Offset(midX, edge.from.y), Offset(midX, edge.to.y), edge.to) - } + else -> listOf( + edge.from, + Offset(edge.trackX, edge.from.y), + Offset(edge.trackX, edge.to.y), + edge.to, + ) } val points = ArrayList(raw.size) for (point in raw) { @@ -577,10 +997,12 @@ private fun DrawScope.drawEdgePaths( /** * Draws every outcome label in a second pass, after all curves, so a - * neighbouring edge can never be drawn across a label. Executed edges use a - * legible on-surface variant of their outcome colour (see [outcomeLabelColor]); - * dimmed edges use a muted colour on a near-opaque background instead of - * inheriting the curve's 0.25 alpha, which left the text unreadable. + * neighbouring edge can never be drawn across a label. Each label sits on its + * own edge's stored [EdgeLayout.labelPoint] (the edge's own lane/track), so + * distinct outcomes never overprint. Executed edges use a legible on-surface + * variant of their outcome colour (see [outcomeLabelColor]); dimmed edges use a + * muted colour on a near-opaque background instead of inheriting the curve's + * 0.25 alpha, which left the text unreadable. */ private fun DrawScope.drawEdgeLabels( layout: GraphLayout, @@ -592,16 +1014,9 @@ private fun DrawScope.drawEdgeLabels( val executed = edge.isExecuted(runState) val textColor = if (executed) outcomeLabelColor(edge.edge, colors) else colors.labelText val measured = textMeasurer.measure(edge.edge.label, TextStyle(fontSize = 11.sp, color = textColor)) - // Every outgoing edge of a stage shares the same `from` anchor, so drawing - // each label at a fixed offset overprints distinct outcomes (success/error, - // blocked/skipped). Give each label its own row in a per-source stack, - // mirroring the independent ports/tracks of internal/tui/graph_layout.go, - // and draw a near-opaque background so crossing edges stay legible. - val spread = (edge.labelCount - 1) / 2f val labelTopLeft = Offset( - x = edge.from.x + 8f, - y = edge.from.y - measured.size.height / 2f + - (edge.labelSlot - spread) * (measured.size.height + 2f), + x = edge.labelPoint.x - measured.size.width / 2f, + y = edge.labelPoint.y - measured.size.height - 2f, ) drawRect( color = colors.labelBackground.copy(alpha = if (executed) 0.92f else 0.86f), @@ -738,24 +1153,13 @@ private fun graphDescription(graph: Graph, runState: RunGraphState?): String { builder.append("Outcome $label goes to ${GraphSemantics.nodeLabel(target)}. ") } } + builder.append("Stages can be tapped for details.") return builder.toString() } private const val MIN_SCALE = 0.3f private const val MAX_SCALE = 3f -/** How far below the stage row a loop route dips before curving back. */ -private const val BACK_EDGE_DIP = 64f - -/** How far above a terminal's top border the bottom-exit route levels off. */ -private const val BOTTOM_EXIT_APPROACH = 32f - -/** How far above the target's left edge a loop route levels off before entering. */ -private const val BACK_EDGE_LEAD = 24f - -/** How far above the terminal row a top-entry route runs before dropping in. */ -private const val LANE_APPROACH = 32f - /** Breathing room left around a fitted graph, and the least content kept visible. */ private val FIT_PADDING = 16.dp private val MIN_VISIBLE = 48.dp diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt index 8cd4208e..c2664a45 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt @@ -47,6 +47,7 @@ import net.awan.pipelines.ui.components.KeyValueRow import net.awan.pipelines.ui.components.LoadingState import net.awan.pipelines.ui.components.collapsibleSection import net.awan.pipelines.ui.components.pipelineDetailTabs +import net.awan.pipelines.ui.graph.StageDetailSheet import net.awan.pipelines.ui.graph.WorkflowGraph import net.awan.pipelines.ui.theme.pipelinesText @@ -189,6 +190,9 @@ private fun PipelineSummaryTab(detail: PipelineDetail, wide: Boolean, modifier: @Composable private fun PipelineGraphTab(detail: PipelineDetail, modifier: Modifier) { val text = pipelinesText() + // The stage whose detail sheet is open; survives configuration changes. The + // sheet is an overlay on this screen (no navigation route). + var selectedStage by rememberSaveable { mutableStateOf(null) } LazyColumn( modifier = modifier, contentPadding = PaddingValues(vertical = 16.dp), @@ -199,13 +203,25 @@ private fun PipelineGraphTab(detail: PipelineDetail, modifier: Modifier) { verticalArrangement = Arrangement.spacedBy(8.dp), ) { Text( - "Pinch to zoom, drag to pan. Edges are labelled with their outcome; error* is the implicit fallback.", + "Pinch to zoom, drag to pan, tap a stage for details. Edges are labelled with their outcome; error* is the implicit fallback.", style = text.meta, ) - WorkflowGraph(graph = detail.graph, modifier = Modifier.fillMaxWidth()) + WorkflowGraph( + graph = detail.graph, + modifier = Modifier.fillMaxWidth(), + onStageTap = { selectedStage = it }, + ) } } } + selectedStage?.let { key -> + StageDetailSheet( + stageKey = key, + graph = detail.graph, + runStep = null, + onDismiss = { selectedStage = null }, + ) + } } @Composable diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt index bf253c01..31d00bf3 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt @@ -76,6 +76,7 @@ import net.awan.pipelines.ui.components.runStateOf import net.awan.pipelines.ui.displayMap import net.awan.pipelines.ui.displayText import net.awan.pipelines.ui.formatDuration +import net.awan.pipelines.ui.graph.StageDetailSheet import net.awan.pipelines.ui.graph.WorkflowGraph import net.awan.pipelines.ui.theme.pipelinesText import net.awan.pipelines.ui.visitCount @@ -313,6 +314,8 @@ private fun RunSummaryTab(run: RunDetail, wide: Boolean, modifier: Modifier) { private fun RunGraphTab(run: RunDetail, modifier: Modifier) { val text = pipelinesText() val runState = remember(run.id, run.steps) { RunGraphState.from(run) } + // The stage whose detail sheet is open; the sheet overlays this screen. + var selectedStage by rememberSaveable { mutableStateOf(null) } LazyColumn( modifier = modifier, contentPadding = PaddingValues(vertical = 16.dp), @@ -326,7 +329,7 @@ private fun RunGraphTab(run: RunDetail, modifier: Modifier) { Text("This server did not include the run graph.", style = text.meta) } else { Text( - "Executed stages and routes are highlighted; the rest are dimmed. Pinch to zoom, drag to pan.", + "Executed stages and routes are highlighted; the rest are dimmed. Pinch to zoom, drag to pan, tap a stage for details.", style = text.meta, ) WorkflowGraph( @@ -334,11 +337,22 @@ private fun RunGraphTab(run: RunDetail, modifier: Modifier) { modifier = Modifier.fillMaxWidth(), runState = runState, selectedStage = runState.currentStage, + onStageTap = { selectedStage = it }, ) } } } } + selectedStage?.let { key -> + StageDetailSheet( + stageKey = key, + graph = run.graph, + // This run's latest step for the stage (a stage can be visited more + // than once); null when the run never reached it. + runStep = run.steps.lastOrNull { it.stage == key }, + onDismiss = { selectedStage = null }, + ) + } } /** diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt index 1e865eec..f75ca759 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt @@ -7,6 +7,7 @@ import net.awan.pipelines.data.protocol.Graph import net.awan.pipelines.data.protocol.Protocol import net.awan.pipelines.data.protocol.Stage import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Test import kotlin.math.hypot @@ -24,6 +25,30 @@ class WorkflowGraphTest { ), ) + /** + * A denser graph than [sampleGraph]: many multi-outcome nodes, several edges + * into each terminal, two routes to the same next stage, a forward jump and + * further back edges. The per-edge track invariant must hold here too. + */ + private fun denseGraph() = Graph( + stages = listOf( + stage("a", mapOf("success" to "b", "fast" to "c", "error" to "#failure", "abort" to "#failure")), + stage("b", mapOf("success" to "c", "retry" to "a", "blocked" to "#failure", "error" to "#failure")), + stage("c", mapOf("success" to "d", "skip" to "d", "error" to "#failure")), + stage("d", mapOf("success" to "e", "error" to "#failure")), + stage( + "e", + mapOf( + "success" to "#success", + "done" to "#success", + "missing" to "#failure", + "revisit" to "b", + "stay" to "e", + ), + ), + ), + ) + /** * Regression for the back-edge ordering defect: `reviewer rejected -> implementer` * used to feed the longest-path relaxation and push `implementer` past @@ -392,4 +417,113 @@ class WorkflowGraphTest { val negative = zoomAbout(offset, 0.5f, Offset(80f, 60f), zoom = -2f, 0.3f, 3f) assertEquals(offset, negative.offset) } + + /** + * The fix: no two edges may share a collinear run. For every unordered pair + * of edges, no horizontal segment shares a y over an overlapping x range and + * no vertical segment shares an x over an overlapping y range. Verified on the + * sample graph and a denser multi-outcome / multi-terminal graph; crossings + * are still allowed, only overlaps are not. + */ + @Test + fun noTwoEdgesShareACollinearRun() { + for (graph in listOf(sampleGraph(), denseGraph())) { + assertNoSharedRuns(layoutGraph(graph, Density(1f))) + } + } + + /** Distinct edges leaving/entering one node must use distinct ports. */ + @Test + fun distinctEdgesUseDistinctPorts() { + for (graph in listOf(sampleGraph(), denseGraph())) { + val layout = layoutGraph(graph, Density(1f)) + layout.edges.groupBy { it.edge.source }.forEach { (source, list) -> + assertEquals("ports leaving $source", list.size, list.map { it.from }.toSet().size) + } + layout.edges.groupBy { it.edge.target }.forEach { (target, list) -> + assertEquals("ports entering $target", list.size, list.map { it.to }.toSet().size) + } + } + } + + /** Layout is pure and deterministic: two calls give equal routes. */ + @Test + fun layoutIsDeterministic() { + val first = layoutGraph(sampleGraph(), Density(1f)) + val second = layoutGraph(sampleGraph(), Density(1f)) + assertEquals(first.edges.map { it.points }, second.edges.map { it.points }) + } + + /** + * Hit-testing and the tap→graph transform are pure: a tap inside a stage + * returns that stage, a tap on a terminal returns the terminal and a tap on + * empty space returns null, at several pan and zoom values. Hit-testing uses + * the same layout (ports/tracks) as drawing. + */ + @Test + fun hitTestFindsNodesAtSeveralPansAndZooms() { + val layout = layoutGraph(sampleGraph(), Density(1f)) + val transforms = listOf( + Offset.Zero to 1f, + Offset(-140f, 60f) to 1.5f, + Offset(90f, -30f) to 0.5f, + ) + for ((offset, scale) in transforms) { + for (key in listOf("planner", "ui_reviewer", Protocol.FAILURE_END, Protocol.SUCCESS_END)) { + val node = layout.nodes.single { it.key == key } + val centre = Offset(node.x + node.width / 2f, node.y + node.height / 2f) + val tap = centre * scale + offset + assertEquals( + "tap on $key at scale $scale", + key, + hitTest(layout, toGraphPoint(tap, offset, scale)), + ) + } + val empty = Offset(layout.width + 500f, layout.height + 500f) + assertNull(hitTest(layout, toGraphPoint(empty * scale + offset, offset, scale))) + } + } + + private fun assertNoSharedRuns(layout: GraphLayout) { + val edges = layout.edges + for (i in edges.indices) { + for (j in i + 1 until edges.size) { + assertNoSharedRuns(edges[i], edges[j]) + } + } + } + + private fun assertNoSharedRuns(a: EdgeLayout, b: EdgeLayout) { + val message = "routes ${a.edge} and ${b.edge}" + for (i in 1 until a.points.size) { + val a0 = a.points[i - 1] + val a1 = a.points[i] + if (a0.y != a1.y) continue + val aMin = minOf(a0.x, a1.x) + val aMax = maxOf(a0.x, a1.x) + for (k in 1 until b.points.size) { + val b0 = b.points[k - 1] + val b1 = b.points[k] + if (b0.y != b1.y || b0.y != a0.y) continue + val bMin = minOf(b0.x, b1.x) + val bMax = maxOf(b0.x, b1.x) + assertTrue("$message share a horizontal run at y=${a0.y}", !(aMin < bMax && bMin < aMax)) + } + } + for (i in 1 until a.points.size) { + val a0 = a.points[i - 1] + val a1 = a.points[i] + if (a0.x != a1.x) continue + val aMin = minOf(a0.y, a1.y) + val aMax = maxOf(a0.y, a1.y) + for (k in 1 until b.points.size) { + val b0 = b.points[k - 1] + val b1 = b.points[k] + if (b0.x != b1.x || b0.x != a0.x) continue + val bMin = minOf(b0.y, b1.y) + val bMax = maxOf(b0.y, b1.y) + assertTrue("$message share a vertical run at x=${a0.x}", !(aMin < bMax && bMin < aMax)) + } + } + } }