A code browser: files at any bookmark or tag, highlighted, the README rendered, history and changes (refs #3) 98dbd1220929

package io.oxygenhub.android.ui.code

import androidx.compose.foundation.clickable

import androidx.compose.foundation.horizontalScroll

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Box

import androidx.compose.foundation.layout.Row

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.rememberScrollState

import androidx.compose.material.icons.Icons

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

import androidx.compose.material.icons.outlined.AccountTree

import androidx.compose.material.icons.outlined.Folder

import androidx.compose.material.icons.outlined.History

import androidx.compose.material.icons.outlined.Link

import androidx.compose.material3.AssistChip

import androidx.compose.material3.DropdownMenu

import androidx.compose.material3.DropdownMenuItem

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.Text

import androidx.compose.material3.TextButton

import androidx.compose.runtime.Composable

import androidx.compose.runtime.getValue

import androidx.compose.runtime.mutableStateOf

import androidx.compose.runtime.remember

import androidx.compose.runtime.setValue

import androidx.compose.ui.Alignment

import androidx.compose.ui.Modifier

import androidx.compose.ui.unit.dp

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import com.mikepenz.markdown.m3.Markdown

import io.oxygenhub.android.api.TreeEntry

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

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

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

/**

 * A repository's code (#3): where you are (the reference, then each folder

 * of the path, tappable), the folder's entries, and its README rendered.

 */

@Composable

fun CodeBrowser(

    vm: CodeViewModel,

    onOpenFile: (ref: String, path: String) -> Unit,

    onOpenHistory: (ref: String) -> Unit,

) {

    val state by vm.state.collectAsStateWithLifecycle()

    val ref by vm.ref.collectAsStateWithLifecycle()

    val path by vm.path.collectAsStateWithLifecycle()

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

        LazyColumn(Modifier.fillMaxWidth()) {

            item {

                Where(vm, ref, path, onOpenHistory)

                HorizontalDivider()

            }

            if (path.isNotEmpty()) {

                item {

                    ListItem(

                        modifier = Modifier.clickable { vm.up() },

                        leadingContent = { Icon(Icons.Outlined.Folder, contentDescription = null) },

                        headlineContent = { Text("..") },

                    )

                }

            }

            if (dir.entries.isEmpty()) {

                item { EmptyState(Icons.Outlined.Folder, "Nothing here", "This folder is empty at $ref.") }

            }

            items(dir.entries, key = { it.path }) { e ->

                Entry(e) { if (e.isDir) vm.open(e.path) else onOpenFile(ref, e.path) }

            }

            dir.readme?.let { readme ->

                item {

                    ElevatedCard(Modifier.fillMaxWidth().padding(12.dp)) {

                        Text(

                            readme.path.substringAfterLast('/'),

                            style = MaterialTheme.typography.titleSmall,

                            modifier = Modifier.padding(start = 16.dp, top = 12.dp, end = 16.dp),

                        )

                        Box(Modifier.padding(16.dp)) {

                            if (readme.path.lowercase().let { it.endsWith(".md") || it.endsWith(".markdown") }) {

                                Markdown(readme.text)

                            } else {

                                Text(readme.text, style = MaterialTheme.typography.bodyMedium)

                            }

                        }

                    }

                }

            }

        }

    }

}

/** The reference (a menu of bookmarks and tags) and the path, each folder a step back. */

@Composable

private fun Where(vm: CodeViewModel, ref: String, path: String, onOpenHistory: (String) -> Unit) {

    var picking by remember { mutableStateOf(false) }

    val refs by vm.refs.collectAsStateWithLifecycle()

    Row(

        Modifier.fillMaxWidth().horizontalScroll(rememberScrollState()).padding(horizontal = 12.dp, vertical = 6.dp),

        verticalAlignment = Alignment.CenterVertically,

        horizontalArrangement = Arrangement.spacedBy(4.dp),

    ) {

        Box {

            AssistChip(

                onClick = {

                    vm.loadRefs()

                    picking = true

                },

                label = { Text(ref) },

                leadingIcon = { Icon(Icons.Outlined.AccountTree, contentDescription = "Bookmark or tag") },

            )

            DropdownMenu(expanded = picking, onDismissRequest = { picking = false }) {

                when (val r = refs) {

                    is Load.Ready -> {

                        r.value.first.forEach { b ->

                            DropdownMenuItem(text = { Text(b) }, onClick = {

                                picking = false

                                vm.setRef(b)

                            })

                        }

                        r.value.second.forEach { t ->

                            DropdownMenuItem(

                                text = { Text(t) },

                                leadingIcon = { Icon(Icons.Outlined.Link, contentDescription = "Tag") },

                                onClick = {

                                    picking = false

                                    vm.setRef(t)

                                },

                            )

                        }

                    }

                    is Load.Failed -> DropdownMenuItem(text = { Text(r.message) }, onClick = { picking = false })

                    Load.Loading -> DropdownMenuItem(text = { Text("Loading…") }, onClick = {})

                }

            }

        }

        TextButton(onClick = { vm.open("") }) { Text(vm.name) }

        val parts = path.split('/').filter { it.isNotEmpty() }

        parts.forEachIndexed { i, part ->

            Text("/", color = MaterialTheme.colorScheme.onSurfaceVariant)

            TextButton(onClick = { vm.open(parts.take(i + 1).joinToString("/")) }) { Text(part) }

        }

        TextButton(onClick = { onOpenHistory(ref) }) {

            Icon(Icons.Outlined.History, contentDescription = null)

            Text(" History")

        }

    }

}

@Composable

private fun Entry(e: TreeEntry, onClick: () -> Unit) {

    ListItem(

        modifier = Modifier.clickable(onClick = onClick),

        leadingContent = {

            Icon(

                if (e.isDir) Icons.Outlined.Folder else Icons.AutoMirrored.Outlined.InsertDriveFile,

                contentDescription = if (e.isDir) "Folder" else "File",

                tint = if (e.isDir) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant,

            )

        },

        headlineContent = { Text(e.name) },

        supportingContent = when {

            e.conflicted -> {

                { Text("conflicted", color = MaterialTheme.colorScheme.error) }

            }

            e.kind == "subrepo" -> {

                { Text("subrepo") }

            }

            else -> null

        },

        trailingContent = e.size?.takeIf { !e.isDir }?.let { { Text(bytes(it), style = MaterialTheme.typography.labelSmall) } },

    )

}

/** 1.2 KB, 3.4 MB. */

fun bytes(n: Long): String = when {

    n < 1024 -> "$n B"

    n < 1024 * 1024 -> "%.1f KB".format(n / 1024.0)

    else -> "%.1f MB".format(n / (1024.0 * 1024.0))

}

package io.oxygenhub.android.ui.code

import androidx.compose.foundation.clickable

import androidx.compose.foundation.horizontalScroll

import androidx.compose.foundation.isSystemInDarkTheme

import androidx.compose.foundation.layout.Arrangement

import androidx.compose.foundation.layout.Box

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.width

import androidx.compose.foundation.lazy.LazyColumn

import androidx.compose.foundation.lazy.itemsIndexed

import androidx.compose.foundation.lazy.items

import androidx.compose.foundation.rememberScrollState

import androidx.compose.foundation.text.selection.SelectionContainer

import androidx.compose.material.icons.Icons

import androidx.compose.material.icons.outlined.History

import androidx.compose.material3.FilterChip

import androidx.compose.material3.HorizontalDivider

import androidx.compose.material3.Icon

import androidx.compose.material3.IconButton

import androidx.compose.material3.ListItem

import androidx.compose.material3.MaterialTheme

import androidx.compose.material3.Text

import androidx.compose.material3.TextButton

import androidx.compose.runtime.Composable

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.Modifier

import androidx.compose.ui.text.font.FontFamily

import androidx.compose.ui.text.style.TextAlign

import androidx.compose.ui.unit.dp

import androidx.lifecycle.compose.collectAsStateWithLifecycle

import com.mikepenz.markdown.m3.Markdown

import io.oxygenhub.android.api.ChangeSummary

import io.oxygenhub.android.api.FileChange

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

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

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

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

/** A file at a reference: highlighted with line numbers, or rendered when it is Markdown. */

@Composable

fun FileScreen(vm: FileViewModel, onBack: () -> Unit, onOpenHistory: () -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

    var rendered by rememberSaveable { mutableStateOf(vm.isMarkdown) }

    AppScreen(

        title = vm.path.substringAfterLast('/'),

        subtitle = "${vm.owner}/${vm.name} · ${vm.ref.take(24)} · ${vm.path}",

        onBack = onBack,

        actions = {

            IconButton(onClick = onOpenHistory) { Icon(Icons.Outlined.History, contentDescription = "This file's history") }

        },

    ) {

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

            Column {

                if (vm.isMarkdown) {

                    Row(Modifier.padding(horizontal = 12.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {

                        FilterChip(selected = rendered, onClick = { rendered = true }, label = { Text("Rendered") })

                        FilterChip(selected = !rendered, onClick = { rendered = false }, label = { Text("Source") })

                    }

                }

                if (vm.isMarkdown && rendered) {

                    LazyColumn { item { Box(Modifier.padding(16.dp)) { Markdown(text) } } }

                } else {

                    CodeView(text, vm.path)

                }

            }

        }

    }

}

/** Lines with their numbers, highlighted, scrolling sideways together. */

@Composable

fun CodeView(text: String, path: String) {

    val dark = isSystemInDarkTheme()

    val lines = remember(text, path, dark) { highlightLines(text.trimEnd('\n'), path, dark) }

    val numbers = lines.size.toString().length

    val sideways = rememberScrollState()

    SelectionContainer {

        LazyColumn(Modifier.fillMaxWidth().horizontalScroll(sideways)) {

            itemsIndexed(lines) { i, line ->

                Row {

                    Text(

                        (i + 1).toString(),

                        modifier = Modifier.width((numbers * 9 + 16).dp).padding(end = 8.dp),

                        textAlign = TextAlign.End,

                        fontFamily = FontFamily.Monospace,

                        style = MaterialTheme.typography.bodySmall,

                        color = MaterialTheme.colorScheme.outline,

                    )

                    Text(line, fontFamily = FontFamily.Monospace, style = MaterialTheme.typography.bodySmall, softWrap = false)

                }

            }

        }

    }

}

/** A reference's history, or a file's, newest first. */

@Composable

fun HistoryScreen(vm: HistoryViewModel, onBack: () -> Unit, onOpenChange: (ChangeSummary) -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

    AppScreen(title = "History", subtitle = listOfNotNull("${vm.owner}/${vm.name}", vm.ref.take(24), vm.path).joinToString(" · "), onBack = onBack) {

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

            LazyColumn {

                items(page.changes, key = { it.hash }) { c -> ChangeRow(c) { onOpenChange(c) } }

                if (page.hasMore) {

                    item {

                        TextButton(onClick = vm::more, enabled = !page.loadingMore, modifier = Modifier.fillMaxWidth()) {

                            Text(if (page.loadingMore) "Loading…" else page.moreFailed ?: "Older changes (${page.total - page.changes.size} more)")

                        }

                    }

                }

            }

        }

    }

}

@Composable

private fun ChangeRow(c: ChangeSummary, onClick: () -> Unit) {

    ListItem(

        modifier = Modifier.clickable(onClick = onClick),

        headlineContent = { Text(c.subject.ifEmpty { "(no message)" }, maxLines = 2) },

        supportingContent = { Text("${c.author.account ?: c.author.name} · ${relativeTime(c.whenMs)}") },

        trailingContent = { Text(c.short.take(8), fontFamily = FontFamily.Monospace, style = MaterialTheme.typography.labelSmall) },

    )

    HorizontalDivider()

}

/** One change: its message, where it is, and the files it touched, each opening at the change. */

@Composable

fun ChangeScreen(vm: ChangeViewModel, onBack: () -> Unit, onOpenFile: (path: String) -> Unit) {

    val state by vm.state.collectAsStateWithLifecycle()

    val status = LocalStatusColors.current

    AppScreen(title = vm.hash.take(12), subtitle = "${vm.owner}/${vm.name}", onBack = onBack) {

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

            LazyColumn {

                item {

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

                        Text(d.change.subject, style = MaterialTheme.typography.titleMedium)

                        Text(

                            "${d.change.author.account ?: d.change.author.name} · ${relativeTime(d.change.whenMs)}",

                            style = MaterialTheme.typography.bodySmall,

                            color = MaterialTheme.colorScheme.onSurfaceVariant,

                        )

                        val rest = d.change.message.lines().drop(1).joinToString("\n").trim()

                        if (rest.isNotEmpty()) Markdown(rest)

                        val where = d.inBookmarks.map { it } + d.inTags.map { "tag $it" }

                        if (where.isNotEmpty()) Text("In " + where.joinToString(", "), style = MaterialTheme.typography.bodySmall)

                    }

                    HorizontalDivider()

                }

                items(d.files, key = { it.path }) { f -> FileRow(f, status.ok, status.bad) { if (f.kind != "removed") onOpenFile(f.path) } }

            }

        }

    }

}

@Composable

private fun FileRow(f: FileChange, added: androidx.compose.ui.graphics.Color, removed: androidx.compose.ui.graphics.Color, onClick: () -> Unit) {

    ListItem(

        modifier = Modifier.clickable(onClick = onClick),

        headlineContent = { Text(f.path) },

        supportingContent = {

            Text(

                when (f.kind) {

                    "renamed" -> "renamed from ${f.from}"

                    else -> f.kind

                },

            )

        },

        trailingContent = {

            Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {

                Text("+${f.added}", color = added, style = MaterialTheme.typography.labelMedium)

                Text("−${f.removed}", color = removed, style = MaterialTheme.typography.labelMedium)

            }

        },

    )

}

package io.oxygenhub.android.ui.code

import androidx.lifecycle.ViewModel

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.TreeEntry

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

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

import kotlinx.coroutines.Job

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.StateFlow

import kotlinx.coroutines.flow.asStateFlow

/**

 * A repository's code (#3): a directory of its tree at a bookmark, tag or

 * change, folders first, and the directory's README to show below it.

 */

class CodeViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

    /** The bookmark to start at; the repository's default when not given. */

    defaultRef: String? = null,

) : ViewModel() {

    /** What a directory holds, and its README's text when it has one. */

    data class Dir(val ref: String, val path: String, val entries: List<TreeEntry>, val readme: Readme?)

    data class Readme(val path: String, val text: String)

    private val _ref = MutableStateFlow(defaultRef.orEmpty())

    val ref: StateFlow<String> = _ref.asStateFlow()

    private val _path = MutableStateFlow("")

    val path: StateFlow<String> = _path.asStateFlow()

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

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

    /** The bookmarks and tags to browse at, fetched once the picker opens. */

    private val _refs = MutableStateFlow<Load<Pair<List<String>, List<String>>>>(Load.Loading)

    val refs: StateFlow<Load<Pair<List<String>, List<String>>>> = _refs.asStateFlow()

    private var job: Job? = null

    private var refsJob: Job? = null

    init {

        refresh()

    }

    fun open(path: String) {

        if (path == _path.value) return

        _path.value = path

        _state.value = Load.Loading

        refresh()

    }

    /** One directory up; false at the top. */

    fun up(): Boolean {

        val p = _path.value

        if (p.isEmpty()) return false

        open(p.substringBeforeLast('/', ""))

        return true

    }

    fun setRef(ref: String) {

        if (ref == _ref.value) return

        _ref.value = ref

        _state.value = Load.Loading

        refresh()

    }

    fun loadRefs() {

        if (_refs.value is Load.Ready) return

        refsJob = load(_refs, refsJob) { api.refs(owner, name) }

    }

    fun refresh() {

        val path = _path.value

        job = load(_state, job) {

            val ref = _ref.value.ifEmpty { api.repository(owner, name).defaultBookmark.also { _ref.value = it } }

            val entries = order(api.tree(owner, name, ref, path))

            val readme = readmeOf(entries)?.let { e ->

                // A README that will not load is left out, not an error.

                runCatching { Readme(e.path, api.file(owner, name, ref, e.path)) }.getOrNull()

            }

            Dir(ref, path, entries, readme)

        }

    }

    companion object {

        /** Folders first, then files, each by name as a person reads them. */

        fun order(entries: List<TreeEntry>): List<TreeEntry> =

            entries.sortedWith(compareBy<TreeEntry> { !it.isDir }.thenBy(String.CASE_INSENSITIVE_ORDER) { it.name })

        /** The README a directory shows: Markdown first. */

        fun readmeOf(entries: List<TreeEntry>): TreeEntry? {

            val files = entries.filter { !it.isDir }

            return listOf("README.md", "readme.md", "README.markdown", "README", "README.txt")

                .firstNotNullOfOrNull { n -> files.firstOrNull { it.name.equals(n, ignoreCase = false) } }

                ?: files.firstOrNull { it.name.lowercase().startsWith("readme") }

        }

    }

}

/** A file at a reference: its text, to show highlighted, or rendered when it is Markdown. */

class FileViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

    val ref: String,

    val path: String,

) : ViewModel() {

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

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

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) { api.file(owner, name, ref, path) }

    }

    val isMarkdown: Boolean get() = path.lowercase().let { it.endsWith(".md") || it.endsWith(".markdown") }

}

package io.oxygenhub.android.ui.code

import androidx.compose.ui.graphics.Color

import androidx.compose.ui.text.AnnotatedString

import androidx.compose.ui.text.SpanStyle

import androidx.compose.ui.text.font.FontWeight

import dev.snipme.highlights.Highlights

import dev.snipme.highlights.model.BoldHighlight

import dev.snipme.highlights.model.ColorHighlight

import dev.snipme.highlights.model.SyntaxLanguage

import dev.snipme.highlights.model.SyntaxThemes

/** The language to highlight a file as, from its name; plain text when unknown. */

fun languageOf(path: String): SyntaxLanguage {

    val name = path.substringAfterLast('/').lowercase()

    return when (name.substringAfterLast('.', "")) {

        "rs" -> SyntaxLanguage.RUST

        "kt", "kts" -> SyntaxLanguage.KOTLIN

        "java" -> SyntaxLanguage.JAVA

        "js", "mjs", "cjs", "jsx" -> SyntaxLanguage.JAVASCRIPT

        "ts", "tsx" -> SyntaxLanguage.TYPESCRIPT

        "py" -> SyntaxLanguage.PYTHON

        "sh", "bash", "zsh" -> SyntaxLanguage.SHELL

        "c", "h" -> SyntaxLanguage.C

        "cc", "cpp", "cxx", "hpp", "hh" -> SyntaxLanguage.CPP

        "go" -> SyntaxLanguage.GO

        "rb" -> SyntaxLanguage.RUBY

        "swift" -> SyntaxLanguage.SWIFT

        "dart" -> SyntaxLanguage.DART

        "cs" -> SyntaxLanguage.CSHARP

        "php" -> SyntaxLanguage.PHP

        "pl", "pm" -> SyntaxLanguage.PERL

        else -> if (name == "makefile" || name == "dockerfile") SyntaxLanguage.SHELL else SyntaxLanguage.DEFAULT

    }

}

/**

 * [code] highlighted for [path], one AnnotatedString per line, so a long

 * file is laid out a line at a time. Plain lines when the language is not

 * known or the file is too long to highlight quickly.

 */

fun highlightLines(code: String, path: String, dark: Boolean): List<AnnotatedString> {

    val lines = code.split('\n')

    val language = languageOf(path)

    if (language == SyntaxLanguage.DEFAULT || code.length > MAX_HIGHLIGHT) return lines.map { AnnotatedString(it) }

    val whole = AnnotatedString.Builder(code)

    val spans = runCatching {

        Highlights.Builder().code(code).language(language).theme(SyntaxThemes.default(dark)).build().getHighlights()

    }.getOrDefault(emptyList())

    for (h in spans) {

        val (start, end) = h.location.start to h.location.end

        if (start < 0 || end > code.length || start >= end) continue

        when (h) {

            is ColorHighlight -> whole.addStyle(SpanStyle(color = Color(0xFF000000.toInt() or h.rgb)), start, end)

            is BoldHighlight -> whole.addStyle(SpanStyle(fontWeight = FontWeight.Bold), start, end)

        }

    }

    val text = whole.toAnnotatedString()

    var at = 0

    return lines.map { line ->

        val piece = text.subSequence(at, at + line.length)

        at += line.length + 1

        piece

    }

}

/** Beyond this many characters a file is shown plain: highlighting it would stall the screen. */

const val MAX_HIGHLIGHT = 200_000

package io.oxygenhub.android.ui.code

import androidx.lifecycle.ViewModel

import androidx.lifecycle.viewModelScope

import io.oxygenhub.android.api.ChangeDetail

import io.oxygenhub.android.api.ChangeSummary

import io.oxygenhub.android.api.HubApi

import io.oxygenhub.android.api.userMessage

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

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

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 reference's history, or a file's, newest first, a page at a time (#3). */

class HistoryViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

    val ref: String,

    /** Only the changes to this path, when given. */

    val path: String?,

) : ViewModel() {

    /** The changes so far, and how many there are in all. */

    data class Page(val changes: List<ChangeSummary>, val total: Int, val loadingMore: Boolean = false, val moreFailed: String? = null) {

        val hasMore: Boolean get() = changes.size < total

    }

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

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

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) { api.history(owner, name, ref, path, 0, PAGE).let { Page(it.changes, it.total) } }

    }

    /** The next page, added at the end. */

    fun more() {

        val page = (_state.value as? Load.Ready)?.value ?: return

        if (page.loadingMore || !page.hasMore) return

        _state.value = Load.Ready(page.copy(loadingMore = true, moreFailed = null))

        viewModelScope.launch {

            _state.value = try {

                val next = api.history(owner, name, ref, path, page.changes.size, PAGE)

                Load.Ready(Page(page.changes + next.changes, next.total))

            } catch (e: CancellationException) {

                throw e

            } catch (e: Exception) {

                Load.Ready(page.copy(loadingMore = false, moreFailed = e.userMessage()))

            }

        }

    }

    companion object {

        const val PAGE = 50

    }

}

/** One change: its message, where it is, and the files it touched. */

class ChangeViewModel(

    private val api: HubApi,

    val owner: String,

    val name: String,

    val hash: String,

) : ViewModel() {

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

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

    private var job: Job? = null

    init {

        refresh()

    }

    fun refresh() {

        job = load(_state, job) { api.change(owner, name, hash) }

    }

}

package io.oxygenhub.android.ui

import io.oxygenhub.android.FakeHubApi

import io.oxygenhub.android.MainDispatcherRule

import io.oxygenhub.android.api.ChangeSummary

import io.oxygenhub.android.api.History

import io.oxygenhub.android.api.TreeEntry

import io.oxygenhub.android.ui.code.CodeViewModel

import io.oxygenhub.android.ui.code.HistoryViewModel

import io.oxygenhub.android.ui.code.languageOf

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

import dev.snipme.highlights.model.SyntaxLanguage

import org.junit.Assert.assertEquals

import org.junit.Assert.assertFalse

import org.junit.Assert.assertNull

import org.junit.Assert.assertTrue

import org.junit.Rule

import org.junit.Test

class CodeBrowserTest {

    @get:Rule val main = MainDispatcherRule()

    private val api = FakeHubApi()

    private fun <T> ready(load: Load<T>): T = (load as Load.Ready).value

    private val top = listOf(

        TreeEntry("src", "src", "dir"),

        TreeEntry("README.md", "README.md", "file", size = 12),

        TreeEntry("Cargo.toml", "Cargo.toml", "file"),

        TreeEntry("assets", "assets", "dir"),

    )

    @Test

    fun startsAtTheDefaultBookmarkFoldersFirstWithTheReadme() {

        api.repository = api.repository.copy(defaultBookmark = "trunk")

        api.tree = { _, path -> if (path.isEmpty()) top else listOf(TreeEntry("main.rs", "src/main.rs")) }

        api.files = mapOf("README.md" to "# Demo")

        val vm = CodeViewModel(api, "andymccall", "demo")

        val dir = ready(vm.state.value)

        assertEquals("trunk", vm.ref.value)

        assertEquals(listOf("assets", "src", "Cargo.toml", "README.md"), dir.entries.map { it.name })

        assertEquals("# Demo", dir.readme?.text)

        assertTrue("tree trunk:" in api.calls)

        vm.open("src")

        assertEquals(listOf("main.rs"), ready(vm.state.value).entries.map { it.name })

        assertNull("no README here", ready(vm.state.value).readme)

        assertTrue(vm.up())

        assertEquals("", vm.path.value)

        assertFalse("already at the top", vm.up())

    }

    @Test

    fun aReadmeThatWillNotLoadIsLeftOut() {

        api.tree = { _, _ -> top }

        val dir = ready(CodeViewModel(api, "andymccall", "demo", "main").state.value)

        assertNull(dir.readme)

        assertEquals(4, dir.entries.size)

    }

    @Test

    fun anotherBookmarkOrTagIsBrowsedFromItsTop() {

        api.tree = { ref, _ -> if (ref == "v1.0") listOf(TreeEntry("OLD", "OLD")) else top }

        api.refs = listOf("main", "develop") to listOf("v1.0")

        val vm = CodeViewModel(api, "andymccall", "demo", "main")

        vm.loadRefs()

        assertEquals(listOf("main", "develop") to listOf("v1.0"), ready(vm.refs.value))

        vm.setRef("v1.0")

        assertEquals(listOf("OLD"), ready(vm.state.value).entries.map { it.name })

    }

    @Test

    fun historyComesAPageAtATime() {

        val c = { n: Int -> ChangeSummary("%064x".format(n), "change $n\n\nbody") }

        api.history = History("main", total = 3, changes = listOf(c(1), c(2)))

        val vm = HistoryViewModel(api, "andymccall", "demo", "main", "src/main.rs")

        assertEquals(listOf("change 1", "change 2"), ready(vm.state.value).changes.map { it.subject })

        assertTrue(ready(vm.state.value).hasMore)

        assertTrue("history main:src/main.rs" in api.calls)

        api.history = History("main", total = 3, offset = 2, changes = listOf(c(3)))

        vm.more()

        assertEquals(3, ready(vm.state.value).changes.size)

        assertFalse(ready(vm.state.value).hasMore)

    }

    @Test

    fun filesAreHighlightedByTheirNames() {

        assertEquals(SyntaxLanguage.RUST, languageOf("crates/hub/src/main.rs"))

        assertEquals(SyntaxLanguage.KOTLIN, languageOf("app/build.gradle.kts"))

        assertEquals(SyntaxLanguage.SHELL, languageOf("Makefile"))

        assertEquals(SyntaxLanguage.DEFAULT, languageOf("pipeline.kdl"))

    }

}

    implementation(libs.markdown.renderer.m3)

    implementation(libs.highlights)

    /** One repository (`GET /repos/{owner}/{name}`): its default bookmark, for the code browser. */

    suspend fun repository(owner: String, name: String): Repository

    /** A directory of the tree at [ref] (a bookmark, tag or change), [path] "" for the top. */

    suspend fun tree(owner: String, name: String, ref: String, path: String = ""): List<TreeEntry>

    /** A file's bytes at [ref], as text. */

    suspend fun file(owner: String, name: String, ref: String, path: String): String

    /** [ref]'s history, newest first; only changes to [path] when given. */

    suspend fun history(owner: String, name: String, ref: String, path: String? = null, offset: Int = 0, limit: Int = 50): History

    suspend fun change(owner: String, name: String, hash: String): ChangeDetail

    /** The repository's bookmarks and tags, to browse at. */

    suspend fun refs(owner: String, name: String): Pair<List<String>, List<String>>

    override suspend fun repository(owner: String, name: String): Repository = get(url("repos", owner, name), Repository.serializer())

    private fun parts(path: String): Array<String> = path.split('/').filter { it.isNotEmpty() }.toTypedArray()

    override suspend fun tree(owner: String, name: String, ref: String, path: String): List<TreeEntry> =

        get(url("repos", owner, name, "tree", ref, *parts(path)), ListSerializer(TreeEntry.serializer()))

    override suspend fun file(owner: String, name: String, ref: String, path: String): String =

        call(request(url("repos", owner, name, "file", ref, *parts(path))).get().build(), notifyUnauthorized = true)

    override suspend fun history(owner: String, name: String, ref: String, path: String?, offset: Int, limit: Int): History =

        get(

            url("repos", owner, name, "history", ref) {

                path?.let { addQueryParameter("path", it) }

                addQueryParameter("offset", offset.toString())

                addQueryParameter("limit", limit.toString())

            },

            History.serializer(),

        )

    override suspend fun change(owner: String, name: String, hash: String): ChangeDetail =

        get(url("repos", owner, name, "changes", hash), ChangeDetail.serializer())

    override suspend fun refs(owner: String, name: String): Pair<List<String>, List<String>> {

        val bookmarks = get(url("repos", owner, name, "bookmarks"), ListSerializer(NamedRef.serializer())).map { it.name }

        val tags = get(url("repos", owner, name, "tags"), ListSerializer(NamedRef.serializer())).map { it.name }

        return bookmarks to tags

    }

/** A file or directory of a repository's tree at some reference (the code browser, #3). */

@Serializable

data class TreeEntry(

    val name: String,

    val path: String,

    /** `file`, `dir`, `symlink` or `subrepo`. */

    val kind: String = "file",

    val exec: Boolean = false,

    val size: Long? = null,

    val conflicted: Boolean = false,

) {

    val isDir: Boolean get() = kind == "dir"

}

/** Who made a change, as the hub knows them. */

@Serializable

data class ChangeAuthor(val name: String = "", val email: String = "", val account: String? = null)

/** A change in a history or a proposal. */

@Serializable

data class ChangeSummary(

    val hash: String,

    val message: String = "",

    val author: ChangeAuthor = ChangeAuthor(),

    @SerialName("when_ms") val whenMs: Long = 0,

) {

    val subject: String get() = message.lineSequence().firstOrNull().orEmpty()

    val short: String get() = hash.take(12)

}

/** A page of a reference's history (`GET …/history/{r}`), newest first. */

@Serializable

data class History(

    val reference: String = "",

    val total: Int = 0,

    val offset: Int = 0,

    val changes: List<ChangeSummary> = emptyList(),

)

/** A file a change touched, and how. */

@Serializable

data class FileChange(

    val path: String,

    /** `added`, `modified`, `removed` or `renamed`. */

    val kind: String = "modified",

    val from: String? = null,

    val added: Int = 0,

    val removed: Int = 0,

)

/** One change, whole (`GET …/changes/{hash}`). */

@Serializable

data class ChangeDetail(

    val change: ChangeSummary,

    val body: String = "",

    @SerialName("in_bookmarks") val inBookmarks: List<String> = emptyList(),

    @SerialName("in_tags") val inTags: List<String> = emptyList(),

    val files: List<FileChange> = emptyList(),

)

/** A bookmark or tag to browse at. */

@Serializable

data class NamedRef(val name: String)

import androidx.compose.runtime.rememberCoroutineScope

import io.oxygenhub.android.ui.code.ChangeScreen

import io.oxygenhub.android.ui.code.ChangeViewModel

import io.oxygenhub.android.ui.code.CodeViewModel

import io.oxygenhub.android.ui.code.FileScreen

import io.oxygenhub.android.ui.code.FileViewModel

import io.oxygenhub.android.ui.code.HistoryScreen

import io.oxygenhub.android.ui.code.HistoryViewModel

import io.oxygenhub.android.ui.proposals.ProposalScreen

import io.oxygenhub.android.ui.proposals.ProposalViewModel

import io.oxygenhub.android.ui.proposals.ProposalsViewModel

import io.oxygenhub.android.ui.repos.RepositoryScreen

import kotlin.reflect.KClass

import kotlinx.coroutines.launch

/** A file at a reference, a history (of a file when [path] is given), and a change (#3). */

@Serializable data class FileRoute(val owner: String, val name: String, val ref: String, val path: String)

@Serializable data class HistoryRoute(val owner: String, val name: String, val ref: String, val path: String? = null)

@Serializable data class ChangeRoute(val owner: String, val name: String, val hash: String)

                        rememberViewModel(key = "code:$slug") { CodeViewModel(api, owner, name) },

                        onOpenFile = { ref, path -> nav.navigate(FileRoute(owner, name, ref, path)) },

                        onOpenHistory = { ref -> nav.navigate(HistoryRoute(owner, name, ref)) },

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

                    onOpenFile = { ref, path -> nav.navigate(FileRoute(r.owner, r.name, ref, path)) },

                    onOpenHistory = { ref -> nav.navigate(HistoryRoute(r.owner, r.name, ref)) },

                )

            }

            composable<FileRoute> { e ->

                val r = e.toRoute<FileRoute>()

                FileScreen(

                    rememberViewModel { FileViewModel(api, r.owner, r.name, r.ref, r.path) },

                    onBack = { nav.popBackStack() },

                    onOpenHistory = { nav.navigate(HistoryRoute(r.owner, r.name, r.ref, r.path)) },

                )

            }

            composable<HistoryRoute> { e ->

                val r = e.toRoute<HistoryRoute>()

                HistoryScreen(

                    rememberViewModel { HistoryViewModel(api, r.owner, r.name, r.ref, r.path) },

                    onBack = { nav.popBackStack() },

                    onOpenChange = { nav.navigate(ChangeRoute(r.owner, r.name, it.hash)) },

                )

            }

            composable<ChangeRoute> { e ->

                val r = e.toRoute<ChangeRoute>()

                ChangeScreen(

                    rememberViewModel { ChangeViewModel(api, r.owner, r.name, r.hash) },

                    onBack = { nav.popBackStack() },

                    onOpenFile = { path -> nav.navigate(FileRoute(r.owner, r.name, r.hash, path)) },

import io.oxygenhub.android.ui.code.CodeBrowser

import io.oxygenhub.android.ui.code.CodeViewModel

/** A repository's tabs: its code, its issues and its proposals (#3). */

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

    code: CodeViewModel,

    onOpenFile: (ref: String, path: String) -> Unit,

    onOpenHistory: (ref: String) -> Unit,

    initialTab: RepositoryTab = RepositoryTab.Code,

                RepositoryTab.Code -> CodeBrowser(code, onOpenFile, onOpenHistory)

    var repository: io.oxygenhub.android.api.Repository = io.oxygenhub.android.api.Repository("andymccall", "demo", defaultBookmark = "main")

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

    var tree: (String, String) -> List<io.oxygenhub.android.api.TreeEntry> = { _, _ -> emptyList() }

    override suspend fun tree(owner: String, name: String, ref: String, path: String) =

        tree.invoke(ref, path).also { calls += "tree $ref:$path" }

    var files: Map<String, String> = emptyMap()

    override suspend fun file(owner: String, name: String, ref: String, path: String): String {

        calls += "file $ref:$path"

        return files[path] ?: throw io.oxygenhub.android.api.HubException.Http(404, "no such file")

    }

    var history: io.oxygenhub.android.api.History = io.oxygenhub.android.api.History()

    override suspend fun history(owner: String, name: String, ref: String, path: String?, offset: Int, limit: Int) =

        history.also { calls += "history $ref:${path.orEmpty()}" }

    var change: (String) -> io.oxygenhub.android.api.ChangeDetail = { error("no change") }

    override suspend fun change(owner: String, name: String, hash: String) = change.invoke(hash).also { calls += "change $hash" }

    var refs: Pair<List<String>, List<String>> = listOf("main") to emptyList()

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

# The code browser (#3): Markdown rendered in Compose, and syntax highlighting.

markdownRenderer = "0.38.1"

highlights = "1.1.0"

markdown-renderer-m3 = { group = "com.mikepenz", name = "multiplatform-markdown-renderer-m3", version.ref = "markdownRenderer" }

highlights = { group = "dev.snipme", name = "highlights", version.ref = "highlights" }