padded_cell 0.1.0 → 0.2.0

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

@@ -0,0 +1,50 @@
+use std::io::{self, Write};
+
+use super::FileReport;
+
+/// Writes `reports` as an LCOV tracefile:
+///
+/// ```text
+/// SF:./app/models/user.rb
+/// DA:3,1                  each line of code outside :nocov: blocks
+/// LF:12                   lines of code, those in :nocov: blocks included
+/// LH:9                    lines covered
+/// BRDA:4,0,1,2            each branch outside blocks: line, 0, number, hits
+/// BRDA:6,0,2,-            ("-" for none)
+/// end_of_record
+/// ```
+///
+/// An empty `DA` or `BRDA` section leaves an empty line.
+///
+/// # Errors
+///
+/// What writing to `out` returns.
+pub fn write_lcov(reports: &[FileReport<'_>], out: &mut impl Write) -> io::Result<()> {
+    for report in reports {
+        writeln!(out, "SF:./{}", report.file.name)?;
+        let (mut code, mut covered, mut first) = (0_u64, 0_u64, true);
+        for line in report.lines() {
+            code = code.strict_add(u64::from(line.hits.is_some()));
+            covered = covered.strict_add(u64::from(line.covered()));
+            if let Some(hits) = line.hits
+                && !line.skipped
+            {
+                if !first {
+                    out.write_all(b"\n")?;
+                }
+                first = false;
+                write!(out, "DA:{},{hits}", line.number)?;
+            }
+        }
+        write!(out, "\nLF:{code}\nLH:{covered}\n")?;
+        for (number, branch) in (1_u64..).zip(report.reported_branches()) {
+            if number > 1 {
+                out.write_all(b"\n")?;
+            }
+            write!(out, "BRDA:{},0,{number},", branch.report_line())?;
+            if branch.hits == 0 { out.write_all(b"-")? } else { write!(out, "{}", branch.hits)? }
+        }
+        out.write_all(b"\nend_of_record\n")?;
+    }
+    Ok(())
+}

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

@@ -0,0 +1,93 @@
+use std::fs;
+
+use tempfile::TempDir;
+
+use super::super::FileCoverage;
+use super::super::test_support::{calc, reports, summary};
+use super::*;
+
+/// Calc misses two branches; gap.rb misses a line holding backticks, and
+/// one line further down.
+#[test]
+fn totals_groups_then_the_code_that_never_ran() {
+    let dir = TempDir::new().unwrap();
+    let gap = dir.path().join("gap.rb");
+    fs::write(&gap, "def a\n  1\nend\n\ndef b\n  x = \"```\"\n  :y\nend\n\n:z\n").unwrap();
+    let mut lines =
+        vec![Some(1), Some(1), None, None, Some(1), Some(0), Some(0), None, None, Some(0)];
+    lines.truncate(10);
+    let files = [
+        calc(&dir),
+        FileCoverage {
+            path: gap,
+            name: "lib/gap.rb".to_owned(),
+            lines,
+            branches: Some(Vec::new()),
+            methods: None,
+            loaded: true,
+        },
+    ];
+    let reports = reports(&files);
+    let mut summary = summary(&reports, &[Criterion::Line, Criterion::Branch]);
+    summary.groups =
+        vec![("Core".to_owned(), vec![0], super::super::Totals::of_files(&reports[..1]))];
+    summary.meta.project_name = "App".to_owned();
+    summary.meta.timestamp = "2026-10-11T13:00:00.000+02:00".to_owned();
+    summary.meta.commit = Some("0123456789abcdef".to_owned());
+    let mut out = Vec::new();
+    write_markdown(&summary, &mut out).unwrap();
+
+    let expected = "\
+# Coverage: App
+
+Lines 75.00% (9 / 12) · Branches 50.00% (2 / 4)
+
+Generated 2026-10-11T13:00:00.000+02:00 by padded_cell 0.1.0, at `0123456789ab`.
+
+| Group | Lines | Branches |
+|---|---:|---:|
+| Core | 100.00% (6 / 6) | 50.00% (2 / 4) |
+
+## Missed, most first
+
+### `lib/gap.rb`
+
+Lines 50.00% (3 / 6) · Branches 100.00% (0 / 0)
+
+Lines never run: 6-7, 10.
+
+````ruby
+ 6    x = \"```\"
+ 7    :y
+ …
+10  :z
+````
+
+### `lib/calc.rb`
+
+Lines 100.00% (6 / 6) · Branches 50.00% (2 / 4)
+
+Branches never taken: 7 `else`, 16 `else`.
+";
+    assert_eq!(String::from_utf8(out).unwrap(), expected);
+}
+
+#[test]
+fn everything_ran() {
+    let dir = TempDir::new().unwrap();
+    let mut file = calc(&dir);
+    file.branches = None;
+    let files = [file];
+    let reports = reports(&files);
+    let mut out = Vec::new();
+    write_markdown(&summary(&reports, &[Criterion::Line]), &mut out).unwrap();
+    assert!(
+        String::from_utf8(out).unwrap().ends_with("by padded_cell 0.1.0.\n\nEverything ran.\n")
+    );
+}
+
+#[test]
+fn ranges_collapse_runs() {
+    assert_eq!(ranges(&[3, 4, 5, 9, 11, 12]), "3-5, 9, 11-12");
+    assert_eq!(ranges(&[7]), "7");
+}

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

@@ -0,0 +1,201 @@
+use std::io::{self, Write};
+use std::path::Path;
+
+use super::stats::{Criterion, Stats};
+use super::{Branch, FileReport, Line, MethodReport, Summary, chomp, floor2};
+
+#[cfg(test)]
+mod tests;
+
+/// GitHub job summaries take up to 1 MiB: files past it are only counted.
+const BUDGET: usize = 1_000_000;
+/// Lines of missed code shown per file.
+const EXCERPT: usize = 40;
+
+/// Writes `summary` as Markdown.
+///
+/// # Errors
+///
+/// What writing to `out` returns.
+pub fn write_markdown(summary: &Summary<'_>, out: &mut impl Write) -> io::Result<()> {
+    let mut head = Vec::new();
+    header(&mut head, summary)?;
+    out.write_all(&head)?;
+    let mut files: Vec<&FileReport<'_>> =
+        summary.files.iter().filter(|file| missed(file) > 0).collect();
+    if files.is_empty() {
+        return out.write_all(b"Everything ran.\n");
+    }
+    files.sort_by(|a, b| missed(b).cmp(&missed(a)).then_with(|| a.file.name.cmp(&b.file.name)));
+    out.write_all(b"## Missed, most first\n")?;
+    let mut written = head.len();
+    for (index, file) in files.iter().enumerate() {
+        let mut section = Vec::new();
+        file_section(&mut section, summary, file)?;
+        written = written.strict_add(section.len());
+        if written > BUDGET {
+            let rest = files.len().strict_sub(index);
+            return writeln!(out, "\n{rest} more files have missed code: see `lcov.info`.");
+        }
+        out.write_all(&section)?;
+    }
+    Ok(())
+}
+
+fn header(out: &mut Vec<u8>, summary: &Summary<'_>) -> io::Result<()> {
+    let meta = &summary.meta;
+    writeln!(out, "# Coverage: {}\n", meta.project_name)?;
+    totals(out, summary, |criterion| {
+        let stats = summary.totals.get(criterion);
+        (stats, stats.percent())
+    })?;
+    write!(out, "\nGenerated {} by {}", meta.timestamp, meta.generator)?;
+    if let Some(commit) = &meta.commit {
+        write!(out, ", at `{}`", commit.get(..12).unwrap_or(commit))?;
+    }
+    out.write_all(b".\n\n")?;
+    if summary.groups.is_empty() {
+        return Ok(());
+    }
+    out.write_all(b"| Group |")?;
+    for &criterion in &summary.measured {
+        write!(out, " {} |", label(criterion))?;
+    }
+    out.write_all(b"\n|---|")?;
+    out.write_all(&b"---:|".repeat(summary.measured.len()))?;
+    out.write_all(b"\n")?;
+    for (name, _, group) in &summary.groups {
+        write!(out, "| {name} |")?;
+        for &criterion in &summary.measured {
+            let stats = group.get(criterion);
+            write!(out, " {} |", ratio(&stats, stats.percent()))?;
+        }
+        out.write_all(b"\n")?;
+    }
+    out.write_all(b"\n")
+}
+
+fn file_section(out: &mut Vec<u8>, summary: &Summary<'_>, file: &FileReport<'_>) -> io::Result<()> {
+    write!(out, "\n### `{}`\n\n", file.file.name)?;
+    totals(out, summary, |criterion| file.stats.with_percent(criterion))?;
+    let lines: Vec<u32> = file.lines().filter(Line::missed).map(|line| line.number).collect();
+    if !lines.is_empty() {
+        writeln!(out, "\nLines never run: {}.", ranges(&lines))?;
+    }
+    // By line: `208 then, 306 then else`.
+    let mut branches: Vec<(u32, &str)> = file
+        .reported_branches()
+        .filter(Branch::missed)
+        .map(|branch| (branch.report_line(), branch.kind))
+        .collect();
+    branches.sort_by_key(|&(line, _)| line);
+    if !branches.is_empty() {
+        let mut lines: Vec<String> = Vec::new();
+        for chunk in branches.chunk_by(|a, b| a.0 == b.0) {
+            let kinds: Vec<&str> = chunk.iter().map(|&(_, kind)| kind).collect();
+            lines.push(format!("{} `{}`", chunk[0].0, kinds.join(" ")));
+        }
+        writeln!(out, "\nBranches never taken: {}.", lines.join(", "))?;
+    }
+    let methods: Vec<String> = file
+        .methods()
+        .filter(MethodReport::missed)
+        .map(|method| {
+            let method = method.method;
+            format!("`{}#{}` at {}", method.owner, method.name, method.span.start_line)
+        })
+        .collect();
+    if !methods.is_empty() {
+        writeln!(out, "\nMethods never called: {}.", methods.join(", "))?;
+    }
+    excerpt(out, file, &lines)
+}
+
+/// The missed lines, numbered, a `…` between runs.
+fn excerpt(out: &mut Vec<u8>, file: &FileReport<'_>, missed: &[u32]) -> io::Result<()> {
+    if missed.is_empty() {
+        return Ok(());
+    }
+    let shown = &missed[..missed.len().min(EXCERPT)];
+    let texts: Vec<(u32, String)> = file
+        .lines()
+        .filter(|line| shown.binary_search(&line.number).is_ok())
+        .map(|line| (line.number, String::from_utf8_lossy(chomp(line.text)).into_owned()))
+        .collect();
+    // A fence longer than any run of backticks in the code.
+    let longest = texts.iter().map(|(_, text)| longest_run(text, '`')).max().unwrap_or(0);
+    let fence = "`".repeat(longest.max(2).strict_add(1));
+    let width = shown.last().map_or(1, |last| last.to_string().len());
+    let ruby = Path::new(&file.file.name).extension().is_some_and(|extension| extension == "rb");
+    let language = if ruby { "ruby" } else { "" };
+    write!(out, "\n{fence}{language}\n")?;
+    let mut previous = None;
+    for (number, text) in &texts {
+        if previous.is_some_and(|previous: u32| previous.strict_add(1) != *number) {
+            writeln!(out, "{:>width$}", "…")?;
+        }
+        writeln!(out, "{number:>width$}  {text}")?;
+        previous = Some(*number);
+    }
+    if missed.len() > shown.len() {
+        writeln!(out, "… {} more lines", missed.len().strict_sub(shown.len()))?;
+    }
+    writeln!(out, "{fence}")
+}
+
+fn totals(
+    out: &mut Vec<u8>,
+    summary: &Summary<'_>,
+    stats: impl Fn(Criterion) -> (Stats, f64),
+) -> io::Result<()> {
+    let parts: Vec<String> = summary
+        .measured
+        .iter()
+        .map(|&criterion| {
+            let (stats, percent) = stats(criterion);
+            format!("{} {}", label(criterion), ratio(&stats, percent))
+        })
+        .collect();
+    writeln!(out, "{}", parts.join(" · "))
+}
+
+/// `83.83% (82782 / 98745)`
+fn ratio(stats: &Stats, percent: f64) -> String {
+    format!("{:.2}% ({} / {})", floor2(percent), stats.covered, stats.total())
+}
+
+const fn label(criterion: Criterion) -> &'static str {
+    match criterion {
+        Criterion::Line => "Lines",
+        Criterion::Branch => "Branches",
+        Criterion::Method => "Methods",
+    }
+}
+
+/// What a file has left to cover.
+const fn missed(file: &FileReport<'_>) -> u64 {
+    let counts = &file.stats.counts;
+    counts.line.missed.strict_add(counts.branch.missed).strict_add(counts.method.missed)
+}
+
+/// `[3, 4, 5, 9]` as `3-5, 9`.
+fn ranges(numbers: &[u32]) -> String {
+    let mut runs: Vec<(u32, u32)> = Vec::new();
+    for &number in numbers {
+        match runs.last_mut() {
+            Some((_, end)) if end.strict_add(1) == number => *end = number,
+            _ => runs.push((number, number)),
+        }
+    }
+    let runs: Vec<String> = runs
+        .iter()
+        .map(
+            |&(start, end)| if start == end { start.to_string() } else { format!("{start}-{end}") },
+        )
+        .collect();
+    runs.join(", ")
+}
+
+fn longest_run(text: &str, character: char) -> usize {
+    text.split(|other| other != character).map(str::len).max().unwrap_or(0)
+}

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

@@ -0,0 +1,38 @@
+use super::*;
+
+#[test]
+fn defs_with_their_innermost_owner_and_span() {
+    let source = Source::new(
+        concat!(
+            "def top = 1\nmodule A\n  class B::C\n  é = 1; def x(y)\n    y\n  end\n",
+            "    def self.z = 2\n  end\nend\n",
+        )
+        .as_bytes()
+        .to_vec(),
+    );
+    let found: Vec<(String, String, Span)> = static_methods(&source)
+        .unwrap()
+        .into_iter()
+        .map(|method| (method.owner, method.name, method.span))
+        .collect();
+    let span = |start_line, start_column, end_line, end_column| Span {
+        start_line,
+        start_column,
+        end_line,
+        end_column,
+    };
+    assert_eq!(
+        found,
+        [
+            ("Object".to_owned(), "top".to_owned(), span(1, 0, 1, 11)),
+            // Columns count bytes, as Ruby's do: é is two.
+            ("B::C".to_owned(), "x".to_owned(), span(4, 10, 6, 5)),
+            ("B::C".to_owned(), "z".to_owned(), span(7, 4, 7, 18)),
+        ]
+    );
+}
+
+#[test]
+fn sources_that_do_not_parse_have_no_methods() {
+    assert_eq!(static_methods(&Source::new(b"def broken(\n".to_vec())), None);
+}

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

@@ -0,0 +1,62 @@
+use ruby_prism::{ClassNode, DefNode, Location, ModuleNode, Visit};
+
+use super::{Method, Source, Span};
+
+#[cfg(test)]
+mod tests;
+
+/// `None` when the source does not parse.
+#[must_use]
+pub fn static_methods(source: &Source) -> Option<Vec<Method>> {
+    let result = ruby_prism::parse(source.bytes());
+    if result.errors().next().is_some() {
+        return None;
+    }
+    let mut collector = Collector { source, owners: Vec::new(), methods: Vec::new() };
+    collector.visit(&result.node());
+    Some(collector.methods)
+}
+
+struct Collector<'s> {
+    source: &'s Source,
+    owners: Vec<String>,
+    methods: Vec<Method>,
+}
+
+impl Collector<'_> {
+    fn within(&mut self, owner: &Location<'_>, visit: impl FnOnce(&mut Self)) {
+        self.owners.push(String::from_utf8_lossy(owner.as_slice()).into_owned());
+        visit(self);
+        self.owners.pop();
+    }
+
+    fn span(&self, location: &Location<'_>) -> Span {
+        let (start_line, start_column) = self.source.position(location.start_offset());
+        let (end_line, end_column) = self.source.position(location.end_offset());
+        Span { start_line, start_column, end_line, end_column }
+    }
+}
+
+impl<'pr> Visit<'pr> for Collector<'_> {
+    fn visit_class_node(&mut self, node: &ClassNode<'pr>) {
+        self.within(&node.constant_path().location(), |collector| {
+            ruby_prism::visit_class_node(collector, node);
+        });
+    }
+
+    fn visit_module_node(&mut self, node: &ModuleNode<'pr>) {
+        self.within(&node.constant_path().location(), |collector| {
+            ruby_prism::visit_module_node(collector, node);
+        });
+    }
+
+    fn visit_def_node(&mut self, node: &DefNode<'pr>) {
+        self.methods.push(Method {
+            owner: self.owners.last().map_or("Object", String::as_str).to_owned(),
+            name: String::from_utf8_lossy(node.name().as_slice()).into_owned(),
+            span: self.span(&node.location()),
+            hits: 0,
+        });
+        ruby_prism::visit_def_node(self, node);
+    }
+}

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

@@ -0,0 +1,45 @@
+use tempfile::TempDir;
+
+use super::super::{Meta, Totals};
+use super::*;
+
+fn empty() -> Summary<'static> {
+    Summary {
+        files: &[],
+        measured: Vec::new(),
+        totals: Totals::default(),
+        groups: Vec::new(),
+        violations: Vec::new(),
+        meta: Meta::default(),
+    }
+}
+
+#[test]
+fn formats_by_name() {
+    assert_eq!("lcov".parse(), Ok(Format::Lcov));
+    assert_eq!("json".parse(), Ok(Format::Json));
+    assert_eq!("html5".parse::<Format>(), Err(UnknownFormat("html5".to_owned())));
+}
+
+#[test]
+fn writes_into_a_new_directory_without_leftovers() {
+    let dir = TempDir::new().unwrap();
+    let output = dir.path().join("coverage");
+    let written = write(&output, Format::Json, &empty()).unwrap();
+
+    assert_eq!(written, [output.join("coverage.json"), output.join(".resultset.json")]);
+    assert_eq!(
+        std::fs::read(output.join(".resultset.json")).unwrap(),
+        b"{\"padded_cell\":{\"coverage\":{},\"timestamp\":0.0}}\n"
+    );
+    assert_eq!(std::fs::read_dir(&output).unwrap().count(), 2);
+}
+
+#[test]
+fn unwritable_directories_are_file_errors() {
+    let dir = TempDir::new().unwrap();
+    let blocker = dir.path().join("file");
+    std::fs::write(&blocker, "").unwrap();
+    let error = write(&blocker.join("coverage"), Format::Lcov, &empty()).unwrap_err();
+    assert_eq!(error.path, blocker.join("coverage/lcov.info"));
+}

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");
+}