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


			@@ -595,6 +595,46 @@ body.drawer-open .drawer-backdrop {
595	595		flex: none;
596	596		}
597	597
	598	+	/* Repository language breakdown bar. */
	599	+	.lang-bar-wrap {
	600	+	margin: 1rem 0;
	601	+	}
	602	+	.lang-bar {
	603	+	display: flex;
	604	+	height: 0.6rem;
	605	+	border-radius: 999px;
	606	+	overflow: hidden;
	607	+	background: var(--fb-bg-inset);
	608	+	}
	609	+	.lang-seg {
	610	+	height: 100%;
	611	+	}
	612	+	.lang-seg:not(:last-child) {
	613	+	margin-right: 2px;
	614	+	}
	615	+	.lang-legend {
	616	+	list-style: none;
	617	+	display: flex;
	618	+	flex-wrap: wrap;
	619	+	gap: 0.35rem 1.1rem;
	620	+	margin-top: 0.75rem;
	621	+	}
	622	+	.lang-legend li {
	623	+	display: flex;
	624	+	align-items: center;
	625	+	gap: 0.4rem;
	626	+	font-size: 0.9em;
	627	+	}
	628	+	.lang-dot {
	629	+	width: 0.7rem;
	630	+	height: 0.7rem;
	631	+	border-radius: 50%;
	632	+	flex: none;
	633	+	}
	634	+	.lang-legend .lang-name {
	635	+	font-weight: 600;
	636	+	}
	637	+
598	638		/* License summary banner shown above a LICENSE file. */
599	639		.license-banner {
600	640		margin-bottom: 1rem;

@@ @@ -549,6 +549,38 @@ impl Repo { @@
         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>(

@@ @@ -0,0 +1,182 @@ @@
 // 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());
+    }
+}

@@ @@ -18,6 +18,7 @@ mod error; @@
 mod git_http;
 mod icons;
 mod issues;
 mod languages;
 mod layout;
 mod license;
 mod markdown;


			@@ -455,6 +455,45 @@ fn ref_or_default(repo: &Repo, given: &str) -> String {
455	455
456	456		// ---- Repo home ----
457	457
	458	+	/// The Linguist-style language bar: a proportional stripe plus a legend. Shows
	459	+	/// the top languages, lumping the remainder into "Other".
	460	+	fn language_bar(langs: &[crate::languages::LangStat]) -> Markup {
	461	+	const MAX_SHOWN: usize = 8;
	462	+	// Collapse the long tail into a single grey "Other" segment.
	463	+	let (head, tail) = langs.split_at(langs.len().min(MAX_SHOWN));
	464	+	let other: f64 = tail.iter().map(\|l\| l.percent).sum();
	465	+	let pct = \|p: f64\| format!("{p:.1}%");
	466	+	html! {
	467	+	div class="card lang-bar-wrap" {
	468	+	div class="lang-bar" aria-hidden="true" {
	469	+	@for l in head {
	470	+	span class="lang-seg"
	471	+	style=(format!("width:{:.2}%;background:{}", l.percent, l.color)) {}
	472	+	}
	473	+	@if other > 0.0 {
	474	+	span class="lang-seg" style=(format!("width:{other:.2}%;background:#8b8b8b")) {}
	475	+	}
	476	+	}
	477	+	ul class="lang-legend" {
	478	+	@for l in head {
	479	+	li {
	480	+	span class="lang-dot" style=(format!("background:{}", l.color)) {}
	481	+	span class="lang-name" { (l.name) }
	482	+	span class="muted" { (pct(l.percent)) }
	483	+	}
	484	+	}
	485	+	@if other > 0.0 {
	486	+	li {
	487	+	span class="lang-dot" style="background:#8b8b8b" {}
	488	+	span class="lang-name" { "Other" }
	489	+	span class="muted" { (pct(other)) }
	490	+	}
	491	+	}
	492	+	}
	493	+	}
	494	+	}
	495	+	}
	496	+
458	497		async fn repo_home(
459	498		state: &AppState,
460	499		viewer: Option<User>,

			@@ -480,6 +519,14 @@ async fn repo_home(
480	519		.await?;
481	520		let readme = load_readme(state, &ctx.repo.id, &rev, &entries).await;
482	521		let branches = branch_names(state, &ctx.repo.id).await;
	522	+	// The language breakdown of the default branch (best-effort).
	523	+	let langs = git_read(state, &ctx.repo.id, {
	524	+	let rev = rev.clone();
	525	+	move \|repo\| repo.blob_sizes(&rev)
	526	+	})
	527	+	.await
	528	+	.map(\|files\| crate::languages::breakdown(&files))
	529	+	.unwrap_or_default();
483	530		let base = format!("/{}/{}", ctx.owner.username, ctx.repo.path);
484	531		html! {
485	532		(repo_header(state, &ctx, Tab::Code, &rev_name, &branches))

			@@ -489,6 +536,9 @@ async fn repo_home(
489	536		button class="btn" type="submit" { (icon(Icon::Search)) span { "Search" } }
490	537		}
491	538		(tree_table(&ctx.owner.username, &ctx.repo.path, &rev_name, "", &entries))
	539	+	@if !langs.is_empty() {
	540	+	(language_bar(&langs))
	541	+	}
492	542		@if let Some(rendered) = readme {
493	543		div class="card markdown readme" { (rendered) }
494	544		}

@@ @@ -980,6 +980,47 @@ async fn new_repo_can_use_sha256_object_format() { @@
+}
 #[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();