hanna/fabrica

feat(web): license detection banner on LICENSE files

aefa2ff · hanna committed on 2026-07-25

Add a lightweight license detector (curated marker-phrase matching for MIT,
Apache-2.0, BSD-2/3-Clause, 0BSD, ISC, MPL-2.0, GPL-2/3.0, LGPL-3.0, AGPL-3.0,
Unlicense) and show a GitHub-style summary above a LICENSE/COPYING file: the
license name and SPDX id plus its permissions, conditions, and limitations,
with a "not legal advice" note. Unrecognized licenses simply show no banner.

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

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

assets/base.css +71 −0

crates/web/src/icons.rs +8 −0

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

crates/web/src/license.rs +261 −0

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

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

   flex: none;
+}
+/* License summary banner shown above a LICENSE file. */
+.license-banner {
+  margin-bottom: 1rem;
+}
+.license-head {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+}
+.license-head > .icon {
+  width: 2rem;
+  height: 2rem;
+  flex: none;
+  color: var(--fb-fg-muted);
+}
+.license-head h3 {
+  margin: 0;
+}
+.license-eyebrow {
+  margin: 0;
+  font-size: 0.85em;
+}
+.license-desc {
+  margin: 0.75rem 0;
+}
+.license-cols {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 1rem;
+  padding-top: 0.75rem;
+  border-top: 1px solid var(--fb-border);
+}
+.license-col h4 {
+  margin: 0 0 0.5rem;
+  font-size: 0.9rem;
+}
+.license-col ul {
+  list-style: none;
+  display: flex;
+  flex-direction: column;
+  gap: 0.3rem;
+}
+.license-col li {
+  display: flex;
+  align-items: center;
+  gap: 0.4rem;
+}
+.license-col li .icon {
+  width: 0.95rem;
+  height: 0.95rem;
+  flex: none;
+}
+.license-col li.ok .icon {
+  color: var(--fb-success);
+}
+.license-col li.no .icon {
+  color: var(--fb-danger);
+}
+.license-col li.cond .icon {
+  color: var(--fb-accent);
+}
+.license-note {
+  margin: 0.75rem 0 0;
+  font-size: 0.82em;
+}
+@media (max-width: 40rem) {
+  .license-cols {
+    grid-template-columns: 1fr;
+  }
+}
 /* Pagination controls for long lists. */
 .pagination {
   display: flex;

     Compass,
     MapPin,
     Mail,
+    Check,
+    X,
+    Scale,
     Globe,
     Download,
     Github,
             Icon::Mail => {
                 r#"<rect width="20" height="16" x="2" y="4" rx="2"/><path d="m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"/>"#
+            }
+            Icon::Check => r#"<path d="M20 6 9 17l-5-5"/>"#,
+            Icon::X => r#"<path d="M18 6 6 18"/><path d="m6 6 12 12"/>"#,
+            Icon::Scale => {
+                r#"<path d="m16 16 3-8 3 8c-.87.65-1.92 1-3 1s-2.13-.35-3-1Z"/><path d="m2 16 3-8 3 8c-.87.65-1.92 1-3 1s-2.13-.35-3-1Z"/><path d="M7 21h10"/><path d="M12 3v18"/><path d="M3 7h2c2 0 5-1 7-2 2 1 5 2 7 2h2"/>"#
+            }
             Icon::Globe => {
                 r#"<circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/>"#
+            }

 mod icons;
 mod issues;
 mod layout;
+mod license;
 mod markdown;
 mod pages;
 mod pulls;

         attr_lang.as_deref(),
         source_view,
     );
+    // For a license file, detect it and show a rights summary above the content.
+    let license = (!blob.is_binary && crate::license::is_license_path(&path))
+        .then(|| crate::license::detect(&String::from_utf8_lossy(&blob.content)))
+        .flatten();
     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))
+        @if let Some(info) = license {
+            (license_banner(info))
+        }
         (content_body)
     };
     let (jar, chrome) = build_chrome(state, jar, viewer, uri.path().to_string());
     Ok((jar, page(&chrome, &title, body)).into_response())
+}
+/// The GitHub-style license summary banner: name, description, and the
+/// permissions / conditions / limitations columns. Informational, not legal
+/// advice.
+fn license_banner(info: &crate::license::LicenseInfo) -> Markup {
+    let column = |title: &str, items: &[&str], marker: Icon, class: &str| {
+        html! {
+            div class="license-col" {
+                h4 { (title) }
+                @if items.is_empty() {
+                    p class="muted license-none" { "None" }
+                } @else {
+                    ul {
+                        @for item in items {
+                            li class=(class) { (icon(marker)) span { (item) } }
+                        }
+                    }
+                }
+            }
+        }
+    };
+    html! {
+        div class="card license-banner" {
+            div class="license-head" {
+                (icon(Icon::Scale))
+                div {
+                    p class="muted license-eyebrow" { "This repository is licensed under the" }
+                    h3 { (info.name) " " span class="muted mono" { "(" (info.spdx) ")" } }
+                }
+            }
+            p class="license-desc muted" { (info.description) }
+            div class="license-cols" {
+                (column("Permissions", info.permissions, Icon::Check, "ok"))
+                (column("Conditions", info.conditions, Icon::Issue, "cond"))
+                (column("Limitations", info.limitations, Icon::X, "no"))
+            }
+            p class="license-note muted" { "This is a summary, not legal advice." }
+        }
+    }
+}
 /// Render a blob: a rendered preview for markdown, highlighted code with line
 /// anchors, an inline image, or a binary notice.
 fn render_blob(

+}
 #[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();
+    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();
+    let mit = "MIT License\n\nPermission is hereby granted, free of charge, to any person \
+         obtaining a copy of this software.\n";
+    seed_commit(&raw, "main", &[], &[("LICENSE", mit)], "add license", 1);
+    let res = app
+        .oneshot(get("/ada/proj/-/blob/main/LICENSE"))
+        .await
+        .unwrap();
+    assert_eq!(res.status(), StatusCode::OK);
+    let html = body_string(res).await;
+    assert!(html.contains("MIT License"), "license name shown");
+    assert!(html.contains("Permissions"), "rights columns shown");
+    assert!(html.contains("license-banner"), "banner rendered");
+}
+#[tokio::test]
 async fn pulls_404_when_disabled() {
     let (state, app) = app().await;
     let ada = state.store.user_by_username("ada").await.unwrap().unwrap();

+// 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/.
+//! Lightweight license detection for the file view.
+//!
+//! This is not a full SPDX matcher (à la GitHub's licensee): it recognizes a
+//! curated set of common licenses by distinctive marker phrases and maps each to
+//! a small table of permissions / conditions / limitations sourced from
+//! [choosealicense.com](https://choosealicense.com). It is deliberately
+//! conservative — an unrecognized or heavily modified license simply shows no
+//! banner. The rights summary is informational, never legal advice.
+/// A recognized license and its rights summary.
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct LicenseInfo {
+    /// Human-readable name, e.g. "MIT License".
+    pub name: &'static str,
+    /// SPDX identifier, e.g. "MIT".
+    pub spdx: &'static str,
+    /// One-line plain description.
+    pub description: &'static str,
+    /// What the license permits.
+    pub permissions: &'static [&'static str],
+    /// What it requires.
+    pub conditions: &'static [&'static str],
+    /// What it limits.
+    pub limitations: &'static [&'static str],
+}
+/// Whether `path`'s filename looks like a license file (`LICENSE`, `LICENCE`,
+/// `COPYING`, optionally with an extension, case-insensitive).
+pub(crate) fn is_license_path(path: &str) -> bool {
+    let name = path.rsplit('/').next().unwrap_or(path).to_ascii_lowercase();
+    let stem = name.split('.').next().unwrap_or(&name);
+    matches!(
+        stem,
+        "license" | "licence" | "copying" | "copyright" | "unlicense"
+    )
+}
+/// Detect the license from a file's text, or `None` if it is not one of the
+/// recognized licenses. Matching is order-sensitive (most specific first).
+pub(crate) fn detect(content: &str) -> Option<&'static LicenseInfo> {
+    // Collapse whitespace and lowercase so wrapping/indentation doesn't matter.
+    let normalized: String = content
+        .to_ascii_lowercase()
+        .split_whitespace()
+        .collect::<Vec<_>>()
+        .join(" ");
+    let has = |needle: &str| normalized.contains(needle);
+    // Order matters: check more specific markers before generic ones.
+    if has("gnu affero general public license") {
+        return Some(&AGPL_3_0);
+    }
+    if has("gnu lesser general public license") {
+        return Some(&LGPL_3_0);
+    }
+    if has("gnu general public license") {
+        if has("version 2") {
+            return Some(&GPL_2_0);
+        }
+        return Some(&GPL_3_0);
+    }
+    if has("mozilla public license version 2.0") {
+        return Some(&MPL_2_0);
+    }
+    if has("apache license") && has("version 2.0") {
+        return Some(&APACHE_2_0);
+    }
+    if has("this is free and unencumbered software released into the public domain") {
+        return Some(&UNLICENSE);
+    }
+    if has("permission to use, copy, modify, and/or distribute this software") {
+        // 0BSD drops ISC's "provided that the above copyright" retention clause.
+        if has("provided that the above copyright") {
+            return Some(&ISC);
+        }
+        return Some(&BSD_0);
+    }
+    if has("redistribution and use in source and binary forms") {
+        if has("neither the name") {
+            return Some(&BSD_3_CLAUSE);
+        }
+        return Some(&BSD_2_CLAUSE);
+    }
+    if has("permission is hereby granted, free of charge") {
+        return Some(&MIT);
+    }
+    None
+}
+// ---- Rights vocabulary (choosealicense.com labels) ----
+const COMMERCIAL: &str = "Commercial use";
+const MODIFY: &str = "Modification";
+const DISTRIBUTE: &str = "Distribution";
+const PRIVATE: &str = "Private use";
+const PATENT: &str = "Patent use";
+const LIABILITY: &str = "Liability";
+const WARRANTY: &str = "Warranty";
+const TRADEMARK: &str = "Trademark use";
+const KEEP_NOTICE: &str = "License and copyright notice";
+const STATE_CHANGES: &str = "State changes";
+const DISCLOSE_SOURCE: &str = "Disclose source";
+const SAME_LICENSE: &str = "Same license";
+const NETWORK_DISCLOSE: &str = "Network use is distribution";
+const PERMISSIVE: &[&str] = &[COMMERCIAL, MODIFY, DISTRIBUTE, PRIVATE];
+const PERMISSIVE_PATENT: &[&str] = &[COMMERCIAL, MODIFY, DISTRIBUTE, PATENT, PRIVATE];
+const NO_WARRANTY: &[&str] = &[LIABILITY, WARRANTY];
+const MIT: LicenseInfo = LicenseInfo {
+    name: "MIT License",
+    spdx: "MIT",
+    description: "A short, permissive license: do almost anything, provided the copyright and license notice are preserved.",
+    permissions: PERMISSIVE,
+    conditions: &[KEEP_NOTICE],
+    limitations: NO_WARRANTY,
+};
+const APACHE_2_0: LicenseInfo = LicenseInfo {
+    name: "Apache License 2.0",
+    spdx: "Apache-2.0",
+    description: "A permissive license with an express grant of patent rights and requirements to note changes.",
+    permissions: PERMISSIVE_PATENT,
+    conditions: &[KEEP_NOTICE, STATE_CHANGES],
+    limitations: &[TRADEMARK, LIABILITY, WARRANTY],
+};
+const BSD_2_CLAUSE: LicenseInfo = LicenseInfo {
+    name: "BSD 2-Clause License",
+    spdx: "BSD-2-Clause",
+    description: "A permissive license that requires preservation of the copyright and license notices.",
+    permissions: PERMISSIVE,
+    conditions: &[KEEP_NOTICE],
+    limitations: NO_WARRANTY,
+};
+const BSD_3_CLAUSE: LicenseInfo = LicenseInfo {
+    name: "BSD 3-Clause License",
+    spdx: "BSD-3-Clause",
+    description: "A permissive license like BSD 2-Clause, also forbidding use of contributors' names to endorse derivatives.",
+    permissions: PERMISSIVE,
+    conditions: &[KEEP_NOTICE],
+    limitations: NO_WARRANTY,
+};
+const BSD_0: LicenseInfo = LicenseInfo {
+    name: "BSD Zero Clause License",
+    spdx: "0BSD",
+    description: "A public-domain-equivalent license with no attribution requirement whatsoever.",
+    permissions: PERMISSIVE,
+    conditions: &[],
+    limitations: NO_WARRANTY,
+};
+const ISC: LicenseInfo = LicenseInfo {
+    name: "ISC License",
+    spdx: "ISC",
+    description: "A permissive license functionally equivalent to MIT/BSD 2-Clause, with simpler language.",
+    permissions: PERMISSIVE,
+    conditions: &[KEEP_NOTICE],
+    limitations: NO_WARRANTY,
+};
+const MPL_2_0: LicenseInfo = LicenseInfo {
+    name: "Mozilla Public License 2.0",
+    spdx: "MPL-2.0",
+    description: "A file-level copyleft license: modified files must stay open, but they can be combined with proprietary code.",
+    permissions: PERMISSIVE_PATENT,
+    conditions: &[DISCLOSE_SOURCE, KEEP_NOTICE, SAME_LICENSE],
+    limitations: &[TRADEMARK, LIABILITY, WARRANTY],
+};
+const GPL_2_0: LicenseInfo = LicenseInfo {
+    name: "GNU General Public License v2.0",
+    spdx: "GPL-2.0",
+    description: "A strong copyleft license: derivatives must be released under the same terms with source available.",
+    permissions: PERMISSIVE,
+    conditions: &[DISCLOSE_SOURCE, KEEP_NOTICE, SAME_LICENSE, STATE_CHANGES],
+    limitations: NO_WARRANTY,
+};
+const GPL_3_0: LicenseInfo = LicenseInfo {
+    name: "GNU General Public License v3.0",
+    spdx: "GPL-3.0",
+    description: "A strong copyleft license with a patent grant: derivatives must stay open under the same terms.",
+    permissions: PERMISSIVE_PATENT,
+    conditions: &[DISCLOSE_SOURCE, KEEP_NOTICE, SAME_LICENSE, STATE_CHANGES],
+    limitations: NO_WARRANTY,
+};
+const LGPL_3_0: LicenseInfo = LicenseInfo {
+    name: "GNU Lesser General Public License v3.0",
+    spdx: "LGPL-3.0",
+    description: "A weaker copyleft: the library stays open under the same terms, but may be linked from other software.",
+    permissions: PERMISSIVE_PATENT,
+    conditions: &[DISCLOSE_SOURCE, KEEP_NOTICE, SAME_LICENSE, STATE_CHANGES],
+    limitations: NO_WARRANTY,
+};
+const AGPL_3_0: LicenseInfo = LicenseInfo {
+    name: "GNU Affero General Public License v3.0",
+    spdx: "AGPL-3.0",
+    description: "Like GPLv3, but network use counts as distribution — users interacting over a network must get the source.",
+    permissions: PERMISSIVE_PATENT,
+    conditions: &[
+        DISCLOSE_SOURCE,
+        KEEP_NOTICE,
+        NETWORK_DISCLOSE,
+        SAME_LICENSE,
+        STATE_CHANGES,
+    ],
+    limitations: NO_WARRANTY,
+};
+const UNLICENSE: LicenseInfo = LicenseInfo {
+    name: "The Unlicense",
+    spdx: "Unlicense",
+    description: "A public-domain dedication: do anything, with no conditions at all.",
+    permissions: PERMISSIVE,
+    conditions: &[],
+    limitations: NO_WARRANTY,
+};
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn recognizes_license_filenames() {
+        assert!(is_license_path("LICENSE"));
+        assert!(is_license_path("license.md"));
+        assert!(is_license_path("path/to/COPYING"));
+        assert!(is_license_path("LICENCE.txt"));
+        assert!(!is_license_path("src/main.rs"));
+        assert!(!is_license_path("readme.md"));
+    }
+    #[test]
+    fn detects_common_licenses() {
+        assert_eq!(
+            detect("Permission is hereby granted, free of charge, to any person").map(|l| l.spdx),
+            Some("MIT")
+        );
+        assert_eq!(
+            detect("Apache License\nVersion 2.0, January 2004").map(|l| l.spdx),
+            Some("Apache-2.0")
+        );
+        assert_eq!(
+            detect("GNU GENERAL PUBLIC LICENSE\nVersion 3, 29 June 2007").map(|l| l.spdx),
+            Some("GPL-3.0")
+        );
+        let zero_bsd = "BSD Zero Clause License\n\nPermission to use, copy, modify, \
+             and/or distribute this software for any purpose with or without fee is \
+             hereby granted.";
+        assert_eq!(detect(zero_bsd).map(|l| l.spdx), Some("0BSD"));
+        assert!(detect("just some random text file").is_none());
+    }
+}