Coverage reports, built in 554ccacfc123

-- Coverage reports from OxygenFlow jobs (oxygenhub#113): a job's artifact

-- named `coverage` (LCOV) is parsed when uploaded. The totals and each

-- file's counts are kept here; the per-line counts stay in the artifact's

-- blob and are read again for the file view.

CREATE TABLE coverage_reports (

    id               INTEGER PRIMARY KEY,

    repo_id          INTEGER NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,

    run_id           INTEGER NOT NULL REFERENCES flow_runs(id) ON DELETE CASCADE,

    job_id           INTEGER NOT NULL UNIQUE,

    job              TEXT NOT NULL,

    run_number       INTEGER NOT NULL,

    bookmark         TEXT NOT NULL,

    state            TEXT NOT NULL,

    heads            TEXT NOT NULL,

    blob             TEXT NOT NULL,

    format           TEXT NOT NULL,

    lines_found      INTEGER NOT NULL,

    lines_hit        INTEGER NOT NULL,

    functions_found  INTEGER NOT NULL,

    functions_hit    INTEGER NOT NULL,

    branches_found   INTEGER NOT NULL,

    branches_hit     INTEGER NOT NULL,

    files            INTEGER NOT NULL,

    -- Files the report named that are not in the run's state.

    dropped          INTEGER NOT NULL,

    created_ms       INTEGER NOT NULL

);

CREATE INDEX coverage_reports_bookmark ON coverage_reports (repo_id, bookmark, created_ms);

CREATE TABLE coverage_files (

    report_id        INTEGER NOT NULL REFERENCES coverage_reports(id) ON DELETE CASCADE,

    path             TEXT NOT NULL,

    lines_found      INTEGER NOT NULL,

    lines_hit        INTEGER NOT NULL,

    functions_found  INTEGER NOT NULL,

    functions_hit    INTEGER NOT NULL,

    branches_found   INTEGER NOT NULL,

    branches_hit     INTEGER NOT NULL,

    PRIMARY KEY (report_id, path)

);

//! Coverage reports (oxygenhub#113): Coveralls built into the hub. An

//! OxygenFlow job that declares an artifact named `coverage` in LCOV

//! format (what `cargo llvm-cov --lcov`, Istanbul, coverage.py and

//! gcov/lcov write) has it parsed when it is uploaded. The totals and each

//! file's counts are kept per run; the per-line counts are read again from

//! the artifact's blob for the file view. Paths are taken relative to the

//! job's workspace (`/src`), and only files of the run's state are kept.

use crate::db::{now_ms, Pool};

use crate::Shared;

use std::collections::{BTreeMap, HashSet};

use std::sync::Mutex;

/// The artifact name a pipeline gives its report.

pub const ARTIFACT: &str = "coverage";

/// The largest report parsed.

pub const MAX_REPORT: usize = 64 << 20;

/// One file's coverage, from a report.

#[derive(Clone, Debug, Default, PartialEq, Eq)]

pub struct FileCoverage {

    /// Relative to the repository's root.

    pub path: String,

    /// Each instrumented line and how often it ran, by line number.

    pub lines: BTreeMap<u32, u64>,

    pub functions_found: u64,

    pub functions_hit: u64,

    pub branches_found: u64,

    pub branches_hit: u64,

    /// The file's own `LF`/`LH` totals, when it had one record: the tool's

    /// own count, which can name lines the `DA` lines leave out (llvm-cov

    /// does), so the hub agrees with what the tool printed.

    pub declared_lines: Option<(u64, u64)>,

}

impl FileCoverage {

    pub fn lines_found(&self) -> u64 {

        self.declared_lines.map(|d| d.0).unwrap_or(self.lines.len() as u64)

    }

    pub fn lines_hit(&self) -> u64 {

        self.declared_lines.map(|d| d.1).unwrap_or_else(|| self.lines.values().filter(|n| **n > 0).count() as u64)

    }

}

/// A path as a report names it, relative to the repository: the Flow

/// workspace's `/src/` and a leading `./` taken off. `None` for a path

/// outside the repository.

pub fn relative(path: &str) -> Option<String> {

    let p = path.trim();

    let p = p.strip_prefix("/src/").unwrap_or(p);

    let p = p.strip_prefix("./").unwrap_or(p);

    if p.is_empty() || p.starts_with('/') || p.contains('\\') || p.split('/').any(|s| s.is_empty() || s == "." || s == "..") {

        return None;

    }

    Some(p.to_string())

}

#[derive(Default)]

struct Acc {

    lines: BTreeMap<u32, u64>,

    functions: BTreeMap<String, u64>,

    branches: BTreeMap<(u32, String, String), u64>,

    declared_fn: (u64, u64),

    declared_br: (u64, u64),

    declared_lines: (Option<u64>, Option<u64>),

    records: u32,

}

/// Parse an LCOV report into each file's coverage, records for the same

/// file (from several test binaries) added together. Files whose paths

/// are outside the repository are counted in the second value.

pub fn parse_lcov(text: &str) -> Result<(Vec<FileCoverage>, usize), String> {

    let mut files: BTreeMap<String, Acc> = BTreeMap::new();

    let mut current: Option<Option<String>> = None;

    let mut outside = HashSet::new();

    let mut records = 0usize;

    // A new SF: record has begun and not yet been counted for its file.

    let mut started = false;

    let num = |s: &str| s.trim().parse::<u64>().unwrap_or(0);

    for line in text.lines() {

        let line = line.trim();

        if let Some(path) = line.strip_prefix("SF:") {

            records += 1;

            let rel = relative(path);

            if rel.is_none() {

                outside.insert(path.to_string());

            }

            current = Some(rel);

            started = true;

            continue;

        }

        if line == "end_of_record" {

            current = None;

            continue;

        }

        let Some(Some(path)) = &current else { continue };

        let acc = files.entry(path.clone()).or_default();

        if line == "TN:" || line.starts_with("TN:") {

            continue;

        }

        if std::mem::take(&mut started) {

            acc.records += 1;

        }

        if let Some(n) = line.strip_prefix("LF:") {

            acc.declared_lines.0 = Some(num(n));

        } else if let Some(n) = line.strip_prefix("LH:") {

            acc.declared_lines.1 = Some(num(n));

        } else if let Some(rest) = line.strip_prefix("DA:") {

            let mut parts = rest.split(',');

            if let (Some(l), Some(n)) = (parts.next(), parts.next()) {

                if let Ok(l) = l.trim().parse::<u32>() {

                    *acc.lines.entry(l).or_default() += num(n);

                }

            }

        } else if let Some(rest) = line.strip_prefix("FN:") {

            if let Some((_, name)) = rest.split_once(',') {

                acc.functions.entry(name.to_string()).or_default();

            }

        } else if let Some(rest) = line.strip_prefix("FNDA:") {

            if let Some((n, name)) = rest.split_once(',') {

                *acc.functions.entry(name.to_string()).or_default() += num(n);

            }

        } else if let Some(rest) = line.strip_prefix("BRDA:") {

            let parts: Vec<&str> = rest.split(',').collect();

            if let [l, block, branch, taken] = parts[..] {

                if let Ok(l) = l.trim().parse::<u32>() {

                    let taken = if taken.trim() == "-" { 0 } else { num(taken) };

                    *acc.branches.entry((l, block.to_string(), branch.to_string())).or_default() += taken;

                }

            }

        } else if let Some(n) = line.strip_prefix("FNF:") {

            acc.declared_fn.0 = acc.declared_fn.0.max(num(n));

        } else if let Some(n) = line.strip_prefix("FNH:") {

            acc.declared_fn.1 = acc.declared_fn.1.max(num(n));

        } else if let Some(n) = line.strip_prefix("BRF:") {

            acc.declared_br.0 = acc.declared_br.0.max(num(n));

        } else if let Some(n) = line.strip_prefix("BRH:") {

            acc.declared_br.1 = acc.declared_br.1.max(num(n));

        }

    }

    if records == 0 {

        return Err("this is not an LCOV report: it names no source file (no SF: line)".into());

    }

    let out = files

        .into_iter()

        .map(|(path, a)| {

            let (functions_found, functions_hit) = if a.functions.is_empty() {

                a.declared_fn

            } else {

                (a.functions.len() as u64, a.functions.values().filter(|n| **n > 0).count() as u64)

            };

            let (branches_found, branches_hit) = if a.branches.is_empty() {

                a.declared_br

            } else {

                (a.branches.len() as u64, a.branches.values().filter(|n| **n > 0).count() as u64)

            };

            let declared_lines = match (a.records, a.declared_lines) {

                (1, (Some(f), Some(h))) if h <= f && f >= a.lines.len() as u64 => Some((f, h)),

                _ => None,

            };

            FileCoverage { path, lines: a.lines, functions_found, functions_hit, branches_found, branches_hit, declared_lines }

        })

        .collect();

    Ok((out, outside.len()))

}

/// A percentage to one decimal place, or none when nothing was counted.

pub fn percent(hit: i64, found: i64) -> Option<f64> {

    (found > 0).then(|| (hit as f64 * 1000.0 / found as f64).round() / 10.0)

}

#[derive(Clone, Debug, sqlx::FromRow)]

pub struct Report {

    pub id: i64,

    pub repo_id: i64,

    pub run_id: i64,

    pub job_id: i64,

    pub job: String,

    pub run_number: i64,

    pub bookmark: String,

    pub state: String,

    pub heads: String,

    pub blob: String,

    pub format: String,

    pub lines_found: i64,

    pub lines_hit: i64,

    pub functions_found: i64,

    pub functions_hit: i64,

    pub branches_found: i64,

    pub branches_hit: i64,

    pub files: i64,

    pub dropped: i64,

    pub created_ms: i64,

}

impl Report {

    pub fn percent(&self) -> Option<f64> {

        percent(self.lines_hit, self.lines_found)

    }

    pub fn functions_percent(&self) -> Option<f64> {

        percent(self.functions_hit, self.functions_found)

    }

    pub fn branches_percent(&self) -> Option<f64> {

        percent(self.branches_hit, self.branches_found)

    }

    pub fn head_list(&self) -> Vec<&str> {

        self.heads.split(',').filter(|h| !h.is_empty()).collect()

    }

}

#[derive(Clone, Debug, sqlx::FromRow)]

pub struct FileRow {

    pub report_id: i64,

    pub path: String,

    pub lines_found: i64,

    pub lines_hit: i64,

    pub functions_found: i64,

    pub functions_hit: i64,

    pub branches_found: i64,

    pub branches_hit: i64,

}

impl FileRow {

    pub fn percent(&self) -> Option<f64> {

        percent(self.lines_hit, self.lines_found)

    }

    pub fn missed(&self) -> i64 {

        self.lines_found - self.lines_hit

    }

}

/// Repositories with a report, so their pages show the Coverage tab:

/// keyed by the hub's repository root and the id, unique even between

/// hubs in one process.

static HAS: Mutex<Option<HashSet<String>>> = Mutex::new(None);

fn key(app: &Shared, repo_id: i64) -> String {

    format!("{}#{repo_id}", app.repos.root().display())

}

pub fn has_reports(app: &Shared, repo_id: i64) -> bool {

    HAS.lock().unwrap_or_else(|p| p.into_inner()).as_ref().is_some_and(|s| s.contains(&key(app, repo_id)))

}

fn mark(app: &Shared, repo_id: i64) {

    HAS.lock().unwrap_or_else(|p| p.into_inner()).get_or_insert_with(HashSet::new).insert(key(app, repo_id));

}

/// At start: which repositories have reports.

pub async fn load(app: &Shared) -> sqlx::Result<()> {

    let ids: Vec<(i64,)> = sqlx::query_as("SELECT DISTINCT repo_id FROM coverage_reports").fetch_all(&app.db).await?;

    for (id,) in ids {

        mark(app, id);

    }

    Ok(())

}

/// What a run's report is kept with.

pub struct Origin<'a> {

    pub repo_id: i64,

    pub run_id: i64,

    pub run_number: i64,

    pub job_id: i64,

    pub job: &'a str,

    pub bookmark: &'a str,

    pub state: &'a str,

    pub heads: &'a [String],

    pub blob: &'a str,

}

/// Keep a parsed report: the files outside `in_state` are dropped and

/// counted. Replaces an earlier report of the same job.

pub async fn keep(app: &Shared, o: &Origin<'_>, files: Vec<FileCoverage>, outside: usize, in_state: &HashSet<String>) -> sqlx::Result<i64> {

    let (kept, missing): (Vec<FileCoverage>, Vec<FileCoverage>) = files.into_iter().partition(|f| in_state.contains(&f.path));

    let sum = |f: &dyn Fn(&FileCoverage) -> u64| kept.iter().map(f).sum::<u64>() as i64;

    let mut tx = crate::db::begin_write(&app.db).await?;

    sqlx::query("DELETE FROM coverage_reports WHERE job_id = ?").bind(o.job_id).execute(&mut *tx).await?;

    let id: i64 = sqlx::query_scalar(

        "INSERT INTO coverage_reports (repo_id, run_id, job_id, job, run_number, bookmark, state, heads, blob, format, \

         lines_found, lines_hit, functions_found, functions_hit, branches_found, branches_hit, files, dropped, created_ms) \

         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'lcov', ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id",

    )

    .bind(o.repo_id)

    .bind(o.run_id)

    .bind(o.job_id)

    .bind(o.job)

    .bind(o.run_number)

    .bind(o.bookmark)

    .bind(o.state)

    .bind(o.heads.join(","))

    .bind(o.blob)

    .bind(sum(&|f| f.lines_found()))

    .bind(sum(&|f| f.lines_hit()))

    .bind(sum(&|f| f.functions_found))

    .bind(sum(&|f| f.functions_hit))

    .bind(sum(&|f| f.branches_found))

    .bind(sum(&|f| f.branches_hit))

    .bind(kept.len() as i64)

    .bind((missing.len() + outside) as i64)

    .bind(now_ms())

    .fetch_one(&mut *tx)

    .await?;

    for f in &kept {

        sqlx::query(

            "INSERT INTO coverage_files (report_id, path, lines_found, lines_hit, functions_found, functions_hit, branches_found, branches_hit) \

             VALUES (?, ?, ?, ?, ?, ?, ?, ?)",

        )

        .bind(id)

        .bind(&f.path)

        .bind(f.lines_found() as i64)

        .bind(f.lines_hit() as i64)

        .bind(f.functions_found as i64)

        .bind(f.functions_hit as i64)

        .bind(f.branches_found as i64)

        .bind(f.branches_hit as i64)

        .execute(&mut *tx)

        .await?;

    }

    tx.commit().await?;

    mark(app, o.repo_id);

    Ok(id)

}

pub async fn report(pool: &Pool, repo_id: i64, id: i64) -> sqlx::Result<Option<Report>> {

    sqlx::query_as("SELECT * FROM coverage_reports WHERE id = ? AND repo_id = ?").bind(id).bind(repo_id).fetch_optional(pool).await

}

/// The newest reports on a bookmark, newest first.

pub async fn on_bookmark(pool: &Pool, repo_id: i64, bookmark: &str, limit: i64) -> sqlx::Result<Vec<Report>> {

    sqlx::query_as("SELECT * FROM coverage_reports WHERE repo_id = ? AND bookmark = ? ORDER BY created_ms DESC, id DESC LIMIT ?")

        .bind(repo_id)

        .bind(bookmark)

        .bind(limit)

        .fetch_all(pool)

        .await

}

pub async fn for_run(pool: &Pool, run_id: i64) -> sqlx::Result<Vec<Report>> {

    sqlx::query_as("SELECT * FROM coverage_reports WHERE run_id = ? ORDER BY job").bind(run_id).fetch_all(pool).await

}

pub async fn files(pool: &Pool, report_id: i64) -> sqlx::Result<Vec<FileRow>> {

    sqlx::query_as("SELECT * FROM coverage_files WHERE report_id = ? ORDER BY path").bind(report_id).fetch_all(pool).await

}

#[cfg(test)]

mod tests {

    use super::*;

    const LCOV: &str = "TN:\nSF:/src/crates/a/src/lib.rs\nFN:3,alpha\nFN:9,beta\nFNDA:4,alpha\nFNDA:0,beta\nFNF:2\nFNH:1\n\

DA:3,4\nDA:4,4\nDA:9,0\nDA:10,0\nBRDA:4,0,0,3\nBRDA:4,0,1,-\nBRF:2\nBRH:1\nLF:4\nLH:2\nend_of_record\n\

SF:/src/crates/a/src/lib.rs\nDA:9,1\nend_of_record\n\

SF:./README.md\nDA:1,1\nend_of_record\n\

SF:/home/runner/.cargo/registry/src/dep/lib.rs\nDA:1,1\nend_of_record\n";

    #[test]

    fn lcov_reports_are_read_and_merged() {

        let (files, outside) = parse_lcov(LCOV).unwrap();

        assert_eq!(outside, 1, "the dependency outside the workspace");

        assert_eq!(files.len(), 2);

        let lib = &files[1];

        assert_eq!(lib.path, "crates/a/src/lib.rs");

        assert_eq!(lib.lines, [(3, 4), (4, 4), (9, 1), (10, 0)].into_iter().collect());

        assert_eq!((lib.lines_found(), lib.lines_hit()), (4, 3), "the second record ran line 9");

        assert_eq!((lib.functions_found, lib.functions_hit), (2, 1));

        assert_eq!((lib.branches_found, lib.branches_hit), (2, 1));

        assert_eq!(files[0].path, "README.md");

        assert_eq!(lib.declared_lines, None, "two records: counted from the lines");

        // One record whose totals name lines its DA lines leave out, as llvm-cov writes.

        let (one, _) = parse_lcov("SF:/src/a.rs\nDA:1,1\nDA:2,0\nLF:5\nLH:3\nend_of_record\n").unwrap();

        assert_eq!((one[0].lines_found(), one[0].lines_hit()), (5, 3));

        assert!(parse_lcov("not a report\n").unwrap_err().contains("not an LCOV report"));

    }

    #[test]

    fn paths_are_taken_relative_to_the_workspace() {

        assert_eq!(relative("/src/a/b.rs").as_deref(), Some("a/b.rs"));

        assert_eq!(relative("./a/b.rs").as_deref(), Some("a/b.rs"));

        assert_eq!(relative("a/b.rs").as_deref(), Some("a/b.rs"));

        for bad in ["/etc/passwd", "a/../b", "", "/src/", "a//b", "C:\\x\\y.rs"] {

            assert_eq!(relative(bad), None, "{bad}");

        }

        assert_eq!(percent(1, 3), Some(33.3));

        assert_eq!(percent(0, 0), None);

    }

}

//! Coverage pages (oxygenhub#113): a repository's coverage, its trend,

//! every file, and each file's lines marked run or missed; and a badge.

use super::{filters, lookup, Error, Page, RepoShell, Shell};

use crate::auth::Viewer;

use crate::coverage::{self, FileRow, Report};

use crate::repos::view::{self, FileBody, RefKind, RefTarget};

use crate::Shared;

use askama::Template;

use axum::extract::{Path, Query, State};

use axum::response::{IntoResponse, Response};

use serde::Deserialize;

use std::collections::BTreeMap;

use std::sync::{Arc, Mutex};

/// Reports drawn on the trend.

const TREND: i64 = 30;

#[derive(Deserialize, Default)]

pub struct CoverageQuery {

    /// A bookmark other than the default.

    bookmark: Option<String>,

    /// One report, by id.

    report: Option<i64>,

    /// `missed` (default), `percent` or `path`.

    sort: Option<String>,

}

#[derive(Template)]

#[template(path = "coverage.html")]

pub struct CoveragePage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    report: Option<Report>,

    /// Against the report before it on the bookmark, in percentage points.

    delta: Option<f64>,

    files: Vec<FileRow>,

    sort: String,

    trend: String,

    runs: usize,

}

impl CoveragePage {

    pub fn pct(&self, p: Option<f64>) -> String {

        p.map(|p| format!("{p:.1}%")).unwrap_or_else(|| "–".into())

    }

    pub fn delta_text(&self) -> Option<String> {

        self.delta.map(|d| if d.abs() < 0.05 { "unchanged".to_string() } else { format!("{d:+.1}") })

    }

    pub fn class_of(&self, p: Option<f64>) -> &'static str {

        level(p)

    }

}

/// A colour class for a percentage.

pub fn level(p: Option<f64>) -> &'static str {

    match p {

        Some(p) if p >= 90.0 => "cov-good",

        Some(p) if p >= 75.0 => "cov-fair",

        Some(p) if p >= 50.0 => "cov-low",

        Some(_) => "cov-poor",

        None => "cov-none",

    }

}

/// The trend as an SVG line chart, oldest on the left.

fn trend_svg(reports: &[Report], url: &str) -> String {

    let points: Vec<(f64, &Report)> = reports.iter().rev().filter_map(|r| r.percent().map(|p| (p, r))).collect();

    if points.len() < 2 {

        return String::new();

    }

    let (w, h, pad) = (640.0, 120.0, 8.0);

    let lo = points.iter().map(|p| p.0).fold(100.0f64, f64::min).floor().max(0.0);

    let hi = points.iter().map(|p| p.0).fold(0.0f64, f64::max).ceil().min(100.0);

    let (lo, hi) = if hi - lo < 2.0 { ((lo - 1.0).max(0.0), (hi + 1.0).min(100.0)) } else { (lo, hi) };

    let step = (w - 2.0 * pad) / (points.len() - 1) as f64;

    let y = |p: f64| pad + (hi - p) / (hi - lo) * (h - 2.0 * pad);

    let line: Vec<String> = points.iter().enumerate().map(|(i, (p, _))| format!("{:.1},{:.1}", pad + i as f64 * step, y(*p))).collect();

    let mut svg = format!(

        r#"<svg class="cov-trend" viewBox="0 0 {w} {h}" role="img" aria-label="Coverage over the last {n} runs, from {first:.1}% to {last:.1}%"><text x="{w}" y="12" text-anchor="end" class="axis">{hi}%</text><text x="{w}" y="{hb}" text-anchor="end" class="axis">{lo}%</text><polyline points="{pts}"/>"#,

        n = points.len(),

        first = points[0].0,

        last = points[points.len() - 1].0,

        hb = h - 2.0,

        pts = line.join(" "),

    );

    for (i, (p, r)) in points.iter().enumerate() {

        svg.push_str(&format!(

            r#"<a href="{url}/coverage?report={id}"><circle cx="{x:.1}" cy="{y:.1}" r="3.5"><title>Run #{run}: {p:.1}%</title></circle></a>"#,

            id = r.id,

            x = pad + i as f64 * step,

            y = y(*p),

            run = r.run_number,

        ));

    }

    svg.push_str("</svg>");

    svg

}

/// `GET /{owner}/{name}/coverage`.

pub async fn overview(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Query(q): Query<CoverageQuery>,

) -> Result<Page<CoveragePage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/coverage"), &viewer);

    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let e = |e| Error::from_db(shell.clone(), e);

    let report = match q.report {

        Some(id) => Some(coverage::report(&app.db, row.id, id).await.map_err(e)?.ok_or_else(|| Error::not_found(shell.clone()))?),

        None => None,

    };

    let bookmark = report.as_ref().map(|r| r.bookmark.clone()).or(q.bookmark.clone()).unwrap_or_else(|| row.default_bookmark.clone());

    let history = coverage::on_bookmark(&app.db, row.id, &bookmark, TREND).await.map_err(e)?;

    let report = report.or_else(|| history.first().cloned());

    let delta = report.as_ref().and_then(|r| {

        let before = history.iter().find(|h| h.created_ms < r.created_ms || (h.created_ms == r.created_ms && h.id < r.id))?;

        Some(r.percent()? - before.percent()?)

    });

    let mut files = match &report {

        Some(r) => coverage::files(&app.db, r.id).await.map_err(e)?,

        None => vec![],

    };

    let sort = match q.sort.as_deref() {

        Some("percent") => "percent",

        Some("path") => "path",

        _ => "missed",

    };

    match sort {

        "percent" => files.sort_by(|a, b| a.percent().unwrap_or(101.0).total_cmp(&b.percent().unwrap_or(101.0)).then(a.path.cmp(&b.path))),

        "path" => {}

        _ => files.sort_by(|a, b| b.missed().cmp(&a.missed()).then(a.path.cmp(&b.path))),

    }

    let repo = RepoShell::new(&app, &row, "coverage").with_role(role);

    let trend = trend_svg(&history, &repo.url);

    Ok(Page(CoveragePage { shell, repo, bookmark, report, delta, files, sort: sort.into(), trend, runs: history.len() }))

}

/// One line of a file, as the file view shows it.

pub struct CovLine {

    pub number: usize,

    pub html: String,

    /// None: not an instrumented line.

    pub hits: Option<u64>,

}

#[derive(Template)]

#[template(path = "coverage_file.html")]

pub struct CoverageFilePage {

    shell: Shell,

    repo: RepoShell,

    report: Report,

    file: FileRow,

    lines: Vec<CovLine>,

    note: Option<String>,

}

impl CoverageFilePage {

    pub fn pct(&self, p: Option<f64>) -> String {

        p.map(|p| format!("{p:.1}%")).unwrap_or_else(|| "–".into())

    }

    pub fn class_of(&self, p: Option<f64>) -> &'static str {

        level(p)

    }

}

/// The line counts of the report last read, by file: the file view reads

/// the report's artifact again, so that browsing one report's files

/// parses it once.

type Parsed = Arc<BTreeMap<String, BTreeMap<u32, u64>>>;

static LAST: Mutex<Option<(String, Parsed)>> = Mutex::new(None);

async fn line_counts(app: &Shared, repo: &crate::repos::RepoName, blob: &str) -> Option<Parsed> {

    if let Some((b, p)) = LAST.lock().ok()?.as_ref() {

        if b == blob {

            return Some(p.clone());

        }

    }

    let r = oxy_core::hash::ObjectRef::from_hex(blob)?;

    let bytes = app.repos.read(repo, move |repo, _| Ok(repo.read_blob(&r)?)).await.ok()?;

    let parsed = tokio::task::spawn_blocking(move || {

        let text = String::from_utf8_lossy(&bytes);

        coverage::parse_lcov(&text).ok().map(|(files, _)| files.into_iter().map(|f| (f.path, f.lines)).collect::<BTreeMap<_, _>>())

    })

    .await

    .ok()??;

    let parsed = Arc::new(parsed);

    if let Ok(mut last) = LAST.lock() {

        *last = Some((blob.to_string(), parsed.clone()));

    }

    Some(parsed)

}

/// `GET /{owner}/{name}/coverage/{report}/file/{*path}`.

pub async fn file(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, id, path)): Path<(String, String, i64, String)>,

) -> Result<Page<CoverageFilePage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/coverage/{id}/file/{path}"), &viewer);

    let (repo_name, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let e = |e| Error::from_db(shell.clone(), e);

    let report = coverage::report(&app.db, row.id, id).await.map_err(e)?.ok_or_else(|| Error::not_found(shell.clone()))?;

    let file = coverage::files(&app.db, report.id)

        .await

        .map_err(e)?

        .into_iter()

        .find(|f| f.path == path)

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    let counts = line_counts(&app, &repo_name, &report.blob).await.and_then(|p| p.get(&path).cloned()).unwrap_or_default();

    let heads: Vec<_> = report.head_list().into_iter().filter_map(oxy_core::hash::ChangeHash::from_hex).collect();

    let limit = app.config.limits.render_limit.0;

    let p = path.clone();

    let target = RefTarget { label: report.state.clone(), kind: RefKind::Change, heads };

    let fv = app

        .repos

        .read(&repo_name, move |r, cache| view::file(r, cache, target, &p, limit))

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

    let (lines, note) = match &fv.body {

        FileBody::Text(text) => {

            let html = crate::render::highlight::lines(&path, text);

            let lines = html

                .into_iter()

                .enumerate()

                .map(|(i, h)| CovLine { number: i + 1, html: h, hits: counts.get(&(i as u32 + 1)).copied() })

                .collect();

            (lines, None)

        }

        FileBody::Binary => (vec![], Some("This file is binary.".to_string())),

        FileBody::TooLarge => (vec![], Some("This file is too large to show.".to_string())),

    };

    let repo = RepoShell::new(&app, &row, "coverage").with_role(role);

    Ok(Page(CoverageFilePage { shell, repo, report, file, lines, note }))

}

/// `GET /{owner}/{name}/coverage/badge.svg`: the default bookmark's latest coverage.

pub async fn badge(State(app): State<Shared>, viewer: Viewer, Path((owner, name)): Path<(String, String)>) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/coverage"), &viewer);

    let (_, row, _) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let latest = coverage::on_bookmark(&app.db, row.id, &row.default_bookmark, 1).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let pct = latest.first().and_then(|r| r.percent());

    let text = pct.map(|p| format!("{p:.1}%")).unwrap_or_else(|| "unknown".into());

    let colour = match level(pct) {

        "cov-good" => "#2da44e",

        "cov-fair" => "#97ca00",

        "cov-low" => "#dfb317",

        "cov-poor" => "#e05d44",

        _ => "#6e7781",

    };

    let label = "coverage";

    let (lw, tw) = (label.len() as u32 * 7 + 10, text.len() as u32 * 7 + 10);

    let svg = format!(

        r##"<svg xmlns="http://www.w3.org/2000/svg" width="{w}" height="20" role="img" aria-label="{label}: {text}"><title>{label}: {text}</title><rect width="{lw}" height="20" rx="3" fill="#555"/><rect x="{lw}" width="{tw}" height="20" rx="3" fill="{colour}"/><rect x="{lw}" width="4" height="20" fill="{colour}"/><g fill="#fff" font-family="Verdana,DejaVu Sans,sans-serif" font-size="11" text-anchor="middle"><text x="{lx}" y="14">{label}</text><text x="{tx}" y="14">{text}</text></g></svg>"##,

        w = lw + tw,

        lx = lw / 2,

        tx = lw + tw / 2,

    );

    Ok((

        [(axum::http::header::CONTENT_TYPE, "image/svg+xml; charset=utf-8"), (axum::http::header::CACHE_CONTROL, "no-cache, max-age=60")],

        svg,

    )

        .into_response())

}

{% extends "base.html" %}

{% import "repo_tabs.html" as m %}

{% block title %}Coverage · {{ repo.owner }}/{{ repo.name }}{% endblock %}

{% block tabs %}{% call m::tabs(repo, "coverage") %}{% endblock %}

{% block content %}

<div class="head"><h1>Coverage <small>of {{ bookmark }}</small></h1></div>

{% if let Some(r) = report %}

<section class="cov-summary">

  <div class="cov-big {{ self.class_of(r.percent()) }}">{{ self.pct(r.percent()) }}{% if let Some(d) = self.delta_text() %} <span class="cov-delta" title="Against the run before it on {{ bookmark }}">{{ d }}</span>{% endif %}</div>

  <dl class="facts">

    <dt>Lines</dt><dd>{{ r.lines_hit }} of {{ r.lines_found }} run</dd>

    {% if r.functions_found > 0 %}<dt>Functions</dt><dd>{{ self.pct(r.functions_percent()) }} ({{ r.functions_hit }} of {{ r.functions_found }})</dd>{% endif %}

    {% if r.branches_found > 0 %}<dt>Branches</dt><dd>{{ self.pct(r.branches_percent()) }} ({{ r.branches_hit }} of {{ r.branches_found }})</dd>{% endif %}

    <dt>From</dt><dd><a href="{{ repo.url }}/flow/{{ r.run_number }}">run #{{ r.run_number }}</a>, job {{ r.job }}, <time title="{{ r.created_ms|when_i }}">{{ r.created_ms|ago_i }}</time></dd>

    <dt>Files</dt><dd>{{ r.files }}{% if r.dropped > 0 %} <span class="mute small">({{ r.dropped }} named in the report are not in this state and are left out)</span>{% endif %}</dd>

    <dt>Badge</dt><dd><img src="{{ repo.url }}/coverage/badge.svg" alt="coverage badge"> <code class="small">[![coverage]({{ shell.base_url }}{{ repo.url }}/coverage/badge.svg)]({{ shell.base_url }}{{ repo.url }}/coverage)</code></dd>

  </dl>

</section>

{% if !trend.is_empty() %}<section class="panel"><h2>The last {{ runs }} runs</h2>{{ trend|safe }}</section>{% endif %}

<section class="panel">

  <h2>Files <small class="mute">sorted by {% if sort == "missed" %}lines missed{% else if sort == "percent" %}coverage, lowest first{% else %}path{% endif %}:

    {% if sort != "missed" %}<a href="?report={{ r.id }}&sort=missed">lines missed</a> {% endif %}{% if sort != "percent" %}<a href="?report={{ r.id }}&sort=percent">lowest first</a> {% endif %}{% if sort != "path" %}<a href="?report={{ r.id }}&sort=path">path</a>{% endif %}</small></h2>

  <div class="table"><table class="cov-files">

  <tr><th>File</th><th>Coverage</th><th class="num">Lines</th><th class="num">Missed</th></tr>

  {% for f in files %}<tr>

    <td><a href="{{ repo.url }}/coverage/{{ r.id }}/file/{{ f.path }}">{{ f.path }}</a></td>

    <td><span class="cov-bar {{ self.class_of(f.percent()) }}" role="img" aria-label="{{ self.pct(f.percent()) }}"><span style="width: {% if let Some(p) = f.percent() %}{{ p }}{% else %}0{% endif %}%"></span></span> {{ self.pct(f.percent()) }}</td>

    <td class="num">{{ f.lines_found }}</td>

    <td class="num">{{ f.missed() }}</td>

  </tr>{% endfor %}

  </table></div>

</section>

{% else %}

<section class="panel">

  <p>No coverage report for <strong>{{ bookmark }}</strong> yet.</p>

  <p>Give a job in <code>.flow/pipeline.kdl</code> an artifact named <code>coverage</code> holding an LCOV report, and the hub reads it when the job uploads it. For Rust:</p>

<pre>job "coverage" {

    sandbox "rust"

    exec "cargo" "llvm-cov" "--workspace" "--lcov" "--output-path" "/src/target/lcov.info"

    output {

        artifact "coverage" { path "/src/target/lcov.info" }

    }

}</pre>

  <p class="small mute">Istanbul (<code>--reporter=lcov</code>), coverage.py (<code>coverage lcov</code>) and gcov with lcov write LCOV too. Paths are read relative to the job's <code>/src</code>.</p>

</section>

{% endif %}

{% endblock %}

{% extends "base.html" %}

{% import "repo_tabs.html" as m %}

{% block title %}{{ file.path }} · Coverage · {{ repo.owner }}/{{ repo.name }}{% endblock %}

{% block tabs %}{% call m::tabs(repo, "coverage") %}{% endblock %}

{% block content %}

<div class="head"><h1><a href="{{ repo.url }}/coverage?report={{ report.id }}">Coverage</a> / {{ file.path }} <small class="{{ self.class_of(file.percent()) }}">{{ self.pct(file.percent()) }}</small></h1>

<p class="small mute">{{ file.lines_hit }} of {{ file.lines_found }} lines run{% if file.functions_found > 0 %}, {{ file.functions_hit }} of {{ file.functions_found }} functions{% endif %}{% if file.branches_found > 0 %}, {{ file.branches_hit }} of {{ file.branches_found }} branches{% endif %} · <a href="{{ repo.url }}/flow/{{ report.run_number }}">run #{{ report.run_number }}</a> on {{ report.bookmark }} · <span class="cov-key cov-hit">run</span> <span class="cov-key cov-miss">missed</span></p></div>

{% if let Some(n) = note %}<p class="mute">{{ n }}</p>{% endif %}

{% if !lines.is_empty() %}

<table class="code cov-code">

{% for l in lines %}<tr id="L{{ l.number }}" class="{% if let Some(h) = l.hits %}{% if *h > 0 %}cov-hit{% else %}cov-miss{% endif %}{% endif %}"><td class="n">{{ l.number }}</td><td class="cov-hits">{% if let Some(h) = l.hits %}{{ h }}×{% endif %}</td><td class="t"><pre>{{ l.html|safe }}</pre></td></tr>

{% endfor %}</table>

{% endif %}

{% endblock %}

- **Coverage reports, built in (#113).** A Flow job's artifact named `coverage` in LCOV format is read when uploaded, and the job's log says what it found. A Coverage tab shows the latest percentage and its change, a trend over the last 30 runs, every file with a bar, and each file's lines marked run or missed, as Coveralls does. A badge is at `/OWNER/NAME/coverage/badge.svg`, and the run page shows each job's coverage. Totals match `cargo llvm-cov`'s own.

    let report_bytes = (name == crate::coverage::ARTIFACT).then(|| body.clone());

    // A coverage report (#113) is read now; what it says, or why it could

    // not be read, goes in the job's log. It never fails the upload.

    if let Some(bytes) = report_bytes {

        let said = match read_coverage(&app, &repo, &row, &run, &job, &a.blob, bytes).await {

            Ok(text) | Err(text) => text,

        };

        let record = flow_core::api::Record { t: 0, stream: "flow".into(), text: said };

        fdb::append_log(&app.db, job.id, &[record], MAX_RECORDS as i64).await.ok();

    }

}

/// Parse and keep a job's coverage report: what it says, or why not.

async fn read_coverage(

    app: &Shared,

    repo: &RepoName,

    row: &db::repos::RepoRow,

    run: &fdb::Run,

    job: &fdb::Job,

    blob: &str,

    bytes: axum::body::Bytes,

) -> Result<String, String> {

    if bytes.len() > crate::coverage::MAX_REPORT {

        return Err(format!(

            "coverage: the report is {} MiB; at most {} MiB is read",

            bytes.len() >> 20,

            crate::coverage::MAX_REPORT >> 20

        ));

    }

    let text = String::from_utf8(bytes.to_vec()).map_err(|_| "coverage: the report is not text (LCOV is expected)".to_string())?;

    let (files, outside) = tokio::task::spawn_blocking(move || crate::coverage::parse_lcov(&text))

        .await

        .map_err(|e| format!("coverage: {e}"))?

        .map_err(|e| format!("coverage: {e}"))?;

    let heads: Vec<ChangeHash> = run.head_list().into_iter().filter_map(ChangeHash::from_hex).collect();

    let in_state: std::collections::HashSet<String> = app

        .repos

        .read(repo, move |r, cache| Ok(cache.load(r, &heads)?.snapshot.files.keys().cloned().collect()))

        .await

        .map_err(|e| format!("coverage: the run's files could not be read: {e}"))?;

    let heads: Vec<String> = run.head_list().into_iter().map(String::from).collect();

    let origin = crate::coverage::Origin {

        repo_id: row.id,

        run_id: run.id,

        run_number: run.number,

        job_id: job.id,

        job: &job.name,

        bookmark: &run.bookmark,

        state: &run.state,

        heads: &heads,

        blob,

    };

    let id = crate::coverage::keep(app, &origin, files, outside, &in_state).await.map_err(|e| format!("coverage: {e}"))?;

    let Some(r) = crate::coverage::report(&app.db, row.id, id).await.map_err(|e| format!("coverage: {e}"))? else {

        return Err("coverage: the report was not kept".into());

    };

    let pct = r.percent().map(|p| format!("{p:.1}%")).unwrap_or_else(|| "no lines".into());

    let dropped =

        if r.dropped > 0 { format!(" ({} named files are not in this state and were left out)", r.dropped) } else { String::new() };

    Ok(format!("coverage: {pct} of lines ({} of {}) in {} files{dropped}", r.lines_hit, r.lines_found, r.files))

pub mod coverage;

    coverage::load(&app).await?;

    /// The job's coverage report, when it uploaded one (#113): its id and percentage.

    pub coverage: Option<(i64, String)>,

    let reports = crate::coverage::for_run(&app.db, run.id).await.unwrap_or_default();

        let coverage = reports

            .iter()

            .find(|r| r.job_id == j.id)

            .map(|r| (r.id, r.percent().map(|p| format!("{p:.1}%")).unwrap_or_else(|| "no lines".into())));

        logs.push(JobLog { duration: crate::flow::duration(j), j: j.clone(), artifacts, lines, last_seq, coverage });

pub mod coverage;

        .route("/{owner}/{name}/coverage", get(coverage::overview))

        .route("/{owner}/{name}/coverage/badge.svg", get(coverage::badge))

        .route("/{owner}/{name}/coverage/{id}/file/{*path}", get(coverage::file))

    /// Whether it has coverage reports, for the Coverage tab (#113).

    pub coverage: bool,

            coverage: crate::coverage::has_reports(app, row.id),

/// oxygenhub#113: a job's artifact named `coverage` (LCOV) is read when

/// it is uploaded. The job's log says what it found; the Coverage tab,

/// the file view, the badge and the run page show it.

#[tokio::test(flavor = "multi_thread")]

async fn a_coverage_artifact_becomes_a_coverage_report() {

    let h = hub().await;

    create(&h.app, "andy", "cov").await;

    let url = format!("{}/andy/cov", h.base);

    let work = tempfile::tempdir().unwrap();

    let c = client(&url, work.path());

    write(

        work.path(),

        ".flow/pipeline.kdl",

        &format!(

            "schema-version 1\nsandbox \"alpine\" {{\n    rootfs \"cas://blob/{ROOTFS}\"\n}}\njob \"coverage\" {{\n    sandbox \"alpine\"\n    exec \"make\" \"coverage\"\n    output {{\n        artifact \"coverage\" {{\n            path \"/src/lcov.info\"\n        }}\n    }}\n}}\n"

        ),

    );

    write(work.path(), "src/lib.rs", "pub fn add(a: u32, b: u32) -> u32 {\n    a + b\n}\n\npub fn unused() {\n    todo!()\n}\n");

    c.snapshot("test").unwrap();

    c.commit("Code and coverage", &[]).unwrap();

    assert!(c.push("origin", false).unwrap().iter().all(|r| r.ok));

    let run = runs_of(&h.app, "andy", "cov").await.remove(0);

    assert!(!call(&h.app, "GET", "/andy/cov", None, None).await.1.contains(">Coverage</a>"), "no tab before a report");

    let id = claim(&h.app).await.unwrap()["job_id"].as_i64().unwrap();

    let (st, text) = upload(&h.app, id, "coverage", b"this is not a report").await;

    assert_eq!(st, StatusCode::OK, "a bad report never fails the upload: {text}");

    let lcov = "TN:\nSF:/src/src/lib.rs\nFN:1,add\nFN:5,unused\nFNDA:3,add\nFNDA:0,unused\nDA:1,3\nDA:2,3\nDA:5,0\nDA:6,0\nend_of_record\n\

SF:/src/src/gone.rs\nDA:1,1\nend_of_record\nSF:/usr/lib/rustlib/x.rs\nDA:1,1\nend_of_record\n";

    let (st, text) = upload(&h.app, id, "coverage", lcov.as_bytes()).await;

    assert_eq!(st, StatusCode::OK, "{text}");

    let log: Vec<String> = db::flow::log(&h.app.db, id, 0, 50).await.unwrap().into_iter().map(|l| l.text).collect();

    assert!(log.iter().any(|l| l.contains("coverage: this is not an LCOV report")), "{log:?}");

    assert!(

        log.iter().any(|l| l == "coverage: 50.0% of lines (2 of 4) in 1 files (2 named files are not in this state and were left out)"),

        "{log:?}"

    );

    let (st, page) = call(&h.app, "GET", "/andy/cov/coverage", None, None).await;

    assert_eq!(st, StatusCode::OK);

    assert!(page.contains(">Coverage</a>") && page.contains("50.0%") && page.contains("2 of 4 run"), "{page}");

    assert!(page.contains("1 of 2") && page.contains("/andy/cov/coverage/") && page.contains("/file/src/lib.rs"), "{page}");

    let report = crate_report(&h.app, run.id).await;

    let (st, file) = call(&h.app, "GET", &format!("/andy/cov/coverage/{report}/file/src/lib.rs"), None, None).await;

    assert_eq!(st, StatusCode::OK, "{file}");

    assert_eq!(file.matches("class=\"cov-hit\"").count(), 2, "{file}");

    assert_eq!(file.matches("class=\"cov-miss\"").count(), 2, "{file}");

    assert!(file.contains("3×"), "{file}");

    assert_eq!(call(&h.app, "GET", &format!("/andy/cov/coverage/{report}/file/src/gone.rs"), None, None).await.0, StatusCode::NOT_FOUND);

    let (_, badge) = call(&h.app, "GET", "/andy/cov/coverage/badge.svg", None, None).await;

    assert!(badge.contains("coverage: 50.0%"), "{badge}");

    let (_, run_page) = call(&h.app, "GET", &format!("/andy/cov/flow/{}", run.number), None, None).await;

    assert!(run_page.contains("coverage 50.0%"), "{run_page}");

}

async fn crate_report(app: &Shared, run_id: i64) -> i64 {

    oxygenhub::coverage::for_run(&app.db, run_id).await.unwrap()[0].id

}

### 13.6 Coverage reports (oxygenhub#113, first part done 2026-10-05)

Coverage is built in, as Coveralls or Codecov would be, fed by OxygenFlow.

- **Reports.** A job's artifact named `coverage` in LCOV format (`cargo llvm-cov --lcov`, Istanbul's `lcov` reporter, `coverage lcov`, gcov with lcov) is read when the job uploads it. The hub writes what it found into the job's log (`coverage: 88.6% of lines (951 of 1073) in 5 files`), or why it could not read it; a bad report never fails the upload. At most 64 MiB is read.

- **Counting.** Paths are taken relative to the job's `/src`; a path outside the repository, or a file the run's state does not hold, is left out and counted. Records for one file are added together. A file with a single record keeps the tool's own `LF`/`LH` totals, since `llvm-cov` declares lines its `DA` lines leave out; the totals then match what the tool printed.

- **Stored.** `coverage_reports` keeps each report's totals (lines, functions, branches) with its run, job, bookmark and state; `coverage_files` each file's counts. The per-line counts stay in the artifact's blob and are read again for the file view.

- **Pages.** A Coverage tab, shown once a repository has a report: the bookmark's latest percentage with its change against the report before, a trend of the last 30 runs, every file with a bar (sorted by lines missed, lowest coverage, or path), and a file view with each line run or missed and how often it ran. `/OWNER/NAME/coverage/badge.svg` is a badge of the default bookmark's latest coverage. The run page shows each job's coverage beside its artifacts.

- **Next:** coverage of a proposal's projected state against its target, file by file, and a `coverage` check with a minimum and a largest drop set in the repository's settings; Cobertura XML; the API; and a coverage job in Oxygen's own pipeline (cargo-llvm-cov in the Flow build image).

  <summary><span class="flow-glyph st-{{ l.j.status }}" data-glyph>{{ crate::web::flow::glyph(l.j.status) }}</span> <strong>{{ l.j.name }}</strong> <span class="small mute" data-meta>{{ l.j.status }}{% if let Some(c) = l.j.exit_code %} · exit {{ c }}{% endif %} · {{ l.duration }}{% if !l.j.runner.is_empty() %} · on {{ l.j.runner }}{% endif %}</span>{% if !l.j.receipt_attest.is_empty() %} <span class="small mute">· <a href="{{ repo.url }}/receipts/{{ l.j.receipt_attest }}" title="Receipt {{ l.j.receipt_hash }}, kept in the repository; check it with oxy receipt verify">signed receipt</a> by {{ l.j.receipt_signer }}</span>{% else if !l.j.receipt_note.is_empty() %} <span class="small warn" title="{{ l.j.receipt_note }}">· receipt not kept: {{ l.j.receipt_note }}</span>{% else if !l.j.receipt_hash.is_empty() %} <span class="small mute">· unsigned receipt <code title="{{ l.j.receipt_hash }}">{{ l.j.receipt_hash|short }}</code></span>{% endif %}{% if !l.artifacts.is_empty() %} <span class="small mute">· {{ l.artifacts.len()|plural("artifact", "artifacts") }}</span>{% endif %}{% if let Some((cid, pct)) = l.coverage %} <span class="small">· <a href="{{ repo.url }}/coverage?report={{ cid }}">coverage {{ pct }}</a></span>{% endif %}</summary>

    {% if repo.coverage %}<a href="{{ repo.url }}/coverage"{% if tab == "coverage" %} class="on" aria-current="page"{% endif %}>Coverage</a>{% endif %}

/* Coverage (#113). */

.cov-summary { display: flex; gap: 2em; align-items: center; flex-wrap: wrap; margin: 1em 0; }

.cov-big { font-size: 3em; font-weight: 600; line-height: 1; }

.cov-delta { font-size: .35em; vertical-align: middle; opacity: .8; }

.cov-good { color: #1a7f37; } .cov-fair { color: #4d7c0f; } .cov-low { color: #9a6700; } .cov-poor { color: #cf222e; } .cov-none { color: inherit; }

.cov-bar { display: inline-block; width: 8em; height: .7em; background: rgba(127,127,127,.2); border-radius: 3px; vertical-align: middle; overflow: hidden; }

.cov-bar > span { display: block; height: 100%; background: currentColor; }

.cov-files td.num, .cov-files th.num { text-align: right; }

.cov-trend { width: 100%; max-width: 640px; height: auto; }

.cov-trend polyline { fill: none; stroke: #2da44e; stroke-width: 2; }

.cov-trend circle { fill: #2da44e; }

.cov-trend .axis { font-size: 10px; fill: currentColor; opacity: .6; }

.cov-code tr.cov-hit td.t, .cov-key.cov-hit { background: rgba(45,164,78,.15); }

.cov-code tr.cov-miss td.t, .cov-key.cov-miss { background: rgba(207,34,46,.18); }

.cov-code td.cov-hits { text-align: right; padding: 0 .5em; opacity: .6; font-size: .85em; white-space: nowrap; user-select: none; }

.cov-key { padding: 0 .4em; border-radius: 3px; }