Diffs on a change, natively 0414607973cb

- **Diffs on a change (#21):** each file a change touched shows its diff in the app: context, removed and added lines with their old and new numbers, tinted, long lines wrapped, gaps between hunks marked. A small change (up to five files, 400 lines) opens every diff; a larger one starts folded and a file's row opens it. The icon on the row still opens the file at the change. From the hub's change API (hub #320); an older hub sends no lines, and the row says so.

    /** The diff with three lines of context (hub #320), cut at 2000 lines. */

    val lines: List<DiffLine> = emptyList(),

    val truncated: Boolean = false,

/** A line of a file's diff: `context`, `add`, `del`, or `gap` for lines left out between hunks. */

@Serializable

data class DiffLine(

    val kind: String = "context",

    val old: Int? = null,

    val new: Int? = null,

    val text: String = "",

)

import androidx.compose.foundation.background

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

import androidx.compose.material.icons.outlined.ExpandLess

import androidx.compose.material.icons.outlined.ExpandMore

import androidx.compose.ui.graphics.Color

import io.oxygenhub.android.api.DiffLine

/** Files a change touched whose diffs open by default: all of them for a small change. */

fun openByDefault(files: List<FileChange>): Set<String> =

    if (files.size <= 5 && files.sumOf { it.lines.size } <= 400) files.map { it.path }.toSet() else emptySet()

/** One change: its message, where it is, and the files it touched, each with its diff and a way to the file at the change. */

            var open by rememberSaveable(d.change.hash) { mutableStateOf(openByDefault(d.files).toList()) }

                d.files.forEach { f ->

                    val expanded = f.path in open

                    item(key = f.path) {

                        FileRow(

                            f,

                            expanded,

                            status.ok,

                            status.bad,

                            onToggle = { open = if (expanded) open - f.path else open + f.path },

                            onOpen = if (f.kind != "removed") ({ onOpenFile(f.path) }) else null,

                        )

                    }

                    if (expanded) {

                        val numbers = f.lines.maxOfOrNull { maxOf(it.old ?: 0, it.new ?: 0) }?.toString()?.length ?: 1

                        itemsIndexed(f.lines, key = { i, _ -> "${f.path}\u0000$i" }) { _, l -> DiffRow(l, numbers, status.ok, status.bad) }

                        if (f.lines.isEmpty() || f.truncated) {

                            item(key = "${f.path}\u0000end") {

                                Text(

                                    if (f.truncated) "The diff goes on; open the file to see it whole." else "No lines changed (${f.kind}).",

                                    modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),

                                    style = MaterialTheme.typography.bodySmall,

                                    color = MaterialTheme.colorScheme.onSurfaceVariant,

                                )

                            }

                        }

                        item(key = "${f.path}\u0000rule") { HorizontalDivider() }

                    }

                }

private fun FileRow(

    f: FileChange,

    expanded: Boolean,

    added: Color,

    removed: Color,

    onToggle: () -> Unit,

    onOpen: (() -> Unit)?,

) {

        modifier = Modifier.clickable(onClick = onToggle),

        leadingContent = {

            Icon(

                if (expanded) Icons.Outlined.ExpandLess else Icons.Outlined.ExpandMore,

                contentDescription = if (expanded) "Hide the diff" else "Show the diff",

            )

        },

                Text(if (f.kind == "renamed") "renamed from ${f.from}" else f.kind)

                Text("+${f.added}", color = added)

                Text("−${f.removed}", color = removed)

        },

        trailingContent = onOpen?.let { open ->

            { IconButton(onClick = open) { Icon(Icons.AutoMirrored.Outlined.OpenInNew, contentDescription = "The file at this change") } }

}

/** A diff line: old and new numbers, then the text on a tint of its kind; long lines wrap. */

@Composable

private fun DiffRow(l: DiffLine, numbers: Int, added: Color, removed: Color) {

    val tint = when (l.kind) {

        "add" -> added.copy(alpha = 0.14f)

        "del" -> removed.copy(alpha = 0.14f)

        "gap" -> MaterialTheme.colorScheme.surfaceVariant

        else -> Color.Transparent

    }

    val gutter = Modifier.width((numbers * 8 + 8).dp).padding(end = 4.dp)

    val small = MaterialTheme.typography.bodySmall

    Row(Modifier.fillMaxWidth().background(tint).padding(horizontal = 8.dp)) {

        if (l.kind == "gap") {

            Text("⋯", modifier = Modifier.padding(vertical = 2.dp), style = small, color = MaterialTheme.colorScheme.onSurfaceVariant)

            return@Row

        }

        Text(l.old?.toString() ?: "", gutter, textAlign = TextAlign.End, fontFamily = FontFamily.Monospace, style = small, color = MaterialTheme.colorScheme.outline)

        Text(l.new?.toString() ?: "", gutter, textAlign = TextAlign.End, fontFamily = FontFamily.Monospace, style = small, color = MaterialTheme.colorScheme.outline)

        Text(

            when (l.kind) {

                "add" -> "+"

                "del" -> "−"

                else -> " "

            },

            Modifier.width(12.dp),

            fontFamily = FontFamily.Monospace,

            style = small,

            color = if (l.kind == "add") added else if (l.kind == "del") removed else MaterialTheme.colorScheme.outline,

        )

        Text(l.text, Modifier.weight(1f), fontFamily = FontFamily.Monospace, style = small)

    }

import io.oxygenhub.android.api.ChangeDetail

import io.oxygenhub.android.api.FileChange

import io.oxygenhub.android.api.HubJson

import io.oxygenhub.android.ui.code.openByDefault

    @Test

    fun aChangeCarriesItsDiffAndSmallOnesOpen() {

        val json = """{"change":{"hash":"ab","message":"grow a"},"files":[{"path":"a.txt","kind":"modified","added":1,"removed":1,

            "lines":[{"kind":"context","old":1,"new":1,"text":"a"},{"kind":"del","old":2,"text":"b"},{"kind":"add","new":2,"text":"c"},{"kind":"gap"}]}]}"""

        val d = HubJson.decodeFromString(ChangeDetail.serializer(), json)

        val f = d.files.single()

        assertEquals(listOf("context", "del", "add", "gap"), f.lines.map { it.kind })

        assertEquals(2 to null, f.lines[1].old to f.lines[1].new)

        assertFalse(f.truncated)

        assertEquals(setOf("a.txt"), openByDefault(d.files))

        val many = (1..6).map { FileChange("f$it") }

        assertTrue("a change of many files starts folded", openByDefault(many).isEmpty())

        val old = HubJson.decodeFromString(ChangeDetail.serializer(), """{"change":{"hash":"ab"},"files":[{"path":"a.txt"}]}""")

        assertTrue("a hub before #320 sends no lines", old.files.single().lines.isEmpty())

    }