hanna/fabrica

feat(web): repository language breakdown bar

52b640c · hanna committed on 2026-07-25

Add a dependency-free language classifier (filename/extension → language + a
Linguist-palette color, ignoring lock files and minified assets) and a git
blob_sizes walk (cheap odb header reads, capped) to weight by bytes. The repo
home shows a proportional language stripe plus a legend of the top languages,
lumping the tail into "Other".

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

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

assets/base.css +40 −0

crates/git/src/repo.rs +32 −0

crates/web/src/languages.rs +182 −0

crates/web/src/lib.rs +1 −0

crates/web/src/repo.rs +50 −0

crates/web/src/tests.rs +41 −0

   flex: none;
+}
+/* Repository language breakdown bar. */
+.lang-bar-wrap {
+  margin: 1rem 0;
+}
+.lang-bar {
+  display: flex;
+  height: 0.6rem;
+  border-radius: 999px;
+  overflow: hidden;
+  background: var(--fb-bg-inset);
+}
+.lang-seg {
+  height: 100%;
+}
+.lang-seg:not(:last-child) {
+  margin-right: 2px;
+}
+.lang-legend {
+  list-style: none;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.35rem 1.1rem;
+  margin-top: 0.75rem;
+}
+.lang-legend li {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+  font-size: 0.9em;
+}
+.lang-dot {
+  width: 0.7rem;
+  height: 0.7rem;
+  border-radius: 50%;
+  flex: none;
+}
+.lang-legend .lang-name {
+  font-weight: 600;
+}
 /* License summary banner shown above a LICENSE file. */
 .license-banner {
   margin-bottom: 1rem;

         Ok(paths)
+    }
+    /// Every regular-file path in `rev`'s tree paired with its blob size in bytes,
+    /// for language statistics. Sizes come from the object header (no content is
+    /// decompressed). Bounded to 20000 files so a pathological tree can't stall a
+    /// page.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`GitError`] if the revision or its tree cannot be read.
+    pub fn blob_sizes(&self, rev: &Resolved) -> Result<Vec<(String, u64)>, GitError> {
+        const CAP: usize = 20_000;
+        let commit = self.commit_at(&rev.oid)?;
+        let tree = commit.tree()?;
+        let odb = self.inner.odb()?;
+        let mut out: Vec<(String, u64)> = Vec::new();
+        tree.walk(git2::TreeWalkMode::PreOrder, |root, entry| {
+            if out.len() >= CAP {
+                return git2::TreeWalkResult::Abort;
+            }
+            let is_blob = entry.filemode() != i32::from(git2::FileMode::Tree)
+                && entry.filemode() != i32::from(git2::FileMode::Commit)
+                && entry.filemode() != i32::from(git2::FileMode::Link);
+            if is_blob
+                && let Some(name) = entry.name()
+                && let Ok((size, _)) = odb.read_header(entry.id())
+            {
+                out.push((format!("{root}{name}"), size as u64));
+            }
+            git2::TreeWalkResult::Ok
+        })?;
+        Ok(out)
+    }
     /// The tree at `path` within a commit, or `None` if the path is absent or is
     /// not a directory. An empty `path` yields the root tree.
     fn subtree_at<'a>(

+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+//! Repository language breakdown for the language bar.
+//!
+//! A pragmatic, dependency-free classifier: files are mapped to a language by
+//! filename or extension against a curated table (colors follow GitHub Linguist),
+//! then weighted by blob size. Unrecognized extensions and obvious non-code files
+//! (lock files, minified assets) are ignored, which keeps the bar focused on the
+//! languages a project is actually written in — it is an approximation, not
+//! Linguist.
+/// One language's share of a repository.
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct LangStat {
+    /// Display name, e.g. "Rust".
+    pub name: &'static str,
+    /// Hex color (Linguist palette), e.g. "#dea584".
+    pub color: &'static str,
+    /// Total bytes attributed to this language.
+    pub bytes: u64,
+    /// Percentage of the counted total, 0–100.
+    pub percent: f64,
+}
+/// Compute the language breakdown from `(path, size)` pairs, largest first.
+/// Returns an empty vec when nothing is recognized.
+pub(crate) fn breakdown(files: &[(String, u64)]) -> Vec<LangStat> {
+    use std::collections::HashMap;
+    let mut totals: HashMap<&'static str, (&'static str, u64)> = HashMap::new();
+    let mut total: u64 = 0;
+    for (path, size) in files {
+        if *size == 0 || is_ignored(path) {
+            continue;
+        }
+        if let Some((name, color)) = classify(path) {
+            let entry = totals.entry(name).or_insert((color, 0));
+            entry.1 += *size;
+            total += *size;
+        }
+    }
+    if total == 0 {
+        return Vec::new();
+    }
+    let mut stats: Vec<LangStat> = totals
+        .into_iter()
+        .map(|(name, (color, bytes))| LangStat {
+            name,
+            color,
+            bytes,
+            #[allow(clippy::cast_precision_loss)]
+            percent: (bytes as f64) * 100.0 / (total as f64),
+        })
+        .collect();
+    // Largest first; ties broken by name for a stable order.
+    stats.sort_by(|a, b| b.bytes.cmp(&a.bytes).then_with(|| a.name.cmp(b.name)));
+    stats
+}
+/// Files never counted toward language stats (lock files, minified/vendored
+/// assets, and generated maps).
+#[allow(clippy::case_sensitive_file_extension_comparisons)] // `name` is lowercased first.
+fn is_ignored(path: &str) -> bool {
+    let name = path.rsplit('/').next().unwrap_or(path).to_ascii_lowercase();
+    name.ends_with(".min.js")
+        || name.ends_with(".min.css")
+        || name.ends_with(".map")
+        || matches!(
+            name.as_str(),
+            "package-lock.json"
+                | "yarn.lock"
+                | "pnpm-lock.yaml"
+                | "cargo.lock"
+                | "poetry.lock"
+                | "composer.lock"
+                | "gemfile.lock"
+                | "flake.lock"
+        )
+}
+/// Classify a path to `(language, color)` by exact filename first, then by the
+/// longest matching extension.
+fn classify(path: &str) -> Option<(&'static str, &'static str)> {
+    let name = path.rsplit('/').next().unwrap_or(path).to_ascii_lowercase();
+    // A few languages are keyed by filename rather than extension.
+    let by_name = match name.as_str() {
+        "dockerfile" => Some(("Dockerfile", "#384d54")),
+        "makefile" => Some(("Makefile", "#427819")),
+        "cmakelists.txt" => Some(("CMake", "#DA3434")),
+        _ => None,
+    };
+    if by_name.is_some() {
+        return by_name;
+    }
+    // Longest-suffix extension match (so `.tar.gz`-style compounds could extend).
+    let ext = name.rsplit('.').next()?;
+    // Guard against extension-less files (rsplit returns the whole name).
+    if !name.contains('.') {
+        return None;
+    }
+    Some(match ext {
+        "rs" => ("Rust", "#dea584"),
+        "py" | "pyi" => ("Python", "#3572A5"),
+        "js" | "cjs" | "mjs" | "jsx" => ("JavaScript", "#f1e05a"),
+        "ts" | "tsx" => ("TypeScript", "#3178c6"),
+        "go" => ("Go", "#00ADD8"),
+        "c" | "h" => ("C", "#555555"),
+        "cc" | "cpp" | "cxx" | "hpp" | "hh" => ("C++", "#f34b7d"),
+        "cs" => ("C#", "#178600"),
+        "java" => ("Java", "#b07219"),
+        "kt" | "kts" => ("Kotlin", "#A97BFF"),
+        "swift" => ("Swift", "#F05138"),
+        "rb" => ("Ruby", "#701516"),
+        "php" => ("PHP", "#4F5D95"),
+        "sh" | "bash" | "zsh" => ("Shell", "#89e051"),
+        "html" | "htm" => ("HTML", "#e34c26"),
+        "css" => ("CSS", "#563d7c"),
+        "scss" | "sass" => ("SCSS", "#c6538c"),
+        "vue" => ("Vue", "#41b883"),
+        "svelte" => ("Svelte", "#ff3e00"),
+        "astro" => ("Astro", "#ff5a03"),
+        "md" | "markdown" => ("Markdown", "#083fa1"),
+        "mdx" => ("MDX", "#fcb32c"),
+        "json" => ("JSON", "#292929"),
+        "yml" | "yaml" => ("YAML", "#cb171e"),
+        "toml" => ("TOML", "#9c4221"),
+        "nix" => ("Nix", "#7e7eff"),
+        "lua" => ("Lua", "#000080"),
+        "ex" | "exs" => ("Elixir", "#6e4a7e"),
+        "erl" => ("Erlang", "#B83998"),
+        "hs" => ("Haskell", "#5e5086"),
+        "ml" | "mli" => ("OCaml", "#ef7a08"),
+        "clj" | "cljs" => ("Clojure", "#db5855"),
+        "scala" => ("Scala", "#c22d40"),
+        "dart" => ("Dart", "#00B4AB"),
+        "r" => ("R", "#198CE7"),
+        "jl" => ("Julia", "#a270ba"),
+        "zig" => ("Zig", "#ec915c"),
+        "sql" => ("SQL", "#e38c00"),
+        "vim" => ("Vim Script", "#199f4b"),
+        "tf" => ("HCL", "#844FBA"),
+        "proto" => ("Protocol Buffers", "#3765a3"),
+        "gradle" => ("Gradle", "#02303a"),
+        _ => return None,
+    })
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn classifies_by_extension_and_name() {
+        assert_eq!(classify("src/main.rs").map(|l| l.0), Some("Rust"));
+        assert_eq!(classify("a/b/Dockerfile").map(|l| l.0), Some("Dockerfile"));
+        assert_eq!(classify("weird_no_ext"), None);
+        assert_eq!(classify("x.unknownext"), None);
+    }
+    #[test]
+    fn breakdown_sums_and_ranks() {
+        let files = vec![
+            ("a.rs".to_string(), 300),
+            ("b.rs".to_string(), 100),
+            ("c.py".to_string(), 100),
+            ("Cargo.lock".to_string(), 9999), // ignored
+            ("readme".to_string(), 50),       // no extension → ignored
+        ];
+        let stats = breakdown(&files);
+        assert_eq!(stats.len(), 2);
+        assert_eq!(stats[0].name, "Rust");
+        assert_eq!(stats[0].bytes, 400);
+        assert!((stats[0].percent - 80.0).abs() < 0.01);
+        assert_eq!(stats[1].name, "Python");
+    }
+    #[test]
+    fn empty_when_nothing_recognized() {
+        assert!(breakdown(&[("data.bin".to_string(), 10)]).is_empty());
+    }
+}

 mod git_http;
 mod icons;
 mod issues;
+mod languages;
 mod layout;
 mod license;
 mod markdown;

 // ---- Repo home ----
+/// The Linguist-style language bar: a proportional stripe plus a legend. Shows
+/// the top languages, lumping the remainder into "Other".
+fn language_bar(langs: &[crate::languages::LangStat]) -> Markup {
+    const MAX_SHOWN: usize = 8;
+    // Collapse the long tail into a single grey "Other" segment.
+    let (head, tail) = langs.split_at(langs.len().min(MAX_SHOWN));
+    let other: f64 = tail.iter().map(|l| l.percent).sum();
+    let pct = |p: f64| format!("{p:.1}%");
+    html! {
+        div class="card lang-bar-wrap" {
+            div class="lang-bar" aria-hidden="true" {
+                @for l in head {
+                    span class="lang-seg"
+                         style=(format!("width:{:.2}%;background:{}", l.percent, l.color)) {}
+                }
+                @if other > 0.0 {
+                    span class="lang-seg" style=(format!("width:{other:.2}%;background:#8b8b8b")) {}
+                }
+            }
+            ul class="lang-legend" {
+                @for l in head {
+                    li {
+                        span class="lang-dot" style=(format!("background:{}", l.color)) {}
+                        span class="lang-name" { (l.name) }
+                        span class="muted" { (pct(l.percent)) }
+                    }
+                }
+                @if other > 0.0 {
+                    li {
+                        span class="lang-dot" style="background:#8b8b8b" {}
+                        span class="lang-name" { "Other" }
+                        span class="muted" { (pct(other)) }
+                    }
+                }
+            }
+        }
+    }
+}
 async fn repo_home(
     state: &AppState,
     viewer: Option<User>,
             .await?;
             let readme = load_readme(state, &ctx.repo.id, &rev, &entries).await;
             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, {
+                let rev = rev.clone();
+                move |repo| repo.blob_sizes(&rev)
+            })
+            .await
+            .map(|files| crate::languages::breakdown(&files))
+            .unwrap_or_default();
             let base = format!("/{}/{}", ctx.owner.username, ctx.repo.path);
             html! {
                 (repo_header(state, &ctx, Tab::Code, &rev_name, &branches))
                     button class="btn" type="submit" { (icon(Icon::Search)) span { "Search" } }
+                }
                 (tree_table(&ctx.owner.username, &ctx.repo.path, &rev_name, "", &entries))
+                @if !langs.is_empty() {
+                    (language_bar(&langs))
+                }
                 @if let Some(rendered) = readme {
                     div class="card markdown readme" { (rendered) }
+                }

+}
 #[tokio::test]
+async fn repo_home_shows_a_language_bar() {
+    let (state, app, _dir) = app_with_git().await;
+    let ada = state.store.user_by_username("ada").await.unwrap().unwrap();
+    let repo = state
+        .store
+        .create_repo(NewRepo {
+            owner_id: ada.id,
+            group_id: None,
+            name: "proj".to_string(),
+            path: "proj".to_string(),
+            description: None,
+            visibility: model::Visibility::Public,
+            default_branch: "main".to_string(),
+        })
+        .await
+        .unwrap();
+    let hook = state.config.storage.data_dir.join("fabrica");
+    git::create_bare(&state.config.storage.repo_dir, &repo.id, "main", &hook).unwrap();
+    let path = git::repo_path(&state.config.storage.repo_dir, &repo.id).unwrap();
+    let raw = git2::Repository::open_bare(&path).unwrap();
+    seed_commit(
+        &raw,
+        "main",
+        &[],
+        &[
+            ("main.rs", "fn main() { println!(\"hi\"); }\n"),
+            ("util.py", "print('hi')\n"),
+        ],
+        "init",
+,
+    );
+    let res = app.oneshot(get("/ada/proj")).await.unwrap();
+    assert_eq!(res.status(), StatusCode::OK);
+    let html = body_string(res).await;
+    assert!(html.contains("lang-bar"), "language bar rendered");
+    assert!(html.contains("Rust"), "Rust detected");
+    assert!(html.contains("Python"), "Python detected");
+}
+#[tokio::test]
 async fn license_file_shows_a_rights_banner() {
     let (state, app, _dir) = app_with_git().await;
     let ada = state.store.user_by_username("ada").await.unwrap().unwrap();