hanna/fabrica

feat(web): LFS pill and submodule links in the tree view

423c5ec · hanna committed on 2026-07-26

Add git::Repo::tree_annotations(rev, dir), which reads .gitmodules for a
submodule path→URL map and sniffs small blobs for the git-LFS pointer
signature. The tree view uses it to:

- tag LFS-tracked files with an "LFS" pill on the right, and
- render submodule (gitlink) entries as links to their remote (git@ and
  ssh:// URLs are rewritten to browsable https), or a plain row when the
  URL is unknown.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Signed by hannaSSH key fingerprint: SHA256:4g9cWhkAAw8gwqhJUcVbSnGEvdGwklW+1Aa/fMUu59k

assets/base.css +19 −0

crates/git/src/lib.rs +1 −1

crates/git/src/repo.rs +110 −1

crates/git/src/types.rs +10 −0

crates/web/src/repo.rs +60 −7

   text-overflow: ellipsis;
   white-space: nowrap;
+}
+/* A small pill to the right of a tree entry (LFS-tracked file, submodule). */
+.tree-pill {
+  margin-left: auto;
+  flex: none;
+  padding: 0.02rem 0.4rem;
+  font-size: 0.72em;
+  font-weight: 600;
+  letter-spacing: 0.03em;
+  color: var(--fb-fg-muted);
+  border: 1px solid var(--fb-border);
+  border-radius: 999px;
+}
+.lfs-pill {
+  color: var(--fb-accent);
+  border-color: var(--fb-accent);
+}
+.file-row.is-submodule .file-icon {
+  color: var(--fb-accent);
+}
 .blob-header {
   display: flex;

 pub use crate::types::{
     Blob, BranchInfo, CommitDetail, CommitSummary, DeltaStatus, DiffLine, DiffOpts, EntryKind,
     FileDiff, FileDiffs, Hunk, LineOrigin, Oid, Page, Person, RefKind, Resolved, TagInfo,
-    TreeEntry,
+    TreeAnnotations, TreeEntry,
 };
 /// An error from the git layer.

 use crate::types::{
     Blob, BranchInfo, CommitDetail, CommitSummary, DeltaStatus, DiffLine, DiffOpts, EntryKind,
     FileDiff, FileDiffs, Hunk, LineOrigin, Oid, Page, Person, RefKind, Resolved, TagInfo,
-    TreeEntry,
+    TreeAnnotations, TreeEntry,
 };
 /// Filemode bits git uses to distinguish tree-entry kinds.
         Ok(entries)
+    }
+    /// Annotate the directory `path` at `rev`: which file entries are git-LFS
+    /// pointers (small blobs whose content is a pointer), and the whole-repo
+    /// submodule→URL map from `.gitmodules`. Best-effort — a missing or malformed
+    /// `.gitmodules`, or an unreadable blob, simply yields fewer annotations.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`GitError`] only if the revision's commit or root tree is missing.
+    pub fn tree_annotations(
+        &self,
+        rev: &Resolved,
+        path: &Path,
+    ) -> Result<TreeAnnotations, GitError> {
+        /// Pointer files are tiny; skip reading anything larger.
+        const POINTER_MAX: usize = 1024;
+        let commit = self.commit_at(&rev.oid)?;
+        let root = commit.tree()?;
+        let submodules = root
+            .get_path(Path::new(".gitmodules"))
+            .ok()
+            .and_then(|e| e.to_object(&self.inner).ok())
+            .and_then(|o| o.into_blob().ok())
+            .map(|b| parse_gitmodules(b.content()))
+            .unwrap_or_default();
+        let tree = if path.components().next().is_none() {
+            Some(root)
+        } else {
+            root.get_path(path)
+                .ok()
+                .and_then(|e| e.to_object(&self.inner).ok())
+                .and_then(|o| o.into_tree().ok())
+        };
+        let mut lfs = std::collections::HashSet::new();
+        if let Some(tree) = tree {
+            for entry in &tree {
+                if entry.kind() == Some(git2::ObjectType::Blob)
+                    && let Ok(obj) = entry.to_object(&self.inner)
+                    && let Some(blob) = obj.as_blob()
+                    && blob.size() < POINTER_MAX
+                    && is_lfs_pointer(blob.content())
+                    && let Some(name) = entry.name()
+                {
+                    lfs.insert(name.to_string());
+                }
+            }
+        }
+        Ok(TreeAnnotations { lfs, submodules })
+    }
     /// Read the file at `path` within revision `rev`.
     ///
     /// # Errors
     window.contains(&0)
+}
+/// Whether a blob's content is a git-LFS pointer (its mandatory first line).
+fn is_lfs_pointer(content: &[u8]) -> bool {
+    content.starts_with(b"version https://git-lfs.github.com/spec/v1")
+}
+/// Parse a `.gitmodules` file into a `submodule path → url` map. The format is
+/// git-config: `[submodule "name"]` sections each with `path` and `url` keys.
+fn parse_gitmodules(content: &[u8]) -> HashMap<String, String> {
+    let text = String::from_utf8_lossy(content);
+    let mut map = HashMap::new();
+    let mut path: Option<String> = None;
+    let mut url: Option<String> = None;
+    for line in text.lines() {
+        let line = line.trim();
+        if line.starts_with('[') {
+            if let (Some(p), Some(u)) = (path.take(), url.take()) {
+                map.insert(p, u);
+            }
+        } else if let Some(rest) = line.strip_prefix("path") {
+            if let Some(v) = rest.trim_start().strip_prefix('=') {
+                path = Some(v.trim().to_string());
+            }
+        } else if let Some(rest) = line.strip_prefix("url") {
+            if let Some(v) = rest.trim_start().strip_prefix('=') {
+                url = Some(v.trim().to_string());
+            }
+        }
+    }
+    if let (Some(p), Some(u)) = (path, url) {
+        map.insert(p, u);
+    }
+    map
+}
 #[cfg(test)]
 mod tests {
     #![allow(clippy::unwrap_used, clippy::expect_used)]
     use super::*;
     use crate::{create_bare, repo_path};
+    #[test]
+    fn detects_lfs_pointer_content() {
+        let pointer = b"version https://git-lfs.github.com/spec/v1\noid sha256:abc\nsize 12\n";
+        assert!(is_lfs_pointer(pointer));
+        assert!(!is_lfs_pointer(b"#!/bin/sh\necho hi\n"));
+        assert!(!is_lfs_pointer(b""));
+    }
+    #[test]
+    fn parses_gitmodules_path_and_url() {
+        let text = b"[submodule \"vendor/lib\"]\n\tpath = vendor/lib\n\turl = https://example.com/lib.git\n\
+                     [submodule \"x\"]\n\tpath = tools/x\n\turl = git@host:org/x.git\n";
+        let map = parse_gitmodules(text);
+        assert_eq!(
+            map.get("vendor/lib").map(String::as_str),
+            Some("https://example.com/lib.git")
+        );
+        assert_eq!(
+            map.get("tools/x").map(String::as_str),
+            Some("git@host:org/x.git")
+        );
+    }
     const ID: &str = "01hzxk9m2n8p7q6r5s4t3v2w1x";
     /// A populated bare repository plus the temp dir keeping it alive.

     Submodule,
+}
+/// Extra per-directory facts for the tree view that need reading blobs: which
+/// file entries are git-LFS pointers, and each submodule's remote URL.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct TreeAnnotations {
+    /// Entry names in the listed directory whose blob is a git-LFS pointer.
+    pub lfs: std::collections::HashSet<String>,
+    /// Submodule repo-path → remote URL, parsed from `.gitmodules`.
+    pub submodules: std::collections::HashMap<String, String>,
+}
 /// One entry in a tree listing.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct TreeEntry {

             })
             .await?;
             let readme = load_readme(state, &ctx.repo.id, &rev, &entries).await;
+            let annotations = git_read(state, &ctx.repo.id, {
+                let rev = rev.clone();
+                move |repo| repo.tree_annotations(&rev, FsPath::new(""))
+            })
+            .await
+            .unwrap_or_default();
             let branches = branch_names(state, &ctx.repo.id).await;
             // The language breakdown of the default branch (best-effort).
             let langs = git_read(state, &ctx.repo.id, {
                 @if !langs.is_empty() {
                     (language_bar(&langs))
+                }
-                (tree_table(&ctx.owner.username, &ctx.repo.path, &rev_name, "", &entries))
+                (tree_table(&ctx.owner.username, &ctx.repo.path, &rev_name, "", &entries, &annotations))
                 @if let Some(rendered) = readme {
                     div class="card markdown readme" { (rendered) }
+                }
         move |repo| repo.tree_entries(&rev, FsPath::new(&path))
     })
     .await?;
+    let annotations = git_read(state, &ctx.repo.id, {
+        let rev = rev.clone();
+        let path = path.clone();
+        move |repo| repo.tree_annotations(&rev, FsPath::new(&path))
+    })
+    .await
+    .unwrap_or_default();
     let branches = branch_names(state, &ctx.repo.id).await;
     let body = html! {
         (repo_header(state, &ctx, Tab::Code, &rev_name, &branches))
         (breadcrumb(&ctx.owner.username, &ctx.repo.path, &rev_name, &path))
-        (tree_table(&ctx.owner.username, &ctx.repo.path, &rev_name, &path, &entries))
+        (tree_table(&ctx.owner.username, &ctx.repo.path, &rev_name, &path, &entries, &annotations))
     };
     let (jar, chrome) = build_chrome(state, jar, viewer, uri.path().to_string());
     let title = format!("{}/{}: {path}", ctx.owner.username, ctx.repo.path);
     rev: &str,
     dir: &str,
     entries: &[git::TreeEntry],
+    annotations: &git::TreeAnnotations,
 ) -> Markup {
     let href = |name: &str, kind: git::EntryKind| {
         let sub = if dir.is_empty() {
     html! {
         div class="file-tree card" {
             @for entry in sorted {
-                @let is_dir = entry.kind == git::EntryKind::Directory;
+                @let full = if dir.is_empty() { entry.name.clone() } else { format!("{dir}/{}", entry.name) };
-                a class=(if is_dir { "file-row is-dir" } else { "file-row" })
+                @if entry.kind == git::EntryKind::Submodule {
-                  href=(href(&entry.name, entry.kind)) {
+                    // A gitlink: link out to the submodule's remote (from .gitmodules).
-                    span class="file-icon" { (icon(entry_icon(entry.kind))) }
+                    @let url = annotations.submodules.get(&full).map(|u| submodule_href(u));
-                    span class="file-name" { (entry.name) }
+                    @if let Some(url) = url {
+                        a class="file-row is-submodule" href=(url) rel="noopener" {
+                            span class="file-icon" { (icon(Icon::Box)) }
+                            span class="file-name" { (entry.name) }
+                            span class="tree-pill" { "submodule" }
+                        }
+                    } @else {
+                        span class="file-row is-submodule" {
+                            span class="file-icon" { (icon(Icon::Box)) }
+                            span class="file-name" { (entry.name) }
+                            span class="tree-pill" { "submodule" }
+                        }
+                    }
+                } @else {
+                    @let is_dir = entry.kind == git::EntryKind::Directory;
+                    a class=(if is_dir { "file-row is-dir" } else { "file-row" })
+                      href=(href(&entry.name, entry.kind)) {
+                        span class="file-icon" { (icon(entry_icon(entry.kind))) }
+                        span class="file-name" { (entry.name) }
+                        @if annotations.lfs.contains(&entry.name) {
+                            span class="tree-pill lfs-pill" { "LFS" }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+/// Turn a submodule's `.gitmodules` URL into a browsable https link (best-effort).
+fn submodule_href(url: &str) -> String {
+    let u = url.trim();
+    if let Some(rest) = u.strip_prefix("git@")
+        && let Some((host, path)) = rest.split_once(':')
+    {
+        return format!("https://{host}/{}", path.trim_end_matches(".git"));
+    }
+    if let Some(rest) = u.strip_prefix("ssh://") {
+        let rest = rest.strip_prefix("git@").unwrap_or(rest);
+        if let Some((host, path)) = rest.split_once('/') {
+            return format!("https://{host}/{}", path.trim_end_matches(".git"));
+        }
+    }
+    u.trim_end_matches(".git").to_string()
+}
 /// An icon glyph for a tree entry kind.
 fn entry_icon(kind: git::EntryKind) -> Icon {
     match kind {