padded_cell 0.1.0 → 0.3.0

data/ext/padded_cell_native/core/src/chart/output.rs

@@ -0,0 +1,103 @@
+use std::fs::{self, File};
+use std::io::{self, BufWriter, Write};
+use std::path::{Path, PathBuf};
+use std::str::FromStr;
+
+use super::{
+    Summary, write_coverage_json, write_last_run, write_lcov, write_markdown, write_resultset,
+};
+use crate::FileError;
+
+#[cfg(test)]
+mod tests;
+
+/// A report format.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Format {
+    /// `lcov.info`
+    Lcov,
+    /// `coverage.json` and `.resultset.json`.
+    Json,
+    /// `coverage.md`: totals, then the code that never ran.
+    Markdown,
+}
+
+impl Format {
+    /// The files the format writes, in the report directory.
+    #[must_use]
+    pub const fn file_names(self) -> &'static [&'static str] {
+        match self {
+            Self::Lcov => &["lcov.info"],
+            Self::Json => &["coverage.json", ".resultset.json"],
+            Self::Markdown => &["coverage.md"],
+        }
+    }
+}
+
+/// A format name nothing writes.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+#[error("unknown coverage format {0:?} (known: markdown, lcov, json)")]
+pub struct UnknownFormat(pub String);
+
+impl FromStr for Format {
+    type Err = UnknownFormat;
+
+    fn from_str(name: &str) -> Result<Self, UnknownFormat> {
+        match name {
+            "lcov" => Ok(Self::Lcov),
+            "json" => Ok(Self::Json),
+            "markdown" => Ok(Self::Markdown),
+            _ => Err(UnknownFormat(name.to_owned())),
+        }
+    }
+}
+
+/// Writes `summary` in `format` into `dir`, which it creates; returns the
+/// paths written.
+///
+/// # Errors
+///
+/// [`FileError`] for the file that could not be written.
+pub fn write(dir: &Path, format: Format, summary: &Summary<'_>) -> Result<Vec<PathBuf>, FileError> {
+    format
+        .file_names()
+        .iter()
+        .map(|&name| {
+            write_file(dir, name, |out| match name {
+                "lcov.info" => write_lcov(summary.files, out),
+                "coverage.json" => write_coverage_json(summary, out),
+                "coverage.md" => write_markdown(summary, out),
+                _ => write_resultset(summary, out),
+            })
+        })
+        .collect()
+}
+
+/// Writes `.last_run.json`, which the next run's `maximum_drop` reads.
+///
+/// # Errors
+///
+/// [`FileError`] when it could not be written.
+pub fn write_last_run_file(dir: &Path, summary: &Summary<'_>) -> Result<PathBuf, FileError> {
+    write_file(dir, ".last_run.json", |out| write_last_run(summary, out))
+}
+
+/// Replaces `dir/name` at once: a reader never sees half a report.
+pub(super) fn write_file(
+    dir: &Path,
+    name: &str,
+    render: impl FnOnce(&mut BufWriter<File>) -> io::Result<()>,
+) -> Result<PathBuf, FileError> {
+    let path = dir.join(name);
+    let partial = dir.join(format!(".{name}.partial"));
+    let error = |source| FileError { path: path.clone(), source };
+    fs::create_dir_all(dir).map_err(error)?;
+    let written = File::create(&partial).and_then(|file| {
+        let mut out = BufWriter::new(file);
+        render(&mut out)?;
+        out.flush()?;
+        out.into_inner().map_err(io::IntoInnerError::into_error)?.sync_all()
+    });
+    written.and_then(|()| fs::rename(&partial, &path)).map_err(error)?;
+    Ok(path)
+}

data/ext/padded_cell_native/core/src/chart/results/tests.rs

@@ -0,0 +1,96 @@
+use tempfile::TempDir;
+
+use super::super::FileCoverage;
+use super::super::test_support::{calc, reports, summary};
+use super::*;
+
+fn render(file: &FileCoverage, measured: &[Criterion], write: WriteFn) -> String {
+    let files = [file.clone()];
+    let reports = reports(&files);
+    let mut summary = summary(&reports, measured);
+    summary.groups = vec![("Core".to_owned(), vec![0], summary.totals)];
+    summary.violations = vec![Violation {
+        scope: Scope::File("lib/calc.rb".to_owned()),
+        criterion: Criterion::Branch,
+        limit: 60.0,
+        actual: 50.0,
+    }];
+    summary.meta = Meta {
+        root: "/app".to_owned(),
+        timestamp: "2026-10-11T13:00:00.000+02:00".to_owned(),
+        created_at: 1_791_716_400.5,
+        commit: None,
+        project_name: "App".to_owned(),
+        generator: "padded_cell 0.1.0".to_owned(),
+    };
+    let mut out = Vec::new();
+    write(&summary, &mut out).unwrap();
+    String::from_utf8(out).unwrap()
+}
+
+type WriteFn = fn(&Summary<'_>, &mut Vec<u8>) -> io::Result<()>;
+
+#[test]
+fn last_run_holds_the_floored_percents_measured() {
+    let dir = TempDir::new().unwrap();
+    let rendered = render(&calc(&dir), &[Criterion::Line, Criterion::Branch], write_last_run);
+    assert_eq!(
+        rendered,
+        "{\n  \"result\": {\n    \"line\": 100.0,\n    \"branch\": 50.0\n  }\n}\n"
+    );
+}
+
+/// Keys as Ruby's `Array#to_s` writes them; ids numbered in compile order.
+#[test]
+fn resultset_keys_are_rubys() {
+    let dir = TempDir::new().unwrap();
+    let measured = [Criterion::Line, Criterion::Branch, Criterion::Method];
+    let rendered = render(&calc(&dir), &measured, write_resultset);
+    for expected in [
+        r#"{"padded_cell":{"coverage":{""#,
+        r#"/calc.rb":{"lines":[null,null,1,1,2,1,null,1,null,null,null,null,1,null,null,1,null],"#,
+        concat!(
+            r#""branches":{"[:if, 0, 5, 4, 9, 7]":"#,
+            r#"{"[:then, 1, 6, 6, 6, 15]":1,"[:else, 2, 8, 6, 8, 12]":0},"#,
+        ),
+        r#""[:if, 3, 16, 20, 16, 37]":{"[:then, 4, 16, 27, 16, 31]":1,"#,
+        r#""methods":{"[Calc, :sign, 4, 2, 10, 5]":2,"#,
+        r#""timestamp":1791716400.5}}"#,
+    ] {
+        assert!(rendered.contains(expected), "{expected} in {rendered}");
+    }
+    assert_eq!(ruby_symbol("&."), r#":"&.""#);
+    assert_eq!(ruby_symbol("empty?"), ":empty?");
+}
+
+#[test]
+fn coverage_json_sections() {
+    let dir = TempDir::new().unwrap();
+    let rendered = render(&calc(&dir), &[Criterion::Line, Criterion::Branch], |s, o| {
+        write_coverage_json(s, o)
+    });
+    for expected in [
+        &format!("  \"$schema\": \"{SCHEMA}\",\n"),
+        "    \"simplecov_version\": \"padded_cell 0.1.0\",\n",
+        "    \"commit\": null,\n",
+        "    \"method_coverage\": false\n",
+        "      \"source\": [\n        \"# frozen_string_literal: true\",\n",
+        "        \"ignored\",\n",
+        concat!(
+            "          \"type\": \"else\",\n          \"start_line\": 8,\n",
+            "          \"end_line\": 8,\n          \"coverage\": 0,\n",
+            "          \"inline\": false,\n          \"report_line\": 7\n",
+        ),
+        "      \"branches_covered_percent\": 50.0,\n",
+        "    \"Core\": {\n      \"lines\": {\n",
+        "      \"files\": [\n        \"lib/calc.rb\"\n      ]\n",
+        concat!(
+            "  \"errors\": {\n    \"minimum_coverage_by_file\": {\n",
+            "      \"lib/calc.rb\": {\n        \"branches\": {\n",
+            "          \"expected\": 60.0,\n          \"actual\": 50.0\n",
+        ),
+    ] {
+        assert!(rendered.contains(expected), "{expected:?} in {rendered}");
+    }
+    assert!(!rendered.contains("\"methods\""), "methods were not measured");
+}

data/ext/padded_cell_native/core/src/chart/results.rs

@@ -0,0 +1,379 @@
+use std::io::{self, Write};
+
+use super::json::Json;
+use super::stats::{Criterion, Stats, Totals};
+use super::thresholds::{CRITERIA, Scope, Violation};
+use super::{Branch, FileReport, Line, chomp, floor2};
+
+#[cfg(test)]
+mod tests;
+
+const SCHEMA: &str = concat!(
+    "https://raw.githubusercontent.com/simplecov-ruby/simplecov/main/",
+    "schemas/coverage-v1.3.schema.json",
+);
+const COMMAND: &str = "padded_cell";
+
+/// About the run.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Meta {
+    /// The project root, absolute.
+    pub root: String,
+    /// ISO 8601, with milliseconds.
+    pub timestamp: String,
+    /// The same moment, in seconds since the epoch.
+    pub created_at: f64,
+    /// The root's git HEAD.
+    pub commit: Option<String>,
+    pub project_name: String,
+    /// What wrote the report: `padded_cell 0.1.0`.
+    pub generator: String,
+}
+
+/// Everything a report says about a run.
+#[derive(Debug)]
+pub struct Summary<'a> {
+    pub files: &'a [FileReport<'a>],
+    pub measured: Vec<Criterion>,
+    pub totals: Totals,
+    /// Name, indices into `files`, and their totals.
+    pub groups: Vec<(String, Vec<usize>, Totals)>,
+    pub violations: Vec<Violation>,
+    pub meta: Meta,
+}
+
+impl Summary<'_> {
+    /// `criterion` was measured.
+    #[must_use]
+    pub fn measures(&self, criterion: Criterion) -> bool {
+        self.measured.contains(&criterion)
+    }
+}
+
+/// `coverage.json`.
+///
+/// # Errors
+///
+/// What writing to `out` returns.
+pub fn write_coverage_json(summary: &Summary<'_>, out: &mut impl Write) -> io::Result<()> {
+    Json::pretty(out).object(|json| {
+        json.key("$schema")?.str(SCHEMA)?;
+        json.key("meta")?.object(|json| meta(json, summary))?;
+        json.key("total")?.object(|json| statistics(json, summary, &summary.totals))?;
+        json.key("coverage")?.object(|json| {
+            summary.files.iter().try_for_each(|file| {
+                json.key(&file.file.name)?.object(|json| source_file(json, summary, file))
+            })
+        })?;
+        json.key("groups")?.object(|json| {
+            summary.groups.iter().try_for_each(|(name, members, totals)| {
+                json.key(name)?.object(|json| {
+                    statistics(json, summary, totals)?;
+                    json.key("files")?.array(|json| {
+                        let names = members.iter().filter_map(|&index| summary.files.get(index));
+                        names.into_iter().try_for_each(|file| json.item()?.str(&file.file.name))
+                    })
+                })
+            })
+        })?;
+        json.key("errors")?.object(|json| errors(json, &summary.violations))
+    })
+}
+
+/// `.resultset.json`: Ruby's Coverage result, keyed by absolute path, under
+/// the command name.
+///
+/// # Errors
+///
+/// What writing to `out` returns.
+pub fn write_resultset(summary: &Summary<'_>, out: &mut impl Write) -> io::Result<()> {
+    Json::compact(out).object(|json| {
+        json.key(COMMAND)?.object(|json| {
+            json.key("coverage")?.object(|json| {
+                let methods = summary.measures(Criterion::Method);
+                summary.files.iter().try_for_each(|file| {
+                    let path = file.file.path.to_string_lossy();
+                    json.key(&path)?.object(|json| resultset_file(json, file, methods))
+                })
+            })?;
+            json.key("timestamp")?.float(summary.meta.created_at)
+        })
+    })?;
+    out.write_all(b"\n")
+}
+
+/// `.last_run.json`: the run's percents, floored, which the next run's
+/// `maximum_drop` compares with.
+///
+/// # Errors
+///
+/// What writing to `out` returns.
+pub fn write_last_run(summary: &Summary<'_>, out: &mut impl Write) -> io::Result<()> {
+    Json::pretty(out).object(|json| {
+        json.key("result")?.object(|json| {
+            summary.measured.iter().try_for_each(|&criterion| {
+                json.key(criterion.singular())?
+                    .float(floor2(summary.totals.get(criterion).percent()))
+            })
+        })
+    })?;
+    out.write_all(b"\n")
+}
+
+fn meta<W: Write>(json: &mut Json<'_, W>, summary: &Summary<'_>) -> io::Result<()> {
+    let meta = &summary.meta;
+    json.key("schema_version")?.str("1.3")?;
+    json.key("simplecov_version")?.str(&meta.generator)?;
+    json.key("command_name")?.str(COMMAND)?;
+    json.key("command_names")?.array(|json| json.item()?.str(COMMAND))?;
+    json.key("project_name")?.str(&meta.project_name)?;
+    json.key("timestamp")?.str(&meta.timestamp)?;
+    json.key("root")?.str(&meta.root)?;
+    match &meta.commit {
+        Some(commit) => json.key("commit")?.str(commit)?,
+        None => json.key("commit")?.null()?,
+    }
+    json.key("primary_coverage")?.str("line")?;
+    for criterion in CRITERIA {
+        let key = format!("{}_coverage", criterion.singular());
+        json.key(&key)?.bool(summary.measures(criterion))?;
+    }
+    Ok(())
+}
+
+fn statistics<W: Write>(
+    json: &mut Json<'_, W>,
+    summary: &Summary<'_>,
+    totals: &Totals,
+) -> io::Result<()> {
+    summary.measured.iter().try_for_each(|&criterion| {
+        let stats = totals.get(criterion);
+        json.key(criterion.plural())?
+            .object(|json| statistic(json, criterion, &stats, stats.percent()))
+    })
+}
+
+fn statistic<W: Write>(
+    json: &mut Json<'_, W>,
+    criterion: Criterion,
+    stats: &Stats,
+    percent: f64,
+) -> io::Result<()> {
+    json.key("covered")?.uint(stats.covered)?;
+    json.key("missed")?.uint(stats.missed)?;
+    if criterion == Criterion::Line {
+        json.key("omitted")?.uint(stats.omitted)?;
+    }
+    json.key("total")?.uint(stats.total())?;
+    json.key("percent")?.float(percent)?;
+    json.key("strength")?.float(stats.strength())
+}
+
+fn source_file<W: Write>(
+    json: &mut Json<'_, W>,
+    summary: &Summary<'_>,
+    file: &FileReport<'_>,
+) -> io::Result<()> {
+    json.key("source")?.array(|json| {
+        file.lines()
+            .try_for_each(|line| json.item()?.str(&String::from_utf8_lossy(chomp(line.text))))
+    })?;
+    let stats = &file.stats;
+    json.key("lines")?.array(|json| file.lines().try_for_each(|line| hits(json.item()?, &line)))?;
+    json.key("lines_covered_percent")?.float(stats.percent(Criterion::Line))?;
+    json.key("covered_lines")?.uint(stats.counts.line.covered)?;
+    json.key("missed_lines")?.uint(stats.counts.line.missed)?;
+    json.key("omitted_lines")?.uint(stats.counts.line.omitted)?;
+    json.key("total_lines")?.uint(stats.counts.line.total())?;
+    if summary.measures(Criterion::Branch) {
+        json.key("branches")?
+            .array(|json| file.branches().try_for_each(|b| branch(json.item()?, &b)))?;
+        counts(json, "branches", stats.percent(Criterion::Branch), &stats.counts.branch)?;
+    }
+    if summary.measures(Criterion::Method) {
+        json.key("methods")?.array(|json| {
+            file.methods().try_for_each(|method| {
+                json.item()?.object(|json| {
+                    let name = format!("{}#{}", method.method.owner, method.method.name);
+                    json.key("name")?.str(&name)?;
+                    json.key("start_line")?.uint(method.method.span.start_line.into())?;
+                    json.key("end_line")?.uint(method.method.span.end_line.into())?;
+                    let coverage = json.key("coverage")?;
+                    if method.skipped {
+                        coverage.str("ignored")
+                    } else {
+                        coverage.uint(method.method.hits)
+                    }
+                })
+            })
+        })?;
+        counts(json, "methods", stats.percent(Criterion::Method), &stats.counts.method)?;
+    }
+    Ok(())
+}
+
+fn counts<W: Write>(
+    json: &mut Json<'_, W>,
+    name: &str,
+    percent: f64,
+    stats: &Stats,
+) -> io::Result<()> {
+    json.key(&format!("{name}_covered_percent"))?.float(percent)?;
+    json.key(&format!("covered_{name}"))?.uint(stats.covered)?;
+    json.key(&format!("missed_{name}"))?.uint(stats.missed)?;
+    json.key(&format!("total_{name}"))?.uint(stats.total())
+}
+
+/// Hits, `null` for no code, `"ignored"` for a skipped line.
+fn hits<W: Write>(json: &mut Json<'_, W>, line: &Line<'_>) -> io::Result<()> {
+    match line.hits {
+        _ if line.skipped => json.str("ignored"),
+        Some(hits) => json.uint(hits),
+        None => json.null(),
+    }
+}
+
+fn branch<W: Write>(json: &mut Json<'_, W>, branch: &Branch<'_>) -> io::Result<()> {
+    json.object(|json| {
+        json.key("type")?.str(branch.kind)?;
+        json.key("start_line")?.uint(branch.start_line.into())?;
+        json.key("end_line")?.uint(branch.end_line.into())?;
+        let coverage = json.key("coverage")?;
+        if branch.skipped {
+            coverage.str("ignored")?;
+        } else {
+            coverage.uint(branch.hits)?;
+        }
+        json.key("inline")?.bool(branch.inline)?;
+        json.key("report_line")?.uint(branch.report_line().into())
+    })
+}
+
+/// The violations, by kind.
+fn errors<W: Write>(json: &mut Json<'_, W>, violations: &[Violation]) -> io::Result<()> {
+    let total: Vec<&Violation> = violations.iter().filter(|v| v.scope == Scope::Total).collect();
+    section(json, "minimum_coverage", "expected", &total)?;
+    named(json, "minimum_coverage_by_file", violations, |v| match &v.scope {
+        Scope::File(name) => Some(name),
+        _ => None,
+    })?;
+    named(json, "minimum_coverage_by_group", violations, |v| match &v.scope {
+        Scope::Group(name) => Some(name),
+        _ => None,
+    })?;
+    let drops: Vec<&Violation> = violations.iter().filter(|v| v.scope == Scope::Drop).collect();
+    section(json, "maximum_coverage_drop", "maximum", &drops)
+}
+
+fn section<W: Write>(
+    json: &mut Json<'_, W>,
+    key: &str,
+    limit: &str,
+    found: &[&Violation],
+) -> io::Result<()> {
+    if found.is_empty() {
+        return Ok(());
+    }
+    json.key(key)?.object(|json| found.iter().try_for_each(|v| violation(json, limit, v)))
+}
+
+/// Violations by file or group name; a name's violations come together.
+fn named<W: Write>(
+    json: &mut Json<'_, W>,
+    key: &str,
+    violations: &[Violation],
+    name: impl Fn(&Violation) -> Option<&String>,
+) -> io::Result<()> {
+    let mut names: Vec<&String> = violations.iter().filter_map(&name).collect();
+    names.dedup();
+    if names.is_empty() {
+        return Ok(());
+    }
+    json.key(key)?.object(|json| {
+        names.iter().try_for_each(|&scope| {
+            let found: Vec<&Violation> =
+                violations.iter().filter(|v| name(v) == Some(scope)).collect();
+            json.key(scope)?
+                .object(|json| found.iter().try_for_each(|v| violation(json, "expected", v)))
+        })
+    })
+}
+
+fn violation<W: Write>(
+    json: &mut Json<'_, W>,
+    limit: &str,
+    violation: &Violation,
+) -> io::Result<()> {
+    json.key(violation.criterion.plural())?.object(|json| {
+        json.key(limit)?.float(violation.limit)?;
+        json.key("actual")?.float(violation.actual)
+    })
+}
+
+fn resultset_file<W: Write>(
+    json: &mut Json<'_, W>,
+    file: &FileReport<'_>,
+    methods: bool,
+) -> io::Result<()> {
+    json.key("lines")?.array(|json| {
+        file.raw_lines().iter().try_for_each(|hits| match hits {
+            Some(hits) => json.item()?.uint(*hits),
+            None => json.item()?.null(),
+        })
+    })?;
+    if let Some(conditions) = &file.file.branches {
+        // Ruby numbers conditions and arms in the order it compiled them.
+        let mut id = 0_u64;
+        json.key("branches")?.object(|json| {
+            conditions.iter().try_for_each(|condition| {
+                json.key(&ruby_tuple(&condition.kind, &mut id, &condition.span))?.object(|json| {
+                    condition.arms.iter().try_for_each(|arm| {
+                        json.key(&ruby_tuple(&arm.kind, &mut id, &arm.span))?.uint(arm.hits)
+                    })
+                })
+            })
+        })?;
+    }
+    if methods {
+        json.key("methods")?.object(|json| {
+            file.methods().try_for_each(|method| {
+                let span = &method.method.span;
+                let key = format!(
+                    "[{}, {}, {}, {}, {}, {}]",
+                    method.method.owner,
+                    ruby_symbol(&method.method.name),
+                    span.start_line,
+                    span.start_column,
+                    span.end_line,
+                    span.end_column
+                );
+                json.key(&key)?.uint(method.method.hits)
+            })
+        })?;
+    }
+    Ok(())
+}
+
+/// `[:if, 0, 2, 4, 6, 7]`, as Ruby's `Array#to_s` writes a branch key.
+fn ruby_tuple(kind: &str, id: &mut u64, span: &super::Span) -> String {
+    let tuple = format!(
+        "[{}, {id}, {}, {}, {}, {}]",
+        ruby_symbol(kind),
+        span.start_line,
+        span.start_column,
+        span.end_line,
+        span.end_column
+    );
+    *id = id.strict_add(1);
+    tuple
+}
+
+/// `:if`, or `:"&."` for a symbol that needs quoting.
+fn ruby_symbol(name: &str) -> String {
+    let plain = name
+        .bytes()
+        .all(|byte| byte.is_ascii_alphanumeric() || b"_?!=[]+-*/%<>~^&|".contains(&byte))
+        && !name.is_empty()
+        && name != "&.";
+    if plain { format!(":{name}") } else { format!(":{name:?}") }
+}

data/ext/padded_cell_native/core/src/chart/source/tests.rs

@@ -0,0 +1,64 @@
+use super::*;
+
+fn source(text: &str) -> Source {
+    Source::new(text.as_bytes().to_vec())
+}
+
+#[test]
+fn lines_split_as_ruby_readlines() {
+    const CASES: &[(&str, &[&str])] = &[
+        ("", &[]),
+        ("a", &["a"]),
+        ("a\nb", &["a\n", "b"]),
+        ("a\nb\n", &["a\n", "b\n"]),
+        ("\n\n", &["\n", "\n"]),
+        ("a\r\nb", &["a\r\n", "b"]),
+    ];
+    for (text, expected) in CASES {
+        let source = source(text);
+        let lines: Vec<&[u8]> = source.lines().collect();
+        let expected: Vec<&[u8]> = expected.iter().map(|line| line.as_bytes()).collect();
+        assert_eq!(lines, expected, "text: {text:?}");
+        assert_eq!(source.len(), expected.len(), "text: {text:?}");
+    }
+}
+
+#[test]
+fn blank_and_comment_lines() {
+    const CASES: &[(&str, bool)] = &[
+        ("", true),
+        ("\n", true),
+        ("  \t\r\n", true),
+        ("# comment\n", true),
+        ("   # indented\n", true),
+        ("\x0b\x0c#\n", true),
+        ("code\n", false),
+        ("x = 1 # comment\n", false),
+        ("  end", false),
+    ];
+    for (line, expected) in CASES {
+        assert_eq!(blank_or_comment(line.as_bytes()), *expected, "line: {line:?}");
+    }
+}
+
+#[test]
+fn nocov_blocks_run_from_marker_to_marker() {
+    let text = "a\n# :nocov:\nb\n  #   :nocov: done\nc\nd # :nocov:\n#:nocov:\ne\n";
+    assert_eq!(source(text).nocov("nocov"), [2..=4, 7..=8]);
+    assert_eq!(source(text).nocov("skip"), []);
+    assert_eq!(source("a\n# :skip:\nb\n").nocov("skip"), [RangeInclusive::new(2, 3)]);
+    // A marker needs both colons: `# :nocov` is a comment.
+    assert_eq!(source("# :nocov\n# nocov:\n").nocov("nocov"), []);
+}
+
+#[test]
+fn unloaded_files_keep_only_their_code() {
+    let source = source("# frozen\n\nclass A\n  # :nocov:\n  def b; end\n  # :nocov:\nend\n");
+    let stub = [Some(0), Some(0), Some(0), Some(0), Some(0), Some(0), Some(0), Some(0)];
+    let skipped = source.nocov("nocov");
+    assert_eq!(
+        source.relevant(&stub, &skipped),
+        [None, None, Some(0), None, None, None, Some(0), None],
+        "comments, blank lines, blocks, and lines past the source are not code"
+    );
+}