Merge branch 'worktree-agent-a3f73161a4ac21646' into integrate/graph-labels

This commit is contained in:
2026-10-31 16:37:08 +00:00
6 changed files with 794 additions and 111 deletions
@@ -4,6 +4,7 @@ import '../domain/graph_definition.dart';
import '../domain/graph_protocol.dart';
import '../routing/route_models.dart';
import 'layout_models.dart';
import 'linear_label_placement.dart';
/// Graph-space spacings for [layoutLinearGraph], the web's
/// `DEFAULT_GRAPH_METRICS` tightened for a phone-sized canvas.
@@ -27,19 +28,71 @@ class LinearGraphMetrics {
final double portSpacing;
final double labelPadding;
final double labelGap;
/// These metrics with every column gap and lane widened by [width] and
/// [height], making room for one more label in each.
LinearGraphMetrics widenedBy(double width, double height) =>
LinearGraphMetrics(
hGap: hGap + width,
pad: pad,
laneSpacing: laneSpacing + height,
terminalGap: terminalGap,
trackStep: trackStep,
portSpacing: portSpacing,
labelPadding: labelPadding,
labelGap: labelGap,
);
}
/// How many times [layoutLinearGraph] widens its gaps for a crowded label
/// before it falls back to the free shelf below the drawing.
const int _maxWidening = 4;
/// The web's `layoutGraph` (web/src/graph.js): stages keep their declaration
/// order on one row; Failure and Success share a lower row, Failure on the
/// left, the pair centred. Every edge that is not a straight step to the next
/// stage gets its own lane below the stage row, in stable edge-id order, so no
/// two runs share a track. Pure: measured extents in, geometry out.
///
/// No label box comes within [edgeLabelClearance] of a node or another label.
/// When a label finds no such spot on its own route, the column gaps and lanes
/// grow by the widest and tallest label and the layout runs again, rather than
/// letting a label cover a node.
(GraphLayout, GraphRouting) layoutLinearGraph({
required List<GraphNode> nodes,
required List<GraphEdge> edges,
required Map<String, NodeExtent> extents,
required Map<int, LabelExtent> labelExtents,
LinearGraphMetrics metrics = const LinearGraphMetrics(),
}) {
var widest = 0.0, tallest = 0.0;
for (final extent in labelExtents.values) {
widest = math.max(widest, extent.width);
tallest = math.max(tallest, extent.height);
}
var m = metrics;
for (var attempt = 0; ; attempt++) {
final (result, misfits) = _layoutPass(
nodes: nodes,
edges: edges,
extents: extents,
labelExtents: labelExtents,
metrics: m,
);
if (misfits.isEmpty || attempt == _maxWidening) return result;
m = m.widenedBy(
widest + 2 * edgeLabelClearance,
tallest + 2 * edgeLabelClearance,
);
}
}
((GraphLayout, GraphRouting), Set<int>) _layoutPass({
required List<GraphNode> nodes,
required List<GraphEdge> edges,
required Map<String, NodeExtent> extents,
required Map<int, LabelExtent> labelExtents,
required LinearGraphMetrics metrics,
}) {
final m = metrics;
final stages = [
@@ -90,20 +143,23 @@ class LinearGraphMetrics {
}
if (stages.isEmpty) {
return (
GraphLayout(
nodes: const [],
width: 0,
height: 0,
rankCount: 0,
ranks: const {},
),
GraphRouting(
routes: const [],
labels: const [],
skipped: skipped,
width: 0,
height: 0,
(
GraphLayout(
nodes: const [],
width: 0,
height: 0,
rankCount: 0,
ranks: const {},
),
GraphRouting(
routes: const [],
labels: const [],
skipped: skipped,
width: 0,
height: 0,
),
),
const <int>{},
);
}
@@ -228,15 +284,6 @@ class LinearGraphMetrics {
return (left.right, stageXs[gap]);
}
(double, double) gapContaining(double x) {
if (x < contentLeft) return (m.pad, contentLeft);
for (var gap = 1; gap < stageCount; gap++) {
final (lo, hi) = gapBounds(gap);
if (x <= hi) return (lo, hi);
}
return gapBounds(stageCount);
}
// Forward edges first: a straight route keeps one horizontal run by sharing
// its y between source and target, fanned per source so two labels clear.
final forwardY = <int, double>{};
@@ -277,7 +324,6 @@ class LinearGraphMetrics {
edge.outcome == 'error' && edge.target == failureEnd;
final routes = <EdgeRoute>[];
final labels = <EdgeLabelBox>[];
for (final edge in placed) {
final source = byKey[edge.source]!;
final target = byKey[edge.target]!;
@@ -423,40 +469,18 @@ class LinearGraphMetrics {
points: points,
),
);
final extent = labelOf(edge);
if (edge.label.isEmpty || extent.width == 0) continue;
final spot = _labelSpot(points, extent.width);
if (spot.vertical) {
// Beside a vertical run, kept inside its own gap clear of both boxes.
final (lo, hi) = gapContaining(spot.x);
final left = math.max(
lo + 2,
math.min(spot.x + m.labelGap, hi - extent.width - 2),
);
labels.add(
EdgeLabelBox(
edgeId: edge.id,
x: left,
y: spot.y - extent.height / 2,
width: extent.width,
height: extent.height,
),
);
} else {
// Above a horizontal run, centred on it.
labels.add(
EdgeLabelBox(
edgeId: edge.id,
x: spot.x - extent.width / 2,
y: spot.y - extent.height - m.labelGap,
width: extent.width,
height: extent.height,
),
);
}
}
// Every label keeps clear of every node and earlier label; one that finds
// no spot on its own route is a misfit, and the caller grows the gaps.
final placement = placeLinearLabels(
routes: routes,
extents: {for (final edge in placed) edge.id: labelOf(edge)},
nodes: boxes,
labelGap: m.labelGap,
);
final labels = placement.labels;
final contentBottom = hasTerminal
? boxes
.where((box) => box.terminal)
@@ -476,14 +500,17 @@ class LinearGraphMetrics {
ranks: {for (final box in boxes) box.key: box.rank},
);
return (
layout,
GraphRouting(
routes: routes,
labels: labels,
skipped: skipped,
width: right,
height: height,
(
layout,
GraphRouting(
routes: routes,
labels: labels,
skipped: skipped,
width: right,
height: height,
),
),
placement.misfits,
);
}
@@ -502,44 +529,6 @@ List<RoutePoint> _collapse(List<RoutePoint> points) {
return result;
}
/// The web's `labelPointFor`: the middle of the widest horizontal run that
/// holds the label, else the longest run, flagged when it is vertical.
({double x, double y, bool vertical}) _labelSpot(
List<RoutePoint> points,
double labelWidth,
) {
if (points.length < 2) {
return (x: points.first.x, y: points.first.y, vertical: false);
}
(RoutePoint, RoutePoint)? bestH;
var bestHw = -1.0;
(RoutePoint, RoutePoint)? bestV;
var bestVh = -1.0;
for (var i = 1; i < points.length; i++) {
final a = points[i - 1];
final b = points[i];
if (a.y == b.y && (b.x - a.x).abs() > bestHw) {
bestHw = (b.x - a.x).abs();
bestH = (a, b);
} else if (a.x == b.x && (b.y - a.y).abs() > bestVh) {
bestVh = (b.y - a.y).abs();
bestV = (a, b);
}
}
({double x, double y, bool vertical}) horizontal(
(RoutePoint, RoutePoint) run,
) => (x: (run.$1.x + run.$2.x) / 2, y: run.$1.y, vertical: false);
({double x, double y, bool vertical}) vertical(
(RoutePoint, RoutePoint) run,
) => (x: run.$1.x, y: (run.$1.y + run.$2.y) / 2, vertical: true);
if (bestH != null && bestHw >= math.max(labelWidth, 24)) {
return horizontal(bestH);
}
if (bestV != null && bestVh >= bestHw) return vertical(bestV);
if (bestH != null) return horizontal(bestH);
return vertical(bestV!);
}
/// Places a run at the first position from `desired`, stepping outward, that
/// keeps `eps` from every placed run whose cross-interval overlaps.
class _SegmentAllocator {
@@ -0,0 +1,260 @@
import 'dart:math' as math;
import '../routing/route_models.dart';
import 'layout_models.dart';
/// The space every placed edge label keeps from every node box and from every
/// other label, in logical pixels.
const double edgeLabelClearance = 4;
/// The labels for one set of routes, and the edges that found no spot on
/// their own route.
class LinearLabelPlacement {
const LinearLabelPlacement({required this.labels, required this.misfits});
/// One box per labelled route, in route order.
final List<EdgeLabelBox> labels;
/// Edge ids whose label had to leave its route for the free shelf below the
/// drawing. A layout grows its gaps and tries again while this is non-empty.
final Set<int> misfits;
}
/// Places one measured label per route so no label box comes within
/// [clearance] of a node box or of an earlier label.
///
/// Each label tries positions along its own route, beside a run with
/// [labelGap] to the wire: the longest horizontal run first (above, then
/// below), sliding from the middle towards both ends, then the other
/// horizontal runs, then vertical runs (right, then left). A first pass also
/// keeps the box off every wire; a second pass allows crossing a wire but
/// never a node or a label. A label with no free spot on its route goes to a
/// shelf below everything and is reported in [LinearLabelPlacement.misfits].
LinearLabelPlacement placeLinearLabels({
required List<EdgeRoute> routes,
required Map<int, LabelExtent> extents,
required List<GraphNodeBox> nodes,
required double labelGap,
double clearance = edgeLabelClearance,
}) {
final labels = <EdgeLabelBox>[];
final misfits = <int>{};
final pending = <(EdgeRoute, LabelExtent)>[];
for (final route in routes) {
final extent = extents[route.id];
if (route.label.isEmpty || extent == null || extent.width == 0) continue;
final candidates = _candidates(route, extent, labelGap);
_Rect? chosen;
for (final avoidWires in const [true, false]) {
for (final rect in candidates) {
if (_free(rect, nodes, labels, clearance) &&
(!avoidWires || !_crossesWire(rect, routes))) {
chosen = rect;
break;
}
}
if (chosen != null) break;
}
if (chosen == null) {
misfits.add(route.id);
pending.add((route, extent));
continue;
}
labels.add(_box(route.id, chosen));
}
// The shelf sits below every node, wire and label, so it cannot overlap.
var shelf = 0.0;
for (final node in nodes) {
shelf = math.max(shelf, node.bottom);
}
for (final route in routes) {
for (final point in route.points) {
shelf = math.max(shelf, point.y);
}
}
for (final label in labels) {
shelf = math.max(shelf, label.bottom);
}
for (final (route, extent) in pending) {
var top = shelf + clearance + labelGap;
final left = math.max(0.0, _centreX(route) - extent.width / 2);
var rect = _Rect(left, top, extent.width, extent.height);
while (!_free(rect, nodes, labels, clearance)) {
top += extent.height + clearance;
rect = _Rect(left, top, extent.width, extent.height);
}
labels.add(_box(route.id, rect));
}
labels.sort(
(a, b) => _indexOf(routes, a.edgeId).compareTo(_indexOf(routes, b.edgeId)),
);
return LinearLabelPlacement(labels: labels, misfits: misfits);
}
/// Whether two axis-aligned boxes come within [clearance] of each other.
bool labelRectsClash(
double ax,
double ay,
double aw,
double ah,
double bx,
double by,
double bw,
double bh,
double clearance,
) =>
ax < bx + bw + clearance &&
bx < ax + aw + clearance &&
ay < by + bh + clearance &&
by < ay + ah + clearance;
int _indexOf(List<EdgeRoute> routes, int id) =>
routes.indexWhere((route) => route.id == id);
EdgeLabelBox _box(int id, _Rect rect) => EdgeLabelBox(
edgeId: id,
x: rect.x,
y: rect.y,
width: rect.w,
height: rect.h,
);
bool _free(
_Rect rect,
List<GraphNodeBox> nodes,
List<EdgeLabelBox> labels,
double clearance,
) {
if (rect.x < 0 || rect.y < 0) return false;
for (final node in nodes) {
if (labelRectsClash(
rect.x,
rect.y,
rect.w,
rect.h,
node.x,
node.y,
node.width,
node.height,
clearance,
)) {
return false;
}
}
for (final label in labels) {
if (labelRectsClash(
rect.x,
rect.y,
rect.w,
rect.h,
label.x,
label.y,
label.width,
label.height,
clearance,
)) {
return false;
}
}
return true;
}
/// True when a wire passes through the label's interior.
bool _crossesWire(_Rect rect, List<EdgeRoute> routes) {
for (final route in routes) {
for (var i = 1; i < route.points.length; i++) {
final a = route.points[i - 1], b = route.points[i];
final x0 = math.min(a.x, b.x), x1 = math.max(a.x, b.x);
final y0 = math.min(a.y, b.y), y1 = math.max(a.y, b.y);
final right = rect.x + rect.w, bottom = rect.y + rect.h;
// Orthogonal segments: one axis is a line, the other an interval.
final acrossX = x0 == x1
? x0 > rect.x && x0 < right
: x0 < right && x1 > rect.x;
final acrossY = y0 == y1
? y0 > rect.y && y0 < bottom
: y0 < bottom && y1 > rect.y;
if (acrossX && acrossY) return true;
}
}
return false;
}
List<_Rect> _candidates(EdgeRoute route, LabelExtent extent, double gap) {
const fractions = <double>[0.5, 0.35, 0.65, 0.2, 0.8, 0, 1];
final w = extent.width, h = extent.height;
final horizontals = <_Run>[];
final verticals = <_Run>[];
for (var i = 1; i < route.points.length; i++) {
final a = route.points[i - 1], b = route.points[i];
if (a.y == b.y && a.x != b.x) {
horizontals.add(_Run(math.min(a.x, b.x), math.max(a.x, b.x), a.y, i));
} else if (a.x == b.x && a.y != b.y) {
verticals.add(_Run(math.min(a.y, b.y), math.max(a.y, b.y), a.x, i));
}
}
int longestFirst(_Run a, _Run b) {
final byLength = b.length.compareTo(a.length);
return byLength != 0 ? byLength : a.order.compareTo(b.order);
}
horizontals.sort(longestFirst);
verticals.sort(longestFirst);
final rects = <_Rect>[];
for (final run in horizontals) {
for (final fraction in fractions) {
final left = _along(run, fraction, w);
rects
..add(_Rect(left, run.at - gap - h, w, h))
..add(_Rect(left, run.at + gap, w, h));
}
}
for (final run in verticals) {
for (final fraction in fractions) {
final top = _along(run, fraction, h);
rects
..add(_Rect(run.at + gap, top, w, h))
..add(_Rect(run.at - gap - w, top, w, h));
}
}
return rects;
}
/// The start of a [size]-long label centred at [fraction] of [run], kept on
/// the run when it is long enough to hold the whole label.
double _along(_Run run, double fraction, double size) {
final centre = run.lo + run.length * fraction;
if (run.length < size) return run.lo + run.length / 2 - size / 2;
return math.min(math.max(centre - size / 2, run.lo), run.hi - size);
}
double _centreX(EdgeRoute route) {
var lo = double.infinity, hi = double.negativeInfinity;
for (final point in route.points) {
lo = math.min(lo, point.x);
hi = math.max(hi, point.x);
}
return route.points.isEmpty ? 0 : (lo + hi) / 2;
}
/// One straight run: [lo]..[hi] along its axis, at [at] across it.
class _Run {
const _Run(this.lo, this.hi, this.at, this.order);
final double lo;
final double hi;
final double at;
final int order;
double get length => hi - lo;
}
class _Rect {
const _Rect(this.x, this.y, this.w, this.h);
final double x;
final double y;
final double w;
final double h;
}
@@ -248,20 +248,46 @@ class RunGraphCanvas extends StatelessWidget {
],
);
}
Widget _takenLabel(EdgeRoute route, Color color) => RunRouteLabel(
edgeId: route.id,
label: route.label,
order: state.routeOrder(route.source, route.outcome, route.target),
style: style.labelStyle,
color: color,
);
}
/// A taken route's label led by its place in the run (`2`, or `2, 5` for a
/// loop), so the path reads in order.
extension on RunGraphCanvas {
Widget _takenLabel(EdgeRoute route, Color color) {
final order = state.routeOrder(route.source, route.outcome, route.target);
final text = Text(route.label, style: style.labelStyle);
///
/// The canvas places this widget and [RunGraphMeasurements] measures the same
/// one, so the routed label box covers the order badge as well as the text.
class RunRouteLabel extends StatelessWidget {
const RunRouteLabel({
super.key,
required this.edgeId,
required this.label,
required this.order,
required this.style,
required this.color,
});
final int edgeId;
final String label;
final List<int> order;
final TextStyle style;
final Color color;
@override
Widget build(BuildContext context) {
final text = Text(label, style: style);
if (order.isEmpty) return text;
return Row(
mainAxisSize: MainAxisSize.min,
children: [
Container(
key: ValueKey('run-route-order:${route.id}'),
key: ValueKey('run-route-order:$edgeId'),
padding: const EdgeInsets.symmetric(horizontal: 5, vertical: 1),
decoration: BoxDecoration(
color: color,
@@ -348,6 +374,7 @@ class RunGraphMeasurements extends StatelessWidget {
required this.maxNodeWidth,
required this.labelStyle,
required this.recordedStatuses,
required this.state,
required this.onNodeSize,
required this.onLabelSize,
});
@@ -357,8 +384,14 @@ class RunGraphMeasurements extends StatelessWidget {
final double maxNodeWidth;
final TextStyle labelStyle;
final Map<String, String?> recordedStatuses;
/// The run whose route order badges lead the taken labels.
final RunGraphState state;
final void Function(String, Size) onNodeSize;
final void Function(String, Size) onLabelSize;
/// Receives each edge's label size keyed by its edge id, because two edges
/// with the same outcome can carry different order badges.
final void Function(int, Size) onLabelSize;
@override
Widget build(BuildContext context) => Offstage(
@@ -391,8 +424,14 @@ class RunGraphMeasurements extends StatelessWidget {
for (final edge in edges)
MeasuredChild(
key: ValueKey('run-label:${edge.id}'),
onSize: (size) => onLabelSize(edge.label, size),
child: Text(edge.label, style: labelStyle),
onSize: (size) => onLabelSize(edge.id, size),
child: RunRouteLabel(
edgeId: edge.id,
label: edge.label,
order: state.routeOrder(edge.source, edge.outcome, edge.target),
style: labelStyle,
color: const Color(0x00000000),
),
),
],
),
@@ -76,7 +76,7 @@ class RunGraphView extends StatefulWidget {
class _RunGraphViewState extends State<RunGraphView> {
final Map<String, Size> _nodeSizes = {};
final Map<String, Size> _labelSizes = {};
final Map<int, Size> _labelSizes = {};
final Map<String, String?> _measuredStatuses = {};
final GraphViewportController _viewport = GraphViewportController();
TextScaler? _scaler;
@@ -99,7 +99,7 @@ class _RunGraphViewState extends State<RunGraphView> {
}
}
void _record(Map<String, Size> sizes, String key, Size size) {
void _record<K>(Map<K, Size> sizes, K key, Size size) {
if (sizes[key] == size) return;
sizes[key] = size;
if (_rebuildScheduled) return;
@@ -122,7 +122,7 @@ class _RunGraphViewState extends State<RunGraphView> {
}
final labelExtents = <int, LabelExtent>{};
for (final edge in edges) {
final size = _labelSizes[edge.label];
final size = _labelSizes[edge.id];
if (size == null) return null;
labelExtents[edge.id] = LabelExtent(
width: size.width,
@@ -239,6 +239,7 @@ class _RunGraphViewState extends State<RunGraphView> {
maxNodeWidth: constraints.maxWidth,
labelStyle: style.labelStyle,
recordedStatuses: statuses,
state: state,
onNodeSize: (key, size) => _record(_nodeSizes, key, size),
onLabelSize: (key, size) => _record(_labelSizes, key, size),
),
@@ -0,0 +1,230 @@
import 'dart:math' as math;
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/graph/domain/graph_definition.dart';
import 'package:pipelines_app/features/graph/layout/layout_models.dart';
import 'package:pipelines_app/features/graph/layout/linear_graph_layout.dart';
import 'package:pipelines_app/features/graph/layout/linear_label_placement.dart';
import 'package:pipelines_app/features/graph/routing/route_models.dart';
GraphNodeBox _node(String key, double x, double y, double w, double h) =>
GraphNodeBox(
key: key,
terminal: false,
stageIndex: 0,
rank: 0,
x: x,
y: y,
width: w,
height: h,
);
EdgeRoute _route(int id, String label, List<(double, double)> points) {
final route = [for (final (x, y) in points) RoutePoint(x, y)];
return EdgeRoute(
id: id,
source: 'a',
outcome: label,
target: 'b',
label: label,
fallback: false,
kind: RouteKind.forward,
straight: route.length == 2,
sourcePort: RoutePort(side: RoutePortSide.right, point: route.first),
targetPort: RoutePort(side: RoutePortSide.left, point: route.last),
points: route,
);
}
/// The gap between two boxes, 0 when they touch or overlap.
double _gap(EdgeLabelBox label, double x, double y, double w, double h) {
final dx = math.max(0.0, math.max(x - label.right, label.x - (x + w)));
final dy = math.max(0.0, math.max(y - label.bottom, label.y - (y + h)));
return math.max(dx, dy);
}
void _expectClear(List<EdgeLabelBox> labels, List<GraphNodeBox> nodes) {
for (final label in labels) {
for (final node in nodes) {
expect(
_gap(label, node.x, node.y, node.width, node.height),
greaterThanOrEqualTo(edgeLabelClearance),
reason: 'label ${label.edgeId} is within clearance of ${node.key}',
);
}
for (final other in labels) {
if (identical(other, label)) continue;
expect(
_gap(label, other.x, other.y, other.width, other.height),
greaterThanOrEqualTo(edgeLabelClearance),
reason: 'labels ${label.edgeId} and ${other.edgeId} collide',
);
}
}
}
/// The distance from a label box to the nearest point of its own route.
double _distanceToRoute(EdgeLabelBox label, EdgeRoute route) {
var best = double.infinity;
for (var i = 1; i < route.points.length; i++) {
final a = route.points[i - 1], b = route.points[i];
best = math.min(
best,
_gap(
label,
math.min(a.x, b.x),
math.min(a.y, b.y),
(a.x - b.x).abs(),
(a.y - b.y).abs(),
),
);
}
return best;
}
void main() {
test('a node just above the wire pushes the label below it', () {
final nodes = [_node('crowd', 60, 20, 80, 28)];
final route = _route(1, 'success', [(0, 50), (200, 50)]);
final placement = placeLinearLabels(
routes: [route],
extents: {1: LabelExtent(width: 50, height: 16)},
nodes: nodes,
labelGap: 3,
);
expect(placement.misfits, isEmpty);
final label = placement.labels.single;
_expectClear(placement.labels, nodes);
expect(_distanceToRoute(label, route), lessThanOrEqualTo(3));
});
test('nodes on both sides of a run slide the label to a free stretch', () {
final nodes = [
_node('above', 40, 10, 120, 36),
_node('below', 40, 54, 120, 36),
];
final route = _route(1, 'retry', [(0, 50), (300, 50)]);
final placement = placeLinearLabels(
routes: [route],
extents: {1: LabelExtent(width: 40, height: 16)},
nodes: nodes,
labelGap: 3,
);
expect(placement.misfits, isEmpty);
_expectClear(placement.labels, nodes);
expect(placement.labels.single.x, greaterThanOrEqualTo(164));
});
test('labels sharing a run never overlap each other', () {
final routes = [
_route(1, 'success', [(0, 50), (240, 50)]),
_route(2, 'error', [(0, 50), (240, 50)]),
_route(3, 'blocked', [(0, 50), (240, 50)]),
];
final placement = placeLinearLabels(
routes: routes,
extents: {
for (final route in routes)
route.id: LabelExtent(width: 60, height: 16),
},
nodes: const [],
labelGap: 3,
);
expect(placement.labels, hasLength(3));
expect(placement.misfits, isEmpty);
_expectClear(placement.labels, const []);
});
test('a label longer than every run still keeps clear of the nodes', () {
final nodes = [
_node('left', 0, 0, 100, 40),
_node('right', 130, 0, 100, 40),
];
final route = _route(1, 'implementer-with-an-unusually-long-outcome', [
(100, 20),
(130, 20),
]);
final placement = placeLinearLabels(
routes: [route],
extents: {1: LabelExtent(width: 260, height: 16)},
nodes: nodes,
labelGap: 3,
);
// No spot on a 30px run holds a 260px label between two boxes, so it is a
// reported misfit on the shelf rather than a label covering a node.
expect(placement.misfits, {1});
_expectClear(placement.labels, nodes);
expect(placement.labels.single.y, greaterThan(40));
});
test('a tight corner between three nodes finds the open side', () {
// An L route: down beside `left`, then along under `below`'s top edge.
final nodes = [
_node('left', 0, 0, 96, 120),
_node('top', 104, 0, 120, 40),
_node('below', 160, 92, 100, 40),
];
final route = _route(1, 'error', [(100, 20), (100, 80), (300, 80)]);
final placement = placeLinearLabels(
routes: [route],
extents: {1: LabelExtent(width: 36, height: 16)},
nodes: nodes,
labelGap: 3,
);
expect(placement.misfits, isEmpty);
_expectClear(placement.labels, nodes);
expect(
_distanceToRoute(placement.labels.single, route),
lessThanOrEqualTo(3),
);
});
test('the linear layout widens its gaps instead of covering a node', () {
GraphNode stage(String key, int index) =>
GraphNode(key: key, terminal: false, stageIndex: index);
final nodes = [stage('plan', 0), stage('build', 1)];
GraphEdge edge(int id, String source, String outcome, String target) =>
GraphEdge(
id: id,
source: source,
outcome: outcome,
target: target,
label: outcome,
fallback: false,
knownTarget: true,
);
final edges = [
edge(0, 'plan', 'success', 'build'),
edge(1, 'build', 'retry', 'build'),
edge(2, 'build', 'rework', 'plan'),
];
final extents = {
'plan': NodeExtent(width: 60, height: 40),
'build': NodeExtent(width: 60, height: 40),
};
// Back-edge labels far wider than the default column gaps.
final labels = {
0: LabelExtent(width: 50, height: 16),
1: LabelExtent(width: 220, height: 16),
2: LabelExtent(width: 240, height: 16),
};
final (layout, routing) = layoutLinearGraph(
nodes: nodes,
edges: edges,
extents: extents,
labelExtents: labels,
);
expect(routing.labels, hasLength(3));
_expectClear(routing.labels, layout.nodes);
for (final label in routing.labels) {
expect(label.right, lessThanOrEqualTo(routing.width));
expect(label.bottom, lessThanOrEqualTo(routing.height));
expect(
_distanceToRoute(label, routing.routeFor(label.edgeId)!),
lessThanOrEqualTo(const LinearGraphMetrics().labelGap),
reason: 'label ${label.edgeId} stays on its own route',
);
}
});
}
@@ -0,0 +1,164 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/graph/layout/linear_label_placement.dart';
import 'package:pipelines_app/features/graph/widgets/definition_graph_canvas.dart';
import 'package:pipelines_app/features/graph/widgets/definition_graph_view.dart';
import 'package:pipelines_app/features/graph/widgets/run_graph_canvas.dart';
import 'package:pipelines_app/features/graph/widgets/run_graph_view.dart';
import '../domain/graph_fixtures.dart';
const String _longKey = 'implementer-with-an-unusually-long-stage-label';
/// The browser probe's definition (tool/graph_canvas_probe.dart): a long
/// wrapping stage, a fallback error, a retry self-loop and blocked/error
/// routes to the terminals.
JsonMap _probeGraph() => <String, dynamic>{
'stages': <dynamic>[
<String, dynamic>{
'key': 'plan',
'type': 'model',
'edges': <String, String?>{'success': 'build', 'error': '#'},
'fallback_error': true,
},
<String, dynamic>{
'key': 'build',
'type': 'model',
'edges': <String, String?>{'success': _longKey, 'retry': 'build'},
},
<String, dynamic>{
'key': _longKey,
'type': 'model',
'edges': <String, String?>{'success': 'audit', 'blocked': '#failure'},
},
<String, dynamic>{
'key': 'audit',
'type': 'model',
'edges': <String, String?>{'success': '#success', 'error': '#failure'},
},
],
};
/// A run that took plan -> build, retried build, then went on to the long
/// stage, so taken labels carry order badges (`1`, `2`, `3`).
JsonMap _probeRun() => <String, dynamic>{
'id': 7,
'steps': <dynamic>[
step(sequence: 1, stage: 'plan', outcome: 'success', target: 'build'),
step(sequence: 2, stage: 'build', outcome: 'retry', target: 'build'),
step(sequence: 3, stage: 'build', outcome: 'success', target: _longKey),
step(
sequence: 4,
stage: _longKey,
status: 'running',
startedAt: '2026-10-21T10:00:00Z',
),
],
'current_stage': _longKey,
'executing': true,
};
Widget _host(Widget child, double scale, double width) => MaterialApp(
home: Scaffold(
body: Builder(
builder: (context) => MediaQuery(
data: MediaQuery.of(
context,
).copyWith(textScaler: TextScaler.linear(scale)),
child: SizedBox(width: width, height: 700, child: child),
),
),
),
);
/// Asserts no placed label comes within the clearance of any placed node or
/// other label, using the on-screen rectangles of the canvas children.
void _expectLabelsClear(WidgetTester tester, Finder canvas) {
final scale = tester
.widget<InteractiveViewer>(find.byType(InteractiveViewer))
.transformationController!
.value
.getMaxScaleOnAxis();
final placed = tester.widgetList<Positioned>(
find.descendant(of: canvas, matching: find.byType(Positioned)),
);
final nodes = <Rect>[];
final labels = <Rect>[];
for (final positioned in placed) {
final rect = tester.getRect(find.byWidget(positioned.child).first);
// Nodes are placed with their measured box, labels by origin only; the
// edge layer fills the whole canvas and is neither.
if (positioned.width != null) {
nodes.add(rect);
} else if (positioned.right == null && positioned.bottom == null) {
labels.add(rect);
}
}
expect(nodes, isNotEmpty);
expect(labels, isNotEmpty);
// Slightly under the graph-space clearance, for float rounding.
final margin = (edgeLabelClearance - 0.01) * scale;
for (final label in labels) {
final grown = label.inflate(margin);
for (final node in nodes) {
expect(
grown.overlaps(node),
isFalse,
reason: 'label $label overlaps node $node',
);
}
for (final other in labels) {
if (other == label) continue;
expect(
grown.overlaps(other),
isFalse,
reason: 'label $label overlaps label $other',
);
}
}
}
void main() {
for (final scale in const [1.0, 2.0]) {
for (final width in const [560.0, 1200.0]) {
testWidgets('definition labels clear nodes at ${scale}x, $width wide', (
tester,
) async {
await tester.pumpWidget(
_host(
DefinitionGraphView(graph: _probeGraph(), onSelected: (_) {}),
scale,
width,
),
);
await tester.pump();
await tester.pump();
_expectLabelsClear(tester, find.byType(DefinitionGraphCanvas));
expect(tester.takeException(), isNull);
});
testWidgets('run labels with order badges clear nodes at ${scale}x, '
'$width wide', (tester) async {
await tester.pumpWidget(
_host(
RunGraphView(
graph: _probeGraph(),
run: _probeRun(),
onStageSelected: (_) {},
now: () => DateTime.utc(2026, 10, 21, 10, 2),
),
scale,
width,
),
);
await tester.pump();
await tester.pump();
expect(find.byType(RunRouteLabel), findsWidgets);
_expectLabelsClear(tester, find.byType(RunGraphCanvas));
expect(tester.takeException(), isNull);
});
}
}
}