From dbcc2d1ca026cb51f114a13681b7bf84d619f346 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Fri, 23 Oct 2026 13:00:51 +0100 Subject: [PATCH] feat(app): run rows lead with the web's coloured status glyph and meta line --- app/lib/features/runs/domain/run_models.dart | 21 ++++++ app/lib/features/runs/ui/runs_list.dart | 25 +++++-- app/lib/ui/status/run_status_icon.dart | 73 +++++++++++++++++++ .../runs/domain/run_row_meta_test.dart | 33 +++++++++ .../runs/ui/run_cancel_wiring_test.dart | 5 +- .../runs/ui/runs_list_widget_test.dart | 22 ++++++ 6 files changed, 170 insertions(+), 9 deletions(-) create mode 100644 app/lib/ui/status/run_status_icon.dart create mode 100644 app/test/features/runs/domain/run_row_meta_test.dart diff --git a/app/lib/features/runs/domain/run_models.dart b/app/lib/features/runs/domain/run_models.dart index ddd1cdd7..21906e85 100644 --- a/app/lib/features/runs/domain/run_models.dart +++ b/app/lib/features/runs/domain/run_models.dart @@ -1,3 +1,4 @@ +import '../../pipelines/pipeline_format.dart'; import '../../../core/api_gateway.dart'; const runStates = [ @@ -134,6 +135,26 @@ bool _isScheduled(JsonMap run) => run['scheduled'] == true || (run['schedule_id'] is num && (run['schedule_id'] as num) > 0); +/// The run row's meta line as the web's `metaText`: `run 7 · 21 Oct 12:00 · +/// 4m 12s` for a finished run, `run 7 · 3m 5s` (elapsed) while it executes. +/// Unusable timestamps are omitted, never printed blank. +String runRowMetaText(JsonMap run, DateTime now) { + final parts = ['run ${run['id']}']; + final created = '${run['created_at'] ?? ''}'; + if (run['executing'] == true) { + final start = parseInstant(created); + if (start != null) { + parts.add(formatDuration(now.difference(start).inSeconds)); + } + } else { + final stamp = formatLocalTimestamp(created); + if (stamp != null) parts.add(stamp); + final duration = durationSeconds(created, '${run['finished_at'] ?? ''}'); + if (duration != null) parts.add(formatDuration(duration)); + } + return parts.join(' · '); +} + String runStatusLabel(JsonMap run) { final status = '${run['status'] ?? ''}'; if (!{'queued', 'running', 'waiting'}.contains(status)) { diff --git a/app/lib/features/runs/ui/runs_list.dart b/app/lib/features/runs/ui/runs_list.dart index 4432aaa0..892b3bcf 100644 --- a/app/lib/features/runs/ui/runs_list.dart +++ b/app/lib/features/runs/ui/runs_list.dart @@ -3,6 +3,7 @@ import 'package:flutter/material.dart'; import '../../../core/api_gateway.dart'; import '../../../ui/adaptive/host.dart'; +import '../../../ui/status/run_status_icon.dart'; import '../../attention/notify/notification_controller.dart'; import '../../attention/runtime/attention_controller.dart'; import '../../attention/runtime/attention_store.dart'; @@ -174,23 +175,31 @@ class RunsList extends StatelessWidget { final identity = runIdentity(run['title'], run['name']); final id = run['id']; final title = identity.label.isEmpty ? 'Run $id' : identity.label; - final subtitle = - '${run['name'] ?? 'Pipeline unavailable'} · ${run['created_at'] ?? 'Time unavailable'}${run['scheduled'] == true ? ' · Scheduled' : ''}'; + // As the web's run row: the coloured status glyph leads (its tooltip and + // accessible name are the state word), then the run, then + // `pipeline · run N · local time · duration`. + final meta = [ + '${run['name'] ?? 'Pipeline unavailable'}', + runRowMetaText(run, DateTime.now()), + if (run['scheduled'] == true) 'Scheduled', + ].join(' · '); + final status = RunStatusIcon( + state: runStateOf(run['status']), + label: runStatusLabel(run), + ); if (usesCupertinoHost(context)) { return CupertinoListTile( + leading: status, title: Text(title), - subtitle: Text(subtitle), - additionalInfo: Text(runStatusLabel(run)), + subtitle: Text(meta), trailing: const CupertinoListTileChevron(), onTap: id is num ? () => onSelected(id) : null, ); } return ListTile( + leading: status, title: Text(title), - subtitle: Column( - crossAxisAlignment: CrossAxisAlignment.start, - children: [Text(subtitle), Text(runStatusLabel(run))], - ), + subtitle: Text(meta), trailing: const Icon(Icons.chevron_right), onTap: id is num ? () => onSelected(id) : null, ); diff --git a/app/lib/ui/status/run_status_icon.dart b/app/lib/ui/status/run_status_icon.dart new file mode 100644 index 00000000..313f12d2 --- /dev/null +++ b/app/lib/ui/status/run_status_icon.dart @@ -0,0 +1,73 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +import '../adaptive/host.dart'; + +/// The one status glyph a run row leads with, as the web's `statusIcon`: a +/// single coloured icon whose tooltip and accessible name say the state. +/// +/// [state] is the normalised run state (`succeeded`, `failed`, `running`, +/// `waiting`, `queued`, `canceled`, `interrupted`, anything else unknown); +/// [label] is the word a person reads. Colours are the platform's dynamic +/// system colours, so the glyph keeps its contrast in light and dark themes. +class RunStatusIcon extends StatelessWidget { + const RunStatusIcon({ + super.key, + required this.state, + required this.label, + this.size = 18, + }); + + final String state; + final String label; + final double size; + + @override + Widget build(BuildContext context) { + final cupertino = usesCupertinoHost(context); + final color = runStatusColor(state).resolveFrom(context); + return Tooltip( + message: label, + child: Semantics( + label: label, + image: true, + excludeSemantics: true, + child: Icon( + cupertino ? _cupertinoIcon(state) : _materialIcon(state), + size: size, + color: color, + ), + ), + ); + } +} + +/// The dynamic colour for a run state, shared by every status glyph. +CupertinoDynamicColor runStatusColor(String state) => switch (state) { + 'succeeded' => CupertinoColors.systemGreen, + 'failed' => CupertinoColors.systemRed, + 'running' || 'active' => CupertinoColors.systemBlue, + 'waiting' => CupertinoColors.systemTeal, + 'interrupted' => CupertinoColors.systemOrange, + _ => CupertinoColors.systemGrey, +}; + +IconData _materialIcon(String state) => switch (state) { + 'succeeded' => Icons.check_circle_outline, + 'failed' => Icons.cancel_outlined, + 'running' || 'active' => Icons.autorenew, + 'canceled' => Icons.block, + 'interrupted' => Icons.pause_circle_outline, + 'waiting' || 'queued' => Icons.schedule, + _ => Icons.help_outline, +}; + +IconData _cupertinoIcon(String state) => switch (state) { + 'succeeded' => CupertinoIcons.check_mark_circled, + 'failed' => CupertinoIcons.xmark_circle, + 'running' || 'active' => CupertinoIcons.arrow_2_circlepath, + 'canceled' => CupertinoIcons.nosign, + 'interrupted' => CupertinoIcons.pause_circle, + 'waiting' || 'queued' => CupertinoIcons.clock, + _ => CupertinoIcons.question_circle, +}; diff --git a/app/test/features/runs/domain/run_row_meta_test.dart b/app/test/features/runs/domain/run_row_meta_test.dart new file mode 100644 index 00000000..14763183 --- /dev/null +++ b/app/test/features/runs/domain/run_row_meta_test.dart @@ -0,0 +1,33 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/pipelines/pipeline_format.dart'; +import 'package:pipelines_app/features/runs/domain/run_models.dart'; + +void main() { + final now = DateTime.utc(2026, 10, 21, 12, 10); + + test('a finished run reads run, local time and duration, as the web', () { + final run = { + 'id': 7, + 'created_at': '2026-10-21T12:00:00Z', + 'finished_at': '2026-10-21T12:04:12Z', + }; + expect( + runRowMetaText(run, now), + 'run 7 · ${formatLocalTimestamp('2026-10-21T12:00:00Z')} · 4m 12s', + ); + }); + + test('an executing run reads its elapsed time instead', () { + final run = { + 'id': 8, + 'executing': true, + 'created_at': '2026-10-21T12:07:00Z', + }; + expect(runRowMetaText(run, now), 'run 8 · 3m 0s'); + }); + + test('unusable timestamps are omitted, never printed blank', () { + expect(runRowMetaText({'id': 9, 'created_at': 'nope'}, now), 'run 9'); + expect(runRowMetaText({'id': 9}, now), 'run 9'); + }); +} diff --git a/app/test/features/runs/ui/run_cancel_wiring_test.dart b/app/test/features/runs/ui/run_cancel_wiring_test.dart index 5677ab93..1299f6f7 100644 --- a/app/test/features/runs/ui/run_cancel_wiring_test.dart +++ b/app/test/features/runs/ui/run_cancel_wiring_test.dart @@ -3,6 +3,7 @@ import 'dart:async'; import 'package:flutter/cupertino.dart'; import 'package:flutter/material.dart'; import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/ui/status/run_status_icon.dart'; import 'package:pipelines_app/core/api_gateway.dart'; import 'package:pipelines_app/features/runs/actions/cancel_wording.dart'; import 'package:pipelines_app/features/runs/screen.dart'; @@ -81,7 +82,9 @@ void main() { await tester.tap(find.text(cupertino ? 'Back' : 'Back to list')); await tester.pumpAndSettle(); expect( - find.textContaining('canceled'), + find.byWidgetPredicate( + (widget) => widget is RunStatusIcon && widget.label == 'canceled', + ), findsWidgets, reason: 'The accepted server state must also update the held list row', diff --git a/app/test/features/runs/ui/runs_list_widget_test.dart b/app/test/features/runs/ui/runs_list_widget_test.dart index cd901dff..03f13eb5 100644 --- a/app/test/features/runs/ui/runs_list_widget_test.dart +++ b/app/test/features/runs/ui/runs_list_widget_test.dart @@ -8,6 +8,7 @@ import 'package:pipelines_app/features/attention/ui/needs_you_runs_heading.dart' import 'package:pipelines_app/features/runs/data/runs_repository.dart'; import 'package:pipelines_app/features/runs/ui/runs_controller.dart'; import 'package:pipelines_app/features/runs/ui/runs_filters.dart'; +import 'package:pipelines_app/ui/status/run_status_icon.dart'; import 'package:pipelines_app/features/runs/ui/runs_list.dart'; class _Gateway implements ApiGateway { @@ -212,4 +213,25 @@ void main() { expect(tester.takeException(), isNull); }); } + + for (final cupertino in [false, true]) { + testWidgets('rows lead with the status glyph, not a status word ' + '(${cupertino ? 'Cupertino' : 'Material'})', (tester) async { + await mount(tester, cupertino: cupertino); + await tester.pumpAndSettle(); + final icons = tester + .widgetList(find.byType(RunStatusIcon)) + .map((icon) => (icon.state, icon.label)) + .toList(); + expect( + icons, + unorderedEquals([('running', 'running'), ('failed', 'failed')]), + ); + expect(find.text('failed'), findsNothing); + expect( + tester.getCenter(find.byType(RunStatusIcon).first).dx, + lessThan(tester.getTopLeft(find.text('Alpha')).dx), + ); + }); + } }