Merge branch 'main' into lane-e
This commit is contained in:
@@ -18,11 +18,21 @@
|
||||
unencrypted ws:// on a trusted LAN/VPN. It is deliberately broad because
|
||||
the user types an arbitrary host. Do not expose the server to the internet.
|
||||
-->
|
||||
<!--
|
||||
adjustNothing: the app reads the IME from the Compose window insets
|
||||
(paneSafeArea / WindowInsets.safeDrawing) everywhere, so the window
|
||||
must not also be resized or panned for the soft input. The default
|
||||
(adjustUnspecified) resized the window on the Pixel 10 Pro Fold for
|
||||
the omni-search field, which is not inside a scrollable parent, and
|
||||
the field then cleared the IME twice (once by the window resize, once
|
||||
by the Compose inset) and floated above the keyboard.
|
||||
-->
|
||||
<activity
|
||||
android:name=".MainActivity"
|
||||
android:exported="true"
|
||||
android:label="@string/app_name"
|
||||
android:theme="@style/Theme.Pipelines">
|
||||
android:theme="@style/Theme.Pipelines"
|
||||
android:windowSoftInputMode="adjustNothing">
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.MAIN" />
|
||||
<category android:name="android.intent.category.LAUNCHER" />
|
||||
|
||||
@@ -10,6 +10,7 @@ import net.awan.pipelines.data.protocol.PipelineSummary
|
||||
import net.awan.pipelines.data.protocol.Protocol
|
||||
import net.awan.pipelines.data.protocol.RunDetail
|
||||
import net.awan.pipelines.data.protocol.RunSummary
|
||||
import net.awan.pipelines.data.protocol.SearchRequest
|
||||
import net.awan.pipelines.data.protocol.SessionEvidence
|
||||
import net.awan.pipelines.data.protocol.UsageStats
|
||||
import net.awan.pipelines.data.transport.NotConnectedException
|
||||
@@ -72,6 +73,16 @@ class PipelinesRepository(
|
||||
suspend fun getRunEvidence(id: Long): List<SessionEvidence> =
|
||||
client.call(Message(type = Protocol.GET_RUN_EVIDENCE, runId = id)).evidence ?: emptyList()
|
||||
|
||||
/**
|
||||
* Sends one omni-search query over the shared transport and returns the raw
|
||||
* reply envelope. The server command is still landing, so the reply is
|
||||
* classified by its envelope type: [Protocol.SEARCH_RESULTS] is the accepted
|
||||
* search, and any other type is an unexpected reply the caller reports rather
|
||||
* than parsing. The typed result payload is added with the results item.
|
||||
*/
|
||||
suspend fun search(query: String): Message =
|
||||
client.call(Message(type = Protocol.SEARCH, search = SearchRequest(query = query.trim())))
|
||||
|
||||
/** Fetches an artifact's bytes (image preview) over the shared HTTP client. */
|
||||
suspend fun fetchArtifactBytes(url: String): ByteArray = client.fetchBytes(url)
|
||||
|
||||
|
||||
@@ -41,6 +41,19 @@ object Protocol {
|
||||
const val GET_STATUS = "get_status"
|
||||
const val STATUS = "status"
|
||||
|
||||
// search.go
|
||||
const val SEARCH = "search"
|
||||
const val SEARCH_RESULTS = "search_results"
|
||||
|
||||
// search.go result kinds (mirrors protocol.SearchKind*); an empty kind
|
||||
// searches every kind and an unknown kind is shown read-only.
|
||||
const val SEARCH_KIND_PIPELINE = "pipeline"
|
||||
const val SEARCH_KIND_VERSION = "version"
|
||||
const val SEARCH_KIND_RUN = "run"
|
||||
const val SEARCH_KIND_STEP = "step"
|
||||
const val SEARCH_KIND_FIELD = "field"
|
||||
const val SEARCH_KIND_ARTIFACT = "artifact"
|
||||
|
||||
// terminals.go
|
||||
const val SUCCESS_END = "#success"
|
||||
const val FAILURE_END = "#failure"
|
||||
@@ -401,6 +414,117 @@ data class SystemStatus(
|
||||
val note: String = "",
|
||||
)
|
||||
|
||||
/**
|
||||
* The omni-search request body (internal/protocol/search.go SearchRequest): the
|
||||
* free text query, an optional single-kind narrowing, and an optional result
|
||||
* cap (0 = server default). The typed, ranked result payload is added with the
|
||||
* search-results item; for now the reply is classified by its envelope type so a
|
||||
* server that cannot answer is reported, never mis-parsed.
|
||||
*/
|
||||
@Serializable
|
||||
data class SearchRequest(
|
||||
val query: String = "",
|
||||
val kind: String = "",
|
||||
val limit: Int = 0,
|
||||
)
|
||||
|
||||
/**
|
||||
* The typed, ranked omni-search reply body (internal/protocol/search.go
|
||||
* SearchResponse). [results] are ordered by score, then recency, then a stable
|
||||
* kind/target tie-break; [truncated] reports that the result cap or the
|
||||
* field-scan budget dropped matches and the scan counters make that bound
|
||||
* observable. An empty [results] list is a real, empty result, not a failure.
|
||||
*/
|
||||
@Serializable
|
||||
data class SearchResponse(
|
||||
val query: String = "",
|
||||
val kind: String = "",
|
||||
val results: List<SearchResult> = emptyList(),
|
||||
val truncated: Boolean = false,
|
||||
@SerialName("scanned_steps") val scannedSteps: Int = 0,
|
||||
@SerialName("scanned_bytes") val scannedBytes: Int = 0,
|
||||
val cap: Int = 0,
|
||||
@SerialName("scan_bound_bytes") val scanBoundBytes: Int = 0,
|
||||
)
|
||||
|
||||
/**
|
||||
* One typed search match (internal/protocol/search.go SearchResult). [kind]
|
||||
* selects which payload is set; [target] is a stable token an existing command
|
||||
* resolves and [matchedField] records why it matched. Every payload is
|
||||
* nullable, so an unknown kind decodes without crashing and is shown read-only
|
||||
* rather than dropped.
|
||||
*/
|
||||
@Serializable
|
||||
data class SearchResult(
|
||||
val kind: String = "",
|
||||
val target: String = "",
|
||||
val score: Int = 0,
|
||||
@SerialName("matched_field") val matchedField: String = "",
|
||||
val recency: String? = null,
|
||||
val pipeline: SearchPipeline? = null,
|
||||
val version: SearchVersion? = null,
|
||||
val run: SearchRun? = null,
|
||||
val step: SearchStep? = null,
|
||||
val field: SearchField? = null,
|
||||
val artifact: SearchArtifact? = null,
|
||||
)
|
||||
|
||||
@Serializable
|
||||
data class SearchPipeline(
|
||||
val id: Long = 0,
|
||||
val name: String = "",
|
||||
val version: Int = 0,
|
||||
val stages: Int = 0,
|
||||
)
|
||||
|
||||
@Serializable
|
||||
data class SearchVersion(
|
||||
@SerialName("pipeline_id") val pipelineId: Long = 0,
|
||||
val version: Int = 0,
|
||||
@SerialName("content_hash") val contentHash: String = "",
|
||||
@SerialName("created_at") val createdAt: String = "",
|
||||
)
|
||||
|
||||
@Serializable
|
||||
data class SearchRun(
|
||||
val id: Long = 0,
|
||||
@SerialName("pipeline_name") val pipelineName: String = "",
|
||||
val status: String = "",
|
||||
val workspace: String? = null,
|
||||
@SerialName("created_at") val createdAt: String = "",
|
||||
@SerialName("finished_at") val finishedAt: String? = null,
|
||||
@SerialName("duration_seconds") val durationSeconds: Double = 0.0,
|
||||
)
|
||||
|
||||
@Serializable
|
||||
data class SearchStep(
|
||||
@SerialName("run_id") val runId: Long = 0,
|
||||
val sequence: Int = 0,
|
||||
val stage: String = "",
|
||||
val visit: Int = 0,
|
||||
val outcome: String? = null,
|
||||
val target: String? = null,
|
||||
val diagnostic: String? = null,
|
||||
)
|
||||
|
||||
@Serializable
|
||||
data class SearchField(
|
||||
@SerialName("run_id") val runId: Long = 0,
|
||||
val sequence: Int = 0,
|
||||
val field: String = "",
|
||||
val snippet: String = "",
|
||||
)
|
||||
|
||||
@Serializable
|
||||
data class SearchArtifact(
|
||||
@SerialName("run_id") val runId: Long = 0,
|
||||
val sequence: Int = 0,
|
||||
val name: String = "",
|
||||
@SerialName("content_type") val contentType: String = "",
|
||||
@SerialName("size_bytes") val sizeBytes: Long = 0,
|
||||
val url: String = "",
|
||||
)
|
||||
|
||||
/**
|
||||
* The shared JSON envelope. Every field is optional/nullable with defaults so
|
||||
* unknown or missing server fields never crash the client.
|
||||
@@ -431,6 +555,8 @@ data class Message(
|
||||
@SerialName("run_id") val runId: Long = 0,
|
||||
@SerialName("run_detail") val runDetail: RunDetail? = null,
|
||||
val runs: List<RunSummary>? = null,
|
||||
val search: SearchRequest? = null,
|
||||
@SerialName("search_results") val searchResults: SearchResponse? = null,
|
||||
val input: Map<String, JsonElement>? = null,
|
||||
@SerialName("allow_tools") val allowTools: Boolean = false,
|
||||
@SerialName("write_paths") val writePaths: List<String>? = null,
|
||||
|
||||
@@ -6,6 +6,8 @@ import androidx.lifecycle.viewmodel.initializer
|
||||
import androidx.lifecycle.viewmodel.viewModelFactory
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
import kotlinx.coroutines.CancellationException
|
||||
import kotlinx.coroutines.Job
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.StateFlow
|
||||
import kotlinx.coroutines.flow.asStateFlow
|
||||
@@ -21,7 +23,9 @@ import net.awan.pipelines.data.SettingsRepository
|
||||
import net.awan.pipelines.data.protocol.BuildInfo
|
||||
import net.awan.pipelines.data.protocol.PipelineDetail
|
||||
import net.awan.pipelines.data.protocol.PipelineSummary
|
||||
import net.awan.pipelines.data.protocol.Protocol
|
||||
import net.awan.pipelines.data.protocol.RunDetail
|
||||
import net.awan.pipelines.data.protocol.SearchResponse
|
||||
import net.awan.pipelines.data.protocol.SessionEvidence
|
||||
import net.awan.pipelines.data.transport.ConnectionState
|
||||
import net.awan.pipelines.data.transport.ServerUrl
|
||||
@@ -92,6 +96,16 @@ class AppViewModel(
|
||||
private val _evidence = MutableStateFlow(LoadState<List<SessionEvidence>>())
|
||||
val evidence: StateFlow<LoadState<List<SessionEvidence>>> = _evidence.asStateFlow()
|
||||
|
||||
private val _search = MutableStateFlow(SearchUiState())
|
||||
|
||||
/** The omni-search panel state: query, last results, loading and any error. */
|
||||
val search: StateFlow<SearchUiState> = _search.asStateFlow()
|
||||
|
||||
// Debounces keystrokes and gates replies so an older query can never land on
|
||||
// top of a newer one; the pure ordering lives in SearchSequencer.
|
||||
private val searchSequencer = SearchSequencer()
|
||||
private var searchJob: Job? = null
|
||||
|
||||
private val startKeys = ConcurrentHashMap<Long, String>()
|
||||
private val retryKeys = ConcurrentHashMap<Long, String>()
|
||||
|
||||
@@ -217,6 +231,62 @@ class AppViewModel(
|
||||
suspend fun fetchArtifactBytes(url: String): ByteArray? =
|
||||
runCatching { repository.fetchArtifactBytes(url) }.getOrNull()
|
||||
|
||||
/**
|
||||
* Records a keystroke and, after a short quiet period, issues one request for
|
||||
* the latest query. A burst of keystrokes cancels the pending request and
|
||||
* collapses to the last one; the previous results stay visible throughout, so
|
||||
* the panel never flickers to empty. A blank query clears the panel locally
|
||||
* (no server scan).
|
||||
*/
|
||||
fun onSearchQueryChanged(query: String) {
|
||||
val edit = searchSequencer.edit(query)
|
||||
searchJob?.cancel()
|
||||
_search.value = _search.value.editing(query)
|
||||
if (query.isBlank()) {
|
||||
_search.value = SearchUiState()
|
||||
return
|
||||
}
|
||||
searchJob = viewModelScope.launch {
|
||||
delay(SEARCH_DEBOUNCE_MILLIS)
|
||||
searchSequencer.begin(edit)?.let { runSearch(it) }
|
||||
}
|
||||
}
|
||||
|
||||
/** Runs the current query immediately (the IME's search action), skipping the debounce. */
|
||||
fun searchNow() {
|
||||
val query = _search.value.query
|
||||
if (query.isBlank()) return
|
||||
val edit = searchSequencer.edit(query)
|
||||
searchJob?.cancel()
|
||||
searchJob = viewModelScope.launch { searchSequencer.begin(edit)?.let { runSearch(it) } }
|
||||
}
|
||||
|
||||
/** Dismissing the field clears the panel and forgets the pending query. */
|
||||
fun clearSearch() {
|
||||
searchJob?.cancel()
|
||||
searchSequencer.edit("")
|
||||
_search.value = SearchUiState()
|
||||
}
|
||||
|
||||
private suspend fun runSearch(request: SentSearch) {
|
||||
_search.value = _search.value.copy(loading = true, error = null)
|
||||
try {
|
||||
val reply = repository.search(request.query)
|
||||
// A reply for a superseded query must never land: the sequencer only
|
||||
// accepts the newest sent token.
|
||||
if (!searchSequencer.accepts(request.token)) return
|
||||
_search.value = if (reply.type == Protocol.SEARCH_RESULTS) {
|
||||
_search.value.loaded(reply.searchResults ?: SearchResponse())
|
||||
} else {
|
||||
_search.value.failed("This server does not support search. Update the Pipelines server, then try again.")
|
||||
}
|
||||
} catch (t: Throwable) {
|
||||
if (t is CancellationException) throw t
|
||||
if (!searchSequencer.accepts(request.token)) return
|
||||
_search.value = _search.value.failed(ErrorMessages.describe(t))
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Drops any previously loaded evidence so a different run never shows the
|
||||
* previous run's records. Evidence is then fetched on demand, never polled.
|
||||
@@ -299,6 +369,9 @@ class AppViewModel(
|
||||
companion object {
|
||||
private const val CONNECT_TIMEOUT_MILLIS = 20_000L
|
||||
|
||||
/** How long the field waits after the last keystroke before issuing one request. */
|
||||
const val SEARCH_DEBOUNCE_MILLIS = 250L
|
||||
|
||||
fun factory(app: PipelinesApplication) = viewModelFactory {
|
||||
initializer { AppViewModel(app.repository, app.settings) }
|
||||
}
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import androidx.compose.runtime.saveable.Saver
|
||||
|
||||
/**
|
||||
* The floating bottom container's two surfaces: the destination icons (the
|
||||
* pill) and the omni-search field it morphs into. [open] is that morph;
|
||||
* [focused] records whether the field owns the keyboard's focus; [query] is the
|
||||
* typed text.
|
||||
*
|
||||
* Opening and dismissing deliberately change nothing else, so the destination
|
||||
* the pill had selected is untouched by a search: the nav route is owned
|
||||
* elsewhere and never navigated away from here, so the reverse morph restores
|
||||
* exactly the pill that was on screen.
|
||||
*/
|
||||
data class OmniSearchState(
|
||||
val open: Boolean = false,
|
||||
val focused: Boolean = false,
|
||||
val query: String = "",
|
||||
) {
|
||||
companion object {
|
||||
/** The resting pill: no field, no text. */
|
||||
val Closed = OmniSearchState()
|
||||
}
|
||||
}
|
||||
|
||||
/** Tapping the Search icon opens the field and asks for focus (keyboard up). */
|
||||
fun openOmniSearch(state: OmniSearchState): OmniSearchState =
|
||||
state.copy(open = true, focused = true)
|
||||
|
||||
/**
|
||||
* Dismissing (Back, the back gesture or a scrim tap) plays the reverse and
|
||||
* returns to the resting pill, clearing the text so the next open starts fresh.
|
||||
*/
|
||||
fun dismissOmniSearch(state: OmniSearchState): OmniSearchState = OmniSearchState.Closed
|
||||
|
||||
/** The field gained ([focused] true) or lost the focus; [open] is unchanged. */
|
||||
fun setOmniSearchFocus(state: OmniSearchState, focused: Boolean): OmniSearchState =
|
||||
state.copy(focused = focused)
|
||||
|
||||
/** Records the typed query; [open] and [focused] are unchanged. */
|
||||
fun setOmniSearchQuery(state: OmniSearchState, query: String): OmniSearchState =
|
||||
state.copy(query = query)
|
||||
|
||||
/**
|
||||
* Encodes an [OmniSearchState] as Bundle-able primitives (a small `List<Any>`),
|
||||
* so a still-open field survives rotation, configuration change and process
|
||||
* death. Paired with [decodeOmniSearch].
|
||||
*/
|
||||
internal fun encodeOmniSearch(state: OmniSearchState): List<Any> =
|
||||
listOf(state.open, state.focused, state.query)
|
||||
|
||||
/** Restores an [OmniSearchState] encoded by [encodeOmniSearch]. */
|
||||
internal fun decodeOmniSearch(encoded: List<Any>): OmniSearchState = OmniSearchState(
|
||||
open = encoded[0] as Boolean,
|
||||
focused = encoded[1] as Boolean,
|
||||
query = encoded[2] as String,
|
||||
)
|
||||
|
||||
/**
|
||||
* Saves/restores an [OmniSearchState] across configuration change and process
|
||||
* death. The payload is primitives only (see [encodeOmniSearch]).
|
||||
*/
|
||||
val OmniSearchStateSaver: Saver<OmniSearchState, List<Any>> = Saver(
|
||||
save = { encodeOmniSearch(it) },
|
||||
restore = { decodeOmniSearch(it) },
|
||||
)
|
||||
@@ -0,0 +1,288 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import androidx.compose.runtime.Immutable
|
||||
import net.awan.pipelines.data.protocol.Protocol
|
||||
import net.awan.pipelines.data.protocol.RunStep
|
||||
import net.awan.pipelines.data.protocol.SearchArtifact
|
||||
import net.awan.pipelines.data.protocol.SearchField
|
||||
import net.awan.pipelines.data.protocol.SearchPipeline
|
||||
import net.awan.pipelines.data.protocol.SearchResponse
|
||||
import net.awan.pipelines.data.protocol.SearchResult
|
||||
import net.awan.pipelines.data.protocol.SearchRun
|
||||
import net.awan.pipelines.data.protocol.SearchStep
|
||||
import net.awan.pipelines.data.protocol.SearchVersion
|
||||
import net.awan.pipelines.ui.screens.runTimeline
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Row model: the badge, title and secondary line of one result. Pure (no
|
||||
// Compose, no coroutines), so the mapping for every kind is unit-testable.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** The short mixed-list type badge for a result kind. */
|
||||
fun searchBadge(kind: String): String = when (kind) {
|
||||
Protocol.SEARCH_KIND_PIPELINE, Protocol.SEARCH_KIND_VERSION -> "pipeline"
|
||||
Protocol.SEARCH_KIND_RUN -> "run"
|
||||
Protocol.SEARCH_KIND_STEP -> "step"
|
||||
Protocol.SEARCH_KIND_ARTIFACT -> "artifact"
|
||||
// A text ("field") match and an unknown kind both read as a generic match;
|
||||
// the unknown one is additionally labelled read-only by [searchRow].
|
||||
else -> "match"
|
||||
}
|
||||
|
||||
/**
|
||||
* One run of snippet text with [matched] true for the span the query hit. The row
|
||||
* renders a matched span with a weight/underline difference, so the match stays
|
||||
* legible without relying on colour.
|
||||
*/
|
||||
@Immutable
|
||||
data class SnippetSpan(val text: String, val matched: Boolean)
|
||||
|
||||
/**
|
||||
* One rendered search row: its type badge, a title and a secondary line. [snippet]
|
||||
* is non-null only for a text ("field") match and carries the snippet split so the
|
||||
* matched span is distinguishable without colour.
|
||||
*/
|
||||
@Immutable
|
||||
data class SearchRow(
|
||||
val badge: String,
|
||||
val title: String,
|
||||
val secondary: String,
|
||||
val snippet: List<SnippetSpan>? = null,
|
||||
)
|
||||
|
||||
/**
|
||||
* The row for one [hit]. [query] is the typed text, used only to locate the
|
||||
* matched span in a text snippet. An unknown/absent payload is never dropped: it
|
||||
* renders its stable target (or a placeholder) and a `read-only` note.
|
||||
*/
|
||||
fun searchRow(hit: SearchResult, query: String): SearchRow {
|
||||
val badge = searchBadge(hit.kind)
|
||||
val pipeline: SearchPipeline? = hit.pipeline
|
||||
val version: SearchVersion? = hit.version
|
||||
val run: SearchRun? = hit.run
|
||||
val step: SearchStep? = hit.step
|
||||
val field: SearchField? = hit.field
|
||||
val artifact: SearchArtifact? = hit.artifact
|
||||
return when {
|
||||
pipeline != null -> SearchRow(
|
||||
badge,
|
||||
pipeline.name.ifBlank { "pipeline ${pipeline.id}" },
|
||||
"pipeline ${pipeline.id} · v${pipeline.version} · ${pipeline.stages} stages",
|
||||
)
|
||||
version != null -> SearchRow(
|
||||
badge,
|
||||
"pipeline ${version.pipelineId} · v${version.version}",
|
||||
listOfNotNull(
|
||||
version.contentHash.takeIf { it.isNotBlank() }?.let { "content $it" },
|
||||
version.createdAt.takeIf { it.isNotBlank() },
|
||||
).joinToString(" · "),
|
||||
)
|
||||
run != null -> SearchRow(
|
||||
badge,
|
||||
"run #${run.id}" + run.pipelineName.takeIf { it.isNotBlank() }?.let { " · $it" }.orEmpty(),
|
||||
listOfNotNull(
|
||||
run.status.takeIf { it.isNotBlank() },
|
||||
run.workspace?.takeIf { it.isNotBlank() },
|
||||
run.createdAt.takeIf { it.isNotBlank() },
|
||||
).joinToString(" · "),
|
||||
)
|
||||
step != null -> SearchRow(
|
||||
badge,
|
||||
"run #${step.runId} · ${step.stage.ifBlank { "step" }} visit ${step.visit}",
|
||||
stepSecondary(step),
|
||||
)
|
||||
field != null -> SearchRow(
|
||||
badge,
|
||||
"run #${field.runId} · step ${field.sequence} · ${field.field.ifBlank { "field" }}",
|
||||
field.snippet,
|
||||
snippetSpans(field.snippet, query),
|
||||
)
|
||||
artifact != null -> SearchRow(
|
||||
badge,
|
||||
artifact.name.ifBlank { "artifact" },
|
||||
listOfNotNull(
|
||||
"run #${artifact.runId}",
|
||||
"step ${artifact.sequence}",
|
||||
artifact.contentType.takeIf { it.isNotBlank() },
|
||||
humanBytes(artifact.sizeBytes),
|
||||
).joinToString(" · "),
|
||||
)
|
||||
else -> SearchRow(
|
||||
badge,
|
||||
hit.target.ifBlank { "Unrecognised result" },
|
||||
if (hit.kind.isBlank()) "read-only" else "kind \"${hit.kind}\" · read-only",
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** The one-line non-snippet summary of a step hit: its outcome, route and first diagnostic line. */
|
||||
private fun stepSecondary(step: SearchStep): String {
|
||||
val parts = listOfNotNull(
|
||||
step.outcome?.takeIf { it.isNotBlank() },
|
||||
step.target?.takeIf { it.isNotBlank() }?.let { "→ $it" },
|
||||
step.diagnostic?.lineSequence()?.firstOrNull { it.isNotBlank() }?.trim()?.takeIf { it.isNotBlank() },
|
||||
)
|
||||
return parts.joinToString(" · ").ifBlank { "step ${step.sequence}" }
|
||||
}
|
||||
|
||||
/**
|
||||
* Splits [snippet] into runs so the first case-insensitive occurrence of [query]
|
||||
* is a distinct, [SnippetSpan.matched] span. When the query is blank or does not
|
||||
* appear (a bare status/date query, or a server-trimmed snippet), the whole
|
||||
* snippet is returned unmatched, so the caller never drops text.
|
||||
*/
|
||||
fun snippetSpans(snippet: String, query: String): List<SnippetSpan> {
|
||||
if (snippet.isEmpty()) return emptyList()
|
||||
val trimmed = query.trim()
|
||||
if (trimmed.isEmpty()) return listOf(SnippetSpan(snippet, false))
|
||||
val index = snippet.indexOf(trimmed, ignoreCase = true)
|
||||
if (index < 0) return listOf(SnippetSpan(snippet, false))
|
||||
val end = index + trimmed.length
|
||||
return buildList {
|
||||
if (index > 0) add(SnippetSpan(snippet.substring(0, index), false))
|
||||
add(SnippetSpan(snippet.substring(index, end), true))
|
||||
if (end < snippet.length) add(SnippetSpan(snippet.substring(end), false))
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Navigation: the destination a result resolves to. Pure, so the mapping for
|
||||
// every kind is unit-testable.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* The navigation a selected search result asks for. A null target (see
|
||||
* [searchTarget]) means the result is shown read-only and selecting it does
|
||||
* nothing.
|
||||
*/
|
||||
sealed interface SearchTarget {
|
||||
/** Open the Pipelines destination at this pipeline's detail (version 0 = latest). */
|
||||
data class Pipeline(val pipelineId: Long, val version: Int) : SearchTarget
|
||||
|
||||
/**
|
||||
* Open the Runs destination at this run. [sequence] > 0 opens the recorded
|
||||
* visit, and [field]/[artifacts] name the section to reveal: a text match
|
||||
* opens the run-detail section holding the matched field, an artifact hit the
|
||||
* visit's stage pane (whose gallery leads), and a step hit the visit's pane.
|
||||
*/
|
||||
data class Run(
|
||||
val runId: Long,
|
||||
val sequence: Int = 0,
|
||||
val field: String = "",
|
||||
val artifacts: Boolean = false,
|
||||
) : SearchTarget
|
||||
}
|
||||
|
||||
/**
|
||||
* The navigation target for [hit], or null for a kind with no known payload (an
|
||||
* unknown match), which is shown read-only rather than dropped.
|
||||
*/
|
||||
fun searchTarget(hit: SearchResult): SearchTarget? = when {
|
||||
hit.pipeline != null -> SearchTarget.Pipeline(hit.pipeline.id, hit.pipeline.version)
|
||||
hit.version != null -> SearchTarget.Pipeline(hit.version.pipelineId, hit.version.version)
|
||||
hit.run != null -> SearchTarget.Run(hit.run.id)
|
||||
hit.step != null -> SearchTarget.Run(hit.step.runId, hit.step.sequence)
|
||||
hit.field != null -> SearchTarget.Run(hit.field.runId, hit.field.sequence, field = hit.field.field)
|
||||
hit.artifact != null -> SearchTarget.Run(hit.artifact.runId, hit.artifact.sequence, artifacts = true)
|
||||
else -> null
|
||||
}
|
||||
|
||||
/** The run-detail tab holding a matched step field's text (see `runDetailTabs`). */
|
||||
fun searchFieldSection(field: String): Int = when (field) {
|
||||
"input" -> 2
|
||||
"output" -> 3
|
||||
"evidence", "transcript" -> 4
|
||||
else -> 0
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves a [SearchTarget.Run] against the loaded run's [steps] into the pane
|
||||
* selection showing the requested visit/section. A visit that cannot be located
|
||||
* (or a bare run target) falls back to the run detail itself, so a hit is never
|
||||
* dropped. [runId] is the run the target named.
|
||||
*/
|
||||
fun resolveRunTarget(target: SearchTarget.Run, runId: Long, steps: List<RunStep>): PaneSelection {
|
||||
// A text match names a section (tab) directly; the matched field's own text
|
||||
// lives in the run-detail section with that name.
|
||||
if (target.field.isNotBlank()) {
|
||||
return PaneSelection(MasterPane.Detail, runId, sectionIndex = searchFieldSection(target.field))
|
||||
}
|
||||
if (target.sequence <= 0) return PaneSelection(MasterPane.Detail, runId)
|
||||
val step = steps.firstOrNull { it.sequence == target.sequence }
|
||||
?: return PaneSelection(MasterPane.Detail, runId)
|
||||
// The visit's stage pane, with the correct zero-based visit index for that
|
||||
// stage (the server's visit number need not equal the index).
|
||||
val visits = runTimeline(steps).visitsByStage[step.stage].orEmpty()
|
||||
val visitIndex = visits.indexOfFirst { it.sequence == target.sequence }.coerceAtLeast(0)
|
||||
return PaneSelection(
|
||||
pane = MasterPane.Stage,
|
||||
itemId = runId,
|
||||
stageKey = step.stage,
|
||||
stageVisit = visitIndex,
|
||||
)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Query sequencing: debounce + stale-response gating. Pure (no coroutines and
|
||||
// no clock) so a keystroke burst and an out-of-order reply are unit-testable.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** One typed query awaiting its debounce window. */
|
||||
data class SearchEdit(val token: Long, val query: String)
|
||||
|
||||
/** A query whose debounce elapsed and which is still the newest edit. */
|
||||
data class SentSearch(val token: Long, val query: String)
|
||||
|
||||
/**
|
||||
* The pure ordering behind omni-search.
|
||||
*
|
||||
* [edit] records a keystroke and returns the pending edit to debounce; when the
|
||||
* quiet period elapses the caller passes it to [begin], which returns the query
|
||||
* to send only if no newer keystroke arrived — so a burst of keystrokes collapses
|
||||
* into one request for the last one. Every sent request carries a monotonically
|
||||
* increasing token and [accepts] is true only for the newest sent token, so a
|
||||
* slower older reply can never overwrite a newer one.
|
||||
*/
|
||||
class SearchSequencer {
|
||||
private var edits = 0L
|
||||
private var newestSent = 0L
|
||||
|
||||
fun edit(query: String): SearchEdit = SearchEdit(++edits, query)
|
||||
|
||||
fun begin(edit: SearchEdit): SentSearch? {
|
||||
if (edit.token != edits) return null
|
||||
newestSent = edit.token
|
||||
return SentSearch(edit.token, edit.query)
|
||||
}
|
||||
|
||||
fun accepts(token: Long): Boolean = token == newestSent
|
||||
}
|
||||
|
||||
/** The omni-search panel state; the previous results stay put while a new query loads. */
|
||||
@Immutable
|
||||
data class SearchUiState(
|
||||
val query: String = "",
|
||||
val results: List<SearchResult> = emptyList(),
|
||||
val loading: Boolean = false,
|
||||
val error: String? = null,
|
||||
val loaded: Boolean = false,
|
||||
)
|
||||
|
||||
/** A keystroke: keep the previous results (no flicker to empty) and mark a request in flight. */
|
||||
fun SearchUiState.editing(query: String): SearchUiState =
|
||||
copy(query = query, loading = query.isNotBlank(), error = null, loaded = false)
|
||||
|
||||
/** A reply landed: replace the results and stop loading. */
|
||||
fun SearchUiState.loaded(response: SearchResponse): SearchUiState =
|
||||
copy(results = response.results, loading = false, error = null, loaded = true)
|
||||
|
||||
/**
|
||||
* A load failed: stop loading and record the reason, keeping any previous results
|
||||
* visible rather than blanking the panel.
|
||||
*/
|
||||
fun SearchUiState.failed(message: String?): SearchUiState =
|
||||
copy(loading = false, error = message, loaded = true)
|
||||
|
||||
/** Whether the panel shows the explicit, query-naming empty state. */
|
||||
fun SearchUiState.isEmptyResult(): Boolean =
|
||||
error == null && !loading && loaded && results.isEmpty() && query.isNotBlank()
|
||||
@@ -1,9 +1,20 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import androidx.activity.compose.BackHandler
|
||||
import androidx.activity.compose.PredictiveBackHandler
|
||||
import androidx.compose.animation.AnimatedContent
|
||||
import androidx.compose.animation.AnimatedVisibility
|
||||
import androidx.compose.animation.SizeTransform
|
||||
import androidx.compose.animation.animateColorAsState
|
||||
import androidx.compose.animation.core.animateDpAsState
|
||||
import androidx.compose.animation.fadeIn
|
||||
import androidx.compose.animation.fadeOut
|
||||
import androidx.compose.animation.togetherWith
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.clickable
|
||||
import androidx.compose.foundation.gestures.detectTapGestures
|
||||
import androidx.compose.foundation.interaction.MutableInteractionSource
|
||||
import androidx.compose.foundation.interaction.collectIsFocusedAsState
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Box
|
||||
import androidx.compose.foundation.layout.Column
|
||||
@@ -12,6 +23,7 @@ import androidx.compose.foundation.layout.WindowInsets
|
||||
import androidx.compose.foundation.layout.WindowInsetsSides
|
||||
import androidx.compose.foundation.layout.consumeWindowInsets
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.offset
|
||||
import androidx.compose.foundation.layout.only
|
||||
import androidx.compose.foundation.layout.padding
|
||||
@@ -20,25 +32,39 @@ import androidx.compose.foundation.layout.windowInsetsPadding
|
||||
import androidx.compose.foundation.selection.selectable
|
||||
import androidx.compose.foundation.shape.CircleShape
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.foundation.text.BasicTextField
|
||||
import androidx.compose.foundation.text.KeyboardActions
|
||||
import androidx.compose.foundation.text.KeyboardOptions
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.AccountTree
|
||||
import androidx.compose.material.icons.filled.Close
|
||||
import androidx.compose.material.icons.filled.History
|
||||
import androidx.compose.material.icons.filled.Search
|
||||
import androidx.compose.material.icons.filled.Settings
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.IconButton
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.Scaffold
|
||||
import androidx.compose.material3.Surface
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.draw.clip
|
||||
import androidx.compose.ui.focus.FocusRequester
|
||||
import androidx.compose.ui.focus.focusRequester
|
||||
import androidx.compose.ui.graphics.SolidColor
|
||||
import androidx.compose.ui.graphics.vector.ImageVector
|
||||
import androidx.compose.ui.input.pointer.pointerInput
|
||||
import androidx.compose.ui.platform.LocalConfiguration
|
||||
import androidx.compose.ui.semantics.Role
|
||||
import androidx.compose.ui.text.input.ImeAction
|
||||
import androidx.compose.ui.unit.Dp
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
@@ -47,6 +73,7 @@ import androidx.navigation.compose.composable
|
||||
import androidx.navigation.compose.currentBackStackEntryAsState
|
||||
import androidx.navigation.compose.rememberNavController
|
||||
import kotlinx.coroutines.flow.collect
|
||||
import net.awan.pipelines.data.protocol.SearchResult
|
||||
import net.awan.pipelines.data.transport.ConnectionState
|
||||
import net.awan.pipelines.ui.components.ConnectionBanner
|
||||
import net.awan.pipelines.ui.components.MotionStandard
|
||||
@@ -65,6 +92,9 @@ import net.awan.pipelines.ui.screens.RunDetailScreen
|
||||
import net.awan.pipelines.ui.screens.RunHistoryScreen
|
||||
import net.awan.pipelines.ui.screens.SettingsScreen
|
||||
import net.awan.pipelines.ui.theme.DESTINATION_PILL_RESERVE
|
||||
import net.awan.pipelines.ui.theme.SPACING_M
|
||||
import net.awan.pipelines.ui.theme.SPACING_S
|
||||
import net.awan.pipelines.ui.theme.SPACING_XS
|
||||
|
||||
private data class TopDestination(val route: String, val label: String, val icon: ImageVector)
|
||||
|
||||
@@ -104,11 +134,54 @@ fun PipelinesApp(vm: AppViewModel) {
|
||||
// every width; only the section index presentation (tab row vs rail) changes.
|
||||
val wide = isWideLayout(LocalConfiguration.current.screenWidthDp)
|
||||
|
||||
// The Runs destination's selection is hoisted here so the Pipelines detail can
|
||||
// jump to a freshly started run (there is no longer a run route to navigate to).
|
||||
// The Pipelines and Runs destinations' selections are hoisted here so a search
|
||||
// result can open either one (and the Pipelines detail can jump to a freshly
|
||||
// started run). There is no longer a run/route to navigate to.
|
||||
var pipelineSelection by rememberSaveable(stateSaver = PaneSelectionSaver) {
|
||||
mutableStateOf(PaneSelection())
|
||||
}
|
||||
var runSelection by rememberSaveable(stateSaver = PaneSelectionSaver) {
|
||||
mutableStateOf(PaneSelection())
|
||||
}
|
||||
// A run search hit that names a recorded visit cannot be resolved until the
|
||||
// run's steps are loaded; the Runs destination applies it then (see below).
|
||||
var runSearchNav by remember { mutableStateOf<SearchTarget.Run?>(null) }
|
||||
|
||||
// The bottom container's morph (destination pill <-> omni-search field) is
|
||||
// saved state, so a still-open field survives rotation, configuration change
|
||||
// and process death. Opening never navigates, so the destination the pill had
|
||||
// selected is untouched and dismissing restores exactly that pill.
|
||||
var searchState by rememberSaveable(stateSaver = OmniSearchStateSaver) {
|
||||
mutableStateOf(OmniSearchState())
|
||||
}
|
||||
val search by vm.search.collectAsStateWithLifecycle()
|
||||
|
||||
/** Back/scrim/close and a selection all dismiss the morph and clear the panel. */
|
||||
val dismissSearch: () -> Unit = {
|
||||
vm.clearSearch()
|
||||
searchState = dismissOmniSearch(searchState)
|
||||
}
|
||||
|
||||
// Selecting a result navigates and closes the search. A read-only (unknown
|
||||
// kind) result has a null target and only closes.
|
||||
val onSelectResult: (SearchResult) -> Unit = { hit ->
|
||||
when (val target = searchTarget(hit)) {
|
||||
is SearchTarget.Pipeline -> {
|
||||
pipelineSelection = PaneSelection(MasterPane.Detail, target.pipelineId, target.version)
|
||||
navController.navigate("pipelines") {
|
||||
popUpTo("pipelines") { inclusive = false }
|
||||
launchSingleTop = true
|
||||
}
|
||||
}
|
||||
is SearchTarget.Run -> {
|
||||
runSelection = PaneSelection(MasterPane.Detail, target.runId)
|
||||
runSearchNav = target.takeIf { it.sequence > 0 }
|
||||
navController.navigate("runs") { launchSingleTop = true }
|
||||
}
|
||||
null -> Unit
|
||||
}
|
||||
dismissSearch()
|
||||
}
|
||||
|
||||
val onNavigate: (TopDestination) -> Unit = { destination ->
|
||||
if (currentRoute != destination.route) {
|
||||
@@ -159,6 +232,8 @@ fun PipelinesApp(vm: AppViewModel) {
|
||||
PipelineDestination(
|
||||
vm = vm,
|
||||
wide = wide,
|
||||
selection = pipelineSelection,
|
||||
onSelectionChange = { pipelineSelection = it },
|
||||
onOpenRun = { runId ->
|
||||
runSelection = PaneSelection(
|
||||
pane = MasterPane.Detail,
|
||||
@@ -174,6 +249,8 @@ fun PipelinesApp(vm: AppViewModel) {
|
||||
wide = wide,
|
||||
selection = runSelection,
|
||||
onSelectionChange = { runSelection = it },
|
||||
pendingNav = runSearchNav,
|
||||
onPendingNavResolved = { runSearchNav = null },
|
||||
)
|
||||
}
|
||||
composable("settings") {
|
||||
@@ -181,19 +258,73 @@ fun PipelinesApp(vm: AppViewModel) {
|
||||
}
|
||||
}
|
||||
}
|
||||
DestinationPill(
|
||||
destinations = destinations,
|
||||
currentRoute = currentRoute,
|
||||
onSelect = onNavigate,
|
||||
// The open search covers the content behind a scrim; tapping it plays
|
||||
// the reverse morph, the same dismissal as Back.
|
||||
AnimatedVisibility(
|
||||
visible = searchState.open,
|
||||
enter = fadeIn(animationSpec = MotionStandard.spec()),
|
||||
exit = fadeOut(animationSpec = MotionStandard.spec()),
|
||||
) {
|
||||
Box(
|
||||
Modifier
|
||||
.fillMaxSize()
|
||||
.background(MaterialTheme.colorScheme.scrim.copy(alpha = SEARCH_SCRIM_ALPHA))
|
||||
.pointerInput(Unit) {
|
||||
detectTapGestures { dismissSearch() }
|
||||
},
|
||||
)
|
||||
}
|
||||
// Composed after the NavHost, so while the field is open Back (button
|
||||
// or gesture) dismisses the morph before any pane's own Back handler.
|
||||
BackHandler(enabled = searchState.open) { dismissSearch() }
|
||||
// The results panel and the destination bar share one bottom-anchored,
|
||||
// inset-clearing column. `paneSafeArea` (WindowInsets.safeDrawing) is
|
||||
// applied once here: the panel then takes exactly the height the IME and
|
||||
// navigation bar leave (weight, `fill = false` so a short panel wraps)
|
||||
// and scrolls inside it, and the input always sits directly below the
|
||||
// panel and above the keyboard. This is the only place the IME is
|
||||
// cleared because the activity declares `adjustNothing`: the window is
|
||||
// never resized for the IME, so the inset below is not counted twice.
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.align(Alignment.BottomEnd)
|
||||
.fillMaxSize()
|
||||
.windowInsetsPadding(paneSafeArea())
|
||||
.padding(end = 16.dp, bottom = 16.dp),
|
||||
)
|
||||
verticalArrangement = Arrangement.Bottom,
|
||||
horizontalAlignment = Alignment.End,
|
||||
) {
|
||||
if (searchState.open && searchState.query.isNotBlank()) {
|
||||
SearchResultsPanel(
|
||||
state = search,
|
||||
onSelect = onSelectResult,
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.weight(1f, fill = false)
|
||||
.padding(bottom = 16.dp),
|
||||
)
|
||||
}
|
||||
DestinationBar(
|
||||
destinations = destinations,
|
||||
currentRoute = currentRoute,
|
||||
state = searchState,
|
||||
onSelect = onNavigate,
|
||||
onOpenSearch = { searchState = openOmniSearch(searchState) },
|
||||
onDismissSearch = dismissSearch,
|
||||
onQueryChange = {
|
||||
searchState = setOmniSearchQuery(searchState, it)
|
||||
vm.onSearchQueryChanged(it)
|
||||
},
|
||||
onFocusChange = { searchState = setOmniSearchFocus(searchState, it) },
|
||||
onSubmitSearch = { vm.searchNow() },
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** How dark the scrim behind the open search field is. */
|
||||
private const val SEARCH_SCRIM_ALPHA = 0.5f
|
||||
|
||||
/**
|
||||
* The Pipelines destination: one sliding pane stack whose pane 0 is the pipeline
|
||||
* list, pane 1 is the selected pipeline (Summary/Graph/Source) and pane 2 is the
|
||||
@@ -203,12 +334,15 @@ fun PipelinesApp(vm: AppViewModel) {
|
||||
* closes every pane to its right via [popTo].
|
||||
*/
|
||||
@Composable
|
||||
private fun PipelineDestination(vm: AppViewModel, wide: Boolean, onOpenRun: (Long) -> Unit) {
|
||||
var selection by rememberSaveable(stateSaver = PaneSelectionSaver) {
|
||||
mutableStateOf(PaneSelection())
|
||||
}
|
||||
private fun PipelineDestination(
|
||||
vm: AppViewModel,
|
||||
wide: Boolean,
|
||||
selection: PaneSelection,
|
||||
onSelectionChange: (PaneSelection) -> Unit,
|
||||
onOpenRun: (Long) -> Unit,
|
||||
) {
|
||||
val depth = selection.depth
|
||||
val onBack: () -> Unit = { selection = backFrom(selection) }
|
||||
val onBack: () -> Unit = { onSelectionChange(backFrom(selection)) }
|
||||
|
||||
PredictiveBackHandler(enabled = depth >= 1) { progress ->
|
||||
// Consume the gesture; on completion perform exactly one Back step.
|
||||
@@ -219,14 +353,14 @@ private fun PipelineDestination(vm: AppViewModel, wide: Boolean, onOpenRun: (Lon
|
||||
SlidingPaneStack(
|
||||
depth = depth,
|
||||
wide = wide,
|
||||
onPopTo = { level -> selection = popTo(selection, level) },
|
||||
onPopTo = { level -> onSelectionChange(popTo(selection, level)) },
|
||||
backContentDescription = { level -> if (level == 0) "Back to pipelines" else "Back to pipeline" },
|
||||
pane = { level, covered, paneModifier ->
|
||||
when (level) {
|
||||
0 -> PipelineListScreen(
|
||||
vm = vm,
|
||||
onOpen = { id, version ->
|
||||
selection = PaneSelection(MasterPane.Detail, id, version)
|
||||
onSelectionChange(PaneSelection(MasterPane.Detail, id, version))
|
||||
},
|
||||
modifier = paneModifier,
|
||||
selectedId = selection.itemId.takeIf { depth >= 1 },
|
||||
@@ -244,11 +378,13 @@ private fun PipelineDestination(vm: AppViewModel, wide: Boolean, onOpenRun: (Lon
|
||||
onBack = onBack,
|
||||
onOpenRun = onOpenRun,
|
||||
selectedSection = clampTabIndex(sectionIndex, pipelineDetailTabs.size),
|
||||
onSelectSection = { selection = selection.copy(sectionIndex = it) },
|
||||
onSelectSection = { onSelectionChange(selection.copy(sectionIndex = it)) },
|
||||
modifier = paneModifier,
|
||||
wide = wide,
|
||||
onOpenStage = { key ->
|
||||
selection = selection.copy(pane = MasterPane.Stage, stageKey = key, stageVisit = 0)
|
||||
onSelectionChange(
|
||||
selection.copy(pane = MasterPane.Stage, stageKey = key, stageVisit = 0),
|
||||
)
|
||||
},
|
||||
covered = covered,
|
||||
)
|
||||
@@ -285,10 +421,24 @@ private fun RunsDestination(
|
||||
wide: Boolean,
|
||||
selection: PaneSelection,
|
||||
onSelectionChange: (PaneSelection) -> Unit,
|
||||
pendingNav: SearchTarget.Run?,
|
||||
onPendingNavResolved: () -> Unit,
|
||||
) {
|
||||
val depth = selection.depth
|
||||
val onBack: () -> Unit = { onSelectionChange(backFrom(selection)) }
|
||||
|
||||
// A run search hit that names a recorded visit is applied once the run's steps
|
||||
// have loaded: the visit's stage pane (or the matched section) replaces the
|
||||
// plain run detail. A target for another run waits for its own detail.
|
||||
val runState by vm.runDetail.collectAsStateWithLifecycle()
|
||||
LaunchedEffect(pendingNav, runState.data) {
|
||||
val target = pendingNav ?: return@LaunchedEffect
|
||||
val run = runState.data ?: return@LaunchedEffect
|
||||
if (run.id != target.runId) return@LaunchedEffect
|
||||
onSelectionChange(resolveRunTarget(target, run.id, run.steps))
|
||||
onPendingNavResolved()
|
||||
}
|
||||
|
||||
PredictiveBackHandler(enabled = depth >= 1) { progress ->
|
||||
progress.collect { }
|
||||
onBack()
|
||||
@@ -359,23 +509,87 @@ internal fun destinationIndicatorOffsetDp(index: Int, itemSize: Dp, gap: Dp): Dp
|
||||
gap + (itemSize + gap) * index.coerceAtLeast(0)
|
||||
|
||||
/**
|
||||
* The Pipelines/Runs/Settings destinations as a floating rounded pill at the
|
||||
* bottom right: the three destinations as icons, inset from the bottom/right
|
||||
* edges (it clears the safe area — system bars, cutout, gesture area and IME —
|
||||
* via windowInsetsPadding), each a [DESTINATION_ITEM_SIZE] touch target.
|
||||
* Selection is one tonal indicator that travels between the icons
|
||||
* ([MotionStandard], so it slides rather than jumping) plus the icon's fading
|
||||
* tint, while the `Role.Tab` selected accessibility state is never conveyed by
|
||||
* colour alone. Tapping switches destination through the caller's existing
|
||||
* navigate/popUpTo logic; the icons own the taps, so a tap registers even while
|
||||
* the indicator is still travelling, and the settled pill equals the old one.
|
||||
* The bottom container: the destination pill that morphs into the omni-search
|
||||
* field. It is one [Surface] so the morph reads as the same container changing
|
||||
* role, not two surfaces swapping. Neither opening nor dismissing navigates, so
|
||||
* the destination the pill had selected is untouched and the reverse restores
|
||||
* exactly that pill.
|
||||
*/
|
||||
@Composable
|
||||
private fun DestinationPill(
|
||||
private fun DestinationBar(
|
||||
destinations: List<TopDestination>,
|
||||
currentRoute: String?,
|
||||
state: OmniSearchState,
|
||||
onSelect: (TopDestination) -> Unit,
|
||||
onOpenSearch: () -> Unit,
|
||||
onDismissSearch: () -> Unit,
|
||||
onQueryChange: (String) -> Unit,
|
||||
onFocusChange: (Boolean) -> Unit,
|
||||
onSubmitSearch: () -> Unit,
|
||||
modifier: Modifier = Modifier,
|
||||
) {
|
||||
val scheme = MaterialTheme.colorScheme
|
||||
Surface(
|
||||
modifier = modifier,
|
||||
shape = RoundedCornerShape(50),
|
||||
color = scheme.surfaceContainerHigh,
|
||||
tonalElevation = 3.dp,
|
||||
shadowElevation = 6.dp,
|
||||
) {
|
||||
// The icons fade out while the field fades in, and the container takes the
|
||||
// new content's size. The field fills the width the caller's inset padding
|
||||
// leaves, so the grown size derives from that plus the field's own layout,
|
||||
// and the position from the container's right-anchored alignment; no pill
|
||||
// size is copied.
|
||||
AnimatedContent(
|
||||
targetState = state.open,
|
||||
transitionSpec = {
|
||||
(fadeIn(animationSpec = MotionStandard.spec()) togetherWith
|
||||
fadeOut(animationSpec = MotionStandard.spec()))
|
||||
.using(SizeTransform(clip = false) { _, _ -> MotionStandard.spec() })
|
||||
},
|
||||
contentAlignment = Alignment.CenterEnd,
|
||||
label = "omni-search-morph",
|
||||
) { open ->
|
||||
if (open) {
|
||||
OmniSearchField(
|
||||
query = state.query,
|
||||
onQueryChange = onQueryChange,
|
||||
onFocusChange = onFocusChange,
|
||||
onSubmit = onSubmitSearch,
|
||||
onDismiss = onDismissSearch,
|
||||
)
|
||||
} else {
|
||||
DestinationIcons(
|
||||
destinations = destinations,
|
||||
currentRoute = currentRoute,
|
||||
onSelect = onSelect,
|
||||
onOpenSearch = onOpenSearch,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The resting destination pill: the Pipelines/Runs/Settings destinations plus the
|
||||
* omni-search entry point, each a [DESTINATION_ITEM_SIZE] touch target. Selection
|
||||
* is one tonal indicator that travels between the icons ([MotionStandard], so it
|
||||
* slides rather than jumping) plus the icon's fading tint, while the `Role.Tab`
|
||||
* selected accessibility state is never conveyed by colour alone. Tapping a
|
||||
* destination switches through the caller's existing navigate/popUpTo logic; the
|
||||
* icons own the taps, so a tap registers even while the indicator is still
|
||||
* travelling, and the settled pill equals the old one.
|
||||
*
|
||||
* The fourth control (Search) does not navigate: it is a plain [Role.Button]
|
||||
* action that morphs this container into the search field.
|
||||
*/
|
||||
@Composable
|
||||
private fun DestinationIcons(
|
||||
destinations: List<TopDestination>,
|
||||
currentRoute: String?,
|
||||
onSelect: (TopDestination) -> Unit,
|
||||
modifier: Modifier = Modifier,
|
||||
onOpenSearch: () -> Unit,
|
||||
) {
|
||||
val scheme = MaterialTheme.colorScheme
|
||||
val selectedIndex = destinations.indexOfFirst { destinationSelected(currentRoute, it.route) }
|
||||
@@ -390,58 +604,131 @@ private fun DestinationPill(
|
||||
animationSpec = MotionStandard.spec(),
|
||||
label = "destination-indicator",
|
||||
)
|
||||
Surface(
|
||||
modifier = modifier,
|
||||
shape = RoundedCornerShape(50),
|
||||
color = scheme.surfaceContainerHigh,
|
||||
tonalElevation = 3.dp,
|
||||
shadowElevation = 6.dp,
|
||||
) {
|
||||
Box {
|
||||
// Drawn behind the icons, so the highlight slides under whichever is
|
||||
// selected; before the nav graph settles there is no selection and
|
||||
// nothing is drawn.
|
||||
if (selectedIndex >= 0) {
|
||||
Box {
|
||||
// Drawn behind the icons, so the highlight slides under whichever is
|
||||
// selected; before the nav graph settles there is no selection and
|
||||
// nothing is drawn.
|
||||
if (selectedIndex >= 0) {
|
||||
Box(
|
||||
Modifier
|
||||
.offset(x = indicatorOffset, y = DESTINATION_ITEM_GAP)
|
||||
.size(DESTINATION_ITEM_SIZE)
|
||||
.clip(CircleShape)
|
||||
.background(scheme.secondaryContainer),
|
||||
)
|
||||
}
|
||||
Row(
|
||||
modifier = Modifier.padding(DESTINATION_ITEM_GAP),
|
||||
horizontalArrangement = Arrangement.spacedBy(DESTINATION_ITEM_GAP),
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
) {
|
||||
destinations.forEach { destination ->
|
||||
val selected = destinationSelected(currentRoute, destination.route)
|
||||
// The glyph tint fades in step with the travelling indicator.
|
||||
val iconColor by animateColorAsState(
|
||||
targetValue = if (selected) scheme.onSecondaryContainer else scheme.onSurfaceVariant,
|
||||
animationSpec = MotionStandard.spec(),
|
||||
label = "destination-icon",
|
||||
)
|
||||
Box(
|
||||
Modifier
|
||||
.offset(x = indicatorOffset, y = DESTINATION_ITEM_GAP)
|
||||
modifier = Modifier
|
||||
.size(DESTINATION_ITEM_SIZE)
|
||||
.clip(CircleShape)
|
||||
.background(scheme.secondaryContainer),
|
||||
)
|
||||
}
|
||||
Row(
|
||||
modifier = Modifier.padding(DESTINATION_ITEM_GAP),
|
||||
horizontalArrangement = Arrangement.spacedBy(DESTINATION_ITEM_GAP),
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
) {
|
||||
destinations.forEach { destination ->
|
||||
val selected = destinationSelected(currentRoute, destination.route)
|
||||
// The glyph tint fades in step with the travelling indicator.
|
||||
val iconColor by animateColorAsState(
|
||||
targetValue = if (selected) scheme.onSecondaryContainer else scheme.onSurfaceVariant,
|
||||
animationSpec = MotionStandard.spec(),
|
||||
label = "destination-icon",
|
||||
.selectable(
|
||||
selected = selected,
|
||||
role = Role.Tab,
|
||||
onClick = { onSelect(destination) },
|
||||
),
|
||||
contentAlignment = Alignment.Center,
|
||||
) {
|
||||
Icon(
|
||||
imageVector = destination.icon,
|
||||
contentDescription = destination.label,
|
||||
tint = iconColor,
|
||||
)
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.size(DESTINATION_ITEM_SIZE)
|
||||
.clip(CircleShape)
|
||||
.selectable(
|
||||
selected = selected,
|
||||
role = Role.Tab,
|
||||
onClick = { onSelect(destination) },
|
||||
),
|
||||
contentAlignment = Alignment.Center,
|
||||
) {
|
||||
Icon(
|
||||
imageVector = destination.icon,
|
||||
contentDescription = destination.label,
|
||||
tint = iconColor,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.size(DESTINATION_ITEM_SIZE)
|
||||
.clip(CircleShape)
|
||||
.clickable(
|
||||
role = Role.Button,
|
||||
onClickLabel = "Search",
|
||||
onClick = onOpenSearch,
|
||||
),
|
||||
contentAlignment = Alignment.Center,
|
||||
) {
|
||||
Icon(
|
||||
imageVector = Icons.Default.Search,
|
||||
contentDescription = "Search",
|
||||
tint = scheme.onSurfaceVariant,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The search field the pill morphs into: a single-line input focused as it opens
|
||||
* (so the keyboard is up), a leading search glyph and a trailing close action. It
|
||||
* reports focus changes into [OmniSearchState] and every keystroke to the caller,
|
||||
* which debounces the query and drives the results panel above it.
|
||||
*/
|
||||
@Composable
|
||||
private fun OmniSearchField(
|
||||
query: String,
|
||||
onQueryChange: (String) -> Unit,
|
||||
onFocusChange: (Boolean) -> Unit,
|
||||
onSubmit: () -> Unit,
|
||||
onDismiss: () -> Unit,
|
||||
) {
|
||||
val scheme = MaterialTheme.colorScheme
|
||||
val interaction = remember { MutableInteractionSource() }
|
||||
val focused by interaction.collectIsFocusedAsState()
|
||||
val focusRequester = remember { FocusRequester() }
|
||||
LaunchedEffect(focused) { onFocusChange(focused) }
|
||||
// Focus as the field opens so the keyboard is up; an open field restored after
|
||||
// a process death re-focuses the same way.
|
||||
LaunchedEffect(Unit) { focusRequester.requestFocus() }
|
||||
|
||||
Row(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.padding(horizontal = SPACING_M, vertical = SPACING_XS),
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
) {
|
||||
Icon(
|
||||
imageVector = Icons.Default.Search,
|
||||
contentDescription = null,
|
||||
tint = scheme.onSurfaceVariant,
|
||||
)
|
||||
BasicTextField(
|
||||
value = query,
|
||||
onValueChange = onQueryChange,
|
||||
singleLine = true,
|
||||
textStyle = MaterialTheme.typography.bodyLarge.copy(color = scheme.onSurface),
|
||||
cursorBrush = SolidColor(scheme.primary),
|
||||
keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),
|
||||
keyboardActions = KeyboardActions(onSearch = { onSubmit() }),
|
||||
interactionSource = interaction,
|
||||
modifier = Modifier
|
||||
.weight(1f)
|
||||
.padding(horizontal = SPACING_S)
|
||||
.focusRequester(focusRequester),
|
||||
decorationBox = { innerTextField ->
|
||||
if (query.isEmpty()) {
|
||||
Text(
|
||||
text = "Search pipelines, runs and artifacts",
|
||||
style = MaterialTheme.typography.bodyLarge,
|
||||
color = scheme.onSurfaceVariant,
|
||||
)
|
||||
}
|
||||
innerTextField()
|
||||
},
|
||||
)
|
||||
IconButton(onClick = onDismiss) {
|
||||
Icon(Icons.Default.Close, contentDescription = "Close search")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,213 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import androidx.compose.foundation.clickable
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.Row
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
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.shape.RoundedCornerShape
|
||||
import androidx.compose.material3.CircularProgressIndicator
|
||||
import androidx.compose.material3.HorizontalDivider
|
||||
import androidx.compose.material3.LinearProgressIndicator
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.Surface
|
||||
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.semantics.Role
|
||||
import androidx.compose.ui.text.AnnotatedString
|
||||
import androidx.compose.ui.text.SpanStyle
|
||||
import androidx.compose.ui.text.buildAnnotatedString
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.text.style.TextDecoration
|
||||
import androidx.compose.ui.text.style.TextOverflow
|
||||
import androidx.compose.ui.text.withStyle
|
||||
import androidx.compose.ui.unit.dp
|
||||
import net.awan.pipelines.data.protocol.SearchResult
|
||||
import net.awan.pipelines.ui.theme.SEARCH_PROGRESS_DP
|
||||
import net.awan.pipelines.ui.theme.SPACING_L
|
||||
import net.awan.pipelines.ui.theme.SPACING_M
|
||||
import net.awan.pipelines.ui.theme.SPACING_S
|
||||
import net.awan.pipelines.ui.theme.SPACING_XXS
|
||||
import net.awan.pipelines.ui.theme.SPACING_XL
|
||||
import net.awan.pipelines.ui.theme.pipelinesText
|
||||
|
||||
/**
|
||||
* The omni-search results panel: one scrolling surface that sits above the search
|
||||
* field. It renders the last accepted results, and while a newer query loads it
|
||||
* keeps those results and adds a thin progress bar rather than blanking; a
|
||||
* failure is reported without discarding what is already shown. Its height is
|
||||
* bounded by the caller (the window's IME/navigation-bar insets), so it scrolls
|
||||
* inside the remainder instead of running under the keyboard.
|
||||
*/
|
||||
@Composable
|
||||
internal fun SearchResultsPanel(
|
||||
state: SearchUiState,
|
||||
onSelect: (SearchResult) -> Unit,
|
||||
modifier: Modifier = Modifier,
|
||||
) {
|
||||
val scheme = MaterialTheme.colorScheme
|
||||
val error = state.error
|
||||
Surface(
|
||||
modifier = modifier,
|
||||
shape = RoundedCornerShape(SPACING_XL),
|
||||
color = scheme.surfaceContainerHigh,
|
||||
tonalElevation = 3.dp,
|
||||
shadowElevation = 6.dp,
|
||||
) {
|
||||
Column(Modifier.fillMaxWidth()) {
|
||||
// A refresh of an already-populated panel shows progress without
|
||||
// replacing the results; the first load shows the searching row below.
|
||||
if (state.loading && state.results.isNotEmpty()) {
|
||||
LinearProgressIndicator(Modifier.fillMaxWidth())
|
||||
}
|
||||
when {
|
||||
error != null -> PanelMessage(error, isError = true)
|
||||
state.isEmptyResult() -> PanelMessage("No matches for \"${state.query}\".", isError = false)
|
||||
state.loading && state.results.isEmpty() -> SearchingRow()
|
||||
state.results.isNotEmpty() -> SearchResultList(state.results, state.query, onSelect)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun PanelMessage(message: String, isError: Boolean) {
|
||||
Text(
|
||||
text = message,
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
color = if (isError) {
|
||||
MaterialTheme.colorScheme.error
|
||||
} else {
|
||||
MaterialTheme.colorScheme.onSurfaceVariant
|
||||
},
|
||||
modifier = Modifier.fillMaxWidth().padding(horizontal = SPACING_L, vertical = SPACING_M),
|
||||
)
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun SearchingRow() {
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth().padding(horizontal = SPACING_L, vertical = SPACING_M),
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = Arrangement.spacedBy(SPACING_M),
|
||||
) {
|
||||
CircularProgressIndicator(Modifier.size(SEARCH_PROGRESS_DP))
|
||||
Text(
|
||||
text = "Searching…",
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun SearchResultList(
|
||||
results: List<SearchResult>,
|
||||
query: String,
|
||||
onSelect: (SearchResult) -> Unit,
|
||||
) {
|
||||
LazyColumn(Modifier.fillMaxWidth()) {
|
||||
items(results) { hit ->
|
||||
SearchResultRow(
|
||||
hit = hit,
|
||||
query = query,
|
||||
onClick = searchTarget(hit)?.let { { onSelect(hit) } },
|
||||
)
|
||||
HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* One result row: its type badge, a title and a secondary line. A text match's
|
||||
* secondary line is its snippet with the matched span rendered bold+underlined,
|
||||
* so the match is distinguishable without relying on colour. A result with no
|
||||
* navigation target (an unknown kind) is shown read-only and is not clickable.
|
||||
*/
|
||||
@Composable
|
||||
private fun SearchResultRow(
|
||||
hit: SearchResult,
|
||||
query: String,
|
||||
onClick: (() -> Unit)?,
|
||||
) {
|
||||
val text = pipelinesText()
|
||||
val row = remember(hit, query) { searchRow(hit, query) }
|
||||
Row(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.then(
|
||||
if (onClick != null) {
|
||||
Modifier.clickable(role = Role.Button, onClick = onClick)
|
||||
} else {
|
||||
Modifier
|
||||
},
|
||||
)
|
||||
.padding(horizontal = SPACING_L, vertical = SPACING_M),
|
||||
horizontalArrangement = Arrangement.spacedBy(SPACING_M),
|
||||
) {
|
||||
TypeBadge(row.badge)
|
||||
Column(
|
||||
modifier = Modifier.weight(1f),
|
||||
verticalArrangement = Arrangement.spacedBy(SPACING_XXS),
|
||||
) {
|
||||
Text(
|
||||
text = row.title,
|
||||
style = text.cardTitle,
|
||||
maxLines = 1,
|
||||
overflow = TextOverflow.Ellipsis,
|
||||
)
|
||||
val snippet = row.snippet
|
||||
if (snippet != null) {
|
||||
Text(
|
||||
text = annotatedSnippet(snippet),
|
||||
style = text.meta,
|
||||
maxLines = 2,
|
||||
overflow = TextOverflow.Ellipsis,
|
||||
)
|
||||
} else {
|
||||
Text(
|
||||
text = row.secondary,
|
||||
style = text.meta,
|
||||
maxLines = 2,
|
||||
overflow = TextOverflow.Ellipsis,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** The row's type badge; its label carries the type, so it never relies on colour. */
|
||||
@Composable
|
||||
private fun TypeBadge(label: String) {
|
||||
Surface(
|
||||
shape = RoundedCornerShape(50),
|
||||
color = MaterialTheme.colorScheme.secondaryContainer,
|
||||
) {
|
||||
Text(
|
||||
text = label,
|
||||
style = MaterialTheme.typography.labelMedium,
|
||||
color = MaterialTheme.colorScheme.onSecondaryContainer,
|
||||
modifier = Modifier.padding(horizontal = SPACING_S, vertical = SPACING_XXS),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/** Renders a snippet, emphasising the matched span with weight+underline (not colour). */
|
||||
private fun annotatedSnippet(spans: List<SnippetSpan>): AnnotatedString = buildAnnotatedString {
|
||||
spans.forEach { span ->
|
||||
if (span.matched) {
|
||||
withStyle(SpanStyle(fontWeight = FontWeight.Bold, textDecoration = TextDecoration.Underline)) {
|
||||
append(span.text)
|
||||
}
|
||||
} else {
|
||||
append(span.text)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -217,3 +217,8 @@ internal val ARTIFACT_PROGRESS_STROKE_DP = 2.dp
|
||||
|
||||
/** Horizontal padding inside the stage-type chip (wider than the shared chip). */
|
||||
internal val STAGE_CHIP_PAD_H = 10.dp
|
||||
|
||||
// ---- Omni-search results panel (ui/SearchResultsPanel.kt) ------------------
|
||||
|
||||
/** The omni-search panel's inline progress spinner. */
|
||||
internal val SEARCH_PROGRESS_DP = 18.dp
|
||||
|
||||
@@ -2,6 +2,7 @@ package net.awan.pipelines.data.protocol
|
||||
|
||||
import kotlinx.serialization.json.JsonPrimitive
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
@@ -96,6 +97,78 @@ class ProtocolModelTest {
|
||||
assertEquals(11L, decoded.runId)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun searchRequestRoundTripsTheQueryAndOmitsEmptyNarrowing() {
|
||||
val request = Message(
|
||||
type = Protocol.SEARCH,
|
||||
id = "android-3",
|
||||
search = SearchRequest(query = "release"),
|
||||
)
|
||||
val encoded = PipelinesJson.encodeToString(Message.serializer(), request)
|
||||
// The query nests under the server's `search` field; the empty kind/limit
|
||||
// narrowing is omitted so it matches internal/protocol/search.go.
|
||||
assertTrue(encoded.contains("\"search\""))
|
||||
assertTrue(encoded.contains("\"query\":\"release\""))
|
||||
assertFalse(encoded.contains("\"kind\""))
|
||||
val decoded = PipelinesJson.decodeFromString(Message.serializer(), encoded)
|
||||
assertEquals(Protocol.SEARCH, decoded.type)
|
||||
assertEquals("release", decoded.search?.query)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun searchResultsDecodeEveryKindAndAnUnknownPayload() {
|
||||
val json = """
|
||||
{
|
||||
"type": "search_results",
|
||||
"id": "android-4",
|
||||
"search_results": {
|
||||
"query": "release",
|
||||
"truncated": true,
|
||||
"scanned_steps": 12,
|
||||
"scanned_bytes": 4096,
|
||||
"cap": 50,
|
||||
"scan_bound_bytes": 1048576,
|
||||
"results": [
|
||||
{"kind": "pipeline", "target": "pipeline:1", "score": 3, "matched_field": "name",
|
||||
"pipeline": {"id": 1, "name": "release", "version": 2, "stages": 3}},
|
||||
{"kind": "version", "target": "pipeline:1:v2", "score": 2, "matched_field": "source",
|
||||
"version": {"pipeline_id": 1, "version": 2, "content_hash": "abc", "created_at": "2026-01-01T00:00:00Z"}},
|
||||
{"kind": "run", "target": "run:11", "score": 2, "matched_field": "status",
|
||||
"run": {"id": 11, "pipeline_name": "release", "status": "failed", "workspace": "/work", "created_at": "2026-01-01T00:00:00Z"}},
|
||||
{"kind": "step", "target": "run:11:4", "score": 1, "matched_field": "diagnostic",
|
||||
"step": {"run_id": 11, "sequence": 4, "stage": "builder", "visit": 2, "outcome": "error"}},
|
||||
{"kind": "field", "target": "run:11:4:output", "score": 1, "matched_field": "output",
|
||||
"field": {"run_id": 11, "sequence": 4, "field": "output", "snippet": "release ready"}},
|
||||
{"kind": "artifact", "target": "/artifacts/11/4/notes.md", "score": 1, "matched_field": "artifact",
|
||||
"artifact": {"run_id": 11, "sequence": 4, "name": "notes.md", "content_type": "text/markdown", "size_bytes": 2048, "url": "/artifacts/11/4/notes.md"}},
|
||||
{"kind": "future_kind", "target": "widget:7", "score": 0, "matched_field": "?"}
|
||||
]
|
||||
}
|
||||
}
|
||||
""".trimIndent()
|
||||
val message = PipelinesJson.decodeFromString(Message.serializer(), json)
|
||||
assertEquals(Protocol.SEARCH_RESULTS, message.type)
|
||||
val response = message.searchResults!!
|
||||
assertEquals("release", response.query)
|
||||
assertTrue(response.truncated)
|
||||
assertEquals(12, response.scannedSteps)
|
||||
assertEquals(50, response.cap)
|
||||
assertEquals(1048576, response.scanBoundBytes)
|
||||
assertEquals(7, response.results.size)
|
||||
assertEquals("release", response.results[0].pipeline?.name)
|
||||
assertEquals(2, response.results[1].version?.version)
|
||||
assertEquals("/work", response.results[2].run?.workspace)
|
||||
assertEquals(4, response.results[3].step?.sequence)
|
||||
assertEquals("release ready", response.results[4].field?.snippet)
|
||||
assertEquals("/artifacts/11/4/notes.md", response.results[5].artifact?.url)
|
||||
// An unknown kind decodes with no known payload and is not dropped.
|
||||
val unknown = response.results[6]
|
||||
assertEquals("future_kind", unknown.kind)
|
||||
assertEquals("widget:7", unknown.target)
|
||||
assertNull(unknown.pipeline)
|
||||
assertNull(unknown.run)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun runStepArtifactsParseWithExactWireNamesOrAbsent() {
|
||||
val json = """
|
||||
|
||||
@@ -0,0 +1,277 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import net.awan.pipelines.data.protocol.Protocol
|
||||
import net.awan.pipelines.data.protocol.RunStep
|
||||
import net.awan.pipelines.data.protocol.SearchArtifact
|
||||
import net.awan.pipelines.data.protocol.SearchField
|
||||
import net.awan.pipelines.data.protocol.SearchPipeline
|
||||
import net.awan.pipelines.data.protocol.SearchResponse
|
||||
import net.awan.pipelines.data.protocol.SearchResult
|
||||
import net.awan.pipelines.data.protocol.SearchRun
|
||||
import net.awan.pipelines.data.protocol.SearchStep
|
||||
import net.awan.pipelines.data.protocol.SearchVersion
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertNotNull
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
class OmniSearchResultsTest {
|
||||
|
||||
// ---- Badges and rows ---------------------------------------------------
|
||||
|
||||
@Test
|
||||
fun everyKindMapsToItsBadge() {
|
||||
assertEquals("pipeline", searchBadge(Protocol.SEARCH_KIND_PIPELINE))
|
||||
assertEquals("pipeline", searchBadge(Protocol.SEARCH_KIND_VERSION))
|
||||
assertEquals("run", searchBadge(Protocol.SEARCH_KIND_RUN))
|
||||
assertEquals("step", searchBadge(Protocol.SEARCH_KIND_STEP))
|
||||
assertEquals("artifact", searchBadge(Protocol.SEARCH_KIND_ARTIFACT))
|
||||
assertEquals("match", searchBadge(Protocol.SEARCH_KIND_FIELD))
|
||||
// A kind the client does not know still gets a badge and is shown.
|
||||
assertEquals("match", searchBadge("future_kind"))
|
||||
assertEquals("match", searchBadge(""))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun eachRowCarriesABadgeTitleAndSecondaryLine() {
|
||||
results().forEach { hit ->
|
||||
val row = searchRow(hit, "release")
|
||||
assertTrue("badge for ${hit.kind}", row.badge.isNotBlank())
|
||||
assertTrue("title for ${hit.kind}", row.title.isNotBlank())
|
||||
assertTrue("secondary for ${hit.kind}", row.secondary.isNotBlank())
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun onlyATextMatchCarriesASnippet() {
|
||||
val field = searchRow(hit(Protocol.SEARCH_KIND_FIELD), "release")
|
||||
assertNotNull(field.snippet)
|
||||
// A non-text result has no snippet and keeps its plain secondary line.
|
||||
val run = searchRow(hit(Protocol.SEARCH_KIND_RUN), "release")
|
||||
assertNull(run.snippet)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anUnknownKindIsShownReadOnlyAndNotDropped() {
|
||||
val unknown = SearchResult(kind = "future_kind", target = "widget:7")
|
||||
val row = searchRow(unknown, "x")
|
||||
assertEquals("widget:7", row.title)
|
||||
assertTrue(row.secondary.contains("read-only"))
|
||||
assertNull("an unknown kind is not navigable", searchTarget(unknown))
|
||||
}
|
||||
|
||||
// ---- Snippet highlighting ---------------------------------------------
|
||||
|
||||
@Test
|
||||
fun theMatchedSpanIsSplitOutCaseInsensitively() {
|
||||
val spans = snippetSpans("the Release notes mention it", "release")
|
||||
assertEquals(3, spans.size)
|
||||
assertEquals("the ", spans[0].text)
|
||||
assertEquals("Release", spans[1].text)
|
||||
assertTrue(spans[1].matched)
|
||||
assertEquals(" notes mention it", spans[2].text)
|
||||
assertFalse(spans[2].matched)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aSnippetWithoutTheQueryIsKeptWholeAndUnmatched() {
|
||||
assertEquals(listOf(SnippetSpan("nothing here", false)), snippetSpans("nothing here", "release"))
|
||||
assertEquals(listOf(SnippetSpan("nothing here", false)), snippetSpans("nothing here", " "))
|
||||
assertTrue(snippetSpans("", "release").isEmpty())
|
||||
}
|
||||
|
||||
// ---- Result-to-target mapping for every kind ---------------------------
|
||||
|
||||
@Test
|
||||
fun pipelineAndVersionHitsOpenThePipelineDetail() {
|
||||
assertEquals(
|
||||
SearchTarget.Pipeline(7L, 3),
|
||||
searchTarget(hit(Protocol.SEARCH_KIND_PIPELINE)),
|
||||
)
|
||||
assertEquals(
|
||||
SearchTarget.Pipeline(9L, 2),
|
||||
searchTarget(hit(Protocol.SEARCH_KIND_VERSION)),
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun runStepFieldAndArtifactHitsOpenRuns() {
|
||||
assertEquals(SearchTarget.Run(11L), searchTarget(hit(Protocol.SEARCH_KIND_RUN)))
|
||||
assertEquals(
|
||||
SearchTarget.Run(11L, sequence = 4),
|
||||
searchTarget(hit(Protocol.SEARCH_KIND_STEP)),
|
||||
)
|
||||
assertEquals(
|
||||
SearchTarget.Run(11L, sequence = 4, field = "output"),
|
||||
searchTarget(hit(Protocol.SEARCH_KIND_FIELD)),
|
||||
)
|
||||
assertEquals(
|
||||
SearchTarget.Run(11L, sequence = 4, artifacts = true),
|
||||
searchTarget(hit(Protocol.SEARCH_KIND_ARTIFACT)),
|
||||
)
|
||||
}
|
||||
|
||||
// ---- Resolving a run target against the loaded run ---------------------
|
||||
|
||||
private val steps = listOf(
|
||||
RunStep(sequence = 1, stage = "planner"),
|
||||
RunStep(sequence = 2, stage = "builder"),
|
||||
RunStep(sequence = 3, stage = "builder"),
|
||||
)
|
||||
|
||||
@Test
|
||||
fun aBareRunTargetOpensTheRunDetail() {
|
||||
assertEquals(
|
||||
PaneSelection(MasterPane.Detail, 11L),
|
||||
resolveRunTarget(SearchTarget.Run(11L), 11L, emptyList()),
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aTextFieldTargetOpensTheRunDetailSectionHoldingIt() {
|
||||
assertEquals(2, searchFieldSection("input"))
|
||||
assertEquals(3, searchFieldSection("output"))
|
||||
assertEquals(4, searchFieldSection("evidence"))
|
||||
assertEquals(4, searchFieldSection("transcript"))
|
||||
assertEquals(0, searchFieldSection("other"))
|
||||
|
||||
assertEquals(
|
||||
PaneSelection(MasterPane.Detail, 11L, sectionIndex = 3),
|
||||
resolveRunTarget(SearchTarget.Run(11L, 4, field = "output"), 11L, steps),
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aStepTargetOpensTheVisitsStagePaneAtTheRightVisitIndex() {
|
||||
// "builder" has two visits; sequence 3 is its second (index 1).
|
||||
val resolved = resolveRunTarget(SearchTarget.Run(11L, sequence = 3), 11L, steps)
|
||||
assertEquals(MasterPane.Stage, resolved.pane)
|
||||
assertEquals(11L, resolved.itemId)
|
||||
assertEquals("builder", resolved.stageKey)
|
||||
assertEquals(1, resolved.stageVisit)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anArtifactTargetOpensTheVisitsStagePane() {
|
||||
val resolved = resolveRunTarget(SearchTarget.Run(11L, sequence = 2, artifacts = true), 11L, steps)
|
||||
assertEquals(MasterPane.Stage, resolved.pane)
|
||||
assertEquals("builder", resolved.stageKey)
|
||||
assertEquals(0, resolved.stageVisit)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aVisitThatCannotBeLocatedFallsBackToTheRunDetail() {
|
||||
assertEquals(
|
||||
PaneSelection(MasterPane.Detail, 11L),
|
||||
resolveRunTarget(SearchTarget.Run(11L, sequence = 99), 11L, steps),
|
||||
)
|
||||
}
|
||||
|
||||
// ---- Debounce + stale-response sequencing ------------------------------
|
||||
|
||||
@Test
|
||||
fun aBurstOfKeystrokesCollapsesToTheLastQuery() {
|
||||
val sequencer = SearchSequencer()
|
||||
val first = sequencer.edit("r")
|
||||
val second = sequencer.edit("re")
|
||||
val third = sequencer.edit("rel")
|
||||
assertNull("a superseded edit is never sent", sequencer.begin(first))
|
||||
assertNull(sequencer.begin(second))
|
||||
assertEquals(SentSearch(third.token, "rel"), sequencer.begin(third))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun anOlderReplyCanNeverOverwriteANewerOne() {
|
||||
val sequencer = SearchSequencer()
|
||||
val sentOld = sequencer.begin(sequencer.edit("old"))!!
|
||||
val sentNew = sequencer.begin(sequencer.edit("new"))!!
|
||||
assertFalse(sequencer.accepts(sentOld.token))
|
||||
assertTrue(sequencer.accepts(sentNew.token))
|
||||
// A token never sent is not accepted either.
|
||||
assertFalse(sequencer.accepts(sentOld.token + 100))
|
||||
}
|
||||
|
||||
// ---- Panel state transitions -------------------------------------------
|
||||
|
||||
@Test
|
||||
fun loadingANewQueryKeepsThePreviousResults() {
|
||||
val previous = listOf(hit(Protocol.SEARCH_KIND_RUN))
|
||||
val state = SearchUiState(query = "old", results = previous, loaded = true)
|
||||
val edited = state.editing("new")
|
||||
assertEquals("new", edited.query)
|
||||
assertEquals(previous, edited.results)
|
||||
assertTrue(edited.loading)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aReplyReplacesTheResultsAndAFailureKeepsThem() {
|
||||
val previous = listOf(hit(Protocol.SEARCH_KIND_RUN))
|
||||
val loaded = SearchUiState(query = "q").loaded(SearchResponse(results = previous))
|
||||
assertEquals(previous, loaded.results)
|
||||
assertTrue(loaded.loaded)
|
||||
assertFalse(loaded.loading)
|
||||
|
||||
val failed = loaded.editing("q2").failed("boom")
|
||||
assertEquals(previous, failed.results)
|
||||
assertEquals("boom", failed.error)
|
||||
assertFalse(failed.loading)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun theEmptyStateNamesTheQueryAndOnlyAppearsWhenLoaded() {
|
||||
val empty = SearchUiState(query = "release").loaded(SearchResponse(results = emptyList()))
|
||||
assertTrue(empty.isEmptyResult())
|
||||
// Still loading: not the empty state.
|
||||
assertFalse(empty.editing("release2").isEmptyResult())
|
||||
// A failure is an error, not an empty result.
|
||||
assertFalse(SearchUiState(query = "release").failed("boom").isEmptyResult())
|
||||
}
|
||||
|
||||
// ---- Fixtures ----------------------------------------------------------
|
||||
|
||||
private fun hit(kind: String): SearchResult = when (kind) {
|
||||
Protocol.SEARCH_KIND_PIPELINE -> SearchResult(
|
||||
kind = kind,
|
||||
target = "pipeline:7",
|
||||
pipeline = SearchPipeline(id = 7, name = "release", version = 3, stages = 4),
|
||||
)
|
||||
Protocol.SEARCH_KIND_VERSION -> SearchResult(
|
||||
kind = kind,
|
||||
target = "pipeline:9:v2",
|
||||
version = SearchVersion(pipelineId = 9, version = 2, contentHash = "abc", createdAt = "2026-01-01T00:00:00Z"),
|
||||
)
|
||||
Protocol.SEARCH_KIND_RUN -> SearchResult(
|
||||
kind = kind,
|
||||
target = "run:11",
|
||||
run = SearchRun(id = 11, pipelineName = "release", status = "succeeded", createdAt = "2026-01-01T00:00:00Z"),
|
||||
)
|
||||
Protocol.SEARCH_KIND_STEP -> SearchResult(
|
||||
kind = kind,
|
||||
target = "run:11:4",
|
||||
step = SearchStep(runId = 11, sequence = 4, stage = "builder", visit = 2, outcome = "success"),
|
||||
)
|
||||
Protocol.SEARCH_KIND_FIELD -> SearchResult(
|
||||
kind = kind,
|
||||
target = "run:11:4:output",
|
||||
field = SearchField(runId = 11, sequence = 4, field = "output", snippet = "the release is ready"),
|
||||
)
|
||||
Protocol.SEARCH_KIND_ARTIFACT -> SearchResult(
|
||||
kind = kind,
|
||||
target = "/artifacts/11/4/notes.md",
|
||||
artifact = SearchArtifact(runId = 11, sequence = 4, name = "notes.md", contentType = "text/markdown", sizeBytes = 2048, url = "/artifacts/11/4/notes.md"),
|
||||
)
|
||||
else -> SearchResult(kind = kind, target = "")
|
||||
}
|
||||
|
||||
private fun results(): List<SearchResult> = listOf(
|
||||
Protocol.SEARCH_KIND_PIPELINE,
|
||||
Protocol.SEARCH_KIND_VERSION,
|
||||
Protocol.SEARCH_KIND_RUN,
|
||||
Protocol.SEARCH_KIND_STEP,
|
||||
Protocol.SEARCH_KIND_FIELD,
|
||||
Protocol.SEARCH_KIND_ARTIFACT,
|
||||
"future_kind",
|
||||
).map(::hit)
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import androidx.compose.runtime.saveable.SaverScope
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
class OmniSearchTest {
|
||||
|
||||
@Test
|
||||
fun restingPillIsClosedUnfocusedAndEmpty() {
|
||||
val state = OmniSearchState()
|
||||
assertFalse(state.open)
|
||||
assertFalse(state.focused)
|
||||
assertEquals("", state.query)
|
||||
// The named closed value is the same resting pill.
|
||||
assertEquals(OmniSearchState.Closed, state)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun openingRequestsTheFieldAndItsFocus() {
|
||||
val opened = openOmniSearch(OmniSearchState())
|
||||
assertTrue(opened.open)
|
||||
assertTrue("opening asks for focus so the keyboard is up", opened.focused)
|
||||
assertEquals("", opened.query)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun focusAndQueryUpdateWithoutClosing() {
|
||||
val typed = setOmniSearchQuery(openOmniSearch(OmniSearchState()), "release")
|
||||
assertEquals("release", typed.query)
|
||||
assertTrue(typed.open)
|
||||
|
||||
// Losing focus (for example the keyboard being dismissed) does not close
|
||||
// the field; it only records the focus change.
|
||||
val blurred = setOmniSearchFocus(typed, false)
|
||||
assertTrue(blurred.open)
|
||||
assertFalse(blurred.focused)
|
||||
assertEquals("release", blurred.query)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun dismissingRestoresTheRestingPillAndClearsTheText() {
|
||||
val open = setOmniSearchQuery(openOmniSearch(OmniSearchState()), "release")
|
||||
val dismissed = dismissOmniSearch(open)
|
||||
assertEquals(OmniSearchState.Closed, dismissed)
|
||||
assertFalse(dismissed.open)
|
||||
assertFalse(dismissed.focused)
|
||||
assertEquals("", dismissed.query)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun savedStateRoundTripsThroughTheSaver() {
|
||||
val scope = SaverScope { true }
|
||||
val cases = listOf(
|
||||
OmniSearchState(),
|
||||
OmniSearchState(open = true, focused = true, query = ""),
|
||||
OmniSearchState(open = true, focused = false, query = "acceptance check"),
|
||||
OmniSearchState(open = true, focused = true, query = "failed"),
|
||||
)
|
||||
cases.forEach { state ->
|
||||
val saved = with(OmniSearchStateSaver) { scope.save(state) }
|
||||
assertEquals(state, OmniSearchStateSaver.restore(saved!!))
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun encodedPayloadIsPrimitivesOnly() {
|
||||
val encoded = encodeOmniSearch(OmniSearchState(open = true, focused = true, query = "release"))
|
||||
assertEquals(listOf(true, true, "release"), encoded)
|
||||
assertEquals(
|
||||
OmniSearchState(open = true, focused = false, query = "release"),
|
||||
decodeOmniSearch(listOf(true, false, "release")),
|
||||
)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user