hanna/fabrica

feat(web): detect LFS via .gitattributes and fix image preview

d528561 · hanna committed on 2026-07-26

- LFS-tracking is now determined by `.gitattributes filter=lfs` (the
  authoritative signal) in addition to the pointer-content sniff, so a
  file tracked by LFS shows the pill even when its blob was committed
  inline. Adds git::Attributes::is_lfs and threads it through the tree
  view and blob view (an "LFS" pill now shows in the blob header too).
- The inline image preview sits flush under the header (no baseline gap)
  and is clipped to the card's rounded bottom corners.

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

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

assets/base.css +15 −0

crates/git/src/attributes.rs +6 −0

crates/git/src/repo.rs +26 −7

crates/web/src/repo.rs +16 −5

   border-top: none;
   border-radius: 0 0 var(--fb-radius) var(--fb-radius);
+}
+/* Inline image preview: flush under the header (no baseline gap), clipped to the
+   rounded bottom corners. */
+.blob-image {
+  background: var(--fb-bg-inset);
+  border: 1px solid var(--fb-border);
+  border-top: none;
+  border-radius: 0 0 var(--fb-radius) var(--fb-radius);
+  overflow: hidden;
+  line-height: 0;
+}
+.blob-image img {
+  display: block;
+  max-width: 100%;
+  margin: 0 auto;
+}
 /* The blob box: border, rounded bottom, scroll, and vertical breathing room. */
 .blob-code {

     pub fn is_vendored(&self) -> bool {
         self.is_set("linguist-vendored")
+    }
+    /// Whether the path is managed by git-LFS (`filter=lfs` in `.gitattributes`).
+    #[must_use]
+    pub fn is_lfs(&self) -> bool {
+        matches!(self.map.get("filter"), Some(AttrValue::Value(v)) if v == "lfs")
+    }
+}
 /// One `.gitattributes` file: its directory prefix (`""` at the tree root) and its

             .map(|b| parse_gitmodules(b.content()))
             .unwrap_or_default();
+        // `.gitattributes` filter=lfs is the authoritative "tracked by LFS" signal
+        // (a file can be LFS-tracked even if a given blob was committed inline).
+        let attrs = self.attributes_set(&rev.oid).ok();
+        let dir_prefix = path_string(path);
         let tree = if path.components().next().is_none() {
             Some(root)
         } else {
         let mut lfs = std::collections::HashSet::new();
         if let Some(tree) = tree {
             for entry in &tree {
-                if entry.kind() == Some(git2::ObjectType::Blob)
+                let Some(name) = entry.name() else { continue };
-                    && let Ok(obj) = entry.to_object(&self.inner)
+                if entry.kind() != Some(git2::ObjectType::Blob) {
-                    && let Some(blob) = obj.as_blob()
+                    continue;
-                    && blob.size() < POINTER_MAX
+                }
-                    && is_lfs_pointer(blob.content())
+                let full = if dir_prefix.is_empty() {
-                    && let Some(name) = entry.name()
+                    name.to_string()
-                {
+                } else {
+                    format!("{dir_prefix}/{name}")
+                };
+                let tracked = attrs
+                    .as_ref()
+                    .is_some_and(|set| set.attributes(&full).is_lfs());
+                let pointer = entry
+                    .to_object(&self.inner)
+                    .ok()
+                    .and_then(|o| {
+                        o.as_blob()
+                            .map(|b| b.size() < POINTER_MAX && is_lfs_pointer(b.content()))
+                    })
+                    .unwrap_or(false);
+                if tracked || pointer {
                     lfs.insert(name.to_string());
+                }
+            }

     })
     .await?;
-    // Read the blob and resolve any attribute language override in one pass.
+    // Read the blob and resolve attribute-driven facts (language, LFS) in one pass.
-    let (blob, attr_lang) = git_read(state, &ctx.repo.id, {
+    let (blob, attr_lang, is_lfs) = git_read(state, &ctx.repo.id, {
         let rev = rev.clone();
         let path = path.clone();
         move |repo| {
             let blob = repo.blob(&rev, FsPath::new(&path))?;
             let attrs = repo.attributes_set(&rev.oid).ok();
-            let lang = attrs.and_then(|set| set.attributes(&path).language().map(str::to_string));
+            let resolved = attrs.map(|set| set.attributes(&path));
-            Ok((blob, lang))
+            let lang = resolved
+                .as_ref()
+                .and_then(|a| a.language().map(str::to_string));
+            let is_lfs = resolved.as_ref().is_some_and(git::Attributes::is_lfs)
+                || (blob.size < 1024
+                    && blob
+                        .content
+                        .starts_with(b"version https://git-lfs.github.com/spec/v1"));
+            Ok((blob, lang, is_lfs))
+        }
     })
     .await?;
         &path,
         &blob,
         attr_lang.as_deref(),
+        is_lfs,
         source_view,
     );
     // For a license file, detect it and show a rights summary above the content.
     path: &str,
     blob: &git::Blob,
     attr_lang: Option<&str>,
+    is_lfs: bool,
     source_view: bool,
 ) -> Markup {
     let base = format!("/{}/{}", ctx.owner.username, ctx.repo.path);
     html! {
         div class="blob-header" {
             span class="muted" { (blob.size) " bytes" }
+            @if is_lfs { span class="badge lfs-pill" { "LFS" } }
             div class="blob-actions" {
                 @if previewable {
                     a class=(toggle_class(show_preview)) href=(blob_url.clone()) { "Preview" }
+            }
+        }
         @if is_image(filename) {
-            p { img src=(raw_url) alt=(filename) style="max-width:100%"; }
+            div class="blob-image" { img src=(raw_url) alt=(filename); }
         } @else if blob.is_binary {
             div class="card" {
                 p class="muted" { "Binary file not shown." }