feat(app): finish measured native graph canvas and clear labels from wires

This commit is contained in:
2026-10-21 21:06:57 +01:00
parent 7be4456fbf
commit bf378c94ca
11 changed files with 1123 additions and 2 deletions
@@ -16,6 +16,7 @@ EdgeLabelBox placeEdgeLabel({
required LabelExtent extent,
required List<GraphNodeBox> nodes,
required List<EdgeLabelBox> placed,
required List<EdgeRoute> routes,
required RoutingConfig config,
required double floorY,
}) {
@@ -29,7 +30,7 @@ EdgeLabelBox placeEdgeLabel({
width: width,
height: height,
);
if (_fits(box, nodes, placed, config)) return box;
if (_fits(box, nodes, placed, routes, config)) return box;
}
// The fallback shelf is below every route and every existing label, so it
@@ -50,7 +51,7 @@ EdgeLabelBox placeEdgeLabel({
width: width,
height: height,
);
if (_fits(box, nodes, placed, config)) return box;
if (_fits(box, nodes, placed, routes, config)) return box;
top += step;
}
// A zero-sized label cannot collide; this is unreachable for real extents.
@@ -67,9 +68,35 @@ bool _fits(
EdgeLabelBox box,
List<GraphNodeBox> nodes,
List<EdgeLabelBox> placed,
List<EdgeRoute> routes,
RoutingConfig config,
) {
if (box.x < 0 || box.y < 0) return false;
// A label clear of nodes can still sit across its self-loop's vertical leg
// or another edge. Keep its measured text rectangle clear of every wire.
final left = box.x - config.labelGap;
final right = box.right + config.labelGap;
final top = box.y - config.labelGap;
final bottom = box.bottom + config.labelGap;
for (final route in routes) {
for (var index = 1; index < route.points.length; index++) {
final a = route.points[index - 1], b = route.points[index];
if (a.x == b.x &&
a.x > left &&
a.x < right &&
math.max(a.y, b.y) > top &&
math.min(a.y, b.y) < bottom) {
return false;
}
if (a.y == b.y &&
a.y > top &&
a.y < bottom &&
math.max(a.x, b.x) > left &&
math.min(a.x, b.x) < right) {
return false;
}
}
}
for (final node in nodes) {
if (boxIntersectsNode(
x: box.x,
@@ -106,6 +106,7 @@ GraphRouting routeGraphEdges({
extent: labelExtents[routes[index].id]!,
nodes: layout.nodes,
placed: labels,
routes: routes,
config: config,
floorY: floorY,
),
@@ -0,0 +1,231 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../../../core/api_gateway.dart';
import '../domain/graph_definition.dart';
import '../layout/graph_node_layout.dart';
import '../layout/layout_models.dart';
import '../painting/graph_edge_layer.dart';
import '../routing/graph_edge_routing.dart';
import '../routing/route_models.dart';
import 'graph_canvas_style.dart';
import 'graph_stage_node.dart';
import 'graph_measurements.dart';
/// The definition's own empty-state wording (web `PIPELINE_GRAPH_EMPTY`).
const String definitionGraphEmpty = 'This pipeline has no stages.';
/// One pipeline definition as a readable native graph: measured stage nodes,
/// routed passive edges behind them and native outcome labels on their boxes.
///
/// [selectedStage] is a node key (including `#success`/`#failure`) and
/// [onSelected] reports the exact key activated. Nothing reads run evidence:
/// nodes show no status and terminals stay plain, so no visit is implied. The
/// view fills bounded caller constraints with a stock [InteractiveViewer].
class DefinitionGraphView extends StatefulWidget {
const DefinitionGraphView({
super.key,
required this.graph,
required this.onSelected,
this.selectedStage,
});
final JsonMap graph;
final String? selectedStage;
final ValueChanged<String> onSelected;
@override
State<DefinitionGraphView> createState() => _DefinitionGraphViewState();
}
class _DefinitionGraphViewState extends State<DefinitionGraphView> {
final Map<String, Size> _nodeSizes = {};
final Map<String, Size> _labelSizes = {};
TextScaler? _scaler;
bool _rebuildScheduled = false;
@override
void didChangeDependencies() {
super.didChangeDependencies();
// A different text scale changes every measured extent; drop the old
// extents so a stale 1x layout is never rendered around 2x text.
final scaler = MediaQuery.textScalerOf(context);
if (scaler != _scaler) {
_scaler = scaler;
_nodeSizes.clear();
_labelSizes.clear();
}
}
/// Records one measured extent and schedules the frame that uses it.
void _record(Map<String, Size> sizes, String key, Size size) {
if (sizes[key] == size) return;
sizes[key] = size;
if (_rebuildScheduled) return;
_rebuildScheduled = true;
WidgetsBinding.instance.addPostFrameCallback((_) {
_rebuildScheduled = false;
if (mounted) setState(() {});
});
}
/// The landed layout and routing for the measured extents, or null until
/// every node and every edge label has a real measurement.
(GraphLayout, GraphRouting)? _geometry(
List<GraphNode> nodes,
List<GraphEdge> edges,
) {
final extents = <String, NodeExtent>{};
for (final node in nodes) {
final size = _nodeSizes[node.key];
if (size == null) return null;
extents[node.key] = NodeExtent(width: size.width, height: size.height);
}
final labelExtents = <int, LabelExtent>{};
for (final edge in edges) {
final size = _labelSizes[edge.label];
if (size == null) return null;
labelExtents[edge.id] = LabelExtent(
width: size.width,
height: size.height,
);
}
final layout = layoutGraphNodes(
nodes: nodes,
edges: edges,
extents: extents,
config: graphCanvasLayoutConfig(labelExtents.values),
);
final routing = routeGraphEdges(
layout: layout,
edges: edges,
labelExtents: labelExtents,
config: graphCanvasRoutingConfig(),
);
return (layout, routing);
}
@override
Widget build(BuildContext context) {
final nodes = graphNodes(widget.graph);
final edges = graphEdges(widget.graph);
final style = GraphCanvasStyle.of(context);
return LayoutBuilder(
builder: (context, constraints) {
assert(
constraints.hasBoundedWidth && constraints.hasBoundedHeight,
'DefinitionGraphView needs a bounded viewport; constrain it, for '
'example with a SizedBox or an Expanded slot.',
);
final geometry = nodes.isEmpty ? null : _geometry(nodes, edges);
return Stack(
fit: StackFit.expand,
children: [
if (nodes.isEmpty)
_message(definitionGraphEmpty, style)
else if (geometry != null)
_canvas(nodes, geometry.$1, geometry.$2, style)
else
const SizedBox.shrink(),
if (nodes.isNotEmpty)
GraphMeasurements(
nodes: nodes,
edges: edges,
maxNodeWidth: constraints.maxWidth,
labelStyle: style.labelStyle,
selectedStage: widget.selectedStage,
onNodeSize: (key, size) => _record(_nodeSizes, key, size),
onLabelSize: (key, size) => _record(_labelSizes, key, size),
),
],
);
},
);
}
Widget _message(String message, GraphCanvasStyle style) {
return Padding(
padding: const EdgeInsets.all(24),
child: Align(
alignment: AlignmentDirectional.topStart,
child: Text(message, style: style.messageStyle),
),
);
}
Widget _canvas(
List<GraphNode> nodes,
GraphLayout layout,
GraphRouting routing,
GraphCanvasStyle style,
) {
final nodesByKey = <String, GraphNode>{
for (final node in nodes) node.key: node,
};
final size = Size(routing.width, routing.height);
return Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Expanded(
child: InteractiveViewer(
constrained: false,
minScale: 0.3,
maxScale: 3,
child: SizedBox.fromSize(
size: size,
child: Stack(
clipBehavior: Clip.none,
children: [
// The passive layer comes first so every edge paints behind
// the native nodes and labels without taking their input.
Positioned.fill(
child: GraphEdgeLayer(
routes: routing.routes,
canvasSize: size,
color: style.edgeColor,
strokeWidth: style.edgeWidth,
),
),
for (final box in layout.nodes)
Positioned(
left: box.x,
top: box.y,
width: box.width,
height: box.height,
child: GraphStageNode(
node: nodesByKey[box.key]!,
selected: box.key == widget.selectedStage,
onSelected: widget.onSelected,
),
),
for (final label in routing.labels)
Positioned(
left: label.x,
top: label.y,
child: Text(
routing.routeFor(label.edgeId)!.label,
style: style.labelStyle,
),
),
],
),
),
),
),
if (routing.skipped.isNotEmpty)
Flexible(
child: SingleChildScrollView(
child: _message(
[
for (final diagnostic in routing.skipped)
'${diagnostic.source} → ${diagnostic.outcome}: '
'${diagnostic.message}',
].join('\n'),
style,
),
),
),
],
);
}
}
@@ -0,0 +1,86 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import '../../../ui/adaptive/host.dart';
import '../layout/layout_models.dart';
import '../routing/route_models.dart';
/// Centralized graph spacing, not component dimensions. Rank separation follows
/// actual native label measurements at any text scale.
GraphLayoutConfig graphCanvasLayoutConfig(Iterable<LabelExtent> labels) {
final widest = labels.fold<double>(
0,
(width, label) => label.width > width ? label.width : width,
);
final routing = graphCanvasRoutingConfig();
return GraphLayoutConfig(
columnGap: widest + 2 * (routing.nodeClearance + routing.labelGap) + 24,
rowGap: 24,
padding: 24,
);
}
RoutingConfig graphCanvasRoutingConfig() => RoutingConfig(
nodeClearance: 12,
laneSpacing: 28,
corridorSpacing: 20,
portSpacing: 12,
labelGap: 6,
boundsPadding: 12,
);
/// The native theme roles one definition graph canvas needs.
///
/// No palette, font family or size is defined here: every value comes from the
/// ambient Material or Cupertino theme, so light/dark and text scaling follow
/// the host exactly. Edge labels and diagnostics are metadata, so they use the
/// host's secondary-label role rather than the node's own label style.
class GraphCanvasStyle {
const GraphCanvasStyle({
required this.labelStyle,
required this.messageStyle,
required this.edgeColor,
required this.edgeWidth,
});
factory GraphCanvasStyle.of(BuildContext context) {
if (usesCupertinoHost(context)) {
final theme = CupertinoTheme.of(context);
final secondary = CupertinoColors.secondaryLabel.resolveFrom(context);
return GraphCanvasStyle(
labelStyle: theme.textTheme.tabLabelTextStyle.copyWith(
color: secondary,
),
messageStyle: theme.textTheme.textStyle.copyWith(color: secondary),
edgeColor: CupertinoColors.separator.resolveFrom(context),
// Cupertino has no divider-thickness token; its separators are one
// logical pixel hairlines, so the stroke keeps that native default.
edgeWidth: 1,
);
}
final theme = Theme.of(context);
final secondary = theme.colorScheme.onSurfaceVariant;
return GraphCanvasStyle(
labelStyle: (theme.textTheme.labelMedium ?? const TextStyle()).copyWith(
color: secondary,
),
messageStyle: (theme.textTheme.bodySmall ?? const TextStyle()).copyWith(
color: secondary,
),
edgeColor: theme.colorScheme.outline,
edgeWidth: theme.dividerTheme.thickness ?? 1,
);
}
/// Style of one routed outcome label.
final TextStyle labelStyle;
/// Style of the empty-state and skipped-edge messages.
final TextStyle messageStyle;
/// Native outline/separator color for the routed edges.
final Color edgeColor;
/// Native hairline thickness for the routed edges and their arrows.
final double edgeWidth;
}
@@ -0,0 +1,64 @@
import 'package:flutter/widgets.dart';
import '../domain/graph_definition.dart';
import 'graph_stage_node.dart';
import 'measured_child.dart';
/// Measures the same native controls that the graph places, at a bound derived
/// from its actual viewport rather than a fixed node dimension.
class GraphMeasurements extends StatelessWidget {
const GraphMeasurements({
super.key,
required this.nodes,
required this.edges,
required this.maxNodeWidth,
required this.labelStyle,
required this.onNodeSize,
required this.onLabelSize,
this.selectedStage,
});
final List<GraphNode> nodes;
final List<GraphEdge> edges;
final double maxNodeWidth;
final TextStyle labelStyle;
final String? selectedStage;
final void Function(String, Size) onNodeSize;
final void Function(String, Size) onLabelSize;
@override
Widget build(BuildContext context) => Offstage(
child: OverflowBox(
alignment: Alignment.topLeft,
minWidth: 0,
maxWidth: double.infinity,
minHeight: 0,
maxHeight: double.infinity,
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.start,
children: [
for (final node in nodes)
MeasuredChild(
key: ValueKey('node:${node.key}'),
onSize: (size) => onNodeSize(node.key, size),
child: ConstrainedBox(
constraints: BoxConstraints(maxWidth: maxNodeWidth),
child: GraphStageNode(
node: node,
selected: node.key == selectedStage,
onSelected: (_) {},
),
),
),
for (final edge in edges)
MeasuredChild(
key: ValueKey('label:${edge.id}'),
onSize: (size) => onLabelSize(edge.label, size),
child: Text(edge.label, style: labelStyle),
),
],
),
),
);
}
@@ -0,0 +1,47 @@
import 'package:flutter/rendering.dart';
import 'package:flutter/widgets.dart';
/// Reports the laid-out size of its real child.
///
/// The definition graph measures the very node and label widgets it renders
/// instead of assuming a height, so a wrapped key, a larger text scale or a
/// platform host all produce the honest extent. The child is laid out with the
/// constraints its caller gives, and [onSize] runs during layout.
///
/// Because it runs inside layout, a caller must not rebuild synchronously:
/// record the size and schedule the rebuild for after the frame. The size is
/// reported again only when it actually changes, so a caller that keeps its
/// reported sizes stable does not loop.
class MeasuredChild extends SingleChildRenderObjectWidget {
const MeasuredChild({super.key, required this.onSize, required super.child});
/// Receives the child's size, in logical pixels, after every size change.
final ValueChanged<Size> onSize;
@override
MeasuredBox createRenderObject(BuildContext context) =>
MeasuredBox(onSize: onSize);
@override
void updateRenderObject(BuildContext context, MeasuredBox renderObject) {
renderObject.onSize = onSize;
}
}
/// The proxy render object behind [MeasuredChild].
class MeasuredBox extends RenderProxyBox {
MeasuredBox({required this.onSize});
ValueChanged<Size> onSize;
Size? _reported;
@override
void performLayout() {
super.performLayout();
final measured = size;
if (measured == _reported) return;
_reported = measured;
onSize(measured);
}
}
+39
View File
@@ -0,0 +1,39 @@
# Measured native definition graph canvas
Retained run71 hit its Code deadline while collecting browser evidence. Manager
completed the existing work directly; no replacement workflow or lost edits.
DefinitionGraphView composes the landed native node, layout, route and passive
edge components. Nodes/labels are measured from their rendered native widgets,
then placed in a stock InteractiveViewer. Selection reports the exact stage or
terminal key; no run status, visit or session is invented. Unknown targets produce
bounded scrollable diagnostics. No node height/width is assumed.
## Corrections from actual checks
- Removed the fixed220px node bound: wrapping follows the caller's viewport.
- Rank gaps follow measured outcome labels, not an assumed2x text width.
- Split offstage native measurement into its own cohesive widget; source files
remain below250lines rather than making an oversized renderer.
- Two original selection tests tapped offscreen terminals. They now pan the real
InteractiveViewer first; a new resize test checks viewport-dependent remeasure.
- Browser inspection found the retry label crossed its own loop wire. Added
three failing pure regressions, then fixed label candidate collision checks to
include ALL route segments. No masking background or routing rewrite.
- Browser fixture now pans to reveal offscreen nodes, instead of assuming the
whole content-sized graph fits one screen. Selected terminal identity and real
pan movement are asserted. Explicit owned Chrome pipe/server cleanup prevents
successful probes leaving the Node process waiting on fixture resources.
## Verification
Graph tests (composition + existing geometry) pass; analyzer clean. Fresh real
Chrome cases cover Material light1x/2x, Cupertino light1x/dark2x, five captures
each (desktop/phone/selection/terminal/pan), under approved temp/
graph-canvas-manager-browser. Each case's probe assertions passed; the cleanup
fix was checked with clean process exit. Material2x label/wire view inspected.
Fixtures bind loopback and touch no production server, session or device.
This is a definition-only component, NOT run-graph parity. Pipeline hook, authored
stage pane, run evidence/recorded-visit integration and keyboard/fit toolbar are
still separate acceptance work. Mobile remains unverified.
@@ -0,0 +1,46 @@
import 'dart:math' as math;
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/graph/domain/graph_definition.dart';
import '../domain/graph_fixtures.dart';
import 'routing_fixtures.dart';
void main() {
for (final width in [52.0, 100.0, 160.0]) {
test(
'measured self-loop labels do not sit across route wires ($width)',
() {
final graph = selfLoopGraph();
final result = routeFor(
graph,
labels: fixedLabels(graphEdges(graph), width: width, height: 32),
);
for (final label in result.labels) {
for (final route in result.routes) {
for (var i = 1; i < route.points.length; i++) {
final a = route.points[i - 1], b = route.points[i];
final vertical =
a.x == b.x &&
a.x > label.x &&
a.x < label.right &&
math.max(a.y, b.y) > label.y &&
math.min(a.y, b.y) < label.bottom;
final horizontal =
a.y == b.y &&
a.y > label.y &&
a.y < label.bottom &&
math.max(a.x, b.x) > label.x &&
math.min(a.x, b.x) < label.right;
expect(
vertical || horizontal,
isFalse,
reason: 'edge ${route.id} crosses label ${label.edgeId}',
);
}
}
}
},
);
}
}
@@ -0,0 +1,258 @@
import 'package:flutter/cupertino.dart';
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/painting/graph_edge_layer.dart';
import 'package:pipelines_app/features/graph/widgets/definition_graph_view.dart';
import 'package:pipelines_app/features/graph/widgets/graph_stage_node.dart';
import '../domain/graph_fixtures.dart';
const String _longKey = 'implementer-with-an-unusually-long-stage-label';
JsonMap _longKeyGraph() => <String, dynamic>{
'stages': <dynamic>[
stage(
'plan',
edges: <String, String?>{'success': _longKey, 'error': '#'},
fallbackError: true,
),
stage(
_longKey,
edges: <String, String?>{'success': '#success', 'error': '#failure'},
),
],
};
JsonMap _emptyGraph() => <String, dynamic>{'stages': <dynamic>[]};
/// One bounded viewport, with an optional real text scale applied below the
/// app so the graph measures text exactly as a device would.
Widget _materialHost(
JsonMap graph, {
String? selected,
ValueChanged<String>? onSelected,
double scale = 1,
}) {
return MaterialApp(
home: Scaffold(
body: Builder(
builder: (context) => MediaQuery(
data: MediaQuery.of(
context,
).copyWith(textScaler: TextScaler.linear(scale)),
child: SizedBox(
width: 900,
height: 700,
child: DefinitionGraphView(
graph: graph,
selectedStage: selected,
onSelected: onSelected ?? (_) {},
),
),
),
),
),
);
}
Widget _cupertinoHost(JsonMap graph, {ValueChanged<String>? onSelected}) {
return CupertinoApp(
home: CupertinoPageScaffold(
child: SizedBox(
width: 900,
height: 700,
child: DefinitionGraphView(
graph: graph,
onSelected: onSelected ?? (_) {},
),
),
),
);
}
/// Settles the two-frame measure-then-place contract.
Future<void> _settle(WidgetTester tester) async {
await tester.pump();
await tester.pump();
}
Finder _node(String key) => find.byWidgetPredicate(
(widget) => widget is GraphStageNode && widget.node.key == key,
);
Rect _nodeRect(WidgetTester tester, String key) => tester.getRect(_node(key));
Future<void> _tapNode(WidgetTester tester, String key) async {
final viewport = tester.getRect(find.byType(InteractiveViewer));
final node = _nodeRect(tester, key);
if (!viewport.contains(node.center)) {
await tester.drag(
find.byType(InteractiveViewer),
viewport.center - node.center,
);
await tester.pumpAndSettle();
}
await tester.tap(_node(key));
await tester.pump();
}
void _expectNoOverlaps(WidgetTester tester) {
final rects = <Rect>[
for (final element in find.byType(GraphStageNode).evaluate())
tester.getRect(find.byWidget(element.widget)),
];
for (var a = 0; a < rects.length; a += 1) {
for (var b = a + 1; b < rects.length; b += 1) {
expect(
rects[a].overlaps(rects[b]),
isFalse,
reason: 'nodes $a and $b overlap: ${rects[a]} and ${rects[b]}',
);
}
}
}
void main() {
testWidgets(
'viewport changes remeasure node width instead of imposing a fixed cap',
(tester) async {
tester.view.physicalSize = const Size(900, 700);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
await tester.pumpWidget(_materialHost(_longKeyGraph()));
await _settle(tester);
final wide = _nodeRect(tester, _longKey);
tester.view.physicalSize = const Size(320, 700);
await tester.pump();
await _settle(tester);
final narrow = _nodeRect(tester, _longKey);
expect(narrow.width, lessThan(wide.width));
expect(narrow.width, lessThanOrEqualTo(320));
expect(narrow.height, greaterThan(wide.height));
_expectNoOverlaps(tester);
expect(tester.takeException(), isNull);
},
);
testWidgets('selection reports the exact definition key', (tester) async {
final picked = <String>[];
await tester.pumpWidget(
_materialHost(linearGraph(), selected: 'build', onSelected: picked.add),
);
await _settle(tester);
expect(find.byType(GraphStageNode), findsNWidgets(5));
expect(find.byType(InteractiveViewer), findsOneWidget);
expect(tester.widget<GraphStageNode>(_node('build')).selected, isTrue);
expect(tester.widget<GraphStageNode>(_node('plan')).selected, isFalse);
await tester.tap(_node('plan'));
await tester.pump();
expect(picked, ['plan']);
await _tapNode(tester, '#success');
expect(picked, ['plan', '#success']);
});
testWidgets('nodes use measured native sizes and never overlap', (
tester,
) async {
tester.view.physicalSize = const Size(320, 700);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
await tester.pumpWidget(_materialHost(_longKeyGraph()));
await _settle(tester);
expect(find.byType(GraphStageNode), findsNWidgets(4));
_expectNoOverlaps(tester);
final plan = _nodeRect(tester, 'plan');
final long = _nodeRect(tester, _longKey);
// The wrapped key is bounded by the graph's measurement bound and is both
// wider and taller than the single-line node: a fixed node size could not
// produce either difference.
expect(long.width, lessThanOrEqualTo(320));
expect(long.width, greaterThan(plan.width));
expect(long.height, greaterThan(plan.height * 1.5));
final layer = tester.widget<GraphEdgeLayer>(find.byType(GraphEdgeLayer));
expect(layer.routes, isNotEmpty);
expect(layer.canvasSize.width, greaterThan(0));
// Every routed edge gets its native outcome label; `error*` is the
// fallback marker carried verbatim from the definition.
expect(find.text('error*'), findsOneWidget);
expect(find.text('success'), findsNWidgets(2));
expect(find.textContaining('no placed node'), findsNothing);
expect(tester.takeException(), isNull);
});
testWidgets('2x text scale re-measures instead of reusing 1x extents', (
tester,
) async {
final graph = linearGraph();
await tester.pumpWidget(_materialHost(graph));
await _settle(tester);
final oneX = _nodeRect(tester, 'plan');
final oneXLabel = tester.getRect(find.text('error*'));
await tester.pumpWidget(_materialHost(graph, scale: 2));
await _settle(tester);
final twoX = _nodeRect(tester, 'plan');
expect(twoX.height, greaterThan(oneX.height));
expect(twoX.width, greaterThan(oneX.width));
expect(
tester.getRect(find.text('error*')).height,
greaterThan(oneXLabel.height),
);
_expectNoOverlaps(tester);
});
testWidgets('unknown endpoints stay honest and invent no node', (
tester,
) async {
await tester.pumpWidget(_materialHost(incompleteGraph()));
await _settle(tester);
expect(find.byType(GraphStageNode), findsNWidgets(4));
expect(_node('ghost'), findsNothing);
// Two routes are drawn; the empty and unknown targets are reported, not
// guessed into nodes.
expect(
tester.widget<GraphEdgeLayer>(find.byType(GraphEdgeLayer)).routes,
hasLength(2),
);
expect(find.textContaining('ghost'), findsOneWidget);
expect(find.textContaining('edge target is empty'), findsOneWidget);
_expectNoOverlaps(tester);
expect(tester.takeException(), isNull);
});
testWidgets('an empty definition states its empty message', (tester) async {
await tester.pumpWidget(_materialHost(_emptyGraph()));
await tester.pump();
expect(find.text(definitionGraphEmpty), findsOneWidget);
expect(find.byType(GraphStageNode), findsNothing);
expect(find.byType(InteractiveViewer), findsNothing);
});
testWidgets('cupertino host composes native buttons and keeps identity', (
tester,
) async {
final picked = <String>[];
await tester.pumpWidget(
_cupertinoHost(linearGraph(), onSelected: picked.add),
);
await _settle(tester);
expect(find.byType(CupertinoButton), findsNWidgets(5));
expect(find.byType(Card), findsNothing);
_expectNoOverlaps(tester);
await _tapNode(tester, '#failure');
expect(picked, ['#failure']);
});
}
+120
View File
@@ -0,0 +1,120 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/graph/widgets/definition_graph_view.dart';
const String _longKey = 'implementer-with-an-unusually-long-stage-label';
/// A definition with forward, fallback, self-loop and terminal edges so one
/// canvas shows measured wrapping nodes, native outcome labels and arrows.
JsonMap _definition() => <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'},
},
],
};
/// Isolated browser fixture for `DefinitionGraphView` only.
///
/// Not wired into the app or shell. `style=cupertino` selects the native
/// Cupertino host, `scale=2` applies a real 2x text scale to the graph viewport,
/// and a click reports the exact stage key in the status line.
void main() {
final parameters = Uri.base.queryParameters;
final cupertino = parameters['style'] == 'cupertino';
final scale = double.tryParse(parameters['scale'] ?? '') ?? 1;
runApp(_ProbeApp(cupertino: cupertino, scale: scale));
}
class _ProbeApp extends StatelessWidget {
const _ProbeApp({required this.cupertino, required this.scale});
final bool cupertino;
final double scale;
@override
Widget build(BuildContext context) {
final page = _ProbePage(scale: scale);
if (cupertino) {
return CupertinoApp(
home: CupertinoPageScaffold(
navigationBar: const CupertinoNavigationBar(
middle: Text('Definition graph'),
),
child: SafeArea(child: page),
),
);
}
return MaterialApp(
theme: ThemeData(platform: TargetPlatform.android),
darkTheme: ThemeData(
platform: TargetPlatform.android,
brightness: Brightness.dark,
),
themeMode: ThemeMode.system,
home: Scaffold(
appBar: AppBar(title: const Text('Definition graph')),
body: SafeArea(child: page),
),
);
}
}
class _ProbePage extends StatefulWidget {
const _ProbePage({required this.scale});
final double scale;
@override
State<_ProbePage> createState() => _ProbePageState();
}
class _ProbePageState extends State<_ProbePage> {
String? _selected = 'build';
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text('Selected: ${_selected ?? 'none'}'),
const SizedBox(height: 8),
Expanded(
child: MediaQuery(
data: MediaQuery.of(
context,
).copyWith(textScaler: TextScaler.linear(widget.scale)),
child: DefinitionGraphView(
graph: _definition(),
selectedStage: _selected,
onSelected: (key) => setState(() => _selected = key),
),
),
),
],
),
);
}
}
+202
View File
@@ -0,0 +1,202 @@
// Browser acceptance for the isolated DefinitionGraphView fixture.
//
// Serves the probe build (`flutter build web -t tool/graph_canvas_probe.dart`)
// on an OS-assigned loopback port, drives a real headless Chrome, asserts the
// native node/label semantics, selection identity, measured node rectangles and
// that a real drag pans the stock InteractiveViewer, then writes captures.
//
// PROBE_VARIANT=material|cupertino PROBE_SCHEME=dark|light PROBE_SCALE=1|2 \
// PROBE_WEB_ROOT=<probe build> OPENCODE_ARTIFACT_DIR=<dir> \
// node tool/graph_canvas_probe.mjs
import { createServer } from 'node:http';
import { spawn } from 'node:child_process';
import { once } from 'node:events';
import { setTimeout as delay } from 'node:timers/promises';
import { join, extname, resolve, sep } from 'node:path';
import { tmpdir } from 'node:os';
import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
const root = resolve(process.env.PROBE_WEB_ROOT ?? join(process.cwd(), 'build/graph_canvas_probe'));
const variant = process.env.PROBE_VARIANT ?? 'material';
const scheme = process.env.PROBE_SCHEME ?? 'dark';
const scale = process.env.PROBE_SCALE ?? '1';
const artifactDir = process.env.OPENCODE_ARTIFACT_DIR ?? join(tmpdir(), 'graph-canvas-capture');
const prefix = scheme === 'light' ? 'light-' : '';
const longKey = 'implementer-with-an-unusually-long-stage-label';
const nodes = ['plan', 'build', longKey, 'audit', 'Success', 'Failure'];
const edgeLabels = ['success', 'error*', 'retry', 'blocked'];
await mkdir(artifactDir, { recursive: true });
const mime = { '.html': 'text/html', '.js': 'text/javascript', '.json': 'application/json', '.wasm': 'application/wasm', '.png': 'image/png', '.ico': 'image/x-icon' };
const server = createServer(async (req, res) => {
try {
const path = resolve(root, '.' + decodeURIComponent(new URL(req.url, 'http://localhost').pathname));
if (path !== root && !path.startsWith(root + sep)) return res.writeHead(403).end();
const filePath = path === root || path.endsWith('/') ? join(path, 'index.html') : path;
const file = await readFile(filePath);
res.writeHead(200, { 'content-type': mime[extname(filePath)] ?? 'application/octet-stream' }).end(file);
} catch { res.writeHead(404).end('not found'); }
});
server.listen(0, '127.0.0.1');
await once(server, 'listening');
const port = server.address().port;
const profile = await mkdtemp(join(tmpdir(), 'graph-canvas-chrome-'));
const chrome = spawn('/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', [
'--headless=new', '--no-first-run', '--no-default-browser-check', '--disable-gpu',
'--remote-debugging-port=0', `--user-data-dir=${profile}`, 'about:blank',
], { stdio: ['ignore', 'ignore', 'pipe'] });
let stderr = '';
chrome.stderr.on('data', data => { stderr += data; });
const waitFor = async fn => {
for (let i = 0; i < 100; i++) { const value = await fn(); if (value) return value; await delay(100); }
throw new Error('Timed out waiting for Chrome DevTools');
};
let ws;
try {
const endpoint = await waitFor(() => stderr.match(/DevTools listening on (ws:\/\/[^\s]+)/)?.[1]);
ws = new WebSocket(endpoint);
await once(ws, 'open');
let id = 0;
const pending = new Map();
ws.addEventListener('message', event => {
const msg = JSON.parse(event.data);
if (msg.id && pending.has(msg.id)) { pending.get(msg.id)(msg); pending.delete(msg.id); }
});
const send = (method, params = {}, sessionId) => new Promise(resolve => {
const callId = ++id; pending.set(callId, resolve);
ws.send(JSON.stringify({ id: callId, method, params, ...(sessionId ? { sessionId } : {}) }));
});
const created = await send('Target.createTarget', { url: 'about:blank' });
const target = created.result.targetId;
const session = (await send('Target.attachToTarget', { targetId: target, flatten: true })).result.sessionId;
await send('Page.enable', {}, session);
await send('Runtime.enable', {}, session);
await send('Emulation.setEmulatedMedia', {
features: [{ name: 'prefers-color-scheme', value: scheme }],
}, session);
const url = `http://127.0.0.1:${port}/?style=${variant}&scale=${scale}`;
const navigation = await send('Page.navigate', { url }, session);
if (navigation.error || navigation.result?.errorText) throw new Error(JSON.stringify(navigation));
await send('Emulation.setDeviceMetricsOverride', { width: 1280, height: 800, deviceScaleFactor: 1, mobile: false }, session);
const evaluate = async expression => {
const response = await send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true }, session);
if (response.error) throw new Error(`Runtime.evaluate failed: ${JSON.stringify(response)}`);
return response.result?.result?.value;
};
await delay(3500);
const loaded = await evaluate('({url:location.href, ready:document.readyState})');
if (!loaded?.url.includes(`127.0.0.1:${port}/?style=${variant}&scale=${scale}`)) throw new Error(`Fixture did not load: ${JSON.stringify(loaded)}`);
await evaluate("document.querySelector('flt-semantics-placeholder')?.click()");
await delay(2500);
const semantics = () => evaluate("[...document.querySelectorAll('flt-semantics')].map(x=>({label:(x.getAttribute('aria-label')||x.innerText||'').trim(), selected:x.getAttribute('aria-current')}))");
const nodeAt = label => `[...document.querySelectorAll('flt-semantics')].find(x => (x.getAttribute('aria-label')||x.innerText||'').trim() === ${JSON.stringify(label)})`;
const body = await evaluate('document.body.innerText');
if (!body.includes('Selected: build')) throw new Error(`Initial selection missing: ${body}`);
const initial = await semantics();
// Flutter web maps Semantics(selected:) to aria-current, not aria-selected.
const current = initial.find(x => x.selected === 'true');
if (!current?.label.startsWith('build')) throw new Error(`Selected node is not announced: ${JSON.stringify(initial)}`);
const nodeRect = async label => evaluate(`(() => { const e=${nodeAt(label)}; if (!e) return null; const r=e.getBoundingClientRect(); return {x:r.x,y:r.y,width:r.width,height:r.height}; })()`);
const rects = {};
for (const label of nodes) {
const rect = await nodeRect(label);
if (rect?.width > 0 && rect?.height > 0) rects[label] = rect;
}
// Measured native nodes occupy separate rectangles: no fixed-size overlap.
const visibleNodes = Object.keys(rects);
for (let a = 0; a < visibleNodes.length; a++) {
for (let b = a + 1; b < visibleNodes.length; b++) {
const one = rects[visibleNodes[a]], two = rects[visibleNodes[b]];
const overlap = one.x < two.x + two.width && two.x < one.x + one.width &&
one.y < two.y + two.height && two.y < one.y + one.height;
if (overlap) throw new Error(`Nodes overlap: ${visibleNodes[a]} ${JSON.stringify(one)} vs ${visibleNodes[b]} ${JSON.stringify(two)}`);
}
}
if (!(rects[longKey].height > rects.plan.height || rects[longKey].width > rects.plan.width)) {
throw new Error(`Long key did not determine its own native extent: ${JSON.stringify(rects)}`);
}
const clickLabel = async label => {
const point = await evaluate(`(() => { const e=${nodeAt(label)}; if (!e) return null; const r=e.getBoundingClientRect(); return {x:r.x+r.width/2,y:r.y+r.height/2}; })()`);
if (!point) return false;
await send('Input.dispatchMouseEvent', { type: 'mousePressed', x: point.x, y: point.y, button: 'left', clickCount: 1 }, session);
await send('Input.dispatchMouseEvent', { type: 'mouseReleased', x: point.x, y: point.y, button: 'left', clickCount: 1 }, session);
return true;
};
const capture = async (name, width, height) => {
await send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 1, mobile: width < 600 }, session);
await delay(2500);
const data = (await send('Page.captureScreenshot', { format: 'png', captureBeyondViewport: false }, session)).result.data;
const file = `${prefix}${variant}-graph-${scale}x-${name}.png`;
await writeFile(`${artifactDir}/${file}`, Buffer.from(data, 'base64'));
return file;
};
const captures = [];
captures.push(await capture('desktop', 1280, 800));
captures.push(await capture('phone', 390, 844));
if (!await clickLabel('plan')) throw new Error('Could not click plan node');
await delay(800);
const afterPlan = await evaluate('document.body.innerText');
if (!afterPlan.includes('Selected: plan')) throw new Error(`plan callback did not carry its key: ${afterPlan}`);
const planCurrent = (await semantics()).find(x => x.selected === 'true');
if (planCurrent?.label !== 'plan') throw new Error(`plan is not announced selected: ${JSON.stringify(planCurrent)}`);
captures.push(await capture('selected-plan', 1280, 800));
const seen = new Set();
const drag = async (start, dx, dy = 0) => {
await send('Input.dispatchMouseEvent', {type:'mousePressed', ...start, button:'left', buttons:1, clickCount:1}, session);
for (let step=1; step<=5; step++) {
await send('Input.dispatchMouseEvent', {type:'mouseMoved', x:start.x+dx*step/5, y:start.y+dy*step/5, button:'left', buttons:1}, session);
await delay(40);
}
await send('Input.dispatchMouseEvent', {type:'mouseReleased', x:start.x+dx, y:start.y+dy, button:'left', clickCount:1}, session);
await delay(800);
};
// Native content-sized graphs need not fit on one screen. Verify offscreen
// nodes through actual pan gestures rather than assuming fixed node boxes.
for (let pass=0; pass<10; pass++) {
const labels = (await semantics()).map(item => item.label);
for (const needle of [...nodes, ...edgeLabels]) {
if (labels.some(label => label.includes(needle))) seen.add(needle);
}
if ([...nodes, ...edgeLabels].every(label => seen.has(label)) &&
(await nodeRect('Success'))?.width > 0) break;
await drag({x:900,y:300}, -500);
}
for (const label of [...nodes, ...edgeLabels]) {
if (!seen.has(label)) throw new Error(`Graph pan never revealed ${label}`);
}
if (!await clickLabel('Success')) throw new Error('Could not click Success terminal');
await delay(800);
const afterTerminal = await evaluate('document.body.innerText');
if (!afterTerminal.includes('Selected: #success')) throw new Error(`terminal callback did not carry its key: ${afterTerminal}`);
captures.push(await capture('selected-terminal',1280,800));
await send('Page.reload', {}, session);
await delay(2500);
await evaluate("document.querySelector('flt-semantics-placeholder')?.click()");
await delay(1500);
// A real drag on a phone viewport, where the measured graph is wider than
// the viewport, must pan the stock InteractiveViewer: the node moves.
await send('Emulation.setDeviceMetricsOverride', { width: 390, height: 844, deviceScaleFactor: 1, mobile: true }, session);
await delay(1500);
const before = await nodeRect('plan');
const start = { x: before.x + before.width / 2, y: before.y + before.height / 2 };
await drag(start, -40, -10);
const after = await nodeRect('plan');
if (!after || (Math.abs(after.x - before.x) < 20 && Math.abs(after.y - before.y) < 20)) {
throw new Error(`Drag did not pan the graph: ${JSON.stringify({ before, after })}`);
}
captures.push(await capture('panned-phone', 390, 844));
console.log(JSON.stringify({ variant, scheme, scale, rects, captures }, null, 2));
} finally {
if (ws?.readyState === WebSocket.OPEN) {
ws.send(JSON.stringify({ id: 2147483647, method: 'Browser.close' }));
}
await Promise.race([once(chrome, 'exit'), delay(3000)]);
ws?.close();
if (chrome.exitCode === null) chrome.kill('SIGTERM');
chrome.stderr.destroy();
chrome.unref();
await new Promise(resolve => {
server.close(resolve);
server.closeAllConnections();
});
await rm(profile, { recursive: true, force: true });
}