d83c62d6

Add file history view

a73x 2026-09-04 11:18

Commit message

Add file history view

src/server/http/mod.rs

Old		New
@@ -35,6 +35,7 @@ pub fn router(state: AppState) -> Router {
35	.route("/{repo_name}/tree", axum::routing::get(repo::tree_root))	35	.route("/{repo_name}/tree", axum::routing::get(repo::tree_root))
36	.route("/{repo_name}/tree/{*rest}", axum::routing::get(repo::tree))	36	.route("/{repo_name}/tree/{*rest}", axum::routing::get(repo::tree))
37	.route("/{repo_name}/blob/{*rest}", axum::routing::get(repo::blob))	37	.route("/{repo_name}/blob/{*rest}", axum::routing::get(repo::blob))
		38	.route("/{repo_name}/history/{*rest}", axum::routing::get(repo::history))
38	.route("/{repo_name}/diff/{oid}", axum::routing::get(repo::diff))	39	.route("/{repo_name}/diff/{oid}", axum::routing::get(repo::diff))
39	.route("/{repo_name}/patches", axum::routing::get(repo::patches))	40	.route("/{repo_name}/patches", axum::routing::get(repo::patches))
40	.route(	41	.route(

src/server/http/repo/history.rs

@@ @@ -0,0 +1,163 @@ @@
+use std::sync::Arc;
+use axum::extract::{Path, State};
+use axum::response::{IntoResponse, Response};
+use super::{
+    collab_counts, head_branch_name, list_branches, not_found, open_repo, AppState, OverviewCommit,
+};
+#[derive(askama::Template, askama_web::WebTemplate)]
+#[template(path = "history.html")]
+pub struct HistoryTemplate {
+    pub site_title: String,
+    pub repo_name: String,
+    pub active_section: String,
+    pub open_patches: usize,
+    pub open_issues: usize,
+    pub ref_name: String,
+    pub branches: Vec<String>,
+    pub file_path: String,
+    pub commits: Vec<OverviewCommit>,
+}
+/// The `(mode, blob oid)` a commit's tree holds at `path`, or `None` if the
+/// path is absent. The mode is part of the comparison because a chmod
+/// 100644→100755 keeps the same oid — `git log -- <path>` counts that as a
+/// change, and so must we.
+fn entry_at(commit: &git2::Commit, path: &str) -> Option<(i32, git2::Oid)> {
+    let tree = commit.tree().ok()?;
+    let entry = tree.get_path(std::path::Path::new(path)).ok()?;
+    // A directory at the path is not a file history entry; skip it.
+    if entry.kind() == Some(git2::ObjectType::Tree) {
+        return None;
+    }
+    Some((entry.filemode(), entry.id()))
+}
+/// Commits reachable from `head` in which the `(mode, oid)` at `path` differs
+/// from the entry in *every* parent. This is git's default TREESAME
+/// simplification: a merge whose entry matches any parent is suppressed (git
+/// follows that parent instead), which keeps a clean non-fast-forward merge
+/// from listing both itself and the source-branch commit. A root commit (no
+/// parents) is included when it introduces the path.
+///
+/// This is `git log -- <path>` without rename following: a move shows up as a
+/// deletion and an addition, which is the honest answer a reader can
+/// re-derive from the diffs it links to.
+fn history_for_path(
+    repo: &git2::Repository,
+    head: &git2::Commit,
+    path: &str,
+    limit: usize,
+) -> Vec<OverviewCommit> {
+    let mut revwalk = match repo.revwalk() {
+        Ok(rw) => rw,
+        Err(_) => return Vec::new(),
+    };
+    if revwalk.push(head.id()).is_err() {
+        return Vec::new();
+    }
+    // Children-before-parents (newest-first), stable across commits that
+    // share a timestamp. Verified against a repo whose three file-touching
+    // commits all landed in the same second: `TIME` reordered them wrongly,
+    // while `TOPOLOGICAL` and the default (`NONE`) both held. `TOPOLOGICAL` is
+    // chosen over the default because it *guarantees* the order rather than
+    // happening to produce it.
+    let _ = revwalk.set_sorting(git2::Sort::TOPOLOGICAL);
+    revwalk
+        .filter_map(|oid| {
+            let oid = oid.ok()?;
+            let commit = repo.find_commit(oid).ok()?;
+            let current = entry_at(&commit, path);
+            // A commit is a history entry iff its entry at `path` differs from
+            // *every* parent — git's TREESAME simplification. A merge whose
+            // entry matches any parent is suppressed (comparing only parent 0
+            // would list a clean merge alongside the source-branch commit that
+            // git log drops it for). A root commit (no parents) is included
+            // only when it introduces the path: "differs from all parents" is
+            // vacuously true for a parentless commit, so a root that lacks the
+            // file must be rejected explicitly.
+            let parents: Vec<git2::Commit> = (0..commit.parent_count())
+                .filter_map(|i| commit.parent(i).ok())
+                .collect();
+            let is_entry = if parents.is_empty() {
+                current.is_some()
+            } else {
+                parents
+                    .iter()
+                    .all(|parent| entry_at(parent, path) != current)
+            };
+            if !is_entry {
+                return None;
+            }
+            let id = oid.to_string();
+            let short_id = id[..8.min(id.len())].to_string();
+            let summary = commit.summary().unwrap_or("").to_string();
+            let author = commit.author().name().unwrap_or("").to_string();
+            let secs = commit.time().seconds();
+            let date = chrono::TimeZone::timestamp_opt(&chrono::Utc, secs, 0)
+                .single()
+                .map(|dt| dt.format("%Y-%m-%d").to_string())
+                .unwrap_or_default();
+            Some(OverviewCommit {
+                id,
+                short_id,
+                summary,
+                author,
+                date,
+            })
+        })
+        .take(limit)
+        .collect()
+}
+pub async fn history(
+    Path((repo_name, rest)): Path<(String, String)>,
+    State(state): State<Arc<AppState>>,
+) -> Response {
+    let (_entry, repo) = match open_repo(&state, &repo_name) {
+        Ok(r) => r,
+        Err(resp) => return resp,
+    };
+    let (open_patches, open_issues) = collab_counts(&repo);
+    let branches = list_branches(&repo);
+    let (ref_name, file_path) = super::tree::split_ref_path(&rest);
+    let ref_name = if ref_name == "HEAD" {
+        head_branch_name(&repo)
+    } else {
+        ref_name
+    };
+    // Resolve the ref so an unknown ref is a 404, but do NOT require the
+    // path to exist at HEAD: a deleted file's history is a legitimate query,
+    // and the walk will simply be empty for a path that was never tracked.
+    let obj = match repo.revparse_single(&ref_name) {
+        Ok(o) => o,
+        Err(_) => return not_found(&state, format!("Ref '{}' not found.", ref_name)),
+    };
+    let commit = match obj.peel_to_commit() {
+        Ok(c) => c,
+        Err(_) => return not_found(&state, "Could not resolve ref to a commit."),
+    };
+    let commits = history_for_path(&repo, &commit, &file_path, 200);
+    HistoryTemplate {
+        site_title: state.site_title.clone(),
+        repo_name,
+        active_section: "tree".to_string(),
+        open_patches,
+        open_issues,
+        ref_name,
+        branches,
+        file_path,
+        commits,
+    }
+    .into_response()
+}

src/server/http/repo/mod.rs

Old		New
@@ -1,6 +1,7 @@
1	mod commits;	1	mod commits;
2	mod diff;	2	mod diff;
3	mod patch_diff;	3	mod patch_diff;
		4	mod history;
4	mod issues;	5	mod issues;
5	mod overview;	6	mod overview;
6	mod patches;	7	mod patches;
@@ -11,6 +12,7 @@ mod tree;
11	pub use commits::{commits, commits_ref};	12	pub use commits::{commits, commits_ref};
12	pub use diff::diff;	13	pub use diff::diff;
13	pub use patch_diff::patch_diff;	14	pub use patch_diff::patch_diff;
		15	pub use history::history;
14	pub use issues::{issue_detail, issues};	16	pub use issues::{issue_detail, issues};
15	pub use overview::overview;	17	pub use overview::overview;
16	pub use patches::{patch_detail, patches};	18	pub use patches::{patch_detail, patches};

src/server/http/repo/tree.rs

Old		New
@@ -48,7 +48,7 @@ pub struct BlobTemplate {
48		48
49	/// Split "ref/path/to/file" — first segment is ref, rest joined is path.	49	/// Split "ref/path/to/file" — first segment is ref, rest joined is path.
50	/// Returns ("HEAD", "") for empty input.	50	/// Returns ("HEAD", "") for empty input.
51	fn split_ref_path(input: &str) -> (String, String) {	51	pub fn split_ref_path(input: &str) -> (String, String) {
52	if input.is_empty() {	52	if input.is_empty() {
53	return ("HEAD".to_string(), String::new());	53	return ("HEAD".to_string(), String::new());
54	}	54	}

src/server/http/templates/blob.html

Old		New
@@ -10,7 +10,9 @@
10	<option value="/{{ repo_name }}/blob/{{ b }}/{{ file_path }}"{% if *b == ref_name %} selected{% endif %}>{{ b }}</option>	10	<option value="/{{ repo_name }}/blob/{{ b }}/{{ file_path }}"{% if *b == ref_name %} selected{% endif %}>{{ b }}</option>
11	{% endfor %}	11	{% endfor %}
12	</select>	12	</select>
13	Size: {{ size_display }}</p>	13	Size: {{ size_display }}
		14	<a href="/{{ repo_name }}/history/{{ ref_name }}/{{ file_path }}">History</a>
		15	</p>
14	{% if is_binary %}	16	{% if is_binary %}
15	<p style="color: #666; font-style: italic;">Binary file</p>	17	<p style="color: #666; font-style: italic;">Binary file</p>
16	{% else %}	18	{% else %}

src/server/http/templates/history.html

@@ @@ -0,0 +1,42 @@ @@
+{% extends "repo_base.html" %}
+{% block title %}History — {{ file_path }} — {{ repo_name }} — {{ site_title }}{% endblock %}
+{% block content %}
+<h2>History:
+  <a href="/{{ repo_name }}/blob/{{ ref_name }}/{{ file_path }}">{{ file_path }}</a>
+</h2>
+<p style="color: #666;">Ref:
+  <select class="mono" onchange="location.href=this.value">
+    {% for b in branches %}
+    <option value="/{{ repo_name }}/history/{{ b }}/{{ file_path }}"{% if *b == ref_name %} selected{% endif %}>{{ b }}</option>
+    {% endfor %}
+  </select>
+</p>
+{% if commits.is_empty() %}
+<p style="color: #666;">No commits touched this file.</p>
+{% else %}
+<div class="table-scroll">
+<table>
+  <thead>
+    <tr>
+      <th>Hash</th>
+      <th>Message</th>
+      <th>Author</th>
+      <th>Date</th>
+    </tr>
+  </thead>
+  <tbody>
+    {% for c in commits %}
+    <tr>
+      <td class="mono"><a href="/{{ repo_name }}/diff/{{ c.id }}">{{ c.short_id }}</a></td>
+      <td>{{ c.summary }}</td>
+      <td style="color: #666;">{{ c.author }}</td>
+      <td class="mono" style="color: #666;">{{ c.date }}</td>
+    </tr>
+    {% endfor %}
+  </tbody>
+</table>
+</div>
+{% endif %}
+{% endblock %}

tests/file_history_test.rs

@@ @@ -0,0 +1,162 @@ @@
+//! The file-history view lists exactly the commits that touched a path.
+//!
+//! Like GitHub's "History" button on a blob: open a file, click History, see
+//! the line of commits that changed it. A commit that touched a *different*
+//! file must not appear, and a commit that *deleted* the file must.
+mod common;
+use common::ServerHarness;
+#[test]
+fn history_lists_only_commits_that_touched_the_file() {
+    let harness = ServerHarness::new("file-history");
+    let repo = harness.work_repo();
+    let first = repo.commit_file("tracked.rs", "v1\n", "add tracked.rs");
+    let _other = repo.commit_file("other.rs", "x\n", "touch a different file");
+    let second = repo.commit_file("tracked.rs", "v2\n", "change tracked.rs");
+    harness.push_head();
+    let name = harness.repo_name();
+    let body = harness
+        .get_ok(&format!("/{name}/history/main/tracked.rs"))
+        .body;
+    // Both commits that touched tracked.rs appear, newest first.
+    let first_pos = body.find(&first[..8]).expect("first commit short id shown");
+    let second_pos = body
+        .find(&second[..8])
+        .expect("second commit short id shown");
+    assert!(
+        second_pos < first_pos,
+        "history is not newest-first:\n{body}"
+    );
+    // The commit that only touched other.rs is absent.
+    assert!(
+        !body.contains(&_other[..8]),
+        "history lists a commit that did not touch the file:\n{body}"
+    );
+    assert!(
+        body.contains("change tracked.rs") && body.contains("add tracked.rs"),
+        "history is missing commit summaries:\n{body}"
+    );
+}
+#[test]
+fn history_view_is_linked_from_the_blob_page() {
+    let harness = ServerHarness::new("file-history-link");
+    let repo = harness.work_repo();
+    repo.commit_file("tracked.rs", "v1\n", "add tracked.rs");
+    harness.push_head();
+    let name = harness.repo_name();
+    let blob = harness
+        .get_ok(&format!("/{name}/blob/main/tracked.rs"))
+        .body;
+    assert!(
+        blob.contains(&format!("/{name}/history/main/tracked.rs")),
+        "the blob page has no History link:\n{blob}"
+    );
+}
+#[test]
+fn history_for_a_path_that_was_never_tracked_is_empty() {
+    let harness = ServerHarness::new("file-history-missing");
+    harness.work_repo().commit_file("tracked.rs", "v1\n", "add");
+    harness.push_head();
+    let name = harness.repo_name();
+    let body = harness
+        .get_ok(&format!("/{name}/history/main/nope.rs"))
+        .body;
+    assert!(
+        body.contains("No commits touched this file."),
+        "a never-tracked path should say so, not 404 or list commits:\n{body}"
+    );
+}
+#[test]
+fn a_commit_that_deletes_the_file_appears_in_its_history() {
+    let harness = ServerHarness::new("file-history-deletion");
+    let repo = harness.work_repo();
+    let added = repo.commit_file("doomed.rs", "v1\n", "add doomed.rs");
+    // Delete the file in a second commit.
+    repo.git(&["rm", "doomed.rs"]);
+    repo.git(&["commit", "-m", "delete doomed.rs"]);
+    harness.push_head();
+    let name = harness.repo_name();
+    let body = harness
+        .get_ok(&format!("/{name}/history/main/doomed.rs"))
+        .body;
+    // Both the adding commit and the deleting commit appear.
+    assert!(
+        body.contains(&added[..8]),
+        "the commit that added the file is missing from its history:\n{body}"
+    );
+    assert!(
+        body.contains("delete doomed.rs"),
+        "the commit that deleted the file is missing from its history:\n{body}"
+    );
+}
+/// A clean non-fast-forward merge whose file entry matches a non-first parent
+/// must be suppressed, the way `git log -- <path>` suppresses it. The old code
+/// compared only parent 0 and listed the merge alongside the source-branch
+/// commit.
+#[test]
+fn a_clean_merge_matching_any_parent_is_suppressed() {
+    let harness = ServerHarness::new("file-history-merge");
+    let repo = harness.work_repo();
+    // A: add f.rs = v1 on main.
+    repo.commit_file("f.rs", "v1\n", "add f");
+    // Branch from main, change f.rs = v2 (the source-branch commit).
+    repo.git(&["checkout", "-b", "topic"]);
+    let topic_commit = repo.commit_file("f.rs", "v2\n", "change f on topic");
+    // Back on main: touch a *different* file so f.rs stays v1, then merge.
+    repo.git(&["checkout", "main"]);
+    repo.commit_file("other.txt", "x\n", "touch other on main");
+    repo.git(&["merge", "--no-ff", "topic", "-m", "merge topic"]);
+    harness.push_head();
+    let name = harness.repo_name();
+    let body = harness.get_ok(&format!("/{name}/history/main/f.rs")).body;
+    let merge_oid = repo.git(&["rev-parse", "HEAD"]).trim().to_string();
+    assert!(
+        !body.contains(&merge_oid[..8]),
+        "the merge commit (TREESAME to a parent) should be suppressed:\n{body}"
+    );
+    assert!(
+        body.contains(&topic_commit[..8]),
+        "the source-branch commit that changed the file should appear:\n{body}"
+    );
+}
+/// A mode-only change (chmod +x) keeps the same blob oid, so an oid-only
+/// comparison omits it. `git log -- <path>` includes it, and so must we.
+#[test]
+fn a_mode_only_change_appears_in_the_history() {
+    let harness = ServerHarness::new("file-history-mode");
+    let repo = harness.work_repo();
+    repo.commit_file("s.sh", "echo hi\n", "add script");
+    repo.git(&["update-index", "--chmod=+x", "s.sh"]);
+    repo.git(&["commit", "-m", "chmod +x"]);
+    harness.push_head();
+    let name = harness.repo_name();
+    let body = harness.get_ok(&format!("/{name}/history/main/s.sh")).body;
+    let chmod_oid = repo.git(&["rev-parse", "HEAD"]).trim().to_string();
+    assert!(
+        body.contains(&chmod_oid[..8]),
+        "a mode-only change (same blob oid) must appear in file history:\n{body}"
+    );
+}