File view: tree sidebar, state permalinks (y, heads joined with +), line range bar with copy lines and copy permalink, blame age shading and blame before this change 6ae41081ccd3

    if (!m) { showBar(0, 0); return; }

    showBar(Math.min(a, b), Math.max(a, b));

  }

  /* The bar for a selected range: copy its text, or a permalink to it. */

  var bar = document.querySelector(".linebar");

  function showBar(a, b) {

    if (!bar) return;

    bar.hidden = !a;

    if (!a) return;

    bar.querySelector("[data-linebar-label]").textContent = a === b ? "Line " + a : "Lines " + a + "–" + b;

    bar.setAttribute("data-range", a + "-" + b);

  }

  function flash(btn) { var t = btn.textContent; btn.textContent = "Copied"; setTimeout(function () { btn.textContent = t; }, 1200); }

  if (bar) {

    bar.querySelector("[data-copy-lines]").addEventListener("click", function (ev) {

      var r = bar.getAttribute("data-range").split("-"), out = [];

      for (var i = +r[0]; i <= +r[1]; i++) { var row = document.getElementById("L" + i); if (row) out.push(row.querySelector("td.t").textContent); }

      navigator.clipboard.writeText(out.join("\n") + "\n").then(function () { flash(ev.target); });

    });

    var pl = bar.querySelector("[data-copy-permalink]");

    if (pl) pl.addEventListener("click", function () {

      navigator.clipboard.writeText(new URL(document.body.getAttribute("data-permalink"), location.href).href + location.hash).then(function () { flash(pl); });

    });

  function permalink() { var p = document.body.getAttribute("data-permalink"); return p ? p + location.hash : null; }

    if (e.key === "y" && !e.ctrlKey && !e.metaKey && !e.altKey && permalink()) { history.replaceState(null, "", permalink()); pending = null; return; }

/// Most heads a state address or a "before this change" link carries.

pub const MAX_STATE_HEADS: usize = 32;

impl RefTarget {

    /// The label for a ref bar: the name, or `# abc123…` for a change,

    /// with `+N` for the further heads of a state.

    pub fn short_label(&self) -> String {

        match self.kind {

            RefKind::Change => {

                let mut parts = self.label.split('+');

                let first: String = parts.next().unwrap_or("").chars().take(12).collect();

                match parts.count() {

                    0 => first,

                    n => format!("{first} +{n}"),

                }

            }

            _ => self.label.clone(),

        }

    }

    /// The `{ref}` that names this target's state for good: its heads

    /// joined with `+` (hub spec §6.6). None for an empty state.

    pub fn permalink(&self) -> Option<String> {

        state_spec(&self.heads)

    }

}

/// Heads as a state address, sorted so one state has one address.

pub fn state_spec(heads: &[ChangeHash]) -> Option<String> {

    if heads.is_empty() || heads.len() > MAX_STATE_HEADS {

        return None;

    }

    let mut hex: Vec<String> = heads.iter().map(|h| h.to_hex()).collect();

    hex.sort();

    hex.dedup();

    Some(hex.join("+"))

}

/// Resolve a bookmark name, a tag name, a change hash prefix, or a state

/// (full hashes joined with `+`).

    if spec.contains('+') {

        let parts: Vec<&str> = spec.split('+').collect();

        if parts.len() > MAX_STATE_HEADS {

            return Err(fail(format!("a state address has at most {MAX_STATE_HEADS} heads")));

        }

        let mut heads = Vec::with_capacity(parts.len());

        for p in parts {

            match ChangeHash::from_hex(p) {

                Some(h) if p.len() == 64 && repo.store().has(&h) => heads.push(h),

                _ => return Err(fail(format!("{p:?} is not a change of this repository"))),

            }

        }

        heads.sort();

        heads.dedup();

        let label = state_spec(&heads).unwrap_or_default();

        return Ok(RefTarget { label, kind: RefKind::Change, heads });

    }

}

/// One row of the file page's tree sidebar (hub spec §6.6).

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct SideEntry {

    pub name: String,

    pub path: String,

    pub depth: usize,

    pub dir: bool,

    /// A directory on the way to the file (expanded), or the file itself.

    pub on_path: bool,

    /// A "more" row standing for the rest of a long directory.

    pub more: bool,

}

/// Entries listed per directory in the sidebar before a "more" row.

const SIDEBAR_PER_DIR: usize = 200;

/// The tree down to `path`: each directory on the way expanded, in tree

/// order (directories first, then case-insensitive names).

pub fn sidebar(snapshot: &Snapshot, path: &str) -> Vec<SideEntry> {

    sidebar_in(&snapshot.files, |f| f.kind == NodeKind::Dir, path)

}

/// `sidebar` over any path map, given which values are directories.

pub fn sidebar_in<V>(files: &BTreeMap<String, V>, is_dir: impl Fn(&V) -> bool + Copy, path: &str) -> Vec<SideEntry> {

    let mut out = Vec::new();

    sidebar_dir(files, is_dir, "", path, 0, &mut out);

    out

}

fn sidebar_dir<V>(

    files: &BTreeMap<String, V>,

    is_dir: impl Fn(&V) -> bool + Copy,

    dir: &str,

    target: &str,

    depth: usize,

    out: &mut Vec<SideEntry>,

) {

    let prefix = if dir.is_empty() { String::new() } else { format!("{dir}/") };

    let mut children: Vec<(&str, bool)> = files

        .range(prefix.clone()..)

        .take_while(|(p, _)| p.starts_with(&prefix))

        .filter(|(p, _)| !p[prefix.len()..].contains('/'))

        .map(|(p, f)| (p.as_str(), is_dir(f)))

        .collect();

    children.sort_by(|a, b| (!a.1).cmp(&!b.1).then_with(|| a.0.to_lowercase().cmp(&b.0.to_lowercase())));

    let total = children.len();

    for (i, (p, dir_entry)) in children.into_iter().enumerate() {

        let on_path = target == p || target.starts_with(&format!("{p}/"));

        // Past the limit, keep only the entry on the way to the file.

        if i >= SIDEBAR_PER_DIR && !on_path {

            continue;

        }

        out.push(SideEntry { name: p[prefix.len()..].to_string(), path: p.to_string(), depth, dir: dir_entry, on_path, more: false });

        if dir_entry && on_path && p != target {

            sidebar_dir(files, is_dir, p, target, depth + 1, out);

        }

    }

    if total > SIDEBAR_PER_DIR {

        out.push(SideEntry {

            name: format!("{} more", total - SIDEBAR_PER_DIR),

            path: dir.to_string(),

            depth,

            dir: true,

            on_path: false,

            more: true,

        });

    }

    pub sidebar: Vec<SideEntry>,

        sidebar: sidebar(snapshot, path),

    /// For each blamed change, the state address of its dependencies:

    /// the state its author built on (None without dependencies).

    pub before: HashMap<ChangeHash, Option<String>>,

    let mut before = HashMap::new();

    for l in &lines {

        before.entry(l.hash).or_insert_with(|| repo.store().get_change(&l.hash).ok().and_then(|c| state_spec(&c.deps)));

    }

    Ok(Blame { file, lines, before })

}

#[cfg(test)]

mod tests {

    use super::*;

    fn tree(paths: &[&str]) -> BTreeMap<String, bool> {

        let mut m = BTreeMap::new();

        for p in paths {

            let mut end = 0;

            let parts: Vec<&str> = p.split('/').collect();

            for (i, part) in parts.iter().enumerate() {

                end += part.len();

                m.insert(p[..end].to_string(), i + 1 < parts.len());

                end += 1;

            }

        }

        m

    }

    #[test]

    fn sidebar_expands_the_path_only() {

        let files = tree(&["README.md", "src/main.rs", "src/lib/a.rs", "src/lib/b.rs", "docs/guide.md", "Zeta.txt"]);

        let rows: Vec<(String, usize, bool, bool)> =

            sidebar_in(&files, |d| *d, "src/lib/b.rs").into_iter().map(|e| (e.path, e.depth, e.dir, e.on_path)).collect();

        let want = [

            ("docs", 0, true, false),

            ("src", 0, true, true),

            ("src/lib", 1, true, true),

            ("src/lib/a.rs", 2, false, false),

            ("src/lib/b.rs", 2, false, true),

            ("src/main.rs", 1, false, false),

            ("README.md", 0, false, false),

            ("Zeta.txt", 0, false, false),

        ];

        assert_eq!(rows, want.iter().map(|(p, d, dir, on)| (p.to_string(), *d, *dir, *on)).collect::<Vec<_>>());

    }

    #[test]

    fn sidebar_cuts_long_directories_but_keeps_the_file() {

        let names: Vec<String> = (0..250).map(|i| format!("big/f{i:03}.txt")).collect();

        let refs: Vec<&str> = names.iter().map(String::as_str).collect();

        let files = tree(&refs);

        let rows = sidebar_in(&files, |d| *d, "big/f240.txt");

        let listed: Vec<&SideEntry> = rows.iter().filter(|e| e.depth == 1 && !e.more).collect();

        assert_eq!(listed.len(), SIDEBAR_PER_DIR + 1, "the limit plus the file itself");

        assert!(listed.last().unwrap().on_path);

        let more = rows.iter().find(|e| e.more).unwrap();

        assert_eq!((more.name.as_str(), more.path.as_str()), ("50 more", "big"));

    }

    #[test]

    fn state_addresses_are_sorted_and_bounded() {

        let a = ChangeHash::from_hex(&"a".repeat(64)).unwrap();

        let b = ChangeHash::from_hex(&"b".repeat(64)).unwrap();

        assert_eq!(state_spec(&[b, a, b]).unwrap(), format!("{}+{}", "a".repeat(64), "b".repeat(64)));

        assert_eq!(state_spec(&[]), None);

        assert_eq!(state_spec(&vec![a; MAX_STATE_HEADS + 1]), None);

        let t = RefTarget { label: state_spec(&[a, b]).unwrap(), kind: RefKind::Change, heads: vec![a, b] };

        assert_eq!(t.short_label(), format!("{} +1", "a".repeat(12)));

        assert_eq!(RefTarget { label: "main".into(), kind: RefKind::Bookmark, heads: vec![a] }.short_label(), "main");

    }

    /// The `{ref}` of this state for good (hub spec §6.6).

    permalink: Option<String>,

    /// 0 (the file's oldest line) to 9 (its newest), for shading.

    pub age: u8,

    /// The state address of the change's dependencies.

    pub before: Option<String>,

}

/// Shade steps from `when` within the file's span of times.

fn age_step(when: u64, oldest: u64, newest: u64) -> u8 {

    if newest <= oldest {

        return 9;

    }

    (((when.saturating_sub(oldest)) as u128 * 9 / (newest - oldest) as u128) as u8).min(9)

}

fn blame_rows(

    lines: &[oxy_core::repo::BlameLine],

    before: &std::collections::HashMap<oxy_core::hash::ChangeHash, Option<String>>,

) -> Vec<BlameRow> {

    let oldest = lines.iter().map(|l| l.when_ms).min().unwrap_or(0);

    let newest = lines.iter().map(|l| l.when_ms).max().unwrap_or(0);

    let mut rows: Vec<BlameRow> = Vec::with_capacity(lines.len());

    let mut i = 0;

    while i < lines.len() {

        let mut run = 1;

        while i + run < lines.len() && lines[i + run].hash == lines[i].hash {

            run += 1;

        }

        for k in 0..run {

            let l = &lines[i + k];

            rows.push(BlameRow {

                first: k == 0,

                hash: l.hash.to_hex(),

                short: l.hash.short(8),

                author: l.author.clone(),

                when_ms: l.when_ms,

                run,

                age: age_step(l.when_ms, oldest, newest),

                before: before.get(&l.hash).cloned().flatten(),

            });

        }

        i += run;

    }

    rows

                let rows = blame_rows(&b.lines, &b.before);

                Ok((b.file, Some(rows)))

    let permalink = f.target.permalink();

    Ok(Page(FilePage { shell, repo: rs, f, lines, language, markdown_html, is_image, is_markdown, blame, permalink }).into_response())

    // Sidebar, permalink, blame shading and "blame before this change" (hub spec §6.6).

    assert!(f.contains("class=\"file-side\""), "sidebar");

    assert!(f.contains("href=\"/andy/demo/tree/main/docs\""), "sibling directory listed");

    let here = f.split("aria-current=\"page\">").nth(1).unwrap_or("");

    assert!(here.trim_start().starts_with("<a href=\"/andy/demo/file/main/src/main.rs\""), "the file marked");

    assert!(f.contains(&format!("data-permalink=\"/andy/demo/file/{c2}/src/main.rs\"")), "permalink at the head");

    assert!(b.contains(&format!("data-permalink=\"/andy/demo/file/{c2}/src/main.rs?blame=1\"")));

    assert!(b.contains("blame age-0") && b.contains("blame age-9"), "oldest and newest shaded");

    assert!(b.contains(&format!("href=\"/andy/demo/file/{c1}/src/main.rs?blame=1#L")), "the state before c2 is c1");

    assert_eq!(b.matches("class=\"before\"").count(), b.matches("blame age-9").count(), "c1 has no dependencies, so no link");

    let before = page(&h.app, &format!("/andy/demo/file/{c1}/src/main.rs?blame=1")).await;

    assert!(before.contains(&c1[..8]) && !before.contains(&c2[..8]), "blamed in c1's state");

    // States: heads joined with +, in any order; not a change otherwise.

    let (lo, hi) = if c1 < c2 { (&c1, &c2) } else { (&c2, &c1) };

    assert!(page(&h.app, &format!("/andy/demo/tree/{hi}+{lo}/src"))

        .await

        .contains(&format!("data-permalink=\"/andy/demo/tree/{lo}+{hi}/src\"")));

    assert_ne!(get(&h.app, &format!("/andy/demo/tree/{c1}+{}", &c2[..12])).await.0, StatusCode::OK, "state heads are full hashes");

| `/{owner}/{name}/tree/{ref}/{path}` | Directory listing at a bookmark, tag, change or state (§6.5). A `{ref}` is a bookmark name, a tag name, a change hash or unique prefix, or a state: full change hashes joined with `+` (`a1…+b2…`), the state those heads make, which is how a state with several heads is addressed permanently |

A sidebar beside the file lists the tree down to it: the root and each directory on the file's path expanded (at most 200 entries each, then a link to the directory), the file marked, other directories linking to their tree pages. It is hidden on narrow screens.

The permalink of a file view is the same path at its state: the target's heads joined with `+` in place of the bookmark or tag. `y` replaces the address with the permalink, keeping the line anchor, as GitHub does. When a line or range is selected, a bar offers **Copy lines** (the text) and **Copy permalink** (the permalink with `#L12-L20`).

The blame gutter shades each run by the age of its change, from the file's oldest (lightest) to newest (strongest) line, in ten steps, with the age also written out so colour is not the only carrier. Each run links **blame before this change**: the same file blamed at the state of the change's dependencies (the state its author built on), so a line can be traced back through every edit. A change without dependencies has no such link; one with more than 32 has none either, to keep addresses bounded.

`/` focuses search, `g c` / `g p` / `g i` jump to Code, Proposals, Issues, `y` on a tree or file page switches to its permalink, `?` shows the sheet. Every interactive element is reachable by keyboard; colour is never the only carrier of meaning (glyphs accompany every status colour); contrast meets WCAG AA in both themes.

  <table><tr><td><kbd>/</kbd></td><td>Search</td></tr><tr><td><kbd>g</kbd> <kbd>c</kbd></td><td>Code</td></tr><tr><td><kbd>g</kbd> <kbd>h</kbd></td><td>History</td></tr><tr><td><kbd>g</kbd> <kbd>b</kbd></td><td>Bookmarks</td></tr><tr><td><kbd>g</kbd> <kbd>t</kbd></td><td>Trust</td></tr><tr><td><kbd>y</kbd></td><td>Permalink to this state (files and trees)</td></tr><tr><td><kbd>?</kbd></td><td>This sheet</td></tr></table>

{% block title %}{{ f.path }} at {{ f.target.short_label() }} · {{ repo.owner }}/{{ repo.name }}{% endblock %}

{% block bodyattrs %} data-repo="{{ repo.url }}" data-ref="{{ f.target.label }}"{% if let Some(p) = permalink %} data-permalink="{{ repo.url }}/file/{{ p }}/{{ f.path }}{% if blame.is_some() %}?blame=1{% endif %}"{% endif %}{% endblock %}

  <span class="ref px">{% if f.target.kind == crate::repos::view::RefKind::Change %}# {{ f.target.short_label() }}{% else %}◆ {{ f.target.label }}{% endif %}</span>

<div class="file-layout">

<nav class="file-side" aria-label="Files">

  <a class="side-root" href="{{ repo.url }}/tree/{{ f.target.label }}">{{ repo.name }}</a>

  <ul>

  {% for e in f.sidebar %}

    <li style="--d: {{ e.depth }}"{% if e.on_path && !e.dir %} class="here" aria-current="page"{% endif %}>

      {% if e.more %}<a class="mute" href="{{ repo.url }}/tree/{{ f.target.label }}/{{ e.path }}">… {{ e.name }}</a>

      {% else if e.dir %}<a href="{{ repo.url }}/tree/{{ f.target.label }}/{{ e.path }}"><span class="glyph" aria-hidden="true">{% if e.on_path %}▾{% else %}▸{% endif %}</span> {{ e.name }}/</a>

      {% else %}<a href="{{ repo.url }}/file/{{ f.target.label }}/{{ e.path }}">{{ e.name }}</a>{% endif %}

    </li>

  {% endfor %}

  </ul>

</nav>

<section class="filebox file-main">

  <div class="linebar" hidden><span class="small mute" data-linebar-label></span><button type="button" class="btn small" data-copy-lines>Copy lines</button>{% if permalink.is_some() %}<button type="button" class="btn small" data-copy-permalink>Copy permalink</button>{% endif %}</div>

          {% if r.first %}<td class="blame age-{{ r.age }}" rowspan="{{ r.run }}"><a class="px" href="{{ repo.url }}/change/{{ r.hash }}" title="{{ r.hash }}">{{ r.short }}</a> <span class="who">{{ r.author }}</span> <time class="mute" title="{{ r.when_ms|when }}">{{ r.when_ms|ago }}</time>{% if let Some(b) = r.before %} <a class="before" href="{{ repo.url }}/file/{{ b }}/{{ f.path }}?blame=1#L{{ n }}" title="Blame the state before this change">↶</a>{% endif %}</td>{% endif %}

</div>

{% block title %}Changes on {{ h.target.short_label() }} · {{ repo.owner }}/{{ repo.name }}{% endblock %}

<div class="head"><h1>Changes <small>{% if h.target.kind == crate::repos::view::RefKind::Change %}up to # {{ h.target.short_label() }}{% else %}on {{ h.target.label }}{% endif %}{% if let Some(p) = h.path %} touching {{ p }}{% endif %} · {{ h.total }}</small></h1></div>

/* File view: tree sidebar, line bar, blame age (hub spec §6.6). */

.file-layout { display: grid; grid-template-columns: minmax(180px, 240px) minmax(0, 1fr); gap: 16px; align-items: start; }

.file-side { position: sticky; top: 12px; max-height: calc(100vh - 24px); overflow: auto; font-size: 13px; background: var(--panel); border: 1px solid var(--line); padding: 8px 0; }

.file-side .side-root { display: block; padding: 2px 12px 6px; font-weight: 600; }

.file-side ul { list-style: none; margin: 0; padding: 0; }

.file-side li a { display: block; padding: 2px 12px 2px calc(12px + var(--d, 0) * 14px); color: var(--text); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }

.file-side li a:hover { background: var(--soft); text-decoration: none; }

.file-side li.here a { background: color-mix(in srgb, var(--acc) 16%, transparent); font-weight: 600; box-shadow: inset 3px 0 0 var(--acc); }

.file-side .glyph { color: var(--dim); font-size: 10px; }

.file-main { min-width: 0; overflow-x: auto; }

.linebar { display: flex; align-items: center; gap: 8px; padding: 6px 12px; border-bottom: 1px solid var(--line); background: color-mix(in srgb, var(--acc) 8%, var(--panel)); }

.linebar[hidden] { display: none; }

.linebar [data-linebar-label] { margin-right: auto; }

table.code td.blame { box-shadow: inset 3px 0 0 color-mix(in srgb, var(--acc) calc(var(--age, 0) * 10%), transparent); }

table.code td.blame.age-0 { --age: 1; } table.code td.blame.age-1 { --age: 2; } table.code td.blame.age-2 { --age: 3; }

table.code td.blame.age-3 { --age: 4; } table.code td.blame.age-4 { --age: 5; } table.code td.blame.age-5 { --age: 6; }

table.code td.blame.age-6 { --age: 7; } table.code td.blame.age-7 { --age: 8; } table.code td.blame.age-8 { --age: 9; }

table.code td.blame.age-9 { --age: 10; }

table.code td.blame .before { color: var(--dim); margin-left: 4px; }

table.code td.blame .before:hover { color: var(--acc); text-decoration: none; }

@media (max-width: 900px) {

  .file-layout { grid-template-columns: minmax(0, 1fr); }

  .file-side { display: none; }

}

{% block title %}{{ t.path }} at {{ t.target.short_label() }} · {{ repo.owner }}/{{ repo.name }}{% endblock %}

{% block bodyattrs %} data-repo="{{ repo.url }}" data-ref="{{ t.target.label }}"{% if let Some(p) = t.target.permalink() %} data-permalink="{{ repo.url }}/tree/{{ p }}/{{ t.path }}"{% endif %}{% endblock %}

  <span class="ref px">{% if t.target.kind == crate::repos::view::RefKind::Change %}# {{ t.target.short_label() }}{% else %}◆ {{ t.target.label }}{% endif %}</span>