crates/hub/src/repos/view.rs at 76f262e1a666 · andymccall/oxygenhub

# 76f262e1a666 oxygenhub / crates / hub / src / repos / view.rs
32.3 KiB · Rust · last changed Milestone 0.3: proposals and review 1 month ago source blame history raw
//! Page-ready views of a repository, computed from `oxy-core` alone (hub
//! spec §1.4). Nothing here knows about HTTP or templates; every function
//! takes an open `Repo` and returns plain data.

use super::{RepoError, StateCache};
use oxy_core::hash::{ChangeHash, KeyId};
use oxy_core::objects::{Change, NodeKind};
use oxy_core::repo::{BlameLine, FileDiff, Repo, SignatureStatus};
use oxy_core::state::{FileContent, Snapshot};
use oxy_core::tree::TreeConflict;
use std::collections::{BTreeMap, BTreeSet, HashMap};

type Result<T> = std::result::Result<T, RepoError>;

fn fail(msg: impl Into<String>) -> RepoError {
    RepoError::Oxy(oxy_core::repo::RepoError::Msg(msg.into()))
}

// ------------------------------------------------------------------ refs

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RefKind {
    Bookmark,
    Tag,
    Change,
}

/// What a `{ref}` path segment resolved to.
#[derive(Clone, Debug)]
pub struct RefTarget {
    /// The name as given (bookmark, tag) or the full hash.
    pub label: String,
    pub kind: RefKind,
    pub heads: Vec<ChangeHash>,
}

/// Resolve a bookmark name, a tag name, or a change hash prefix.
pub fn resolve(repo: &Repo, cache: &StateCache, spec: &str) -> Result<RefTarget> {
    let view = repo.view()?;
    if let Some(heads) = view.bookmarks.get(spec).map(|st| repo.store().get_state(st).map(|s| s.heads)).transpose()? {
        return Ok(RefTarget { label: spec.into(), kind: RefKind::Bookmark, heads });
    }
    if let Some(heads) = repo.tag_heads(spec)? {
        return Ok(RefTarget { label: spec.into(), kind: RefKind::Tag, heads });
    }
    let hash = resolve_change(repo, cache, spec)?;
    Ok(RefTarget { label: hash.to_hex(), kind: RefKind::Change, heads: vec![hash] })
}

/// A change by full hash or unique hex prefix, searched over every
/// bookmark's state.
pub fn resolve_change(repo: &Repo, cache: &StateCache, spec: &str) -> Result<ChangeHash> {
    let spec = spec.trim_start_matches('#');
    if spec.len() < 4 || !spec.chars().all(|c| c.is_ascii_hexdigit()) {
        return Err(fail(format!("{spec:?} is not a change")));
    }
    if let Some(h) = ChangeHash::from_hex(spec) {
        if repo.store().has(&h) {
            return Ok(h);
        }
    }
    let heads = all_heads(repo)?;
    let loaded = cache.load(repo, &heads)?;
    let matches: Vec<ChangeHash> = loaded.state.changes().map(|(h, _)| *h).filter(|h| h.starts_with_hex(spec)).collect();
    match matches.len() {
        1 => Ok(matches[0]),
        0 => Err(fail(format!("no change matches {spec:?}"))),
        _ => Err(fail(format!("{spec:?} is ambiguous"))),
    }
}

/// The heads of every bookmark, deduplicated.
pub fn all_heads(repo: &Repo) -> Result<Vec<ChangeHash>> {
    let mut set = BTreeSet::new();
    for b in repo.bookmarks()? {
        set.extend(b.heads);
    }
    Ok(set.into_iter().collect())
}

// ---------------------------------------------------------------- authors

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AuthorView {
    pub name: String,
    pub email: String,
    pub key: String,
    /// True when the key is not an identity the store knows.
    pub unknown: bool,
    /// The hub account the key is linked to, filled by the web layer.
    pub account: Option<String>,
}

pub fn author(repo: &Repo, key: &KeyId, message: &str) -> AuthorView {
    if key.is_zero() {
        // Imported from Git: the trailer carries the author.
        let line = message.lines().rev().find_map(|l| l.strip_prefix("Git-Author: ")).unwrap_or("unknown");
        let (name, email) = match line.split_once('<') {
            Some((n, e)) => (n.trim().to_string(), e.trim_end_matches('>').trim().to_string()),
            None => (line.trim().to_string(), String::new()),
        };
        return AuthorView { name, email, key: String::new(), unknown: true, account: None };
    }
    match repo.store().get_identity(key) {
        Ok(id) => AuthorView { name: id.name, email: id.email, key: key.to_hex(), unknown: false, account: None },
        Err(_) => AuthorView { name: key.short(12), email: String::new(), key: key.to_hex(), unknown: true, account: None },
    }
}

// ---------------------------------------------------------------- changes

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum SigView {
    Unsigned,
    Valid { key: String, name: String, sealed: bool, revoked: bool },
    Invalid(String),
}

impl SigView {
    pub fn glyph(&self) -> &'static str {
        match self {
            SigView::Unsigned => "○",
            SigView::Valid { revoked: true, .. } => "⊘",
            SigView::Valid { sealed: true, .. } => "◈",
            SigView::Valid { .. } => "✔",
            SigView::Invalid(_) => "✘",
        }
    }

    pub fn class(&self) -> &'static str {
        match self {
            SigView::Unsigned => "sig-unsigned",
            SigView::Valid { revoked: true, .. } => "sig-revoked",
            SigView::Valid { .. } => "sig-valid",
            SigView::Invalid(_) => "sig-invalid",
        }
    }

    pub fn title(&self) -> String {
        match self {
            SigView::Unsigned => "unsigned".into(),
            SigView::Valid { name, sealed: true, revoked: false, .. } => format!("sealed by {name}"),
            SigView::Valid { name, revoked: true, .. } => format!("signed by {name}, key revoked"),
            SigView::Valid { name, .. } => format!("signed by {name}"),
            SigView::Invalid(why) => format!("INVALID: {why}"),
        }
    }
}

pub fn signature(repo: &Repo, hash: &ChangeHash) -> SigView {
    match repo.verify_change(hash) {
        Ok(SignatureStatus::Unsigned) => SigView::Unsigned,
        Ok(SignatureStatus::Valid { key, name, sealed, revoked, .. }) => SigView::Valid { key: key.to_hex(), name, sealed, revoked },
        Ok(SignatureStatus::Invalid(why)) => SigView::Invalid(why),
        Err(e) => SigView::Invalid(e.to_string()),
    }
}

/// One change as history rows and change pages show it.
#[derive(Clone, Debug)]
pub struct ChangeView {
    pub hash: String,
    pub short: String,
    pub title: String,
    pub body: String,
    pub author: AuthorView,
    pub when_ms: u64,
    pub deps: Vec<String>,
    pub head: bool,
    pub resolution: bool,
    pub signature: SigView,
    /// Bookmarks and tags whose state has this change as a head.
    pub labels: Vec<Label>,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Label {
    pub name: String,
    pub kind: RefKind,
}

pub fn split_message(message: &str) -> (String, String) {
    let mut lines = message.lines();
    let title = lines.next().unwrap_or("").trim().to_string();
    let body = lines.collect::<Vec<_>>().join("\n").trim().to_string();
    (title, body)
}

/// Every bookmark and tag head, for labelling rows.
pub fn head_labels(repo: &Repo) -> Result<HashMap<ChangeHash, Vec<Label>>> {
    let mut out: HashMap<ChangeHash, Vec<Label>> = HashMap::new();
    for b in repo.bookmarks()? {
        for h in b.heads {
            out.entry(h).or_default().push(Label { name: b.name.clone(), kind: RefKind::Bookmark });
        }
    }
    for t in repo.tags()? {
        for h in t.heads {
            out.entry(h).or_default().push(Label { name: t.name.clone(), kind: RefKind::Tag });
        }
    }
    Ok(out)
}

pub fn change_view_pub(
    repo: &Repo,
    hash: &ChangeHash,
    meta: &oxy_core::state::ChangeMeta,
    head: bool,
    labels: &HashMap<ChangeHash, Vec<Label>>,
) -> ChangeView {
    change_view(repo, hash, meta, head, labels)
}

fn change_view(
    repo: &Repo,
    hash: &ChangeHash,
    meta: &oxy_core::state::ChangeMeta,
    head: bool,
    labels: &HashMap<ChangeHash, Vec<Label>>,
) -> ChangeView {
    let (title, body) = split_message(&meta.message);
    ChangeView {
        hash: hash.to_hex(),
        short: hash.short(12),
        title,
        body,
        author: author(repo, &meta.author, &meta.message),
        when_ms: meta.hlc.wall_ms,
        deps: meta.deps.iter().map(|d| d.to_hex()).collect(),
        head,
        resolution: meta.kind == oxy_core::objects::ChangeKind::Resolution,
        signature: signature(repo, hash),
        labels: labels.get(hash).cloned().unwrap_or_default(),
    }
}

// ---------------------------------------------------------------- history

#[derive(Clone, Debug)]
pub struct History {
    pub target: RefTarget,
    pub entries: Vec<ChangeView>,
    pub total: usize,
    pub offset: usize,
    pub has_more: bool,
    pub path: Option<String>,
}

/// A window of the history of a state, newest first.
pub fn history(repo: &Repo, cache: &StateCache, target: RefTarget, path: Option<&str>, offset: usize, limit: usize) -> Result<History> {
    let loaded = cache.load(repo, &target.heads)?;
    let head_set: BTreeSet<ChangeHash> = loaded.state.heads().into_iter().collect();
    let mut entries: Vec<(ChangeHash, oxy_core::state::ChangeMeta)> = match path {
        Some(p) => {
            let Some(node) = loaded.snapshot.files.get(p).map(|f| f.node) else { return Err(fail(format!("{p} is not in that state"))) };
            loaded
                .state
                .changes()
                .filter(|(h, _)| {
                    repo.store()
                        .get_change(h)
                        .map(|c| c.tree_ops.iter().any(|o| o.node() == node) || c.edits.iter().any(|x| x.node() == node))
                        .unwrap_or(false)
                })
                .map(|(h, m)| (*h, m.clone()))
                .collect()
        }
        None => loaded.state.changes().map(|(h, m)| (*h, m.clone())).collect(),
    };
    entries.sort_by(|a, b| b.1.hlc.cmp(&a.1.hlc).then(b.0.cmp(&a.0)));
    let total = entries.len();
    let labels = head_labels(repo)?;
    let window: Vec<ChangeView> =
        entries.iter().skip(offset).take(limit).map(|(h, m)| change_view(repo, h, m, head_set.contains(h), &labels)).collect();
    Ok(History { target, entries: window, total, offset, has_more: offset + limit < total, path: path.map(String::from) })
}

// ----------------------------------------------------------------- change

#[derive(Clone, Debug)]
pub struct ChangeDetail {
    pub view: ChangeView,
    pub dependents: Vec<ChangeView>,
    pub deps: Vec<ChangeView>,
    pub files: Vec<FileDiff>,
    /// Base content of each modified file, for context lines.
    pub bases: BTreeMap<String, Vec<u8>>,
    pub in_bookmarks: Vec<String>,
    pub in_tags: Vec<String>,
    pub atoms: usize,
    pub tree_ops: usize,
}

pub fn change(repo: &Repo, cache: &StateCache, hash: &ChangeHash) -> Result<ChangeDetail> {
    let c: Change = repo.store().get_change(hash)?;
    let labels = head_labels(repo)?;
    let heads = all_heads(repo)?;
    let loaded = cache.load(repo, &heads)?;
    let state = &loaded.state;
    let is_head = state.heads().contains(hash);
    let meta = oxy_core::state::ChangeMeta::of(&c);
    let view = change_view(repo, hash, &meta, is_head, &labels);
    let deps = c.deps.iter().filter_map(|d| state.get(d).map(|m| change_view(repo, d, m, state.heads().contains(d), &labels))).collect();
    let mut dependents: Vec<ChangeView> = state
        .changes()
        .filter(|(_, m)| m.deps.contains(hash))
        .map(|(h, m)| change_view(repo, h, m, state.heads().contains(h), &labels))
        .collect();
    dependents.sort_by_key(|c| std::cmp::Reverse(c.when_ms));
    let base = cache.load(repo, &c.deps)?;
    let files = crate::render::diff::change_files(&c, &base.state, &base.snapshot);
    let base_snapshot = &base.snapshot;
    let mut bases = BTreeMap::new();
    for f in &files {
        let old = f.from.as_deref().unwrap_or(&f.path);
        if let Some(FileContent::Text { bytes, .. }) = base_snapshot.files.get(old).map(|s| &s.content) {
            bases.insert(f.path.clone(), bytes.clone());
        }
    }
    let mut in_bookmarks = Vec::new();
    for b in repo.bookmarks()? {
        if cache.load(repo, &b.heads)?.state.contains(hash) {
            in_bookmarks.push(b.name);
        }
    }
    let mut in_tags = Vec::new();
    for t in repo.tags()? {
        if cache.load(repo, &t.heads)?.state.contains(hash) {
            in_tags.push(t.name);
        }
    }
    Ok(ChangeDetail { view, dependents, deps, files, bases, in_bookmarks, in_tags, atoms: c.edits.len(), tree_ops: c.tree_ops.len() })
}

// ------------------------------------------------------------------- tree

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum EntryKind {
    Dir,
    File,
    Symlink,
    Subrepo,
}

#[derive(Clone, Debug)]
pub struct Entry {
    pub name: String,
    pub path: String,
    pub kind: EntryKind,
    pub exec: bool,
    pub size: Option<u64>,
    pub conflicted: bool,
}

#[derive(Clone, Debug)]
pub struct Tree {
    pub target: RefTarget,
    pub path: String,
    pub entries: Vec<Entry>,
    /// `(name, path)` from the root down to this directory.
    pub crumbs: Vec<(String, String)>,
    pub readme: Option<Readme>,
}

#[derive(Clone, Debug)]
pub struct Readme {
    pub path: String,
    pub text: String,
}

pub fn crumbs(path: &str) -> Vec<(String, String)> {
    let mut out = Vec::new();
    let mut so_far = String::new();
    for part in path.split('/').filter(|p| !p.is_empty()) {
        if !so_far.is_empty() {
            so_far.push('/');
        }
        so_far.push_str(part);
        out.push((part.to_string(), so_far.clone()));
    }
    out
}

fn entry_of(path: &str, name: &str, f: &oxy_core::state::FileState) -> Entry {
    let kind = match f.kind {
        NodeKind::Dir => EntryKind::Dir,
        NodeKind::File => EntryKind::File,
        NodeKind::Symlink => EntryKind::Symlink,
        NodeKind::Subrepo => EntryKind::Subrepo,
    };
    let size = match &f.content {
        FileContent::Text { bytes, .. } => Some(bytes.len() as u64),
        _ => None,
    };
    Entry { name: name.to_string(), path: path.to_string(), kind, exec: f.mode.exec, size, conflicted: f.is_conflicted() }
}

/// The entries directly under `dir` (`""` for the root).
pub fn tree(repo: &Repo, cache: &StateCache, target: RefTarget, dir: &str) -> Result<Tree> {
    let loaded = cache.load(repo, &target.heads)?;
    tree_of(repo, target, &loaded.snapshot, dir)
}

pub fn tree_of(_repo: &Repo, target: RefTarget, snapshot: &Snapshot, dir: &str) -> Result<Tree> {
    let dir = dir.trim_matches('/');
    if !dir.is_empty() {
        match snapshot.files.get(dir) {
            Some(f) if f.kind == NodeKind::Dir => {}
            _ => return Err(RepoError::NotFound),
        }
    }
    let prefix = if dir.is_empty() { String::new() } else { format!("{dir}/") };
    let mut entries: Vec<Entry> = snapshot
        .files
        .iter()
        .filter(|(p, _)| p.starts_with(&prefix) && !p[prefix.len()..].contains('/'))
        .map(|(p, f)| entry_of(p, &p[prefix.len()..], f))
        .collect();
    entries.sort_by(|a, b| {
        (a.kind != EntryKind::Dir).cmp(&(b.kind != EntryKind::Dir)).then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
    });
    let readme = entries
        .iter()
        .find(|e| {
            e.kind == EntryKind::File && matches!(e.name.to_lowercase().as_str(), "readme.md" | "readme" | "readme.txt" | "readme.markdown")
        })
        .and_then(|e| match &snapshot.files.get(&e.path)?.content {
            FileContent::Text { bytes, .. } => Some(Readme { path: e.path.clone(), text: String::from_utf8_lossy(bytes).into_owned() }),
            _ => None,
        });
    Ok(Tree { target, path: dir.to_string(), entries, crumbs: crumbs(dir), readme })
}

// ------------------------------------------------------------------- file

#[derive(Clone, Debug)]
pub enum FileBody {
    Text(String),
    Binary,
    TooLarge,
}

#[derive(Clone, Debug)]
pub struct FileView {
    pub target: RefTarget,
    pub path: String,
    pub name: String,
    pub crumbs: Vec<(String, String)>,
    pub kind: EntryKind,
    pub exec: bool,
    pub size: u64,
    pub body: FileBody,
    pub conflicted: bool,
    /// Raw bytes, for the `?plain=1` response and images.
    pub bytes: Vec<u8>,
    pub last_change: Option<ChangeView>,
}

pub fn file(repo: &Repo, cache: &StateCache, target: RefTarget, path: &str, render_limit: u64) -> Result<FileView> {
    let loaded = cache.load(repo, &target.heads)?;
    let snapshot = &loaded.snapshot;
    let path = path.trim_matches('/');
    let Some(f) = snapshot.files.get(path) else { return Err(RepoError::NotFound) };
    let (kind, bytes) = match (&f.kind, &f.content) {
        (NodeKind::Dir, _) => return Err(RepoError::NotFound),
        (NodeKind::Symlink, FileContent::Text { bytes, .. }) => (EntryKind::Symlink, bytes.clone()),
        (NodeKind::Subrepo, FileContent::Text { bytes, .. }) => (EntryKind::Subrepo, bytes.clone()),
        (_, FileContent::Text { bytes, .. }) => (EntryKind::File, bytes.clone()),
        (_, FileContent::Opaque { blobs }) => {
            let bytes = match blobs.first() {
                Some(b) => repo.read_blob(b)?,
                None => Vec::new(),
            };
            (EntryKind::File, bytes)
        }
        (_, FileContent::Dir) => return Err(RepoError::NotFound),
    };
    let size = bytes.len() as u64;
    let body = if size > render_limit {
        FileBody::TooLarge
    } else if is_binary(&bytes) {
        FileBody::Binary
    } else {
        FileBody::Text(String::from_utf8_lossy(&bytes).into_owned())
    };
    let labels = head_labels(repo)?;
    let last_change = repo
        .log_for_path_in(path, &target.heads)
        .ok()
        .and_then(|l| l.into_iter().next())
        .map(|e| change_view(repo, &e.hash, &e.change, e.is_head, &labels));
    let name = path.rsplit('/').next().unwrap_or(path).to_string();
    Ok(FileView {
        target,
        path: path.to_string(),
        name,
        crumbs: crumbs(path),
        kind,
        exec: f.mode.exec,
        size,
        body,
        conflicted: f.is_conflicted(),
        bytes,
        last_change,
    })
}

pub fn is_binary(bytes: &[u8]) -> bool {
    let head = &bytes[..bytes.len().min(8192)];
    head.contains(&0)
        || std::str::from_utf8(head).is_err()
            && head.iter().filter(|b| **b < 0x20 && !matches!(**b, b'\n' | b'\r' | b'\t')).count() > head.len() / 20
}

/// Last change per entry of a directory, for tree rows (fetched lazily).
/// A directory's last change is the newest change touching anything
/// beneath it, as GitHub shows it.
pub fn last_changes(repo: &Repo, cache: &StateCache, heads: &[ChangeHash], paths: &[String]) -> Result<Vec<(String, ChangeView)>> {
    let labels = head_labels(repo)?;
    let loaded = cache.load(repo, heads)?;
    let state = &loaded.state;
    let snapshot = &loaded.snapshot;
    // Newest change touching each node, from one pass over the log.
    let mut newest: HashMap<oxy_core::ids::NodeId, (ChangeHash, u64)> = HashMap::new();
    for e in repo.log_state(heads)? {
        let Ok(c) = repo.store().get_change(&e.hash) else { continue };
        let when = e.change.hlc.wall_ms;
        for node in c.tree_ops.iter().map(|o| o.node()).chain(c.edits.iter().map(|x| x.node())) {
            newest.entry(node).or_insert((e.hash, when));
        }
    }
    let mut out = Vec::new();
    for p in paths {
        let Some(f) = snapshot.files.get(p) else { continue };
        let best = if f.kind == NodeKind::Dir {
            let prefix = format!("{p}/");
            snapshot
                .files
                .iter()
                .filter(|(q, _)| q.starts_with(&prefix))
                .filter_map(|(_, g)| newest.get(&g.node))
                .chain(newest.get(&f.node))
                .max_by_key(|(_, when)| *when)
                .copied()
        } else {
            newest.get(&f.node).copied()
        };
        if let Some((hash, _)) = best {
            if let Some(m) = state.get(&hash) {
                out.push((p.clone(), change_view(repo, &hash, m, state.heads().contains(&hash), &labels)));
            }
        }
    }
    Ok(out)
}

// ------------------------------------------------------------------ blame

#[derive(Clone, Debug)]
pub struct Blame {
    pub file: FileView,
    pub lines: Vec<BlameLine>,
}

pub fn blame(repo: &Repo, cache: &StateCache, target: RefTarget, path: &str, render_limit: u64) -> Result<Blame> {
    let heads = target.heads.clone();
    let file = file(repo, cache, target, path, render_limit)?;
    let lines = repo.blame_in(path, &heads)?;
    Ok(Blame { file, lines })
}

// -------------------------------------------------------------- overview

#[derive(Clone, Debug)]
pub struct BookmarkView {
    pub name: String,
    pub heads: Vec<String>,
    pub changes: usize,
    pub default: bool,
    pub conflicted: bool,
    pub latest_ms: u64,
}

#[derive(Clone, Debug)]
pub struct TagView {
    pub name: String,
    pub heads: Vec<String>,
    pub message: String,
    pub signer: Option<String>,
}

#[derive(Clone, Debug)]
pub struct Overview {
    pub tree: Tree,
    pub changes: usize,
    pub heads: usize,
    pub bookmarks: Vec<BookmarkView>,
    pub tags: Vec<TagView>,
    pub latest: Option<ChangeView>,
    pub conflicted: bool,
    pub license: Option<String>,
    pub policy: PolicyBadge,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PolicyBadge {
    None,
    Active,
    Expired,
}

pub fn bookmarks(repo: &Repo, cache: &StateCache, default: &str) -> Result<Vec<BookmarkView>> {
    let mut out = Vec::new();
    for b in repo.bookmarks()? {
        let loaded = cache.load(repo, &b.heads)?;
        let state = &loaded.state;
        let latest_ms = state.changes().map(|(_, m)| m.hlc.wall_ms).max().unwrap_or(0);
        let conflicted = loaded.snapshot.is_conflicted();
        out.push(BookmarkView {
            name: b.name.clone(),
            heads: b.heads.iter().map(|h| h.to_hex()).collect(),
            changes: state.len(),
            default: b.name == default,
            conflicted,
            latest_ms,
        });
    }
    out.sort_by(|a, b| b.default.cmp(&a.default).then_with(|| a.name.cmp(&b.name)));
    Ok(out)
}

pub fn tags(repo: &Repo) -> Result<Vec<TagView>> {
    let mut out: Vec<TagView> = repo
        .tags()?
        .into_iter()
        .map(|t| TagView { name: t.name, heads: t.heads.iter().map(|h| h.to_hex()).collect(), message: t.message, signer: t.signer })
        .collect();
    out.sort_by(|a, b| b.name.cmp(&a.name));
    Ok(out)
}

pub fn policy_badge(repo: &Repo) -> PolicyBadge {
    match repo.current_policy() {
        Ok(Some((_, sp))) => {
            if sp.policy.expires != 0 && (sp.policy.expires as i64) < crate::db::now_ms() {
                PolicyBadge::Expired
            } else {
                PolicyBadge::Active
            }
        }
        _ => PolicyBadge::None,
    }
}

pub fn overview(repo: &Repo, cache: &StateCache, default_bookmark: &str) -> Result<Overview> {
    let target = match resolve(repo, cache, default_bookmark) {
        Ok(t) => t,
        Err(_) => RefTarget { label: default_bookmark.into(), kind: RefKind::Bookmark, heads: vec![] },
    };
    let heads = target.heads.len();
    // One load of the default state serves the counts, the latest change
    // and the tree (hub spec §16.3).
    let loaded = cache.load(repo, &target.heads)?;
    let state = &loaded.state;
    let snapshot = &loaded.snapshot;
    let changes = state.len();
    let conflicted = snapshot.is_conflicted();
    let labels = head_labels(repo)?;
    let latest = state
        .changes()
        .max_by(|(ha, a), (hb, b)| a.hlc.cmp(&b.hlc).then(ha.cmp(hb)))
        .map(|(h, m)| change_view(repo, h, m, state.heads().contains(h), &labels));
    let tree = tree_of(repo, target, snapshot, "")?;
    let license = tree
        .entries
        .iter()
        .find(|e| matches!(e.name.to_lowercase().as_str(), "license" | "license.md" | "license.txt" | "licence" | "copying"))
        .map(|e| e.path.clone());
    Ok(Overview {
        tree,
        changes,
        heads,
        bookmarks: bookmarks(repo, cache, default_bookmark)?,
        tags: tags(repo)?,
        latest,
        conflicted,
        license,
        policy: policy_badge(repo),
    })
}

// -------------------------------------------------------------- compare

#[derive(Clone, Debug)]
pub struct Compare {
    pub base: RefTarget,
    pub head: RefTarget,
    /// Changes in `head`'s state not in `base`'s.
    pub added: Vec<ChangeView>,
    /// Changes in `base`'s state not in `head`'s.
    pub missing: usize,
    pub files: Vec<FileDiff>,
    pub bases: BTreeMap<String, Vec<u8>>,
}

pub fn compare(repo: &Repo, cache: &StateCache, base: RefTarget, head: RefTarget) -> Result<Compare> {
    let base_loaded = cache.load(repo, &base.heads)?;
    let head_loaded = cache.load(repo, &head.heads)?;
    let base_state = &base_loaded.state;
    let head_state = &head_loaded.state;
    let labels = head_labels(repo)?;
    let mut added: Vec<ChangeView> = head_state
        .changes()
        .filter(|(h, _)| !base_state.contains(h))
        .map(|(h, m)| change_view(repo, h, m, head_state.heads().contains(h), &labels))
        .collect();
    added.sort_by_key(|c| std::cmp::Reverse(c.when_ms));
    let missing = base_state.changes().filter(|(h, _)| !head_state.contains(h)).count();
    let (files, bases) = crate::render::diff::snapshot_diff(&base_loaded.snapshot, &head_loaded.snapshot);
    Ok(Compare { base, head, added, missing, files, bases })
}

// ------------------------------------------------------------ conflicts

#[derive(Clone, Debug)]
pub struct ConflictView {
    pub bookmark: String,
    pub path: String,
    pub kind: String,
    /// The file rendered with `oxy` conflict markers, when a text file.
    pub marked: Option<String>,
    pub contributors: Vec<ChangeView>,
}

pub fn conflicts(repo: &Repo, cache: &StateCache) -> Result<Vec<ConflictView>> {
    let mut out = Vec::new();
    for b in repo.bookmarks()? {
        let loaded = cache.load(repo, &b.heads)?;
        out.extend(conflicts_in(repo, &loaded, &b.name));
    }
    Ok(out)
}

/// The conflicts of one loaded state, labelled with `bookmark`.
pub fn conflicts_in(repo: &Repo, loaded: &super::cache::Loaded, bookmark: &str) -> Vec<ConflictView> {
    let labels = head_labels(repo).unwrap_or_default();
    let mut out = Vec::new();
    {
        let b_name = bookmark.to_string();
        let state = &loaded.state;
        let snapshot = &loaded.snapshot;
        for c in &snapshot.tree.conflicts {
            let (path, kind) = describe_tree_conflict(snapshot, c);
            out.push(ConflictView { bookmark: b_name.clone(), path, kind, marked: None, contributors: vec![] });
        }
        for (path, f) in &snapshot.files {
            if !f.is_conflicted() {
                continue;
            }
            let (kind, marked, contributors) = match &f.content {
                FileContent::Text { .. } => {
                    let (bytes, _) = state.render_file(&f.node);
                    let regions = state.conflict_regions(&f.node);
                    let contributors: Vec<ChangeView> = regions
                        .contributors
                        .iter()
                        .filter_map(|h| state.get(h).map(|m| change_view(repo, h, m, state.heads().contains(h), &labels)))
                        .collect();
                    ("lines".to_string(), Some(String::from_utf8_lossy(&bytes).into_owned()), contributors)
                }
                FileContent::Opaque { blobs } => (format!("replace ({} candidates)", blobs.len()), None, vec![]),
                FileContent::Dir => continue,
            };
            out.push(ConflictView { bookmark: b_name.clone(), path: path.clone(), kind, marked, contributors });
        }
    }
    out
}

fn describe_tree_conflict(snapshot: &Snapshot, c: &TreeConflict) -> (String, String) {
    let by_node = snapshot.tree.by_node();
    let path_of = |n: &oxy_core::ids::NodeId| by_node.get(n).map(|e| e.path.clone()).unwrap_or_else(|| n.short(8));
    match c {
        TreeConflict::Name { name, nodes, .. } => (name.clone(), format!("name: {} entries want this name", nodes.len())),
        TreeConflict::MultiPlacement { node, placements } => (path_of(node), format!("placement: {} places", placements.len())),
        TreeConflict::Orphan { node, .. } => (path_of(node), "orphan: parent directory was removed".into()),
        TreeConflict::Cycle { node } => (path_of(node), "cycle: directory moved into itself".into()),
        other => (String::new(), format!("{other:?}")),
    }
}

// ------------------------------------------------------------------ trust

#[derive(Clone, Debug)]
pub struct KeyView {
    pub key: String,
    pub short: String,
    pub name: String,
    pub email: String,
}

#[derive(Clone, Debug)]
pub struct RuleView {
    pub pattern: String,
    pub keys: Vec<KeyView>,
    pub threshold: u32,
    pub require: String,
    pub allow_conflicts: bool,
}

#[derive(Clone, Debug)]
pub struct PolicyView {
    pub serial: u64,
    pub expires_ms: u64,
    pub expired: bool,
    pub roots: Vec<KeyView>,
    pub root_threshold: u32,
    pub rules: Vec<RuleView>,
    pub revoked: Vec<KeyView>,
    pub signatures: usize,
    pub history: usize,
}

#[derive(Clone, Debug, Default)]
pub struct Verification {
    pub total: usize,
    pub signed: usize,
    pub sealed: usize,
    pub unsigned: usize,
    pub revoked: usize,
    pub invalid: Vec<(String, String)>,
}

#[derive(Clone, Debug)]
pub struct Trust {
    pub policy: Option<PolicyView>,
    pub verification: Verification,
    pub hub_key: String,
    pub hub_delegated_by: Vec<KeyView>,
}

fn key_view(repo: &Repo, ids: &[oxy_core::identity::Identity], key: &KeyId) -> KeyView {
    let found = ids.iter().find(|i| i.hash() == *key).cloned().or_else(|| repo.store().get_identity(key).ok());
    match found {
        Some(i) => KeyView { key: key.to_hex(), short: key.short(12), name: i.name, email: i.email },
        None => KeyView { key: key.to_hex(), short: key.short(12), name: String::new(), email: String::new() },
    }
}

pub fn verification(repo: &Repo, cache: &StateCache) -> Result<Verification> {
    let heads = all_heads(repo)?;
    let loaded = cache.load(repo, &heads)?;
    let state = &loaded.state;
    let mut v = Verification::default();
    for (h, _) in state.changes() {
        v.total += 1;
        match signature(repo, h) {
            SigView::Unsigned => v.unsigned += 1,
            SigView::Valid { sealed, revoked, .. } => {
                if revoked {
                    v.revoked += 1;
                }
                if sealed {
                    v.sealed += 1
                } else {
                    v.signed += 1
                }
            }
            SigView::Invalid(why) => v.invalid.push((h.to_hex(), why)),
        }
    }
    Ok(v)
}

pub fn trust(repo: &Repo, cache: &StateCache, hub_key: &KeyId) -> Result<Trust> {
    let policy = match repo.current_policy()? {
        Some((_, sp)) => {
            let p = &sp.policy;
            let ids = &p.identities;
            let require = |r: &oxy_core::policy::Require| match r {
                oxy_core::policy::Require::Signed => "signed",
                oxy_core::policy::Require::Sealed => "sealed",
                oxy_core::policy::Require::Any => "any",
            };
            Some(PolicyView {
                serial: p.serial,
                expires_ms: p.expires,
                expired: p.expires != 0 && (p.expires as i64) < crate::db::now_ms(),
                roots: p.roots.iter().map(|k| key_view(repo, ids, k)).collect(),
                root_threshold: p.root_threshold,
                rules: p
                    .rules
                    .iter()
                    .map(|r| RuleView {
                        pattern: r.pattern.clone(),
                        keys: r.keys.iter().map(|k| key_view(repo, ids, k)).collect(),
                        threshold: r.threshold,
                        require: require(&r.require).into(),
                        allow_conflicts: r.allow_conflicts,
                    })
                    .collect(),
                revoked: p.revoked.iter().map(|k| key_view(repo, ids, k)).collect(),
                signatures: sp.sigs.len(),
                history: repo.policy_history().map(|h| h.len()).unwrap_or(0),
            })
        }
        None => None,
    };
    // Who has delegated to the hub: every identity in the policy or store
    // that lists the hub key.
    let mut delegated = Vec::new();
    if let Some(p) = repo.current_policy()?.map(|(_, sp)| sp.policy) {
        for i in &p.identities {
            if i.delegates.contains(hub_key) {
                delegated.push(KeyView { key: i.hash().to_hex(), short: i.hash().short(12), name: i.name.clone(), email: i.email.clone() });
            }
        }
    }
    Ok(Trust { policy, verification: verification(repo, cache)?, hub_key: hub_key.to_hex(), hub_delegated_by: delegated })
}
`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet
Keyboard
