padded_cell 0.1.0 → 0.3.0

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

@@ -0,0 +1,175 @@
+use std::io::{self, Write};
+
+#[cfg(test)]
+mod tests;
+
+/// A JSON writer. Containers take a closure writing their members:
+///
+/// ```text
+/// json.object(|json| {
+///     json.key("lines")?.array(|json| json.item()?.uint(1))
+/// })
+/// ```
+pub struct Json<'w, W: Write> {
+    out: &'w mut W,
+    pretty: bool,
+    depth: usize,
+    /// The innermost container has no member yet.
+    empty: bool,
+}
+
+impl<'w, W: Write> Json<'w, W> {
+    /// `JSON.pretty_generate`'s layout: two-space indents, one member per
+    /// line, `[]` and `{}` when empty.
+    pub const fn pretty(out: &'w mut W) -> Self {
+        Self { out, pretty: true, depth: 0, empty: true }
+    }
+
+    /// `JSON.generate`'s: no whitespace.
+    pub const fn compact(out: &'w mut W) -> Self {
+        Self { out, pretty: false, depth: 0, empty: true }
+    }
+
+    /// # Errors
+    ///
+    /// What writing returns.
+    pub fn object(&mut self, members: impl FnOnce(&mut Self) -> io::Result<()>) -> io::Result<()> {
+        self.container(b'{', b'}', members)
+    }
+
+    /// # Errors
+    ///
+    /// What writing returns.
+    pub fn array(&mut self, items: impl FnOnce(&mut Self) -> io::Result<()>) -> io::Result<()> {
+        self.container(b'[', b']', items)
+    }
+
+    /// Starts an object member: its value comes next.
+    ///
+    /// # Errors
+    ///
+    /// What writing returns.
+    pub fn key(&mut self, key: &str) -> io::Result<&mut Self> {
+        self.separate()?;
+        self.raw_str(key)?;
+        self.out.write_all(if self.pretty { b": " } else { b":" })?;
+        Ok(self)
+    }
+
+    /// Starts an array item: its value comes next.
+    ///
+    /// # Errors
+    ///
+    /// What writing returns.
+    pub fn item(&mut self) -> io::Result<&mut Self> {
+        self.separate()?;
+        Ok(self)
+    }
+
+    /// # Errors
+    ///
+    /// What writing returns.
+    pub fn str(&mut self, value: &str) -> io::Result<()> {
+        self.raw_str(value)
+    }
+
+    /// # Errors
+    ///
+    /// What writing returns.
+    pub fn uint(&mut self, value: u64) -> io::Result<()> {
+        write!(self.out, "{value}")
+    }
+
+    /// Ruby's way: `100.0`, not `100`.
+    ///
+    /// # Errors
+    ///
+    /// What writing returns.
+    pub fn float(&mut self, value: f64) -> io::Result<()> {
+        let mut text = value.to_string();
+        if !text.contains(['.', 'e', 'N', 'i']) {
+            text.push_str(".0");
+        }
+        self.out.write_all(text.as_bytes())
+    }
+
+    /// # Errors
+    ///
+    /// What writing returns.
+    pub fn bool(&mut self, value: bool) -> io::Result<()> {
+        self.out.write_all(if value { b"true" } else { b"false" })
+    }
+
+    /// # Errors
+    ///
+    /// What writing returns.
+    pub fn null(&mut self) -> io::Result<()> {
+        self.out.write_all(b"null")
+    }
+
+    fn container(
+        &mut self,
+        open: u8,
+        close: u8,
+        members: impl FnOnce(&mut Self) -> io::Result<()>,
+    ) -> io::Result<()> {
+        self.out.write_all(&[open])?;
+        self.depth = self.depth.strict_add(1);
+        self.empty = true;
+        members(self)?;
+        self.depth = self.depth.strict_sub(1);
+        if !self.empty {
+            self.newline()?;
+        }
+        // The enclosing container has this one as a member.
+        self.empty = false;
+        self.out.write_all(&[close])
+    }
+
+    fn separate(&mut self) -> io::Result<()> {
+        if !self.empty {
+            self.out.write_all(b",")?;
+        }
+        self.empty = false;
+        self.newline()
+    }
+
+    fn newline(&mut self) -> io::Result<()> {
+        if self.pretty {
+            self.out.write_all(b"\n")?;
+            for _ in 0..self.depth {
+                self.out.write_all(b"  ")?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Escapes what JSON requires, in runs: no copy of the string.
+    fn raw_str(&mut self, value: &str) -> io::Result<()> {
+        self.out.write_all(b"\"")?;
+        let bytes = value.as_bytes();
+        let mut start = 0;
+        for (index, &byte) in bytes.iter().enumerate() {
+            let escape: &[u8] = match byte {
+                b'"' => b"\\\"",
+                b'\\' => b"\\\\",
+                0x08 => b"\\b",
+                0x0c => b"\\f",
+                b'\n' => b"\\n",
+                b'\r' => b"\\r",
+                b'\t' => b"\\t",
+                0x20.. => continue,
+                _ => b"",
+            };
+            self.out.write_all(&bytes[start..index])?;
+            if escape.is_empty() {
+                write!(self.out, "\\u{byte:04x}")?;
+            } else {
+                self.out.write_all(escape)?;
+            }
+            start = index.strict_add(1);
+        }
+        self.out.write_all(&bytes[start..])?;
+        self.out.write_all(b"\"")
+    }
+}

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