Merge lane-c: keep the lane's reviewed work

Combine lane-c's incoming work with the local branch.

- PipelinesApp.kt was the only unmerged path: resolution is purely additive over HEAD, keeping HEAD's hoisted selection/onSelectionChange and pendingNav/onPendingNavResolved while adding lane-c's listState wiring and compactLabel/compactIcon.
- graph/StageDetailPane.kt and theme/Dimens.kt auto-merged and retain both sides' changes.
- Incoming branch af68a62 preserved as second parent.
This commit is contained in:
2026-10-16 20:32:11 +01:00
25 changed files with 1862 additions and 387 deletions
+313
View File
@@ -256,6 +256,16 @@ stops it.
clamped to two lines. The raw `resultPreview` is no longer printed, and
progress is shown honestly (completed visits + current stage, with an
indeterminate indicator while executing; no invented total).
- A run still in progress shows the time it has taken so far instead of a
finished duration, everywhere a run's time appears: the runs list meta row,
the pipeline list's last-run line and the run detail summary's Duration row. A
running value is live — recomputed once a second from the server's own
`created_at` (never from when the app loaded, so it stays correct after a
reconnect), using the shared `runDurationText` and a single ticking clock per
screen (`ui/components/LiveTime.kt`) that pauses while the app is backgrounded
and while no shown run is executing. Once the run finishes it keeps its stored
total duration; a missing start omits the value and a future start (clock skew)
reads as `0s` (`FormatTest`, `PipelineLastRunTest`).
- One centralised type scale (`ui/theme/Typography.kt`, passed to
`MaterialTheme` and exposed as named roles) defines the screen/app-bar title,
section header, card title, subtitle/meta, body and monospace data, applied on
@@ -945,6 +955,11 @@ frames and pinch-zoom (adb cannot drive a two-finger pinch).
## Adaptive pane navigation and a fixed peek budget (15 Oct 2026)
> **Superseded** by "The covered edge is measured, not budgeted" below: the fixed
> `PEEK_BUDGET_DP` (`224.dp`) is gone. The covered region is now measured from the
> compact identity a covered edge has to show, so the active pane is no longer
> charged a fixed `224dp` whatever the window width is.
The pane stack was made adaptive to the window width and its peek space changed
from one peek per level to a single fixed budget shared between the covered
panes. `android/` only; nothing in the Pipelines server, its Go source, the
@@ -1210,6 +1225,11 @@ artifacts is a data issue in that run, not re-tested against a repaired copy.
## Covered panes show a compact identity, with a minimum peek width (16 Oct 2026)
> **Superseded** by "The covered edge is measured, not budgeted" below: the
> `MIN_COVERED_PANE_WIDTH_DP`/`PEEK_WIDTH_DP` split of a fixed budget no longer
> decides the layout. A covered edge is now as wide as the identity it has to
> show; the two tokens only bound which statistics that identity shows.
A wide-window stack no longer squeezes a full pane into each covered peek: a
covered pane now renders only its compact identity (a title and at most one
status/subtitle, centred in its strip) and its full body — tab rail, list,
@@ -1294,6 +1314,101 @@ has exactly three pane levels (`MasterPane.List/Detail/Stage`, `MAX_PANE_DEPTH =
centred lines and ellipsizes (e.g. `Pipelines maintenance - plan implem…`) rather
than being rotated.
## Covered panes carry a compact statistics block (16 Oct 2026)
A covered pane's compact identity is no longer a bare title/subtitle: it now
shows a small vertical block of labelled statistics, aggregated client-side from
the run history the app already receives, degrading with the strip's width.
`android/` only; nothing in the Pipelines server, its Go source, the
Docker/compose files or the installer was touched, no dependency was added (the
declared `material-icons-extended` is unchanged), no run was started from the app
and no server field was added.
- **Pipeline statistics.** When the covered pane is a pipeline
(`PipelineDetailScreen`, and `RunDetailScreen` through its run's pipeline) the
block shows the run counts (`runs`/`succeeded`/`failed`/`active`), the last
run's status and how long ago it started, and the average duration over the
runs that finished. `ui/screens/PaneStats.kt` folds the history in one pass; the
counts mirror the server's own vocabulary (`active` = queued/running, per
`internal/pipeline/stats.go`) and a still-running run never drags the average.
A run pane whose run (and so whose pipeline) has not loaded yet stays
title-only: an absent pipeline id is "not known yet", never the whole history,
so it can never show the server-wide summary as if it were the run's pipeline.
- **List statistics.** When the covered pane is a list, `PipelineListScreen` and
`RunHistoryScreen` show the whole history's counts by status and the single most
recent run; a runs list scoped to one pipeline shows that pipeline's own
numbers.
- **Width degradation.** `PaneIdentity` measures its own strip and shows the title
only below one peek width, the run counts up to
`MIN_COVERED_PANE_WIDTH_DP + PEEK_WIDTH_DP`, and the full block above it, so a
thin peek drops whole labelled statistics instead of clipping a number or
printing an unlabelled figure. Each statistic is a label above its own value, so
the number never shares a line with a label that could clip it. The boundaries
reuse the named geometry tokens and the decision is the pure
`paneStatTier`/`visiblePaneStats` pair.
- **One recency rule.** The "most recent run" comparison is the shared
`isMoreRecent` helper, used by the single-pass `latestRunByPipeline` join and by
the covered summary's own fold, so the pipeline row's last-run badge, the "most
recent run" sort and the covered summary all agree on which run is the latest
without grouping the history into intermediate lists.
- **Two aggregation entry points.** `ui/screens/PaneStats.kt` exposes
`pipelineStatLines(runs, pipelineId, now)` for the pipeline-scoped panes and
`listStatLines(runs, now)` for the list panes, so "which statistics, from which
history, or none until it has loaded" lives in one place instead of at each
call site and a null pipeline id can never be mistaken for the whole history.
The fold is a single pass (`RunTally.add` tracks the counts, the finished-run
duration total and the most recent run together), so a scoped pipeline summary
never allocates a filtered list or walks the history twice.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, the cached Gradle 8.11.1
distribution, `ANDROID_HOME=~/Library/Android/sdk`, `--offline`):
- `:app:testDebugUnitTest :app:assembleDebug --offline --console=plain` →
`BUILD SUCCESSFUL in 2s` (41 actionable tasks: 8 executed, 33 up-to-date). The
result XMLs total **279 tests, 0 failures, 0 errors, 0 skipped** across 32
files; `app/build/outputs/apk/debug/app-debug.apk` is 18,204,486 bytes, sha256
`196c9d6f4acbcc75769fd52ecadac66378bad78994056895f26ff65da077718c`. The
`PaneStatsTest` (15 cases) covers the per-pipeline counts, queued as active, the
last run's state/age, the average over finished runs, zero-duration runs, a
pipeline with no runs, an unknown pipeline id, the whole-history list fold and
the labelled lines, and that an absent/unknown pipeline id yields no lines
rather than the list summary; the `PaneIdentityTest` (5 cases) pins the width
tiers, that the counts tier drops only the detail lines, and that every shown
statistic keeps its label and value.
- **APK publish.** `app-debug.apk` was copied to
`~/.local/share/pipelines/data/artifacts/142/3/pipelines-debug-wip-c700b28.apk`
(`c700b28` = `git rev-parse --short HEAD`; the tree is uncommitted WIP on top of
it); `shasum -a 256` matched the built file (`196c9d6f…`). `curl -I
http://10.0.0.249:8080/artifacts/142/3/pipelines-debug-wip-c700b28.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18204486`.
- **Device evidence (emulator-5554).** The debug APK was installed with
`adb -s emulator-5554 install -r` (never the attached Pixel, never
`emulator-5556`) against the live LAN server, and the wide and narrow layouts
were captured with `adb -s emulator-5554 shell screencap -p /sdcard/cap.png`
then `adb -s emulator-5554 pull`. Captures are in the same artifacts directory:
`wide-1-level-runs-list.png`, `wide-2-levels-covered-list-stats.png`,
`wide-3-levels-covered-stats.png` (plus `…pane0…`/`…pane1…` crops) and
`narrow-runs-list.png`. OCR of the covered strips confirms the block: at two
levels the covered runs list reads `Runs / runs 145 / succeeded 90 / failed 39 /
active 6 / last running - 4m ago` (Full tier); at three levels its two covered
strips (82 dp and 112 dp wide) drop the `last` line and keep only the labelled
counts, and the covered run strip reads the run's own pipeline id 11 numbers
(`runs 60 / succeeded 37 / failed 14 / active 5`) — clearly not the server-wide
145, so an unknown pipeline can no longer borrow the list summary. Four levels
remain unreachable: `MAX_PANE_DEPTH = 2` gives exactly three pane levels, so the
three-covered degradation is captured instead.
- **Device-instruction conflict.** The run's Constraints said use `emulator-5554`
exclusively and never the operator's physical device; an appended paragraph said
to use the attached Pixel and never an emulator. There is no path that satisfies
both, and installing this WIP build on the operator's own phone is forbidden by
the task, so the emulator named in the Constraints was used (with the
`device.lock` held) and the Pixel and `emulator-5556` were never touched. While
capturing, another lane repeatedly overwrote the installed APK on
`emulator-5554` (the installed hash reverted from this build to
`2adaf03e…`/`5912d38f…` at 16:18 and 16:20 until reinstalled), which is why the
APK hash was re-checked immediately before the captures that are reported here.
## Run stage pane leads with the run's results (16 Oct 2026)
A stage opened from a run no longer leads with its own definition. The pane now
@@ -3441,3 +3556,201 @@ native 2208x1840 @420 at the end.
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 17928873`.
## Remembering the list scroll position (16 Oct 2026)
Returning from a pipeline or a run now restores the list to exactly where the
operator left it — the same item at the same offset, on either window width — and
the position also survives a configuration change, rotation and process death.
`android/` only; nothing in the Pipelines server, its Go source, the
Docker/compose files or the installer was touched, no dependency was added (the
declared `material-icons-extended` is unchanged), no run was started from the app
and no server field was added.
- **Root cause.** A covered pane is a different composition from an open one: when
a detail opens on a wide window, pane 0 stops drawing its list and draws its
compact identity in a strip instead, so the list screen (and any scroll state it
owned) was discarded, and backing out rebuilt it at the top. The runs
destination is additionally recreated by the `NavHost` when the app-level runs
selection changes. The fix owns each list's scroll state at the app shell, above
the `NavHost` (`PipelinesApp`), and passes it into the list screens, so it is
never inside the pane that comes and goes.
- **One scroll state per list.** `PipelinesApp` holds
`pipelineListState`/`runListState` with `rememberSaveable(saver = LazyListState.Saver)`
and passes them to `PipelineDestination`/`RunsDestination` and on to
`PipelineListScreen`/`RunHistoryScreen` (and `RunHistoryContent`), whose
`LazyColumn` now takes that state. The same two screens serve both window widths
and both entry points, so the runs list reached from a pipeline gets the same
treatment as one opened normally.
- **Restore and clamp rule.** `ui/components/ListScroll.kt` holds the pure
`ListScrollAnchor(index, offset)` and `restoredScrollAnchor(anchor, itemCount)`
(the saved index clamped to the nearest valid item, the offset kept only for the
item that survived) plus the `RestoreListScroll(state, itemCount)` composable,
which is keyed on the item count so it runs once when the list's size settles
and never on the operator's own scrolling. A list that changed underneath (a
filter, a sort, a refresh, items removed) therefore clamps to the nearest
sensible item instead of jumping to the top or throwing, a scroll after coming
back is never overridden, and a list that has not loaded yet is left alone so a
restored position is not reset to the top while the data is still arriving.
- **Runs list before it has loaded (fixed 16 Oct 2026).** The runs list has no
pane-level empty state, so its first frame — before `LaunchedEffect {
vm.refreshRuns() }` has set `loading` — was data-less, not-loading and classified
as content. `RunHistoryContent` then composed an empty list whose only slot was
the "no runs" line, and `RestoreListScroll` clamped the restored index to 0
before the real list arrived: the runs list always came back at the top after
process death (the pipelines list was spared only because its empty state was
classified as a distinct `LoadPhase.Empty`). `listLoadPhase` now takes the
pane's `loaded` signal (`LoadState.loaded`) and reads a data-less list that has
never loaded as loading rather than empty, so the list — and its restored
position — is not composed until the history is actually in hand. Both list
screens pass it.
- **One source for the runs list body.** `RunHistoryScreen` no longer maintains a
second, hand-written copy of the LazyColumn's item count. The pure
`runListEntries(...)` builds the slots (the usage block, the single
empty-or-grouped body and the optional inline error row) once, in layout order;
the column renders exactly that list and `RestoreListScroll` clamps to its size,
so the count can never drift from what is drawn. `RunListEntriesTest` pins the
slot order, the stable keys and the count.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, cached Gradle 8.11.1
distribution, `ANDROID_HOME=~/Library/Android/sdk`, every Gradle command with
`--no-daemon --offline --console=plain`):
- `:app:clean :app:testDebugUnitTest :app:assembleDebug` → `BUILD SUCCESSFUL`;
the tests were then re-executed with `:app:testDebugUnitTest --rerun-tasks`
(not served from the build cache). The result XMLs total **292 tests, 0
failures, 0 errors, 0 skipped** across 34 files. `ListScrollTest` (6 cases)
pins the restore/clamp rule (in-range item keeps its index and offset, the last
item keeps its offset, a shrunken list clamps to its last item and drops the
offset, a negative index clamps to the top, an empty list stays at the top); the
two new `LoadPhaseTest` cases pin that a data-less list that has never loaded
reads as loading while the default keeps the old rule; and `RunListEntriesTest`
(5 cases) pins the runs body's slot order, stable keys and count.
`app/build/outputs/apk/debug/app-debug.apk` is 18,011,393 bytes, sha256
`13b8d2871e9ad522e0d5a826642cdf467a95939408bed519d952e83d5c8dbb02`.
- `:app:lintDebug` aborts on only the two pre-existing `NewApi` errors for
`android:windowLightNavigationBar` (minSdk 26) in `res/values/themes.xml` and
`res/values-night/themes.xml`, which this change did not modify; no error or
warning points at the scroll change.
- **APK publish.** `app-debug.apk` was copied to
`~/.local/share/pipelines/data/artifacts/157/1/pipelines-debug-wip-c700b28.apk`
(`c700b28` = `git rev-parse --short HEAD`; the tree is uncommitted WIP on top of
it); `shasum -a 256` matched the built file (`13b8d287…`). `curl -I
http://10.0.0.249:8080/artifacts/157/1/pipelines-debug-wip-c700b28.apk` returned
`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18011393`.
- **Device evidence (operator's Pixel 10 Pro Fold, `adb -s 58281FDCG000JF`, inner
2076x2152 at the 330 density override ≈1006dp; narrow override `wm size
1080x1920`).** The build was installed with `adb -s 58281FDCG000JF install -r`,
driven against the live LAN server (`curl http://127.0.0.1:8080/healthz` →
`{"healthy":true}`), and captured with `android/scripts/capture_png.sh -s
58281FDCG000JF` (device-side `screencap` to a file, then `pull` — never
`exec-out`), written to `~/.local/share/pipelines/data/artifacts/157/1/`. The
scroll position is read from `uiautomator dump` as the first `run «id» · …` line
(the runs list) or the first `id «n» · v…` line (the pipelines list):
| case | how driven | result |
| --- | --- | --- |
| pipelines, wide, open→back | scroll down (first row `id 6`), tap the pipeline, Back | same first row; `01_list_scrolled.png` vs `03_list_restored.png` differ in **no pixel** (`bbox None`) |
| runs, wide, open→back | scroll down (first row `run 32 · 13 Oct 17:21`), tap the run, Back | same first row; `05_runs_scrolled.png` vs `06_runs_restored.png` differ in **no pixel** (`bbox None`) |
| **runs, process death** | HOME, `adb -s 58281FDCG000JF shell am kill net.awan.pipelines` (`pidof` empty), restore the task from Recents | back on the Runs destination with the same first row `run 41 · 15 Oct 14:35`; `30_runs_before_death.png` vs `31_runs_after_death.png` differ only in the status bar (`bbox (138,67)-(289,95)`) |
| runs, rotation | `user_rotation 1`, then `0` | same top row `run 10 · 11 Oct 16:01` after both |
| pipelines, rotation | `user_rotation 1`, then `0` | same top row in landscape; the first flip re-laid the anchor onto the adjacent row (`id 6`→`id 11`) and was stable on the second and later flips — the list never returned to the top |
| density, config change | `wm density 330`→`340`→`330` | same top row `run 10 · 11 Oct 16:01` |
| pipelines, narrow | `wm size 1080x1920`; scroll, open a pipeline, Back | same first row `id 4`; `70_narrow_pipelines_before.png` vs `72_narrow_pipelines_after.png` differ in **no pixel** (`bbox None`) |
| runs, narrow | `wm size 1080x1920`; scroll, open a run, Back | same first row `run 8 · 11 Oct 14:44`; only the status bar differs |
| list shrank while open | pipelines scrolled to the bottom, then search `quick` | the two matches (`id 9`, `id 10`) are shown — clamped, not blank and not reset to the top — and the process stayed alive with no `FATAL EXCEPTION` in `logcat` |
For the open→back cases the top row and its pixel offset matched exactly (the
screenshot diff isolates only the status-bar clock); rotation, the density
change and process death restored the same destination and top row. `device.lock`
was held for every `adb` command and released afterwards, and no run was started
from the app.
- **Not exercised.** `onOpenRun` from a pipeline detail is only reached through
`StartRunDialog.onStarted` (after starting a run), which the task forbids, so the
runs list reached that way is kept compiling and functional but not driven; it
shares the one `runListState`, so it gets the same treatment as the normally
opened runs list. A real hardware fold to the cover display was not exercised
(narrow was produced with `wm size`).
## The covered edge is measured, not budgeted (16 Oct 2026)
The covered panes used to spend the fixed `PEEK_BUDGET_DP` (`224.dp`) whatever the
window width was, so on a folded window the covered area was over half the screen
and the active pane was left with a fixed, small width. The stack now derives the
covered region from what a covered edge actually has to show and takes the active
pane's width from what remains. `android/` only; no dependency was added, no run
was started from the app, the Pipelines server/Go source/installer/Docker files
were not touched, and the operator's Pixel 10 Pro Fold was not used at all
(implementation verified with the build and the unit tests, per the brief).
- **The region is measured, not budgeted.** `rememberCompactIdentityWidth`
(`ui/components/PaneIdentity.kt`) measures the width one covered edge needs for
its compact identity — an icon plus the shortest label that identifies the pane
— at runtime, with the app's own type role and the platform's font metrics, and
floors it at the platform minimum touch target
(`LocalMinimumInteractiveComponentSize`). `SlidingPaneStack` adds the leading
system-gesture inset (`systemBars ∪ systemGestures`) and uses that as the whole
covered region. No percentage of the window, budget token or new dp constant
stands in for it; the only fixed values left are platform ones (the minimum
touch target and the leading gesture inset) plus the identity's own existing
`SPACING_S` padding and the icon's own default size.
- **The active pane's width is the same at every depth — the invariant.**
`coveredEdgesDp` (`ui/components/SlidingPaneStack.kt`) always returns edges that
sum to exactly the region, so `activeStart` is the region and the active pane
measures `hostWidth - region` at depth 1, 2, 3 and 4 alike. Opening another
level only adds an edge *inside* the region; it never widens the region or
resizes or reflows a pane already there. `SlidingPaneStackTest` asserts the sum
is constant across depths (`theCoveredRegionIsTheSameAtEveryDepthSoTheActiveWidthNeverChanges`).
- **The stack reads as a stack, and depth does not consume width.** The nearest
covered level shows its identity. One older level is shown as a thinner edge —
the platform minimum touch target, the thinnest edge that stays tappable after
the leading inset — and every level older than that folds into that edge's
count (`"<n> more"`) instead of spending width on each. When the region cannot
fit the thin older edge as well as a full touch target for the nearest identity
(one identity width is usually less than two touch targets), the older levels
fold into the nearest edge's count rather than being squeezed: nothing is
derived below the platform minimum. Tapping an edge still calls the same
`onPopTo(level)`, closing everything above it.
- **The old token and what replaced it.** `PEEK_BUDGET_DP` was `224.dp` and is
removed, together with `MIN_ACTIVE_PANE_WIDTH_DP` (`320.dp`) and the
`peekBudgetDp`/`peekStripsDp` split of a fixed budget. What replaced it is the
measured compact-identity width above. `PEEK_WIDTH_DP` (`56.dp`) and
`MIN_COVERED_PANE_WIDTH_DP` (`112.dp`) no longer place anything either: they now
only bound which statistics a covered identity shows (see
`paneStatTier`/`visiblePaneStats`) and are documented as such in `Dimens.kt`.
- **The identity carries an icon.** `PaneIdentity` gained an `icon` parameter
drawn above the title at the vector's own default size, so the drawn identity
matches the width that was measured for it. The list, pipeline-detail,
run-detail and stage panes each pass their own glyph.
Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, the cached Gradle 8.11.1
distribution, `ANDROID_HOME=~/Library/Android/sdk`, `--offline`, every command
with `--no-daemon`):
- `gradle :app:testDebugUnitTest :app:assembleDebug --no-daemon --offline
--console=plain` → `BUILD SUCCESSFUL`. The result XMLs total **293 tests, 0
failures, 0 errors, 0 skipped** across 34 files. The rewritten
`SlidingPaneStackTest` pins the invariant and the fold rules: a narrow window
spends nothing, the edges sum to the region at every depth (so the active width
is constant), one covered level keeps the whole identity edge, two covered
levels show the nearest identity plus one thinner older edge, beyond two the
older levels fold into one count edge, a region too small to fit both a thin
edge and the nearest touch target collapses to a single counted edge, the
nearest edge keeps its touch target after the gesture inset, and the edges stay
monotonic and deterministic.
- `app/build/outputs/apk/debug/app-debug.apk` is 18,247,412 bytes, sha256
`77db131cdb2737da64286384e5f7387540b1c87588b89c36bf4c34821f091372`; it was
copied to `~/.local/share/pipelines/data/artifacts/166/1/pipelines-debug-wip-b003872.apk`
(`b003872` = `git rev-parse --short HEAD`; the tree is WIP on top of it).
`curl -I http://10.0.0.249:8080/artifacts/166/1/pipelines-debug-wip-b003872.apk`
returned `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`,
`Content-Length: 18247412`.
Not verified in this pass: the derived widths on a real window, the stacked look
and the identifiers on the left, the covered area's share of the window, and the
two- and four-level screenshots — all of that is runtime/visual evidence for the
review stages, and the device policy for this brief keeps the implementation to
the build and the unit tests. Four levels are also unreachable in the app itself
(`MasterPane.List/Detail/Stage`, `MAX_PANE_DEPTH = 2`), so the four-level fold is
covered by the pure `coveredEdgesDp` cases rather than by a screenshot.
@@ -48,6 +48,24 @@ fun formatDuration(start: String, end: String): String? =
internal fun secondsSince(start: String, nowMillis: Long): Long? =
parseInstant(start)?.let { ((nowMillis - it.toInstant().toEpochMilli()) / 1000).coerceAtLeast(0) }
/**
* The time a run has taken so far: while it is still [executing], its live
* elapsed time from its server start timestamp to [nowMillis]; once it has
* finished, its stored total duration. The single rule the runs list's meta line,
* the pipeline last-run line and the run detail summary share, so the same run is
* never described differently in the three places. Null when the start (or, for a
* finished run, the end) is unusable, so the caller omits the value instead of
* printing a blank; a running run with a future start (clock skew) reads as `0s`,
* never a negative.
*/
internal fun runDurationText(
createdAt: String,
finishedAt: String,
executing: Boolean,
nowMillis: Long,
): String? =
if (executing) secondsSince(createdAt, nowMillis)?.let(::formatDuration)
else formatDuration(createdAt, finishedAt)
/**
* Human duration for a whole number of seconds. The single formatting rule for
@@ -29,6 +29,7 @@ import androidx.compose.foundation.layout.only
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.windowInsetsPadding
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.foundation.selection.selectable
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
@@ -183,6 +184,13 @@ fun PipelinesApp(vm: AppViewModel) {
dismissSearch()
}
// One list scroll position each, owned here above the NavHost so it survives
// the destination (and list screen) being recreated when a pane is covered or
// the runs selection changes, as well as a configuration change and process
// death. The list screens only clamp it when the list changed underneath.
val pipelineListState = rememberSaveable(saver = LazyListState.Saver) { LazyListState() }
val runListState = rememberSaveable(saver = LazyListState.Saver) { LazyListState() }
val onNavigate: (TopDestination) -> Unit = { destination ->
if (currentRoute != destination.route) {
navController.navigate(destination.route) {
@@ -234,6 +242,7 @@ fun PipelinesApp(vm: AppViewModel) {
wide = wide,
selection = pipelineSelection,
onSelectionChange = { pipelineSelection = it },
listState = pipelineListState,
onOpenRun = { runId ->
runSelection = PaneSelection(
pane = MasterPane.Detail,
@@ -251,6 +260,7 @@ fun PipelinesApp(vm: AppViewModel) {
onSelectionChange = { runSelection = it },
pendingNav = runSearchNav,
onPendingNavResolved = { runSearchNav = null },
listState = runListState,
)
}
composable("settings") {
@@ -339,6 +349,7 @@ private fun PipelineDestination(
wide: Boolean,
selection: PaneSelection,
onSelectionChange: (PaneSelection) -> Unit,
listState: LazyListState,
onOpenRun: (Long) -> Unit,
) {
val depth = selection.depth
@@ -354,6 +365,8 @@ private fun PipelineDestination(
depth = depth,
wide = wide,
onPopTo = { level -> onSelectionChange(popTo(selection, level)) },
compactLabel = "Pipelines",
compactIcon = Icons.Filled.AccountTree,
backContentDescription = { level -> if (level == 0) "Back to pipelines" else "Back to pipeline" },
pane = { level, covered, paneModifier ->
when (level) {
@@ -365,6 +378,7 @@ private fun PipelineDestination(
modifier = paneModifier,
selectedId = selection.itemId.takeIf { depth >= 1 },
covered = covered,
listState = listState,
)
1 -> rememberPaneContent(
selection.itemId.takeIf { it != 0L }?.let {
@@ -423,6 +437,7 @@ private fun RunsDestination(
onSelectionChange: (PaneSelection) -> Unit,
pendingNav: SearchTarget.Run?,
onPendingNavResolved: () -> Unit,
listState: LazyListState,
) {
val depth = selection.depth
val onBack: () -> Unit = { onSelectionChange(backFrom(selection)) }
@@ -448,6 +463,8 @@ private fun RunsDestination(
depth = depth,
wide = wide,
onPopTo = { level -> onSelectionChange(popTo(selection, level)) },
compactLabel = "Runs",
compactIcon = Icons.Filled.History,
backContentDescription = { level -> if (level == 0) "Back to runs" else "Back to run" },
pane = { level, covered, paneModifier ->
when (level) {
@@ -457,6 +474,7 @@ private fun RunsDestination(
modifier = paneModifier,
selectedRunId = selection.itemId.takeIf { depth >= 1 },
covered = covered,
listState = listState,
)
1 -> rememberPaneContent(
selection.itemId.takeIf { it != 0L }?.let { it to selection.sectionIndex },
@@ -0,0 +1,55 @@
package net.awan.pipelines.ui.components
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
/**
* A list's saved scroll position: the index of the first visible item and the
* pixel offset of that item from the viewport's top edge. Both are primitives, so
* the pair round-trips through a Bundle and survives a configuration change or
* process death; it is deliberately independent of any particular list, so the
* restore/clamp rule is pure and unit-testable without a device.
*/
internal data class ListScrollAnchor(val index: Int = 0, val offset: Int = 0)
/**
* The anchor to restore into a list of [itemCount] items: the saved index clamped
* to the nearest valid item, because the list can have shrunk since the anchor was
* written (a filter, a sort, a refresh, items removed). An empty list has no valid
* index, so it stays at the top. The saved pixel offset is kept only when the
* saved item itself survived; a clamped index points at a different item, so it
* starts at its own top rather than part-way down an unrelated row. Never throws,
* and never falls back to the top while the saved item still exists.
*/
internal fun restoredScrollAnchor(anchor: ListScrollAnchor, itemCount: Int): ListScrollAnchor {
if (itemCount <= 0) return ListScrollAnchor()
val index = anchor.index.coerceIn(0, itemCount - 1)
val offset = if (index == anchor.index) anchor.offset else 0
return ListScrollAnchor(index, offset)
}
/**
* Reconciles the live [state] with a list that now has [itemCount] items, so a
* list that changed underneath the operator clamps to the nearest sensible item
* instead of staying past the end (which would draw nothing) or jumping to the
* top. Keyed on [itemCount], so it runs once when the size settles and never on
* the operator's own scrolling — a scroll after coming back is therefore never
* overridden — and an unloaded list ([itemCount] 0) is left alone so a restored
* position is not reset to the top while the data is still on its way.
*/
@Composable
internal fun RestoreListScroll(state: LazyListState, itemCount: Int) {
if (itemCount <= 0) return
LaunchedEffect(itemCount) {
val target = restoredScrollAnchor(
ListScrollAnchor(state.firstVisibleItemIndex, state.firstVisibleItemScrollOffset),
itemCount,
)
if (target.index != state.firstVisibleItemIndex ||
target.offset != state.firstVisibleItemScrollOffset
) {
state.scrollToItem(target.index, target.offset)
}
}
}
@@ -0,0 +1,53 @@
package net.awan.pipelines.ui.components
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableLongStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.compose.LocalLifecycleOwner
import androidx.lifecycle.compose.currentStateAsState
import kotlinx.coroutines.delay
/** A live value advances once a second, never per frame. */
private const val LIVE_TICK_MILLIS = 1_000L
/**
* Whether the host activity is resumed. The one background/focus gate every live
* ticking value shares, so a backgrounded app never keeps waking up once a second
* just to repaint a number nobody can see.
*/
@Composable
internal fun hostResumed(): Boolean {
val lifecycleState by LocalLifecycleOwner.current.lifecycle.currentStateAsState()
return lifecycleState.isAtLeast(Lifecycle.State.RESUMED)
}
/**
* The device clock in epoch millis, advanced once a second while [ticking] is
* true and the host is resumed, and frozen at its last reading otherwise. The
* single ticker behind every live elapsed readout: callers derive their value
* from the server's own start timestamp and this clock, so the numbers stay
* correct after a reconnect (never anchored to when the app happened to load),
* a screen full of running rows runs one coroutine rather than one per row, and
* nothing ticks for a finished run or while the app is backgrounded.
*
* The clock is re-read as the loop (re)starts, so a value frozen while
* backgrounded jumps straight to the correct elapsed on the first frame back.
*/
@Composable
internal fun rememberLiveNowMillis(ticking: Boolean): Long {
var nowMillis by remember { mutableLongStateOf(System.currentTimeMillis()) }
val live = ticking && hostResumed()
LaunchedEffect(live) {
if (!live) return@LaunchedEffect
nowMillis = System.currentTimeMillis()
while (true) {
delay(LIVE_TICK_MILLIS)
nowMillis = System.currentTimeMillis()
}
}
return nowMillis
}
@@ -1,40 +1,119 @@
package net.awan.pipelines.ui.components
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Icon
import androidx.compose.material3.LocalMinimumInteractiveComponentSize
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.rememberTextMeasurer
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import net.awan.pipelines.ui.theme.MIN_COVERED_PANE_WIDTH_DP
import net.awan.pipelines.ui.theme.PEEK_WIDTH_DP
import net.awan.pipelines.ui.theme.SPACING_M
import net.awan.pipelines.ui.theme.SPACING_S
import net.awan.pipelines.ui.theme.SPACING_XS
import net.awan.pipelines.ui.theme.pipelinesText
/**
* A covered pane's compact identity: its title and, when there is one, a single
* status/subtitle line, both centred in the peek strip. A covered pane renders
* this instead of its full body, so its tab rail, list, gallery and scrollable
* body are never drawn squeezed into a sliver.
* One labelled statistic a covered pane shows: its [label] (e.g. `runs`) and its
* [value] (e.g. `11`). The label always travels with its value so a reader can
* tell what the number means, and a [detail] statistic is the kind dropped first
* when the strip is too thin.
*/
data class PaneStat(
val label: String,
val value: String,
val detail: Boolean = false,
)
/**
* How much of a covered pane's statistics block fits at a given width: the title
* only ([Title]), the run counts ([Counts]) or the full block including the last
* run and the average duration ([Full]).
*/
internal enum class PaneStatTier { Title, Counts, Full }
/**
* The statistics tier for a covered strip [widthDp]: a strip narrower than one
* tappable peek ([PEEK_WIDTH_DP]) is too thin even for a labelled number, so it
* keeps the title only; a strip at least one minimum covered pane wide plus one
* peek ([MIN_COVERED_PANE_WIDTH_DP] + [PEEK_WIDTH_DP]) has room for the longest
* line (the last run's status and age), so it shows the full block. The
* boundaries reuse the named identity-tier tokens rather than new literals, and
* the decision is pure so it is unit-testable without a device.
*/
internal fun paneStatTier(widthDp: Dp): PaneStatTier = when {
widthDp < PEEK_WIDTH_DP -> PaneStatTier.Title
widthDp < MIN_COVERED_PANE_WIDTH_DP + PEEK_WIDTH_DP -> PaneStatTier.Counts
else -> PaneStatTier.Full
}
/**
* The statistics of [stats] that fit [tier]: nothing at [PaneStatTier.Title]
* (never a bare figure without its label), only the run counts at
* [PaneStatTier.Counts], and every line at [PaneStatTier.Full]. Pure, so the
* degradation rule is asserted in a unit test without composing anything.
*/
internal fun visiblePaneStats(stats: List<PaneStat>, tier: PaneStatTier): List<PaneStat> = when (tier) {
PaneStatTier.Title -> emptyList()
PaneStatTier.Counts -> stats.filterNot { it.detail }
PaneStatTier.Full -> stats
}
/**
* A covered pane's compact identity: its title and, when there are any, a
* compact vertical statistics block, both centred in the peek strip. A covered
* pane renders this instead of its full body, so its tab rail, list, gallery and
* scrollable body are never drawn squeezed into a sliver.
*
* The strip is narrow but the identity is the whole point of it, so the title
* wraps onto a few centered lines rather than becoming an unreadable ellipsis;
* it is the one place a title may legitimately run over more than one line.
* wraps onto a few centered lines rather than becoming an unreadable ellipsis; it
* is the one place a title may legitimately run over more than one line. The
* statistics are secondary to it and degrade with the width ([paneStatTier]):
* each is a label above its own value, only whole statistics are shown, and a
* strip too thin for a labelled number keeps the title alone — never a number
* clipped mid-digit or a figure without its label. [subtitle] remains for the
* panes whose covered identity is a single status/type word (the stage pane)
* rather than statistics, and [icon] is the pane-kind glyph drawn above the
* title.
*/
@Composable
fun PaneIdentity(title: String, subtitle: String? = null, modifier: Modifier = Modifier) {
fun PaneIdentity(
title: String,
subtitle: String? = null,
stats: List<PaneStat> = emptyList(),
icon: ImageVector? = null,
modifier: Modifier = Modifier,
) {
val text = pipelinesText()
Box(modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
// The strip's width is measured here so the statistics block can degrade with
// the space actually available, never from a fixed depth assumption.
BoxWithConstraints(modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
val shown = visiblePaneStats(stats, paneStatTier(maxWidth))
Column(
modifier = Modifier.padding(horizontal = SPACING_S, vertical = SPACING_M),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
if (icon != null) {
// Drawn at the vector's own default size, which is exactly what
// [rememberCompactIdentityWidth] measures, so the measured width
// and the drawn identity agree without a new size token.
Icon(imageVector = icon, contentDescription = null)
}
Text(
text = title,
style = text.cardTitle,
@@ -51,6 +130,64 @@ fun PaneIdentity(title: String, subtitle: String? = null, modifier: Modifier = M
overflow = TextOverflow.Ellipsis,
)
}
if (shown.isNotEmpty()) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(SPACING_S),
) {
shown.forEach { stat ->
// Each statistic is its own label above its value, so the
// number is on a line wide enough for it and never shares a
// line with a label that could push it into an ellipsis.
Column(horizontalAlignment = Alignment.CenterHorizontally) {
Text(
text = stat.label,
style = text.meta,
textAlign = TextAlign.Center,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
Text(
text = stat.value,
style = text.label,
textAlign = TextAlign.Center,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
}
}
}
}
}
}
}
/**
* The width one covered edge must have to show its compact identity: the wider of
* the identity [icon]'s own size and the measured width of [label] (the shortest
* label that identifies the pane, measured at runtime with the app's own type
* role and the platform's font metrics), plus the identity's own horizontal
* padding. The platform minimum touch target is the floor, so an edge is never
* derived below what can be tapped; no window percentage, budget or new dp token
* stands in for it. The caller passes this to `SlidingPaneStack`, which uses it as
* the whole covered region's width at every depth.
*/
@Composable
internal fun rememberCompactIdentityWidth(label: String, icon: ImageVector? = null): Dp {
val measurer = rememberTextMeasurer()
val text = pipelinesText()
val density = LocalDensity.current
val minTouch = LocalMinimumInteractiveComponentSize.current
return remember(measurer, label, icon, text, density, minTouch) {
val labelWidth = with(density) {
measurer.measure(
text = AnnotatedString(label),
style = text.cardTitle,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
).size.width.toDp()
}
val content = maxOf(labelWidth, icon?.defaultWidth ?: 0.dp)
maxOf(content + SPACING_S * 2, minTouch)
}
}
@@ -11,16 +11,19 @@ import androidx.compose.foundation.layout.fillMaxHeight
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.safeDrawing
import androidx.compose.foundation.layout.systemGestures
import androidx.compose.foundation.layout.union
import androidx.compose.foundation.layout.width
import androidx.compose.material3.LocalMinimumInteractiveComponentSize
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.input.pointer.PointerEventPass
import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalLayoutDirection
@@ -32,14 +35,15 @@ import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import net.awan.pipelines.ui.MAX_PANE_DEPTH
import net.awan.pipelines.ui.theme.MIN_ACTIVE_PANE_WIDTH_DP
import net.awan.pipelines.ui.theme.MIN_COVERED_PANE_WIDTH_DP
import net.awan.pipelines.ui.theme.PEEK_BUDGET_DP
import net.awan.pipelines.ui.theme.PEEK_WIDTH_DP
import net.awan.pipelines.ui.theme.SPACING_XS
import net.awan.pipelines.ui.theme.pipelinesText
// The pane geometry tokens (peek width/budget and the minimum active/covered
// pane widths) live in ui/theme/Dimens.kt, the single source of truth for app
// geometry; this file only derives offsets and widths from them.
// The covered region's width is not a token: it is measured from the compact
// identity a covered pane actually has to show (an icon plus the shortest label
// that identifies it) plus the leading gesture inset, so no screen or constant
// decides how much of a folded window the stack spends. The only fixed values
// left are platform ones: the minimum touch target that keeps an edge tappable
// and the leading system gesture inset this file already reads from the window.
/**
* The one slide timing every pane shares: the [MotionStandard] token, whose
@@ -74,87 +78,73 @@ internal fun paneSlideDelayMillis(level: Int, depth: Int, previousDepth: Int): I
internal fun paneSlideSpec(level: Int, depth: Int, previousDepth: Int): TweenSpec<Dp> =
MotionStandard.spec(delayMillis = paneSlideDelayMillis(level, depth, previousDepth))
/**
* The peek budget actually spent on a wide window: the fixed [PEEK_BUDGET_DP]
* token, reduced only when that would leave the active pane narrower than
* [MIN_ACTIVE_PANE_WIDTH_DP] on a small host. The budget never depends on the
* stack depth, so the active pane keeps a constant width as levels are added.
* Pure so the budget is unit-testable without a device.
*/
internal fun peekBudgetDp(hostWidth: Dp, requested: Dp = PEEK_BUDGET_DP): Dp =
requested.coerceAtMost((hostWidth - MIN_ACTIVE_PANE_WIDTH_DP).coerceAtLeast(0.dp))
/**
* The width of the pane whose open left edge is [offset] on a wide window: from
* that offset to the host's right edge. The active pane therefore measures
* `hostWidth - budget`; a narrow host can never yield a negative width.
* that offset to the host's right edge. The active pane therefore measures the
* host less the covered region; a narrow host can never yield a negative width.
*/
internal fun paneWidthDp(hostWidth: Dp, offset: Dp): Dp =
maxOf(0.dp, hostWidth - offset)
/**
* One covered strip of a wide-window stack, in left-to-right order. [level] is
* the pane whose compact identity it shows; a [folded] count greater than one
* marks a strip that stands in for that many older levels (one edge indicator
* with a count) instead of a single pane, so no covered pane is squeezed below
* the named minimum width.
* One covered pane's visible edge in a wide stack's covered region, in
* left-to-right order. [level] is the pane whose compact identity the edge shows
* (for a folded edge, the newest of the levels it stands in for). [folded] is the
* number of *additional* older levels that edge represents, so those levels
* collapse into its count instead of spending width on each of them.
*/
internal data class PeekStrip(
internal data class PaneEdge(
val level: Int,
val start: Dp,
val width: Dp,
val folded: Int = 1,
val folded: Int = 0,
)
/**
* The covered strips of a wide stack for [covered] covered levels and the fixed
* [budget]. Every shown pane keeps at least `minCovered`; the leftmost strip is
* widened first so that after [startInset] it still leaves [minPeek] tappable,
* and the rest of the budget is then split evenly between the other strips.
* The covered edges of a wide stack for [covered] covered levels, laid out inside
* the one covered region [region]. The region is derived from the measured
* compact-identity width (see [rememberCompactIdentityWidth]) plus the leading
* gesture inset [startInset], and is **the same at every depth**: the nearest
* covered level keeps the whole region less, at most, one thinner edge. The active
* pane's left edge — and therefore its width — is the region, so it never changes
* as levels are added. That is the invariant: opening another level only ever adds
* its own thin edge inside the region, never widens the region.
*
* When [covered] levels cannot each get `minCovered` out of [budget], one strip
* (the leftmost) is reserved as an edge indicator folding the oldest levels into
* a single count, and only the newest levels keep their own peek: the number of
* peeks shown shrinks rather than the width of each. The active pane's left edge
* is therefore still exactly the budget. Pure, so the shared-budget geometry and
* the fold rule need no device; an empty list means nothing is covered.
* The nearest covered level always shows its identity. One older level is shown
* as a thinner edge — the platform minimum touch target [minTouch], the thinnest
* an edge may be and stay tappable after [startInset] — and every level older than
* that collapses into that edge's [PaneEdge.folded] count rather than
* accumulating width. When the region cannot fit that thinner edge as well as a
* full [minTouch] identity, nothing is squeezed below the touch target: the older
* levels fold into the nearest edge's count instead. Pure, so the invariant, the
* thin edge and the fold rule need no device; an empty list means nothing is
* covered.
*/
internal fun peekStripsDp(
internal fun coveredEdgesDp(
covered: Int,
budget: Dp,
region: Dp,
minTouch: Dp,
startInset: Dp,
minPeek: Dp,
minCovered: Dp = MIN_COVERED_PANE_WIDTH_DP,
): List<PeekStrip> {
if (covered <= 0 || budget <= 0.dp) return emptyList()
// How many covered panes the budget can show at the minimum width. When some
// levels have to fold, one of those slots is spent on the edge indicator.
val capacity = if (minCovered > 0.dp) (budget.value / minCovered.value).toInt() else covered
val fold = covered > capacity
val shown = if (fold) (capacity - 1).coerceAtLeast(0) else covered
val folded = covered - shown
val slots = shown + if (fold) 1 else 0
val first = minOf(budget, maxOf(budget / slots, startInset + minPeek))
val rest = budget - first
val steps = slots - 1
val starts = ArrayList<Dp>(slots + 1)
starts += 0.dp
starts += first
for (i in 1 until slots) {
starts += first + rest * i / steps
): List<PaneEdge> {
if (covered <= 0 || region <= 0.dp) return emptyList()
val nearest = covered - 1
if (covered == 1) return listOf(PaneEdge(nearest, 0.dp, region))
// The thinner older edge keeps one touch target after the leading inset; the
// nearest identity needs one too, or the older levels fold into its count.
val older = startInset + minTouch
return if (region >= older + minTouch) {
listOf(
PaneEdge(
level = (covered - 2).coerceAtLeast(0),
start = 0.dp,
width = older,
folded = (covered - 2).coerceAtLeast(0),
),
PaneEdge(nearest, older, region - older),
)
} else {
listOf(PaneEdge(nearest, 0.dp, region, folded = covered - 1))
}
val strips = ArrayList<PeekStrip>(slots)
var slot = 0
if (fold) {
strips += PeekStrip(folded - 1, starts[0], starts[1] - starts[0], folded = folded)
slot = 1
}
for (i in 0 until shown) {
val level = folded + i
val s = slot + i
strips += PeekStrip(level, starts[s], starts[s + 1] - starts[s])
}
return strips
}
/**
@@ -180,18 +170,21 @@ internal fun paneSafeArea(): WindowInsets = WindowInsets.safeDrawing
*
* On a **narrow** window ([wide] false) it is not a stack at all: there is no
* peek and no leftover strip, and each opened pane is a full-window screen that
* slides in over the last. On a **wide** window ([wide] true) the panes stack,
* but the space spent on the covered panes is a single fixed budget shared
* between them: the active pane's left edge is always exactly the budget, so it
* keeps a constant width and the stack never consumes more than the budget
* however deep it gets.
* slides in over the last. On a **wide** window ([wide] true) the panes stack:
* the covered panes sit under the active one, each showing its left edge, and the
* covered region's width is not a constant but is measured from the compact
* identity a covered edge has to show ([compactLabel], see
* [rememberCompactIdentityWidth]) plus the leading gesture inset. The active
* pane's left edge is always exactly that region, so its width is the same at
* every depth: opening another level only adds its own thin edge inside the
* region and never resizes the panes already there.
*
* A covered pane shows a compact identity only (its pane composable is told
* [covered] and is expected to render just a title/status), constrained to the
* visible strip, so its full body is never drawn into a sliver. When the budget
* cannot give every covered pane the named minimum width, the oldest levels
* fold into a single edge indicator carrying their count rather than being
* squeezed.
* visible edge, so its full body is never drawn into a sliver. The nearest
* covered level shows its identity; one older level is a thinner edge and every
* older level than that folds into that edge's count ([coveredEdgesDp]), so no
* level is ever squeezed below the platform minimum touch target.
*
* [depth] is the number of visible panes minus one (0..[MAX_PANE_DEPTH]);
* [pane] composes the level's content. The stack mounts a level while it is open
@@ -211,13 +204,15 @@ internal fun paneSafeArea(): WindowInsets = WindowInsets.safeDrawing
* are retargeted in reverse, and several levels closing in one tap reverse in
* order. A covered pane is hidden from accessibility and made non-interactive so
* TalkBack focus follows the top pane and a tap can never leak through to a
* covered one; on a wide window only its peek strip stays tappable.
* covered one; on a wide window only its edge stays tappable.
*/
@Composable
fun SlidingPaneStack(
depth: Int,
wide: Boolean,
onPopTo: (Int) -> Unit,
compactLabel: String,
compactIcon: ImageVector? = null,
modifier: Modifier = Modifier,
backContentDescription: (Int) -> String = { "Back" },
pane: @Composable (level: Int, covered: Boolean, modifier: Modifier) -> Unit,
@@ -236,48 +231,27 @@ fun SlidingPaneStack(
// The strip/compact identity area: the host clear of the top/bottom insets.
val stripHeight = maxOf(0.dp, maxHeight - topInset - bottomInset)
// Narrow: no peek at all (budget 0, every pane fills the host). Wide: one
// fixed budget shared between the covered panes, folded when it cannot
// give each the named minimum. The platform's minimum interactive size is
// the floor for a tappable strip, never a literal.
val minPeek = maxOf(PEEK_WIDTH_DP, LocalMinimumInteractiveComponentSize.current)
val budget = if (wide) peekBudgetDp(hostWidth) else 0.dp
val strips = peekStripsDp(depth, budget, startInset, minPeek)
val stripByLevel = strips.associateBy { it.level }
val folded = strips.firstOrNull()?.takeIf { it.folded > 1 }?.folded ?: 0
// The active pane always opens at the whole budget (or 0 when narrow).
val activeStart = strips.fold(0.dp) { acc, strip -> acc + strip.width }
// Narrow: no peek at all, so every pane fills the host and the covered
// region is empty. Wide: the region is one measured compact identity plus
// the leading gesture inset; it is the same at every depth, so the active
// pane's width never depends on how deep the stack is. The platform's
// minimum interactive size is the floor for each tappable edge, never a
// literal.
val minTouch = LocalMinimumInteractiveComponentSize.current
val identityWidth = rememberCompactIdentityWidth(compactLabel, compactIcon)
val region = if (wide) identityWidth + startInset else 0.dp
val edges = coveredEdgesDp(depth, region, minTouch, startInset)
val edgeByLevel = edges.associateBy { it.level }
val shownCovered = edges.map { it.level }.toSet()
// The active pane always opens at exactly the covered region's width (0
// when nothing is covered or the window is narrow, so it fills the host).
val activeStart = edges.fold(0.dp) { acc, edge -> acc + edge.width }
// The depth just before the current one, so a pop knows how many levels
// were open (to stagger their reversal). Held stable for a given depth so
// the slide spec never changes part-way through a slide.
val depthTrack = remember { PaneDepthTrack(depth) }
val closingFrom = remember(depth) { depthTrack.previous.also { depthTrack.previous = depth } }
// The folded older levels as one edge indicator with a count, clear of the
// status/nav bars and of the left gesture area; tapping it jumps back to
// the newest folded level.
if (folded > 0) {
val strip = strips.first()
Box(
Modifier
.align(Alignment.TopStart)
.offset(x = startInset, y = topInset)
.width(maxOf(0.dp, strip.width - startInset))
.height(stripHeight)
.clickable(
role = Role.Button,
onClickLabel = backContentDescription(folded - 1),
onClick = { onPopTo(folded - 1) },
)
.semantics {
contentDescription = backContentDescription(folded - 1)
role = Role.Button
},
) {
PaneIdentity("$folded more", null, Modifier.fillMaxSize())
}
}
// Panes 0..MAX are always given their own long-lived animator, in order,
// even while closed, so a retarget slides rather than jumps and the
// animator stays warm; a level beyond the depth waits exactly off the
@@ -285,20 +259,22 @@ fun SlidingPaneStack(
// exact time-reverse of opening.
for (level in 0..MAX_PANE_DEPTH) {
val covered = level < depth
// A level folded into the edge indicator is not drawn on its own.
if (covered && level < folded) continue
val strip = if (covered) stripByLevel[level] else null
// A level folded into an older edge's count is not drawn on its own.
// A narrow window has no edges at all, so every covered level keeps
// composing its full body under the active one, as before.
if (covered && edges.isNotEmpty() && level !in shownCovered) continue
val edge = if (covered) edgeByLevel[level] else null
// An open pane sits at its shared-budget offset; a closed one waits
// exactly off the right edge. Its width is already the width it will
// have when open, so it slides rather than grows.
// An open pane sits at its edge's offset; a closed one waits exactly
// off the right edge. Its width is already the width it will have when
// open, so it slides rather than grows.
val openOffset = when {
level > depth -> hostWidth
level == depth -> activeStart
strip != null -> strip.start
edge != null -> edge.start
else -> 0.dp
}
val openWidth = paneWidthDp(hostWidth, if (level <= depth) openOffset else budget)
val openWidth = paneWidthDp(hostWidth, if (level <= depth) openOffset else region)
val offset by animateDpAsState(
targetValue = openOffset,
animationSpec = paneSlideSpec(level, depth, closingFrom),
@@ -318,20 +294,30 @@ fun SlidingPaneStack(
.fillMaxHeight()
.then(if (level < depth) Modifier.blockPointerInput() else Modifier),
) {
if (strip != null) {
// Constrain the compact identity to the visible strip so it
// is centred in the space the covered pane actually has. It
// rides with the pane's own offset and slides in so it also
// slides back out with it.
val stripInset = if (level == 0) startInset else 0.dp
if (edge != null) {
// Constrain the compact identity to the visible edge so it
// is centred in the space the covered pane actually has, and
// carry this level's share of the folded older levels as a
// count. It rides with the pane's own offset and slides in so
// it also slides back out with it.
val edgeInset = if (edge === edges.first()) startInset else 0.dp
Box(
Modifier
.align(Alignment.TopStart)
.offset(x = stripInset, y = topInset)
.width(maxOf(0.dp, strip.width - stripInset))
.offset(x = edgeInset, y = topInset)
.width(maxOf(0.dp, edge.width - edgeInset))
.height(stripHeight),
) {
pane(level, true, Modifier.fillMaxSize())
if (edge.folded > 0) {
Text(
text = "${edge.folded} more",
style = pipelinesText().meta,
modifier = Modifier
.align(Alignment.TopEnd)
.padding(SPACING_XS),
)
}
}
} else {
pane(level, false, Modifier.fillMaxSize())
@@ -339,26 +325,26 @@ fun SlidingPaneStack(
}
}
// The covered pane's tappable peek (wide windows only): the strip
// The covered pane's tappable edge (wide windows only): the edge
// between this pane's offset and the next pane's, clear of the
// status/nav bars and of the left gesture area. It sits above the
// pane's compact identity so tapping it closes every pane to its
// right; it never overlaps the next pane.
if (strip != null) {
val stripInset = if (level == 0) startInset else 0.dp
if (edge != null) {
val edgeInset = if (edge === edges.first()) startInset else 0.dp
Box(
Modifier
.align(Alignment.TopStart)
.offset(x = strip.start + stripInset, y = topInset)
.width(maxOf(0.dp, strip.width - stripInset))
.offset(x = edge.start + edgeInset, y = topInset)
.width(maxOf(0.dp, edge.width - edgeInset))
.height(stripHeight)
.clickable(
role = Role.Button,
onClickLabel = backContentDescription(level),
onClick = { onPopTo(level) },
onClickLabel = backContentDescription(edge.level),
onClick = { onPopTo(edge.level) },
)
.semantics {
contentDescription = backContentDescription(level)
contentDescription = backContentDescription(edge.level)
role = Role.Button
},
)
@@ -115,11 +115,19 @@ sealed interface LoadPhase {
/**
* Classifies a list pane's [LoadPhase] from its load signals. A failed load with
* no data wins, then a load with no data, then an empty result; anything else is
* [LoadPhase.Content]. [emptyMessage] is non-null exactly when the pane is empty
* and is the text to show, captured so a fading-out empty branch never reads a
* changed query; [emptyActionLabel] labels the one recovery action offered with
* that text (both are captured at classification).
* no data wins, then a list with no data yet ([loaded] false, or a load in
* flight), then an empty result; anything else is [LoadPhase.Content].
* [emptyMessage] is non-null exactly when the pane is empty and is the text to
* show, captured so a fading-out empty branch never reads a changed query;
* [emptyActionLabel] labels the one recovery action offered with that text (both
* are captured at classification).
*
* [loaded] is the pane's "data has arrived at least once" signal. Before the
* first load completes the initial state is both not-loading and data-less, and
* without this it would classify as content: a list that has never loaded must
* read as loading, not as an empty list, so a restored scroll position is never
* clamped against a list that is merely not there yet. It defaults to true so a
* pane that has no such signal keeps the previous behaviour.
*
* When stale data is present neither loading nor an error replaces it: the
* screen keeps showing the data and surfaces the error inline, so [hasData]
@@ -131,9 +139,10 @@ fun listLoadPhase(
hasData: Boolean,
emptyMessage: String?,
emptyActionLabel: String? = null,
loaded: Boolean = true,
): LoadPhase = when {
error != null && !hasData -> LoadPhase.Error(error)
loading && !hasData -> LoadPhase.Loading
!hasData && (loading || !loaded) -> LoadPhase.Loading
emptyMessage != null -> LoadPhase.Empty(emptyMessage, emptyActionLabel)
else -> LoadPhase.Content
}
@@ -11,6 +11,7 @@ import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material.icons.filled.Hub
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
@@ -333,6 +334,7 @@ fun StageDetailPane(
PaneIdentity(
title = GraphSemantics.nodeLabel(stageKey),
subtitle = if (stage != null) effectiveStageType(stage.type) else "terminal",
icon = Icons.Filled.Hub,
modifier = modifier.fillMaxSize(),
)
return
@@ -36,7 +36,6 @@ import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableFloatStateOf
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableLongStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
@@ -75,13 +74,9 @@ 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.lifecycle.Lifecycle
import androidx.lifecycle.compose.LocalLifecycleOwner
import androidx.lifecycle.compose.currentStateAsState
import kotlin.math.abs
import kotlin.math.hypot
import kotlin.math.roundToInt
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import net.awan.pipelines.data.protocol.Graph
import net.awan.pipelines.data.protocol.GraphEdge
@@ -90,6 +85,8 @@ import net.awan.pipelines.data.protocol.GraphSemantics
import net.awan.pipelines.data.protocol.Protocol
import net.awan.pipelines.data.protocol.RunGraphState
import net.awan.pipelines.data.protocol.edges
import net.awan.pipelines.ui.components.hostResumed
import net.awan.pipelines.ui.components.rememberLiveNowMillis
import net.awan.pipelines.ui.formatDuration
import net.awan.pipelines.ui.secondsSince
import net.awan.pipelines.ui.theme.GRAPH_ACTIVE_HALO_GAP
@@ -274,25 +271,18 @@ fun WorkflowGraph(
// finished run; pause when the graph is off screen or when the OS animation
// setting is off. ValueAnimator.areAnimatorsEnabled() reflects the system
// "Remove animations"/animation-scale setting; it is re-read on resume.
val lifecycleState by LocalLifecycleOwner.current.lifecycle.currentStateAsState()
val onScreen = lifecycleState.isAtLeast(Lifecycle.State.RESUMED)
val onScreen = hostResumed()
val animationsEnabled = remember(onScreen) { ValueAnimator.areAnimatorsEnabled() }
val animate = graphShouldAnimate(runState, animationsEnabled, onScreen)
val phase = rememberPulsePhase(animate)
// The active stage's live ticking elapsed time. The loop only runs while
// animating, so a finished run, a paused/off-screen graph and an
// animations-disabled device never wake up once a second; in those cases the
// value is a static snapshot for a clearly marked running state.
// The active stage's live ticking elapsed time, from the shared clock: it
// runs only while the graph is animating a live stage whose start is known,
// so a finished run, a paused/off-screen graph and an animations-disabled
// device never wake up once a second; in those cases the value is a static
// snapshot for a clearly marked running state.
val activeStartedAt = runState?.currentStageStartedAt
var nowMillis by remember { mutableLongStateOf(System.currentTimeMillis()) }
LaunchedEffect(animate, activeStartedAt) {
if (!animate || activeStartedAt.isNullOrBlank()) return@LaunchedEffect
while (true) {
nowMillis = System.currentTimeMillis()
delay(ELAPSED_TICK_MILLIS)
}
}
val nowMillis = rememberLiveNowMillis(animate && !activeStartedAt.isNullOrBlank())
// Measured once per second (never per frame) so the canvas draw adds no
// allocation for the timer.
val elapsedLayout = remember(activeStartedAt, nowMillis, scheme, density, text) {
@@ -1746,9 +1736,6 @@ private fun rememberPulsePhase(animate: Boolean): Float {
/** One pulse (and one full pass of the edge flow) per this many milliseconds. */
private const val PULSE_PERIOD_MILLIS = 1_600
/** The active stage's elapsed time ticks once a second, never per frame. */
private const val ELAPSED_TICK_MILLIS = 1_000L
/** How much of the pulse strength the active halo's soft glow carries. */
private const val ACTIVE_HALO_GLOW = 0.28f
@@ -0,0 +1,179 @@
package net.awan.pipelines.ui.screens
import java.time.OffsetDateTime
import kotlin.math.roundToLong
import net.awan.pipelines.data.protocol.RunSummary
import net.awan.pipelines.ui.components.PaneStat
import net.awan.pipelines.ui.components.RunState
import net.awan.pipelines.ui.components.runStateOf
import net.awan.pipelines.ui.durationSeconds
import net.awan.pipelines.ui.formatDuration
/**
* The compact statistics a covered pipeline pane shows, aggregated client-side
* from the run history the app already receives (never a server field). The
* counts mirror the server's own vocabulary (internal/pipeline/stats.go): active
* is a queued/running run, and the average is over the runs that have finished,
* so a still-running run never drags it down.
*
* [lastState]/[lastAgo] are null for a pipeline with no runs (or an id present in
* no history), and [averageSeconds] is null until at least one run has finished;
* the caller shows the rest and omits those lines rather than inventing a value.
*/
internal data class PipelinePeekStats(
val total: Int,
val succeeded: Int,
val failed: Int,
val active: Int,
val lastState: RunState?,
val lastAgo: String?,
val averageSeconds: Long?,
) {
/** The labelled lines, counts first then the last-run/average details. */
fun lines(): List<PaneStat> = buildList {
addAll(countStats(total, succeeded, failed, active))
lastState?.let { add(PaneStat("last", lastLine(it, lastAgo), detail = true)) }
averageSeconds?.let { add(PaneStat("avg", formatDuration(it), detail = true)) }
}
}
/**
* The compact statistics a covered list pane (the pipelines list or the runs
* list) shows: counts by status plus the single most recent run, aggregated
* client-side from the run history. A list has no single pipeline to average, so
* it carries no duration line.
*/
internal data class ListPeekStats(
val total: Int,
val succeeded: Int,
val failed: Int,
val active: Int,
val lastState: RunState?,
val lastAgo: String?,
) {
/** The labelled lines, counts first then the last-activity detail. */
fun lines(): List<PaneStat> = buildList {
addAll(countStats(total, succeeded, failed, active))
lastState?.let { add(PaneStat("last", lastLine(it, lastAgo), detail = true)) }
}
}
/**
* The whole history's labelled statistics, for a covered list pane (the pipelines
* list, or the runs list with no pipeline filter): counts by status plus the
* single most recent run. Empty until that history has loaded, never a zero-run
* claim before the data is in hand.
*/
internal fun listStatLines(runs: List<RunSummary>?, now: OffsetDateTime): List<PaneStat> =
runs?.let { listPeekStats(it, now).lines() }.orEmpty()
/**
* One pipeline's labelled statistics, for a covered pipeline pane (a pipeline's
* detail, or a run open over its pipeline). Empty until both the history has
* loaded and the [pipelineId] is known: an unknown or absent id is "not known
* yet", never the whole history, so a covered run pane can never show the
* server-wide summary as if it were the run's own pipeline. The entry point the
* pipeline-scoped covered panes share, so the "which history, which pipeline"
* wiring lives here instead of at each call site.
*/
internal fun pipelineStatLines(
runs: List<RunSummary>?,
pipelineId: Long?,
now: OffsetDateTime,
): List<PaneStat> = when {
runs == null || pipelineId == null -> emptyList()
else -> pipelinePeekStats(runs, pipelineId, now).lines()
}
/** One pipeline's statistics over the whole run history, anchored to [now]. */
internal fun pipelinePeekStats(
runs: List<RunSummary>,
pipelineId: Long,
now: OffsetDateTime,
): PipelinePeekStats {
val tally = RunTally()
for (run in runs) if (run.pipelineId == pipelineId) tally.add(run)
val newest = tally.newest
return PipelinePeekStats(
total = tally.total,
succeeded = tally.succeeded,
failed = tally.failed,
active = tally.active,
lastState = newest?.let { runStateOf(it.status) },
lastAgo = newest?.let { formatRanAgo(it.createdAt, now) },
averageSeconds = tally.averageSeconds,
)
}
/** The whole history's statistics, anchored to [now]. */
internal fun listPeekStats(runs: List<RunSummary>, now: OffsetDateTime): ListPeekStats {
val tally = RunTally()
for (run in runs) tally.add(run)
val newest = tally.newest
return ListPeekStats(
total = tally.total,
succeeded = tally.succeeded,
failed = tally.failed,
active = tally.active,
lastState = newest?.let { runStateOf(it.status) },
lastAgo = newest?.let { formatRanAgo(it.createdAt, now) },
)
}
/**
* The per-status counts, the completed-duration total and the most recent run,
* folded together in one pass over a history. [add] is called once per run, so a
* scoped summary ([pipelinePeekStats]) never allocates an intermediate filtered
* list or walks the history a second time for the last run.
*/
private class RunTally {
var total = 0
private set
var succeeded = 0
private set
var failed = 0
private set
var active = 0
private set
private var durationSeconds = 0L
private var durationCount = 0
/** The most recent run seen, by the shared [isMoreRecent] rule, or null. */
var newest: RunSummary? = null
private set
/**
* The rounded mean duration over the runs that finished, or null when none
* has. A zero-duration run is a real measurement and is included, not
* dropped.
*/
val averageSeconds: Long?
get() = if (durationCount > 0) (durationSeconds.toDouble() / durationCount).roundToLong() else null
fun add(run: RunSummary) {
total++
when (runStateOf(run.status)) {
RunState.Succeeded -> succeeded++
RunState.Failed -> failed++
RunState.Running, RunState.Queued -> active++
else -> Unit
}
durationSeconds(run.createdAt, run.finishedAt)?.let {
durationSeconds += it
durationCount++
}
val current = newest
if (current == null || isMoreRecent(run, current)) newest = run
}
}
private fun countStats(total: Int, succeeded: Int, failed: Int, active: Int): List<PaneStat> = listOf(
PaneStat("runs", total.toString()),
PaneStat("succeeded", succeeded.toString()),
PaneStat("failed", failed.toString()),
PaneStat("active", active.toString()),
)
/** `succeeded · 2h ago`, or just the status when the timestamp is unusable. */
private fun lastLine(state: RunState, ago: String?): String =
listOfNotNull(state.label, ago).joinToString(" · ")
@@ -15,6 +15,7 @@ import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material.icons.filled.AccountTree
import androidx.compose.material.icons.filled.ContentCopy
import androidx.compose.material.icons.filled.PlayArrow
import androidx.compose.material.icons.filled.Refresh
@@ -42,6 +43,7 @@ import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalClipboardManager
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import java.time.OffsetDateTime
import net.awan.pipelines.data.ErrorMessages
import net.awan.pipelines.data.protocol.PipelineDetail
import net.awan.pipelines.data.protocol.VersionSummary
@@ -89,6 +91,7 @@ fun PipelineDetailScreen(
covered: Boolean = false,
) {
val state by vm.pipelineDetail.collectAsStateWithLifecycle()
val runsState by vm.runs.collectAsStateWithLifecycle()
var showStart by remember { mutableStateOf(false) }
LaunchedEffect(pipelineId, version) { vm.loadPipeline(pipelineId, version) }
@@ -101,11 +104,18 @@ fun PipelineDetailScreen(
val shownDetail = rememberPaneContent(detail)
// A covered pane shows its compact identity only; the tab rail and section
// body must never be drawn squeezed into the peek strip.
// body must never be drawn squeezed into the peek strip. When the run history
// is in hand the identity carries this pipeline's statistics (run counts, the
// last run and the average duration) instead of a bare version/stage line.
if (covered) {
val now = remember { OffsetDateTime.now() }
val stats = remember(runsState.data, pipelineId, now) {
pipelineStatLines(runsState.data?.runs, pipelineId, now)
}
PaneIdentity(
title = detail?.name ?: "Pipeline",
subtitle = detail?.let { "v$version · ${it.graph.stages.size} stages" },
stats = stats,
icon = Icons.Filled.AccountTree,
modifier = modifier.fillMaxSize(),
)
return
@@ -5,17 +5,18 @@ import java.time.OffsetDateTime
import net.awan.pipelines.data.protocol.RunSummary
import net.awan.pipelines.ui.components.RunState
import net.awan.pipelines.ui.components.runStateOf
import net.awan.pipelines.ui.formatDuration
import net.awan.pipelines.ui.parseInstant
import net.awan.pipelines.ui.runDurationText
/** Shown for a pipeline that appears in list_runs but has recorded no run. */
const val NO_RUNS_RECORDED = "no runs recorded"
/**
* The last-run facts one pipeline row shows: the status chip's [state], how long
* ago the run started, its recorded duration and its run id. Kept as a plain data
* class so the join and its edge cases (no runs, ties, unknown status) are
* unit-testable without composing anything.
* ago the run started, its time so far ([duration]: the live elapsed while it is
* still running, the recorded total once finished) and its run id. Kept as a
* plain data class so the join and its edge cases (no runs, ties, unknown status)
* are unit-testable without composing anything.
*/
internal data class PipelineRunBadge(
val runId: Long,
@@ -52,8 +53,9 @@ internal fun pipelineRunBadges(
/**
* The most recent run of each pipeline, decided from the timestamps (the higher
* run id breaking an exact tie or a bad timestamp), independent of the input
* order. The one fold shared by the last-run badge join above and the "most
* recent run" pipeline sort, so both agree on which run is the latest.
* order. One pass, reusing the shared [isMoreRecent] comparison, so it shares the
* "most recent" rule with the covered panes' last-run line without grouping the
* history into intermediate lists.
*/
internal fun latestRunByPipeline(runs: List<RunSummary>): Map<Long, RunSummary> {
val latest = HashMap<Long, RunSummary>()
@@ -70,11 +72,22 @@ internal fun runBadge(run: RunSummary, now: OffsetDateTime): PipelineRunBadge =
runId = run.id,
state = runStateOf(run.status),
ranAgo = formatRanAgo(run.createdAt, now),
duration = formatDuration(run.createdAt, run.finishedAt),
// A still-running run shows the time it has taken so far, recomputed from
// its start timestamp as [now] advances; a finished one its total duration.
duration = runDurationText(
createdAt = run.createdAt,
finishedAt = run.finishedAt,
executing = run.executing,
nowMillis = now.toInstant().toEpochMilli(),
),
)
/** Timestamps decide recency; the higher run id breaks an exact tie (or a bad timestamp). */
private fun isMoreRecent(candidate: RunSummary, current: RunSummary): Boolean {
/**
* Timestamps decide recency; the higher run id breaks an exact tie (or a bad
* timestamp). The one recency rule, shared by the per-pipeline last-run join and
* the covered panes' most-recent-run line.
*/
internal fun isMoreRecent(candidate: RunSummary, current: RunSummary): Boolean {
val a = parseInstant(candidate.createdAt)
val b = parseInstant(current.createdAt)
if (a != null && b != null) {
@@ -86,7 +99,8 @@ private fun isMoreRecent(candidate: RunSummary, current: RunSummary): Boolean {
/**
* A compact "how long ago" for a run's start: `just now` under a minute, then
* `Nm ago`/`Nh ago`/`Nd ago`, the same integer rhythm as [formatDuration]. Null
* `Nm ago`/`Nh ago`/`Nd ago`, the same integer rhythm as the shared duration
* formatting. Null
* when the timestamp is blank or unparseable, so the caller omits the fragment
* instead of printing a blank. A future start (clock skew) reads as `just now`,
* never a negative age.
@@ -10,6 +10,7 @@ import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.only
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.AccountTree
@@ -34,7 +35,9 @@ import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.style.TextOverflow
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import java.time.Instant
import java.time.OffsetDateTime
import java.time.ZoneId
import net.awan.pipelines.data.protocol.PipelineSummary
import net.awan.pipelines.ui.AppViewModel
import net.awan.pipelines.ui.components.EmptyState
@@ -46,6 +49,7 @@ import net.awan.pipelines.ui.components.ListRow
import net.awan.pipelines.ui.components.LoadPhase
import net.awan.pipelines.ui.components.LoadingState
import net.awan.pipelines.ui.components.PaneIdentity
import net.awan.pipelines.ui.components.RestoreListScroll
import net.awan.pipelines.ui.components.RunState
import net.awan.pipelines.ui.components.RunStatusChip
import net.awan.pipelines.ui.components.SortMenu
@@ -53,6 +57,7 @@ import net.awan.pipelines.ui.components.StateCrossfade
import net.awan.pipelines.ui.components.animateListItem
import net.awan.pipelines.ui.components.listLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.rememberLiveNowMillis
import net.awan.pipelines.ui.theme.SPACING_L
import net.awan.pipelines.ui.theme.SPACING_S
import net.awan.pipelines.ui.theme.pipelinesText
@@ -65,6 +70,7 @@ fun PipelineListScreen(
modifier: Modifier = Modifier,
selectedId: Long? = null,
covered: Boolean = false,
listState: LazyListState,
) {
val state by vm.pipelines.collectAsStateWithLifecycle()
val runsState by vm.runs.collectAsStateWithLifecycle()
@@ -82,8 +88,40 @@ fun PipelineListScreen(
vm.refreshRuns()
}
// "How long ago" is anchored once per composition, not recomputed per row.
val now = remember { OffsetDateTime.now() }
// "How long ago" (and a running run's live elapsed) are anchored to a shared
// clock that ticks only while some run in the history is executing and the app
// is resumed, so the last-run line's elapsed advances and stays correct after
// a reconnect (derived from the server's own start timestamps) while a fully
// finished history costs no wakeups.
val live = runsState.data?.runs?.any { it.executing } == true
val nowMillis = rememberLiveNowMillis(live)
val now = remember(nowMillis) {
OffsetDateTime.ofInstant(Instant.ofEpochMilli(nowMillis), ZoneId.systemDefault())
}
// [listState] is owned by the destination, above the panes: a covered pane is a
// different composition (its compact identity is drawn in a strip), so a state
// held here would be discarded and reset the scroll when a detail closes.
// [RestoreListScroll] clamps it when the list changed underneath.
// A covered pane shows its compact identity only; the search field and list
// must never be drawn squeezed into the peek strip. Its statistics are the
// run history's summary, folded once; before the history has loaded the
// identity stays title-only rather than claiming zero runs. Measured before
// the row badges below so the peek never pays for the unshown fold.
if (covered) {
val stats = remember(runsState.data, now) {
listStatLines(runsState.data?.runs, now)
}
PaneIdentity(
title = "Pipelines",
stats = stats,
icon = Icons.Filled.AccountTree,
modifier = modifier.fillMaxSize(),
)
return
}
// The history is folded to one latest run per pipeline once, feeding both the
// row badges and the "most recent run" ordering rather than folding twice.
val latestRuns = remember(runsState.data) {
@@ -102,18 +140,6 @@ fun PipelineListScreen(
query = ""
}
// A covered pane shows its compact identity only; the search field and list
// must never be drawn squeezed into the peek strip.
if (covered) {
val count = state.data?.size ?: 0
PaneIdentity(
title = "Pipelines",
subtitle = if (count > 0) "$count on this server" else null,
modifier = modifier.fillMaxSize(),
)
return
}
Scaffold(
modifier = modifier,
contentWindowInsets = paneSafeArea(),
@@ -189,6 +215,11 @@ fun PipelineListScreen(
null
},
emptyActionLabel = if (items.isEmpty() && all.isNotEmpty()) "Clear filters" else null,
// Before the first load this frame is both data-less and not
// in flight; without [loaded] it would render the "no
// pipelines are defined" empty message against a server that
// has not answered yet.
loaded = state.loaded,
),
) { phase ->
when (phase) {
@@ -199,19 +230,25 @@ fun PipelineListScreen(
actionLabel = phase.actionLabel,
onAction = if (phase.actionLabel != null) onClearFilters else null,
)
LoadPhase.Content -> LazyColumn(
modifier = Modifier.fillMaxSize(),
contentPadding = PaddingValues(vertical = SPACING_S),
) {
items(items, key = { it.id }) { pipeline ->
PipelineRow(
pipeline = pipeline,
selected = pipeline.id == selectedId,
badge = badges[pipeline.id],
runsKnown = runsKnown,
onClick = { onOpen(pipeline.id, pipeline.version) },
modifier = animateListItem(),
)
LoadPhase.Content -> {
// Restores the saved position (clamped to the current,
// possibly shrunken, list) without fighting a later scroll.
RestoreListScroll(listState, items.size)
LazyColumn(
state = listState,
modifier = Modifier.fillMaxSize(),
contentPadding = PaddingValues(vertical = SPACING_S),
) {
items(items, key = { it.id }) { pipeline ->
PipelineRow(
pipeline = pipeline,
selected = pipeline.id == selectedId,
badge = badges[pipeline.id],
runsKnown = runsKnown,
onClick = { onOpen(pipeline.id, pipeline.version) },
modifier = animateListItem(),
)
}
}
}
}
@@ -16,6 +16,7 @@ import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material.icons.automirrored.filled.DirectionsRun
import androidx.compose.material.icons.filled.AttachFile
import androidx.compose.material.icons.filled.Cancel
import androidx.compose.material.icons.filled.Refresh
@@ -44,6 +45,7 @@ import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import kotlinx.coroutines.delay
import kotlinx.serialization.json.JsonElement
import java.time.OffsetDateTime
import net.awan.pipelines.data.ErrorMessages
import net.awan.pipelines.data.protocol.RunDetail
import net.awan.pipelines.data.protocol.RunGraphState
@@ -69,13 +71,14 @@ import net.awan.pipelines.ui.components.clampTabIndex
import net.awan.pipelines.ui.components.collapsibleSection
import net.awan.pipelines.ui.components.detailLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.rememberLiveNowMillis
import net.awan.pipelines.ui.components.rememberPaneContent
import net.awan.pipelines.ui.components.rememberSectionExpansion
import net.awan.pipelines.ui.components.runDetailTabs
import net.awan.pipelines.ui.components.runStateIcon
import net.awan.pipelines.ui.components.runStateOf
import net.awan.pipelines.ui.displayText
import net.awan.pipelines.ui.formatDuration
import net.awan.pipelines.ui.runDurationText
import net.awan.pipelines.ui.graph.ArtifactGallery
import net.awan.pipelines.ui.graph.ArtifactSelection
import net.awan.pipelines.ui.graph.ArtifactSelectionScaffold
@@ -108,6 +111,7 @@ fun RunDetailScreen(
covered: Boolean = false,
) {
val state by vm.runDetail.collectAsStateWithLifecycle()
val runsState by vm.runs.collectAsStateWithLifecycle()
val evidenceState by vm.evidence.collectAsStateWithLifecycle()
val configuredServerUrl by vm.configuredServerUrl.collectAsStateWithLifecycle()
var confirmCancel by remember { mutableStateOf(false) }
@@ -156,11 +160,21 @@ fun RunDetailScreen(
val summaryTab = runDetailTabs.getOrNull(clampTabIndex(selectedSection, runDetailTabs.size))?.key
// A covered pane shows its compact identity only; the tab rail, timeline and
// graphs must never be drawn squeezed into the peek strip.
// graphs must never be drawn squeezed into the peek strip. The run belongs to
// a pipeline, so its identity carries that pipeline's statistics from the run
// history (counts, last run, average) once the history is in hand; until the
// run (and so its pipeline) has loaded the identity stays title-only rather
// than showing the server-wide summary as if it were this run's pipeline.
if (covered) {
val now = remember { OffsetDateTime.now() }
val pipelineId = run?.pipelineId
val stats = remember(runsState.data, pipelineId, now) {
pipelineStatLines(runsState.data?.runs, pipelineId, now)
}
PaneIdentity(
title = run?.name ?: "Run",
subtitle = run?.status?.takeIf { it.isNotBlank() },
stats = stats,
icon = Icons.AutoMirrored.Filled.DirectionsRun,
modifier = modifier.fillMaxSize(),
)
return
@@ -408,7 +422,7 @@ private fun RunSummaryTab(
KeyValueRow("Content hash", run.contentHash, monospace = true)
KeyValueRow("Started", run.createdAt)
KeyValueRow("Finished", run.finishedAt)
KeyValueRow("Duration", formatDuration(run.createdAt, run.finishedAt) ?: "")
RunDurationRow(run)
KeyValueRow("Retry of", if (run.retryOf > 0) "run ${run.retryOf}" else "")
CodeBlock("Diagnostic", run.diagnostic, Modifier.padding(top = SPACING_S))
}
@@ -417,6 +431,20 @@ private fun RunSummaryTab(
}
}
/**
* The run summary's Duration row. A running run's value is live: the shared
* per-second clock is read here, in the row itself, so the tick recomposes only
* this row and never the artifacts gallery or the rest of the summary. The value
* is derived from the server's start timestamp (re-read on resume, so it stays
* correct after a reconnect) and is never frozen at load; a finished run shows
* its stored total duration.
*/
@Composable
private fun RunDurationRow(run: RunDetail) {
val nowMillis = rememberLiveNowMillis(run.executing)
KeyValueRow("Duration", runDurationText(run.createdAt, run.finishedAt, run.executing, nowMillis) ?: "")
}
/**
* The graph tab on its own: the full-height [WorkflowGraph] panel with its Fit
* and expand controls, given the whole content area. The tab's single LazyColumn
@@ -15,9 +15,10 @@ import androidx.compose.foundation.layout.only
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.List
import androidx.compose.material.icons.filled.Refresh
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
@@ -56,6 +57,7 @@ import net.awan.pipelines.ui.components.ListRow
import net.awan.pipelines.ui.components.LoadPhase
import net.awan.pipelines.ui.components.LoadingState
import net.awan.pipelines.ui.components.PaneIdentity
import net.awan.pipelines.ui.components.RestoreListScroll
import net.awan.pipelines.ui.components.RunState
import net.awan.pipelines.ui.components.RunStatusChip
import net.awan.pipelines.ui.components.RunStatusIcon
@@ -64,9 +66,11 @@ import net.awan.pipelines.ui.components.StateCrossfade
import net.awan.pipelines.ui.components.animateListItem
import net.awan.pipelines.ui.components.listLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.rememberLiveNowMillis
import net.awan.pipelines.ui.components.runStateColor
import net.awan.pipelines.ui.components.runStateOf
import net.awan.pipelines.ui.formatDuration
import net.awan.pipelines.ui.runDurationText
import net.awan.pipelines.ui.theme.ICON_LIST_DP
import net.awan.pipelines.ui.theme.ICON_STATUS_DP
import net.awan.pipelines.ui.theme.PipelinesTextStyles
@@ -86,6 +90,7 @@ fun RunHistoryScreen(
filterPipelineId: Long? = null,
selectedRunId: Long? = null,
covered: Boolean = false,
listState: LazyListState,
) {
val state by vm.runs.collectAsStateWithLifecycle()
val sortKey by vm.runSort.collectAsStateWithLifecycle()
@@ -107,13 +112,26 @@ fun RunHistoryScreen(
pipelineFilterOptions(state.data?.runs.orEmpty())
}
// [listState] is owned by the destination, above the panes: a covered pane is a
// different composition (its compact identity is drawn in a strip), so a state
// held here would be discarded and reset the scroll when a detail closes.
// [RestoreListScroll] clamps it when the history changed underneath.
// A covered pane shows its compact identity only; the usage block, sticky day
// headers and run rows must never be drawn squeezed into the peek strip.
// headers and run rows must never be drawn squeezed into the peek strip. Its
// statistics are the history's status counts and most recent run, folded
// once; a history scoped to one pipeline shows that pipeline's own numbers.
if (covered) {
val count = state.data?.runs?.size ?: 0
val now = remember { OffsetDateTime.now() }
val stats = remember(state.data, filterPipelineId, now) {
val pipelineId = filterPipelineId
if (pipelineId == null) listStatLines(state.data?.runs, now)
else pipelineStatLines(state.data?.runs, pipelineId, now)
}
PaneIdentity(
title = if (filterPipelineId == null) "Runs" else "Runs for this pipeline",
subtitle = if (count > 0) "$count recorded" else null,
stats = stats,
icon = Icons.AutoMirrored.Filled.List,
modifier = modifier.fillMaxSize(),
)
return
@@ -159,6 +177,11 @@ fun RunHistoryScreen(
// usage block and shows the "no runs" line inside the list, where
// the item animation fades it in and out.
emptyMessage = null,
// Before the first history load this frame has no data and no
// in-flight refresh yet; without [loaded] it would read as an
// empty list and the restore below would clamp a restored
// position to the top of the transient one-item list.
loaded = state.loaded,
),
modifier = Modifier.fillMaxSize(),
) { phase ->
@@ -179,6 +202,7 @@ fun RunHistoryScreen(
error = state.error,
onOpenRun = onOpenRun,
onClearFilters = onClearFilters,
listState = listState,
modifier = Modifier.padding(padding),
)
}
@@ -247,6 +271,7 @@ private fun RunHistoryContent(
error: String?,
onOpenRun: (Long) -> Unit,
onClearFilters: () -> Unit,
listState: LazyListState,
modifier: Modifier = Modifier,
) {
val zone = ZoneId.systemDefault()
@@ -265,59 +290,144 @@ private fun RunHistoryContent(
groupRunsByDay(matched, today, zone, runComparator(sort))
}
// The list body built once, in layout order. It is the single source of both
// the LazyColumn's items and their count, so a restored position is clamped to
// the list the column actually draws rather than to a hand-maintained replica
// of it (see [RestoreListScroll]).
val entries = remember(usage, scoped, matched, groups, error) {
runListEntries(
usage = usage,
nothingRecorded = scoped.isEmpty(),
nothingMatched = matched.isEmpty(),
groups = groups,
error = error,
)
}
RestoreListScroll(listState, entries.size)
// One live clock for the whole list: it ticks only while a shown run is
// executing and the app is resumed, and each running row reads its elapsed
// from it rather than starting a coroutine of its own. Elapsed is derived
// from the server's start timestamp, never from when the list loaded, so it
// is still correct after a reconnect; a finished history never ticks.
val live = remember(matched) { matched.any { it.executing } }
val nowMillis = rememberLiveNowMillis(live)
LazyColumn(
state = listState,
modifier = modifier.fillMaxSize(),
contentPadding = PaddingValues(bottom = SPACING_L),
) {
if (usage != null) {
item(key = "usage") {
UsageMetrics(usage, Modifier.padding(horizontal = SPACING_L, vertical = SPACING_S))
}
}
if (scoped.isEmpty()) {
// Nothing exists at all: no filter could reveal a run, so there is no
// clear action.
item(key = "runs-empty") {
EmptyState(
"No runs have been recorded yet.",
modifier = animateListItem(),
)
}
} else if (matched.isEmpty()) {
// Runs exist but every one is filtered out: distinguish this from the
// "nothing exists" case and offer the one clear action.
item(key = "runs-filtered-empty") {
EmptyState(
message = "No runs match the current filters.",
actionLabel = "Clear filters",
onAction = onClearFilters,
modifier = animateListItem(),
)
}
} else {
groups.forEach { group ->
stickyHeader(key = "day-${group.label}") { DayHeader(group.label) }
items(group.runs, key = { "run-${it.id}" }) { run ->
RunRow(
run = run,
selected = run.id == selectedRunId,
onClick = { onOpenRun(run.id) },
entries.forEach { entry ->
when (entry) {
is RunListEntry.Usage -> item(key = entry.key) {
UsageMetrics(
entry.usage,
Modifier.padding(horizontal = SPACING_L, vertical = SPACING_S),
)
}
is RunListEntry.Empty -> item(key = entry.key) {
EmptyState(
message = entry.message,
actionLabel = entry.actionLabel,
// Only the filtered-empty case offers a clear action, which
// [runListEntries] encodes as a non-null label.
onAction = if (entry.actionLabel != null) onClearFilters else null,
modifier = animateListItem(),
)
}
is RunListEntry.Day -> stickyHeader(key = entry.key) { DayHeader(entry.label) }
is RunListEntry.Run -> item(key = entry.key) {
RunRow(
run = entry.run,
selected = entry.run.id == selectedRunId,
nowMillis = nowMillis,
onClick = { onOpenRun(entry.run.id) },
modifier = animateListItem(),
)
}
is RunListEntry.Error -> item(key = entry.key) {
Text(
entry.message,
color = MaterialTheme.colorScheme.error,
style = pipelinesText().body,
modifier = animateListItem(Modifier.padding(SPACING_L)),
)
}
}
}
if (error != null) {
item(key = "runs-error") {
Text(
error,
color = MaterialTheme.colorScheme.error,
style = pipelinesText().body,
modifier = animateListItem(Modifier.padding(SPACING_L)),
)
}
}
}
/**
* One slot the runs list draws, in layout order: the usage block, the single
* empty-or-grouped body and the optional inline error row. [key] is the stable
* LazyColumn key the list has always used. [runListEntries] builds the whole
* list and both the column and the clamp consume it, so the count a restored
* position is clamped against can never drift from the items the column draws.
*/
internal sealed interface RunListEntry {
val key: String
/** The usage aggregates block, present only when the history has a summary. */
data class Usage(val usage: UsageStats) : RunListEntry {
override val key: String get() = "usage"
}
/**
* The single "nothing recorded"/"nothing matches" line. [actionLabel] is
* non-null exactly when filters hid existing runs, the one case with a clear
* action.
*/
data class Empty(val message: String, val actionLabel: String?) : RunListEntry {
override val key: String
get() = if (actionLabel != null) "runs-filtered-empty" else "runs-empty"
}
/** A sticky day header above a group's runs. */
data class Day(val label: String) : RunListEntry {
override val key: String get() = "day-$label"
}
/** One run row. */
data class Run(val run: RunSummary) : RunListEntry {
override val key: String get() = "run-${run.id}"
}
/** The last load's error, kept inline under the stale rows. */
data class Error(val message: String) : RunListEntry {
override val key: String get() = "runs-error"
}
}
/**
* The runs list's slots in layout order: the usage block when there is one, then
* either the single empty line (nothing recorded, or nothing matching the
* filters) or the day groups, then the inline error row when the last load
* failed over stale data. Pure and single-sourced with the LazyColumn, so its
* size is exactly the list's item count.
*/
internal fun runListEntries(
usage: UsageStats?,
nothingRecorded: Boolean,
nothingMatched: Boolean,
groups: List<RunDayGroup>,
error: String?,
): List<RunListEntry> = buildList {
if (usage != null) add(RunListEntry.Usage(usage))
when {
// Nothing exists at all: no filter could reveal a run, so there is no
// clear action.
nothingRecorded -> add(RunListEntry.Empty("No runs have been recorded yet.", null))
// Runs exist but every one is filtered out: distinguish this from the
// "nothing exists" case and offer the one clear action.
nothingMatched -> add(RunListEntry.Empty("No runs match the current filters.", "Clear filters"))
else -> groups.forEach { group ->
add(RunListEntry.Day(group.label))
group.runs.forEach { add(RunListEntry.Run(it)) }
}
}
if (error != null) add(RunListEntry.Error(error))
}
/** A sticky day header ("Today"/"Yesterday"/date) above each group of runs. */
@@ -378,13 +488,15 @@ private fun Metric(label: String, value: String, color: Color, text: PipelinesTe
/**
* One run as a row of the shared real list: a leading status glyph, the run name
* as the title with its version chip, and a secondary line carrying the status
* chip, progress and id/start/duration. The row is selected when its run is the
* one open in the detail pane.
* chip, progress and id/time. The row is selected when its run is the one open in
* the detail pane. [nowMillis] is the shared live clock, read only by a running
* row so its elapsed value advances.
*/
@Composable
private fun RunRow(
run: RunSummary,
selected: Boolean,
nowMillis: Long,
onClick: () -> Unit,
modifier: Modifier = Modifier,
) {
@@ -429,7 +541,7 @@ private fun RunRow(
Text(progressText(run), style = text.meta, maxLines = 1, overflow = TextOverflow.Ellipsis)
}
Text(metaText(run), style = text.meta, maxLines = 1, overflow = TextOverflow.Ellipsis)
Text(metaText(run, nowMillis), style = text.meta, maxLines = 1, overflow = TextOverflow.Ellipsis)
if (run.diagnostic.isNotBlank()) {
Text(
@@ -466,13 +578,20 @@ private fun progressText(run: RunSummary): String = buildString {
if (run.currentStage.isNotBlank()) append(" · stage ${run.currentStage}")
}
/** Run id, start time and duration, all via formatDuration for the duration. */
private fun metaText(run: RunSummary): String = buildString {
/**
* Run id and its time. A running run shows how long it has taken so far: a live
* elapsed value computed from its server start timestamp against [nowMillis],
* replacing the start time and advancing as the shared clock ticks. A finished
* run keeps its start time and total duration.
*/
private fun metaText(run: RunSummary, nowMillis: Long): String = buildString {
append("run ${run.id}")
val start = formatRunStart(run.createdAt)
if (start != null) append(" · $start")
val duration = formatDuration(run.createdAt, run.finishedAt)
if (duration != null) append(" · $duration")
if (run.executing) {
runDurationText(run.createdAt, run.finishedAt, executing = true, nowMillis)?.let { append(" · $it") }
} else {
formatRunStart(run.createdAt)?.let { append(" · $it") }
runDurationText(run.createdAt, run.finishedAt, executing = false, nowMillis)?.let { append(" · $it") }
}
}
private fun formatRunStart(createdAt: String): String? {
@@ -58,29 +58,19 @@ internal val ICON_LIST_DP = 20.dp
/** Wide detail-rail tab glyph size. */
internal val ICON_RAIL_DP = 24.dp
// ---- Pane geometry (ui/components/SlidingPaneStack.kt) ---------------------
// The sliding pane stack derives every offset and width from these plus the
// measured host width and the system insets; no screen hardcodes a peek or pane
// width. [PEEK_WIDTH_DP] is the minimum width of one covered pane's tappable
// peek (the "collapsed strip"). [PEEK_BUDGET_DP] is the fixed *total* peek
// budget a wide window may spend on all covered panes together, however deep the
// stack gets. [MIN_ACTIVE_PANE_WIDTH_DP] is the least width worth leaving to the
// active (topmost) pane before the budget has to be reduced.
// [MIN_COVERED_PANE_WIDTH_DP] is the least width a covered pane's compact
// identity needs to stay readable and tappable; when the budget cannot give
// every covered pane this much, the oldest levels are folded into one edge
// indicator instead of being squeezed below it.
// ---- Covered-pane identity tiers (ui/components/PaneIdentity.kt) -----------
// The sliding pane stack no longer derives its width from a token: the covered
// region is measured from the compact identity a covered edge must show (see
// `rememberCompactIdentityWidth`), so there is no fixed peek budget and the
// active pane's width does not depend on the stack's depth. What remains here
// only bounds the *statistics* a covered identity shows once it is drawn: a
// strip narrower than one peek keeps the title alone, and a strip at least one
// minimum covered pane plus one peek wide has room for the full block.
/** Minimum width of one covered pane's tappable peek (the collapsed strip). */
/** Least width a covered identity needs before it shows labelled statistics. */
internal val PEEK_WIDTH_DP = 56.dp
/** Fixed total peek budget a wide window may spend on all covered panes. */
internal val PEEK_BUDGET_DP = 224.dp
/** Least width left to the active (topmost) pane before the budget is reduced. */
internal val MIN_ACTIVE_PANE_WIDTH_DP = 320.dp
/** Least width a covered pane's compact identity needs to stay usable. */
/** Width beyond which a covered identity has room for its full statistics. */
internal val MIN_COVERED_PANE_WIDTH_DP = 112.dp
// ---- Destination pill (ui/PipelinesApp.kt) ---------------------------------
@@ -46,6 +46,36 @@ class FormatTest {
assertNull(secondsSince("not a timestamp", startMillis))
}
@Test
fun runDurationTextIsLiveElapsedWhileRunningAndStoredDurationOnceFinished() {
val start = "2026-10-15T02:00:00Z"
val startMillis = parseInstant(start)!!.toInstant().toEpochMilli()
// A run that just started reads 0s, not a blank or a fabricated value.
assertEquals("0s", runDurationText(start, "", executing = true, nowMillis = startMillis))
// Minute boundary: 59s is still seconds, 60s rolls over to a minute.
assertEquals("59s", runDurationText(start, "", executing = true, nowMillis = startMillis + 59_000))
assertEquals("1m 0s", runDurationText(start, "", executing = true, nowMillis = startMillis + 60_000))
// Hour boundary: 3599s is still minutes and seconds, 3600s rolls to hours.
assertEquals("59m 59s", runDurationText(start, "", executing = true, nowMillis = startMillis + 3_599_000))
assertEquals("1h 0m", runDurationText(start, "", executing = true, nowMillis = startMillis + 3_600_000))
// A missing start is "no value": never a fabricated 0s and never a crash.
assertNull(runDurationText("", "", executing = true, nowMillis = startMillis))
// A future start (clock skew) clamps to 0s rather than going negative.
assertEquals("0s", runDurationText(start, "", executing = true, nowMillis = startMillis - 5_000))
// A finished run ignores the clock and keeps its stored total duration.
assertEquals(
"2m 5s",
runDurationText(
start,
"2026-10-15T02:02:05Z",
executing = false,
nowMillis = startMillis + 9_999_000,
),
)
// A finished run with no end timestamp has no duration, not an elapsed.
assertNull(runDurationText(start, "", executing = false, nowMillis = startMillis + 9_999_000))
}
@Test
fun fileChangesSummaryOmitsBlankParts() {
assertEquals("", fileChangesSummary(StageFileChanges()))
@@ -0,0 +1,66 @@
package net.awan.pipelines.ui.components
import org.junit.Assert.assertEquals
import org.junit.Test
/**
* The list-scroll restore/clamp rule is pure, so it is checked here without a
* device: a saved position survives while its item is still in the list (the
* same index at the same offset), and a list that shrank underneath the operator
* clamps to the nearest valid item — the saved offset applies only to the saved
* item, an empty list stays at the top, and nothing throws.
*/
class ListScrollTest {
@Test
fun keepsTheSavedIndexAndOffsetWhenTheItemSurvived() {
assertEquals(
ListScrollAnchor(4, 37),
restoredScrollAnchor(ListScrollAnchor(4, 37), itemCount = 9),
)
}
@Test
fun keepsTheOffsetAtTheLastItem() {
assertEquals(
ListScrollAnchor(8, 12),
restoredScrollAnchor(ListScrollAnchor(8, 12), itemCount = 9),
)
}
@Test
fun clampsAShrunkenListToItsLastItemAndDropsTheOffset() {
assertEquals(
ListScrollAnchor(2, 0),
restoredScrollAnchor(ListScrollAnchor(7, 90), itemCount = 3),
)
}
@Test
fun clampsANegativeIndexToTheTopWithoutTheOffset() {
assertEquals(
ListScrollAnchor(0, 0),
restoredScrollAnchor(ListScrollAnchor(-3, 25), itemCount = 5),
)
}
@Test
fun anEmptyListStaysAtTheTop() {
assertEquals(
ListScrollAnchor(0, 0),
restoredScrollAnchor(ListScrollAnchor(6, 40), itemCount = 0),
)
}
@Test
fun aSingleItemListClampsButKeepsTheOffsetOnlyForThatItem() {
assertEquals(
ListScrollAnchor(0, 15),
restoredScrollAnchor(ListScrollAnchor(0, 15), itemCount = 1),
)
assertEquals(
ListScrollAnchor(0, 0),
restoredScrollAnchor(ListScrollAnchor(5, 15), itemCount = 1),
)
}
}
@@ -6,10 +6,11 @@ import org.junit.Test
/**
* The load-phase classification is pure, so the rules the cross-fading screens
* rely on are checked here without a device: a failed load with no data wins over
* loading, a load with no data is loading, an empty result is empty, and stale
* data always keeps the pane on content (the screen shows the error inline
* instead). Detail panes have no empty state, so absent data is an error or a
* load. The message-carrying phases keep the text captured at classification.
* loading, a list with no data yet (a load in flight, or one that has never
* loaded) is loading, an empty result is empty, and stale data always keeps the
* pane on content (the screen shows the error inline instead). Detail panes have
* no empty state, so absent data is an error or a load. The message-carrying
* phases keep the text captured at classification.
*/
class LoadPhaseTest {
@@ -60,16 +61,48 @@ class LoadPhaseTest {
)
}
@Test
fun listThatHasNeverLoadedReportsLoadingEvenBeforeTheRefreshStarts() {
// The runs pane has no pane-level empty state, so a data-less frame with
// no in-flight refresh would read as content unless the pane reports that
// it has never loaded. It must read as loading instead, so the restored
// scroll position is never clamped against the transient not-yet-loaded
// list (the empty line lives inside the loaded list).
assertEquals(
LoadPhase.Loading,
listLoadPhase(
loading = false,
error = null,
hasData = false,
emptyMessage = null,
loaded = false,
),
)
}
@Test
fun listWithoutAnySignalStaysOnContent() {
// A runs pane deliberately has no pane-level empty state, so its initial
// no-data/no-error frame is content (the empty line lives in the list).
// A screen with no "has loaded" signal (the default) keeps the old rule.
assertEquals(
LoadPhase.Content,
listLoadPhase(loading = false, error = null, hasData = false, emptyMessage = null),
)
}
@Test
fun aLoadedButDataLessListWithoutAnEmptyMessageIsStillContent() {
assertEquals(
LoadPhase.Content,
listLoadPhase(
loading = false,
error = null,
hasData = false,
emptyMessage = null,
loaded = true,
),
)
}
// ---- detail panes -------------------------------------------------------
@Test
@@ -0,0 +1,63 @@
package net.awan.pipelines.ui.components
import androidx.compose.ui.unit.dp
import net.awan.pipelines.ui.theme.MIN_COVERED_PANE_WIDTH_DP
import net.awan.pipelines.ui.theme.PEEK_WIDTH_DP
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
/**
* The covered pane's statistics degrade by width through a pure decision, so
* which statistics show at which width is asserted here without a device: a thin
* strip keeps the title only, a medium strip the run counts, and a wide strip the
* full block. No tier ever shows a figure without its label.
*/
class PaneIdentityTest {
private val counts = listOf(
PaneStat("runs", "11"),
PaneStat("succeeded", "9"),
PaneStat("failed", "2"),
PaneStat("active", "1"),
)
private val details = listOf(
PaneStat("last", "succeeded · 2h ago", detail = true),
PaneStat("avg", "1m 5s", detail = true),
)
@Test
fun aStripThinnerThanOnePeekKeepsTheTitleOnly() {
assertEquals(PaneStatTier.Title, paneStatTier(PEEK_WIDTH_DP - 1.dp))
assertTrue(visiblePaneStats(counts + details, PaneStatTier.Title).isEmpty())
}
@Test
fun aMinimumCoveredStripShowsTheRunCounts() {
assertEquals(PaneStatTier.Counts, paneStatTier(MIN_COVERED_PANE_WIDTH_DP))
assertEquals(counts, visiblePaneStats(counts + details, PaneStatTier.Counts))
}
@Test
fun aStripWideEnoughForTheLongestLineShowsEveryStatistic() {
assertEquals(PaneStatTier.Full, paneStatTier(MIN_COVERED_PANE_WIDTH_DP + PEEK_WIDTH_DP))
assertEquals(counts + details, visiblePaneStats(counts + details, PaneStatTier.Full))
}
@Test
fun theTierBoundariesAreMonotonic() {
val widths = listOf(0.dp, PEEK_WIDTH_DP, MIN_COVERED_PANE_WIDTH_DP, 400.dp)
val tiers = widths.map(::paneStatTier)
assertEquals(listOf(PaneStatTier.Title, PaneStatTier.Counts, PaneStatTier.Counts, PaneStatTier.Full), tiers)
}
@Test
fun everyShownStatisticKeepsItsLabel() {
for (tier in PaneStatTier.entries) {
visiblePaneStats(counts + details, tier).forEach {
assertTrue("a statistic without a label at $tier: $it", it.label.isNotBlank())
assertTrue("a statistic without a value at $tier: $it", it.value.isNotBlank())
}
}
}
}
@@ -2,128 +2,119 @@ package net.awan.pipelines.ui.components
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import net.awan.pipelines.ui.theme.MIN_ACTIVE_PANE_WIDTH_DP
import net.awan.pipelines.ui.theme.MIN_COVERED_PANE_WIDTH_DP
import net.awan.pipelines.ui.theme.PEEK_BUDGET_DP
import net.awan.pipelines.ui.theme.PEEK_WIDTH_DP
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
/**
* The pane geometry is pure, so the adaptive width and fold rules are checked
* here without a device: a narrow window spends no peek at all, a wide window
* spends one fixed budget shared between the covered panes however deep the
* stack gets, every shown peek keeps the named minimum covered width, and when
* the budget cannot give the whole stack that much the oldest levels fold into a
* single edge indicator rather than being squeezed.
* The pane geometry is pure, so the width invariant and the fold rules are
* checked here without a device: a narrow window spends no covered region at any
* depth, the covered region — and therefore the active pane's width — is the same
* at every depth, the nearest covered level keeps its identity edge, one older
* level is a thinner edge, and levels older than that fold into that edge's count
* rather than accumulating width. When the region cannot fit both a touch target
* for the thin edge and one for the nearest identity, the older levels fold into
* the nearest edge instead of being squeezed below the platform minimum.
*/
class SlidingPaneStackTest {
private fun assertDp(expected: Dp, actual: Dp, delta: Float = 0.01f) =
assertEquals(expected.value, actual.value, delta)
private fun totalWidth(strips: List<PeekStrip>): Dp =
strips.fold(0.dp) { acc, strip -> acc + strip.width }
private val minTouch = 48.dp
private fun totalWidth(edges: List<PaneEdge>): Dp =
edges.fold(0.dp) { acc, edge -> acc + edge.width }
@Test
fun narrowWindowSpendsNoPeekAtAnyDepth() {
// Budget 0 is the narrow model: no stack and no leftover strip, so there
// are no covered strips and every pane opens at the host's left edge.
fun narrowWindowSpendsNothingAtAnyDepth() {
// A region of 0 is the narrow model: no covered strip, so every pane opens
// at the host's left edge.
for (covered in 0..4) {
assertTrue(peekStripsDp(covered, 0.dp, 30.dp, PEEK_WIDTH_DP).isEmpty())
assertTrue(coveredEdgesDp(covered, 0.dp, minTouch, 30.dp).isEmpty())
}
}
@Test
fun wideActivePaneKeepsAConstantWidthAtEveryDepth() {
fun theCoveredRegionIsTheSameAtEveryDepthSoTheActiveWidthNeverChanges() {
val host = 800.dp
val budget = peekBudgetDp(host)
assertDp(PEEK_BUDGET_DP, budget)
// The covered strips always sum to exactly the budget, so the active
// (topmost) pane's left edge — and its width — never depend on depth.
for (covered in 1..4) {
val strips = peekStripsDp(covered, budget, startInset = 0.dp, minPeek = PEEK_WIDTH_DP)
assertDp(budget, totalWidth(strips))
assertDp(host - budget, paneWidthDp(host, totalWidth(strips)))
val region = 200.dp
// The edges always sum to exactly the region, so the active (topmost)
// pane's left edge — and its width — never depend on depth. That is the
// invariant: opening another level only adds an edge inside the region.
for (covered in 1..6) {
val edges = coveredEdgesDp(covered, region, minTouch, startInset = 30.dp)
assertDp(region, totalWidth(edges))
assertDp(host - region, paneWidthDp(host, totalWidth(edges)))
}
}
@Test
fun twoCoveredLevelsEachKeepTheMinimumCoveredWidth() {
val strips = peekStripsDp(2, PEEK_BUDGET_DP, startInset = 0.dp, minPeek = PEEK_WIDTH_DP)
// Three levels (list + detail + stage): two covered panes, no fold, and
// each has at least the named minimum so its compact identity reads.
assertEquals(2, strips.size)
assertEquals(listOf(0, 1), strips.map { it.level })
strips.forEach { assertTrue("peek below the minimum: $it", it.width >= MIN_COVERED_PANE_WIDTH_DP) }
assertTrue(strips.all { it.folded == 1 })
fun oneCoveredLevelKeepsTheWholeIdentityEdge() {
val edges = coveredEdgesDp(1, 200.dp, minTouch, startInset = 30.dp)
assertEquals(1, edges.size)
assertEquals(0, edges.first().level)
assertDp(200.dp, edges.first().width)
assertEquals(0, edges.first().folded)
}
@Test
fun aFourthLevelFoldsTheOldestIntoOneIndicator() {
// Four levels (three covered) with a budget of two minimums: the oldest
// levels collapse into one edge indicator carrying their count instead of
// squeezing all three, and one peek still shows the newest covered pane.
val strips = peekStripsDp(3, PEEK_BUDGET_DP, startInset = 0.dp, minPeek = PEEK_WIDTH_DP)
assertEquals(2, strips.size)
assertEquals(2, strips.first().folded)
assertEquals(1, strips.last().folded)
assertEquals(2, strips.last().level)
assertTrue(strips.all { it.width >= MIN_COVERED_PANE_WIDTH_DP })
assertDp(PEEK_BUDGET_DP, totalWidth(strips))
fun twoCoveredLevelsShowTheNearestIdentityAndOneThinnerOlderEdge() {
val edges = coveredEdgesDp(2, 200.dp, minTouch, startInset = 30.dp)
assertEquals(2, edges.size)
// The older level (0) is the thinner edge — one touch target after the
// leading gesture inset; the nearest level (1) keeps its identity and a
// full touch target of its own.
assertEquals(listOf(0, 1), edges.map { it.level })
assertDp(30.dp + minTouch, edges.first().width)
assertTrue("nearest identity below the touch target: $edges", edges.last().width >= minTouch)
assertEquals(0, edges.last().folded)
}
@Test
fun foldedLevelsAreTheOldestAndTheNewestStillPeeks() {
val covered = 4
val strips = peekStripsDp(covered, PEEK_BUDGET_DP, startInset = 0.dp, minPeek = PEEK_WIDTH_DP)
// The newest covered level keeps its own peek; all older ones fold.
assertEquals(covered - 1, strips.last().level)
assertEquals(3, strips.first().folded)
fun beyondTwoCoveredLevelsTheOlderOnesFoldIntoOneCountEdge() {
val edges = coveredEdgesDp(4, 260.dp, minTouch, startInset = 30.dp)
assertEquals(2, edges.size)
// Levels 0..2 collapse into the single older edge (showing its newest,
// level 2) carrying their count; the nearest level (3) keeps its identity.
assertEquals(listOf(2, 3), edges.map { it.level })
assertEquals(2, edges.first().folded)
assertEquals(0, edges.last().folded)
assertDp(260.dp, totalWidth(edges))
}
@Test
fun firstStripStaysTappableAfterTheGestureInset() {
val startInset = 30.dp
val strips = peekStripsDp(2, PEEK_BUDGET_DP, startInset, PEEK_WIDTH_DP)
// The leftmost strip is widened so the tappable part (after the inset)
// still measures at least the named minimum.
assertTrue(strips.first().width - startInset >= PEEK_WIDTH_DP)
// Even when the fold forces the smallest split, the widening holds.
val folded = peekStripsDp(4, PEEK_BUDGET_DP, 80.dp, PEEK_WIDTH_DP)
assertTrue(folded.first().width - 80.dp >= PEEK_WIDTH_DP)
fun whenThereIsNoRoomTheOlderLevelsFoldIntoTheNearestCount() {
// A region that cannot give the thin older edge and the nearest identity a
// touch target each collapses to a single edge carrying the count: nothing
// is squeezed below the platform minimum touch target.
val edges = coveredEdgesDp(3, 100.dp, minTouch, startInset = 30.dp)
assertEquals(1, edges.size)
assertEquals(2, edges.first().level)
assertEquals(2, edges.first().folded)
assertDp(100.dp, edges.first().width)
}
@Test
fun budgetShrinksSoTheActivePaneNeverCollapses() {
// A host narrower than the ideal leaves room for: the budget is clamped
// so the active pane keeps at least the named minimum width.
val host = 400.dp
val budget = peekBudgetDp(host)
assertTrue(budget >= 0.dp)
assertTrue(paneWidthDp(host, budget) >= MIN_ACTIVE_PANE_WIDTH_DP)
fun theNearestEdgeKeepsATouchTargetAfterTheGestureInset() {
val startInset = 40.dp
val region = 260.dp
for (covered in 1..5) {
val edges = coveredEdgesDp(covered, region, minTouch, startInset)
val nearest = edges.last()
// The first edge is inset past the left gesture area; any other edge
// is already clear of it.
val inset = if (edges.size == 1) startInset else 0.dp
assertTrue("nearest edge below the touch target: $edges", nearest.width - inset >= minTouch)
}
}
@Test
fun tinyHostNeverProducesNegativeGeometry() {
assertDp(0.dp, peekBudgetDp(100.dp))
val empty = peekStripsDp(3, peekBudgetDp(100.dp), 0.dp, PEEK_WIDTH_DP)
assertTrue(empty.isEmpty())
assertTrue(paneWidthDp(100.dp, 0.dp) >= 0.dp)
// A tiny non-zero budget still yields one usable strip, never negative.
val tiny = peekStripsDp(3, 40.dp, 0.dp, PEEK_WIDTH_DP)
assertEquals(1, tiny.size)
assertTrue(tiny.first().width >= 0.dp)
assertTrue(paneWidthDp(100.dp, totalWidth(tiny)) >= 0.dp)
}
@Test
fun stripsAreMonotonicAndDeterministic() {
// Same inputs give the same strips (opening and closing are mirrors),
// the strips never overlap, and they never run past the budget.
val a = peekStripsDp(3, PEEK_BUDGET_DP, 30.dp, PEEK_WIDTH_DP)
val b = peekStripsDp(3, PEEK_BUDGET_DP, 30.dp, PEEK_WIDTH_DP)
fun edgesAreMonotonicAndDeterministic() {
// Same inputs give the same edges (opening and closing are mirrors), the
// edges never overlap, and they never run past the region.
val a = coveredEdgesDp(4, 260.dp, minTouch, 30.dp)
val b = coveredEdgesDp(4, 260.dp, minTouch, 30.dp)
assertEquals(a, b)
a.zipWithNext { x, y -> assertTrue(y.start >= x.start + x.width) }
assertTrue(a.all { it.width >= 0.dp })
@@ -0,0 +1,225 @@
package net.awan.pipelines.ui.screens
import java.time.OffsetDateTime
import net.awan.pipelines.data.protocol.RunSummary
import net.awan.pipelines.ui.components.RunState
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Test
/**
* The covered-pane statistics are a pure fold of the run history the app already
* holds, so the counts, the last-run facts and the average duration are asserted
* here without a device: per-pipeline counts, a pipeline with no runs, an unknown
* pipeline id (which yields no lines, never the whole-history list summary),
* zero-duration runs and the whole-history list summary.
*/
class PaneStatsTest {
private val now = OffsetDateTime.parse("2026-10-16T12:00:00Z")
private fun run(
id: Long,
pipelineId: Long,
createdAt: String,
finishedAt: String = "",
status: String = "succeeded",
) = RunSummary(
id = id,
pipelineId = pipelineId,
createdAt = createdAt,
finishedAt = finishedAt,
status = status,
)
@Test
fun pipelineStatsCountOnlyThatPipelineByStatus() {
val stats = pipelinePeekStats(
listOf(
run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"),
run(2, 10, "2026-10-16T10:00:00Z", "2026-10-16T10:01:00Z", status = "failed"),
run(3, 10, "2026-10-16T11:00:00Z", status = "running"),
run(4, 11, "2026-10-16T09:30:00Z", "2026-10-16T09:31:00Z"),
),
pipelineId = 10,
now = now,
)
assertEquals(3, stats.total)
assertEquals(1, stats.succeeded)
assertEquals(1, stats.failed)
assertEquals(1, stats.active)
}
@Test
fun queuedRunsCountAsActive() {
val stats = pipelinePeekStats(
listOf(run(1, 10, "2026-10-16T11:00:00Z", status = "queued")),
pipelineId = 10,
now = now,
)
assertEquals(1, stats.active)
assertEquals(1, stats.total)
}
@Test
fun lastRunCarriesItsStateAndHowLongAgoItStarted() {
val stats = pipelinePeekStats(
listOf(
run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"),
run(2, 10, "2026-10-16T11:00:00Z", "2026-10-16T11:01:00Z", status = "failed"),
),
pipelineId = 10,
now = now,
)
// The newer run wins even though the input order is oldest-first.
assertEquals(RunState.Failed, stats.lastState)
assertEquals("1h ago", stats.lastAgo)
}
@Test
fun averageDurationIsOverTheRunsThatFinished() {
val stats = pipelinePeekStats(
listOf(
run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"),
run(2, 10, "2026-10-16T10:00:00Z", "2026-10-16T10:02:00Z"),
// A still-running run has no finished_at and must not drag the average.
run(3, 10, "2026-10-16T11:00:00Z", status = "running"),
),
pipelineId = 10,
now = now,
)
assertEquals(90L, stats.averageSeconds)
}
@Test
fun zeroDurationRunsAreRealMeasurementsInTheAverage() {
val stats = pipelinePeekStats(
listOf(
run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:00:00Z"),
run(2, 10, "2026-10-16T10:00:00Z", "2026-10-16T10:01:00Z"),
),
pipelineId = 10,
now = now,
)
// 0s and 60s average to 30s: the zero is counted, not skipped.
assertEquals(30L, stats.averageSeconds)
}
@Test
fun aPipelineWithNoRunsIsAllZerosAndNoLastRun() {
val stats = pipelinePeekStats(
listOf(run(1, 11, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z")),
pipelineId = 10,
now = now,
)
assertEquals(0, stats.total)
assertEquals(0, stats.succeeded)
assertEquals(0, stats.failed)
assertEquals(0, stats.active)
assertNull(stats.lastState)
assertNull(stats.lastAgo)
assertNull(stats.averageSeconds)
}
@Test
fun unknownPipelineIdIsAllZerosAndNoLastRun() {
val stats = pipelinePeekStats(
listOf(run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z")),
pipelineId = 99,
now = now,
)
assertEquals(0, stats.total)
assertNull(stats.lastState)
assertNull(stats.averageSeconds)
}
@Test
fun emptyHistoryIsAllZerosAndNoLastRun() {
val stats = pipelinePeekStats(emptyList(), pipelineId = 10, now = now)
assertEquals(0, stats.total)
assertNull(stats.lastState)
assertNull(stats.averageSeconds)
}
@Test
fun listStatsFoldTheWholeHistoryAndFindTheMostRecentRun() {
val stats = listPeekStats(
listOf(
run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"),
run(2, 11, "2026-10-16T11:30:00Z", status = "running"),
run(3, 11, "2026-10-16T08:00:00Z", status = "failed"),
),
now = now,
)
assertEquals(3, stats.total)
assertEquals(1, stats.succeeded)
assertEquals(1, stats.failed)
assertEquals(1, stats.active)
assertEquals(RunState.Running, stats.lastState)
assertEquals("30m ago", stats.lastAgo)
}
@Test
fun linesKeepALabelWithEveryNumberAndMarkTheDetailLines() {
val lines = pipelinePeekStats(
listOf(run(1, 10, "2026-10-16T11:00:00Z", "2026-10-16T11:01:00Z")),
pipelineId = 10,
now = now,
).lines()
assertEquals(listOf("runs", "succeeded", "failed", "active", "last", "avg"), lines.map { it.label })
assertEquals(listOf("1", "1", "0", "0"), lines.take(4).map { it.value })
assertTrue(lines.take(4).none { it.detail })
assertTrue(lines.drop(4).all { it.detail })
}
@Test
fun aPipelineWithNoRunsShowsCountsButNoLastRunOrAverageLines() {
val lines = pipelinePeekStats(emptyList(), pipelineId = 10, now = now).lines()
assertEquals(listOf("runs", "succeeded", "failed", "active"), lines.map { it.label })
}
@Test
fun listLinesCarryNoAverage() {
val lines = listPeekStats(emptyList(), now).lines()
assertEquals(listOf("runs", "succeeded", "failed", "active"), lines.map { it.label })
}
@Test
fun anUnknownPipelineYieldsNoLinesInsteadOfTheWholeHistorySummary() {
val history = listOf(
run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"),
run(2, 11, "2026-10-16T09:30:00Z", "2026-10-16T09:31:00Z"),
)
// A run pane whose pipeline is not known yet (the run has not loaded) must
// not borrow the server-wide list summary; it shows no statistics at all.
assertTrue(pipelineStatLines(history, null, now).isEmpty())
// Nor before the history has loaded, even for a known pipeline.
assertTrue(pipelineStatLines(null, 10, now).isEmpty())
}
@Test
fun pipelineStatLinesFoldOnlyTheNamedPipeline() {
val history = listOf(
run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"),
run(2, 11, "2026-10-16T09:30:00Z", "2026-10-16T09:31:00Z"),
)
val lines = pipelineStatLines(history, 10, now)
assertEquals(listOf("runs", "succeeded", "failed", "active", "last", "avg"), lines.map { it.label })
assertEquals("1", lines.first().value)
}
@Test
fun listStatLinesAreEmptyUntilLoadedThenFoldTheWholeHistory() {
assertTrue(listStatLines(null, now).isEmpty())
val lines = listStatLines(
listOf(
run(1, 10, "2026-10-16T09:00:00Z", "2026-10-16T09:01:00Z"),
run(2, 11, "2026-10-16T09:30:00Z", status = "running"),
),
now,
)
assertEquals(listOf("runs", "succeeded", "failed", "active", "last"), lines.map { it.label })
assertEquals("2", lines.first().value)
}
}
@@ -18,12 +18,14 @@ class PipelineLastRunTest {
createdAt: String,
finishedAt: String = createdAt,
status: String = "succeeded",
executing: Boolean = false,
) = RunSummary(
id = id,
pipelineId = pipelineId,
createdAt = createdAt,
finishedAt = finishedAt,
status = status,
executing = executing,
)
@Test
@@ -96,10 +98,30 @@ class PipelineLastRunTest {
}
@Test
fun metaLineOmitsAMissingDuration() {
// A running run has no finished_at, so the duration fragment is dropped.
fun metaLineShowsTheLiveElapsedOfARunningRun() {
// A running run has no finished_at, so its time fragment is the elapsed
// from its start to the anchor, recomputed as the shared clock advances.
val badge = pipelineRunBadges(
listOf(run(42, 10, "2026-10-16T11:00:00Z", finishedAt = "", status = "running")),
listOf(
run(
42,
10,
"2026-10-16T11:57:30Z",
finishedAt = "",
status = "running",
executing = true,
),
),
now,
).getValue(10L)
assertEquals("2m ago · 2m 30s · run 42", badge.metaLine())
}
@Test
fun metaLineOmitsAMissingDuration() {
// A finished run with no end timestamp has no duration fragment.
val badge = pipelineRunBadges(
listOf(run(42, 10, "2026-10-16T11:00:00Z", finishedAt = "")),
now,
).getValue(10L)
assertEquals("1h ago · run 42", badge.metaLine())
@@ -0,0 +1,90 @@
package net.awan.pipelines.ui.screens
import net.awan.pipelines.data.protocol.RunSummary
import net.awan.pipelines.data.protocol.UsageStats
import org.junit.Assert.assertEquals
import org.junit.Test
/**
* The runs list's slots are built in one pure place, so the count a restored
* scroll position is clamped against is exactly what the LazyColumn draws: the
* usage block, the single empty-or-grouped body and the optional inline error
* row, in that order, with the stable keys the layout has always used.
*/
class RunListEntriesTest {
private fun run(id: Long) = RunSummary(id = id, name = "p$id")
@Test
fun usageThenDayGroupsThenRunsInOrder() {
val groups = listOf(
RunDayGroup("Today", listOf(run(2), run(1))),
RunDayGroup("Yesterday", listOf(run(3))),
)
val entries = runListEntries(
usage = UsageStats(total = 3),
nothingRecorded = false,
nothingMatched = false,
groups = groups,
error = null,
)
assertEquals(
listOf("usage", "day-Today", "run-2", "run-1", "day-Yesterday", "run-3"),
entries.map { it.key },
)
assertEquals(6, entries.size)
}
@Test
fun nothingRecordedIsOneEmptyLineWithoutAnAction() {
val entries = runListEntries(
usage = UsageStats(total = 0),
nothingRecorded = true,
nothingMatched = false,
groups = emptyList(),
error = null,
)
assertEquals(listOf("usage", "runs-empty"), entries.map { it.key })
val empty = entries.last() as RunListEntry.Empty
assertEquals("No runs have been recorded yet.", empty.message)
assertEquals(null, empty.actionLabel)
}
@Test
fun nothingMatchedIsOneEmptyLineWithTheClearAction() {
val entries = runListEntries(
usage = null,
nothingRecorded = false,
nothingMatched = true,
groups = emptyList(),
error = null,
)
assertEquals(listOf("runs-filtered-empty"), entries.map { it.key })
assertEquals("Clear filters", (entries.single() as RunListEntry.Empty).actionLabel)
}
@Test
fun theInlineErrorRowIsAppendedUnderTheRows() {
val entries = runListEntries(
usage = null,
nothingRecorded = false,
nothingMatched = false,
groups = listOf(RunDayGroup("Today", listOf(run(1)))),
error = "offline",
)
assertEquals(listOf("day-Today", "run-1", "runs-error"), entries.map { it.key })
assertEquals("offline", (entries.last() as RunListEntry.Error).message)
}
@Test
fun aNotYetRecordedHistoryWinsOverAFilteredEmptyOne() {
val entries = runListEntries(
usage = null,
nothingRecorded = true,
nothingMatched = true,
groups = emptyList(),
error = null,
)
assertEquals(listOf("runs-empty"), entries.map { it.key })
}
}