Releases and search on the phone (refs #3) dfbc3e972872

package io.oxygenhub.android.ui.releases

import androidx.compose.foundation.clickable

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Column

import androidx.compose.foundation.layout.fillMaxSize

import androidx.compose.foundation.layout.fillMaxWidth

import androidx.compose.foundation.layout.padding

import androidx.compose.foundation.lazy.LazyColumn

import androidx.compose.foundation.lazy.items

import androidx.compose.foundation.text.KeyboardActions

import androidx.compose.foundation.text.KeyboardOptions

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.outlined.Download

import androidx.compose.material.icons.outlined.NewReleases

import androidx.compose.material.icons.outlined.Search

import androidx.compose.material3.ElevatedCard

import androidx.compose.material3.HorizontalDivider

import androidx.compose.material3.Icon

import androidx.compose.material3.ListItem

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.OutlinedTextField

import androidx.compose.material3.Text

import androidx.compose.runtime.Composable

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.saveable.rememberSaveable

import androidx.compose.runtime.setValue

import androidx.compose.ui.Modifier

import androidx.compose.ui.platform.LocalUriHandler

import androidx.compose.ui.text.input.ImeAction

import androidx.compose.ui.unit.dp

import androidx.lifecycle.ViewModel

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import androidx.lifecycle.viewModelScope

import com.mikepenz.markdown.m3.Markdown

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.Release

import io.oxygenhub.android.api.SearchHit

import io.oxygenhub.android.ui.code.bytes

import io.oxygenhub.android.ui.common.AppScreen

import io.oxygenhub.android.ui.common.EmptyState

import io.oxygenhub.android.ui.common.Load

import io.oxygenhub.android.ui.common.LoadContent

import io.oxygenhub.android.ui.common.load

import io.oxygenhub.android.ui.common.relativeTime

import kotlinx.coroutines.CancellationException

import kotlinx.coroutines.Job

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

import kotlinx.coroutines.launch

/** A repository's releases, newest first. */

class ReleasesViewModel(private val api: HubApi, val owner: String, val name: String) : ViewModel() {

    private val _state = MutableStateFlow<Load<List<Release>>>(Load.Loading)

    val state: StateFlow<Load<List<Release>>> = _state.asStateFlow()

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) { api.releases(owner, name).sortedByDescending { it.createdMs } }

    }

}

/** Issues and proposals found across the account's repositories. */

class SearchViewModel(private val api: HubApi) : ViewModel() {

    private val _state = MutableStateFlow<Load<List<SearchHit>>?>(null)

    /** Null before the first search. */

    val state: StateFlow<Load<List<SearchHit>>?> = _state.asStateFlow()

    private var job: Job? = null

    fun search(query: String) {

        val q = query.trim()

        if (q.isEmpty()) return

        job?.cancel()

        _state.value = Load.Loading

        job = viewModelScope.launch {

            _state.value = try {

                Load.Ready(api.search(q))

            } catch (e: CancellationException) {

                throw e

            } catch (e: Exception) {

                Load.failed(e)

            }

        }

    }

}

/** The releases tab: each release's notes rendered and its files to download. */

@Composable

fun ReleaseList(vm: ReleasesViewModel) {

    val state by vm.state.collectAsStateWithLifecycle()

    val uri = LocalUriHandler.current

    LoadContent(state, onRefresh = vm::refresh) { releases ->

        if (releases.isEmpty()) {

            EmptyState(Icons.Outlined.NewReleases, "No releases", "Tagged releases of ${vm.owner}/${vm.name} show here.")

        } else {

            LazyColumn(Modifier.fillMaxSize(), verticalArrangement = Arrangement.spacedBy(8.dp)) {

                items(releases, key = { it.tag }) { r ->

                    ElevatedCard(Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 4.dp)) {

                        Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) {

                            Text(r.title.ifEmpty { r.tag }, style = MaterialTheme.typography.titleMedium)

                            Text(

                                listOfNotNull(

                                    r.tag,

                                    "latest".takeIf { r.latest },

                                    "pre-release".takeIf { r.prerelease },

                                    r.signer?.let { "signed by $it" },

                                    relativeTime(r.createdMs).takeIf { it.isNotEmpty() },

                                ).joinToString(" · "),

                                style = MaterialTheme.typography.labelMedium,

                                color = MaterialTheme.colorScheme.onSurfaceVariant,

                            )

                            if (r.notes.isNotBlank()) Markdown(r.notes)

                            r.assets.forEach { a ->

                                ListItem(

                                    modifier = Modifier.clickable { if (a.url.isNotBlank()) uri.openUri(a.url) },

                                    leadingContent = { Icon(Icons.Outlined.Download, contentDescription = "Download") },

                                    headlineContent = { Text(a.name) },

                                    supportingContent = { Text("${bytes(a.size)} · ${a.downloads} downloads") },

                                )

                            }

                        }

                    }

                }

            }

        }

    }

}

/** Search issues and proposals; a result opens on its own screen. */

@Composable

fun SearchScreen(vm: SearchViewModel, onBack: () -> Unit, onOpen: (SearchHit) -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

    var query by rememberSaveable { mutableStateOf("") }

    AppScreen(title = "Search", onBack = onBack) {

        Column(Modifier.fillMaxSize()) {

            OutlinedTextField(

                query,

                { query = it },

                label = { Text("Issues and proposals") },

                singleLine = true,

                leadingIcon = { Icon(Icons.Outlined.Search, contentDescription = null) },

                keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),

                keyboardActions = KeyboardActions(onSearch = { vm.search(query) }),

                modifier = Modifier.fillMaxWidth().padding(12.dp),

            )

            when (val s = state) {

                null -> EmptyState(Icons.Outlined.Search, "Search", "Words from titles, bodies and comments, in every repository you can read.")

                else -> LoadContent(s, onRefresh = { vm.search(query) }) { hits ->

                    if (hits.isEmpty()) {

                        EmptyState(Icons.Outlined.Search, "Nothing found", "No issue or proposal matches \"$query\".")

                    } else {

                        LazyColumn {

                            items(hits, key = { "${it.repository}#${it.number}" }) { h ->

                                ListItem(

                                    modifier = Modifier.clickable { onOpen(h) },

                                    overlineContent = { Text("${h.repository} · ${h.kind} #${h.number}") },

                                    headlineContent = { Text(h.title) },

                                    supportingContent = if (h.snippet.isNotBlank()) {

                                        { Text(h.snippet, maxLines = 2) }

                                    } else {

                                        null

                                    },

                                )

                                HorizontalDivider()

                            }

                        }

                    }

                }

            }

        }

    }

}

package io.oxygenhub.android.ui

import io.oxygenhub.android.FakeHubApi

import io.oxygenhub.android.MainDispatcherRule

import io.oxygenhub.android.api.HubException

import io.oxygenhub.android.api.Release

import io.oxygenhub.android.api.SearchHit

import io.oxygenhub.android.ui.common.Load

import io.oxygenhub.android.ui.releases.ReleasesViewModel

import io.oxygenhub.android.ui.releases.SearchViewModel

import org.junit.Assert.assertEquals

import org.junit.Assert.assertNull

import org.junit.Assert.assertTrue

import org.junit.Rule

import org.junit.Test

class ReleasesAndSearchTest {

    @get:Rule val main = MainDispatcherRule()

    private val api = FakeHubApi()

    @Test

    fun releasesNewestFirst() {

        api.releaseList = listOf(Release("v0.9.3", createdMs = 1), Release("v0.9.4", createdMs = 2))

        val tags = (ReleasesViewModel(api, "andymccall", "oxygenhub").state.value as Load.Ready).value.map { it.tag }

        assertEquals(listOf("v0.9.4", "v0.9.3"), tags)

    }

    @Test

    fun searchFindsIssuesAndProposalsAndSaysWhenItFails() {

        api.hits = { q -> if (q == "board") listOf(SearchHit("issue", "andymccall/oxygenhub", 293, "Boards that keep growing")) else throw HubException.Http(500, "down") }

        val vm = SearchViewModel(api)

        assertNull("nothing searched yet", vm.state.value)

        vm.search("   ")

        assertNull("a blank search is no search", vm.state.value)

        vm.search(" board ")

        val hits = (vm.state.value as Load.Ready).value

        assertEquals(listOf(293L), hits.map { it.number })

        assertEquals("andymccall" to "oxygenhub", hits[0].owner to hits[0].name)

        assertTrue("search board" in api.calls)

        vm.search("fails")

        assertTrue(vm.state.value is Load.Failed)

    }

}

    /** A repository's releases, newest first. */

    suspend fun releases(owner: String, name: String): List<Release>

    /** Issues and proposals matching [query], across the repositories the caller can read. */

    suspend fun search(query: String): List<SearchHit>

    override suspend fun releases(owner: String, name: String): List<Release> =

        get(url("repos", owner, name, "releases"), ListSerializer(Release.serializer()))

    override suspend fun search(query: String): List<SearchHit> =

        get(url("search") { addQueryParameter("q", query) }, ListSerializer(SearchHit.serializer()))

/** A release of a repository: its tag, notes and files. */

@Serializable

data class Release(

    val tag: String,

    val title: String = "",

    val notes: String = "",

    val prerelease: Boolean = false,

    val latest: Boolean = false,

    val author: String = "",

    val signer: String? = null,

    val assets: List<ReleaseAsset> = emptyList(),

    @SerialName("created_ms") val createdMs: Long = 0,

    val url: String = "",

)

@Serializable

data class ReleaseAsset(val name: String, val size: Long = 0, val hash: String = "", val downloads: Long = 0, val url: String = "")

/** An issue or proposal search found (`GET /search?q=`). */

@Serializable

data class SearchHit(

    /** `issue` or `proposal`. */

    val kind: String = "issue",

    val repository: String = "",

    val number: Long = 0,

    val title: String = "",

    val snippet: String = "",

) {

    val owner: String get() = repository.substringBefore('/')

    val name: String get() = repository.substringAfter('/')

}

import androidx.compose.material.icons.automirrored.outlined.CallMerge

import androidx.compose.material.icons.outlined.EditNote

import androidx.compose.material.icons.outlined.Search

import androidx.compose.material3.IconButton

import androidx.compose.ui.text.style.TextOverflow

import io.oxygenhub.android.api.ProposalBrief

import io.oxygenhub.android.ui.common.relativeTime

import io.oxygenhub.android.ui.theme.LocalStatusColors

    onSearch: (() -> Unit)? = null,

    AppScreen(

        title = "Dashboard",

        subtitle = hub.substringAfter("://"),

        actions = {

            if (onSearch != null) {

                IconButton(onClick = onSearch) { Icon(Icons.Outlined.Search, contentDescription = "Search issues and proposals") }

            }

        },

    ) {

import io.oxygenhub.android.ui.releases.ReleasesViewModel

import io.oxygenhub.android.ui.releases.SearchScreen

import io.oxygenhub.android.ui.releases.SearchViewModel

@Serializable data object SearchRoute

                    onSearch = { nav.navigate(SearchRoute) },

            }

            composable<SearchRoute> {

                SearchScreen(rememberViewModel { SearchViewModel(api) }, onBack = { nav.popBackStack() }) { h ->

                    nav.navigate(if (h.kind == "proposal") ProposalRoute(h.owner, h.name, h.number) else IssueRoute(h.owner, h.name, h.number))

                }

                        rememberViewModel(key = "releases:$slug") { ReleasesViewModel(api, owner, name) },

                    rememberViewModel { ReleasesViewModel(api, r.owner, r.name) },

import io.oxygenhub.android.ui.releases.ReleaseList

import io.oxygenhub.android.ui.releases.ReleasesViewModel

enum class RepositoryTab(val label: String) { Code("Code"), Issues("Issues"), Proposals("Proposals"), Runs("Runs"), Releases("Releases") }

    releases: ReleasesViewModel,

                RepositoryTab.Releases -> ReleaseList(releases)

    var releaseList: List<io.oxygenhub.android.api.Release> = emptyList()

    override suspend fun releases(owner: String, name: String) = releaseList.also { calls += "releases" }

    var hits: (String) -> List<io.oxygenhub.android.api.SearchHit> = { emptyList() }

    override suspend fun search(query: String) = hits(query).also { calls += "search $query" }