padded_cell 0.1.0 → 0.3.0

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

@@ -0,0 +1,153 @@
+use std::ops::RangeInclusive;
+use std::path::Path;
+
+use crate::FileError;
+
+#[cfg(test)]
+mod tests;
+
+/// A source file split into lines the way Ruby's `readlines` splits it:
+/// after each newline, and a last line without one.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct Source {
+    bytes: Vec<u8>,
+    /// Where each line ends, its newline included.
+    ends: Vec<usize>,
+}
+
+impl Source {
+    /// # Errors
+    ///
+    /// [`FileError`] when the file cannot be read.
+    pub fn read(path: &Path) -> Result<Self, FileError> {
+        Ok(Self::new(FileError::read(path)?))
+    }
+
+    #[must_use]
+    pub fn new(bytes: Vec<u8>) -> Self {
+        let mut ends: Vec<usize> = newline_ends(&bytes);
+        if bytes.last().is_some_and(|&last| last != b'\n') {
+            ends.push(bytes.len());
+        }
+        Self { bytes, ends }
+    }
+
+    /// The number of lines.
+    #[must_use]
+    pub const fn len(&self) -> usize {
+        self.ends.len()
+    }
+
+    #[must_use]
+    pub const fn is_empty(&self) -> bool {
+        self.ends.is_empty()
+    }
+
+    #[must_use]
+    pub fn bytes(&self) -> &[u8] {
+        &self.bytes
+    }
+
+    /// The 1-based line and the 0-based byte column of `offset`.
+    #[must_use]
+    pub fn position(&self, offset: usize) -> (u32, u32) {
+        let line = self.ends.partition_point(|&end| end <= offset);
+        let number = |value: usize| u32::try_from(value).unwrap_or(u32::MAX);
+        (number(line.strict_add(1)), number(offset.strict_sub(self.line_start(offset))))
+    }
+
+    /// Where the line holding `offset` starts.
+    #[must_use]
+    pub fn line_start(&self, offset: usize) -> usize {
+        let line = self.ends.partition_point(|&end| end <= offset);
+        line.checked_sub(1).map_or(0, |previous| self.ends[previous])
+    }
+
+    /// Each line, its newline included.
+    pub fn lines(&self) -> impl Iterator<Item = &[u8]> {
+        let starts = std::iter::once(0).chain(self.ends.iter().copied());
+        starts.zip(&self.ends).map(|(start, &end)| &self.bytes[start..end])
+    }
+
+    /// The `# :token:` blocks: from a marker comment to the next, both
+    /// included. A block left open runs to the last line.
+    #[must_use]
+    pub fn nocov(&self, token: &str) -> Vec<RangeInclusive<u32>> {
+        let mut markers: Vec<u32> = self
+            .lines()
+            .zip(1..)
+            .filter(|(line, _)| nocov_marker(line, token))
+            .map(|(_, n)| n)
+            .collect();
+        if markers.len() % 2 == 1 {
+            markers.push(u32::try_from(self.len()).unwrap_or(u32::MAX));
+        }
+        markers.as_chunks::<2>().0.iter().map(|&[start, end]| start..=end).collect()
+    }
+
+    /// The lines of a file that never loaded, from `Coverage.line_stub`:
+    /// blank and comment lines, and lines in `skipped` blocks, are not code.
+    #[must_use]
+    pub fn relevant(
+        &self,
+        stub: &[Option<u64>],
+        skipped: &[RangeInclusive<u32>],
+    ) -> Vec<Option<u64>> {
+        let mut lines = self.lines();
+        stub.iter()
+            .zip(1..)
+            .map(|(&hits, number)| {
+                let text = lines.next()?;
+                let code =
+                    !blank_or_comment(text) && !skipped.iter().any(|block| block.contains(&number));
+                if code { hits } else { None }
+            })
+            .collect()
+    }
+}
+
+/// Without its line ending, as Ruby's `chomp`.
+#[must_use]
+pub fn chomp(line: &[u8]) -> &[u8] {
+    let line = line.strip_suffix(b"\n").unwrap_or(line);
+    line.strip_suffix(b"\r").unwrap_or(line)
+}
+
+/// Offsets just past each newline.
+fn newline_ends(bytes: &[u8]) -> Vec<usize> {
+    bytes
+        .iter()
+        .enumerate()
+        .filter(|&(_, &byte)| byte == b'\n')
+        .map(|(index, _)| index.strict_add(1))
+        .collect()
+}
+
+/// Ruby's `\s`: ASCII whitespace only.
+pub const fn ruby_space(byte: u8) -> bool {
+    matches!(byte, b' ' | b'\t' | b'\n' | b'\x0b' | b'\x0c' | b'\r')
+}
+
+/// Without its leading `\s`.
+pub fn trim_start(line: &[u8]) -> &[u8] {
+    let start = line.iter().position(|&byte| !ruby_space(byte)).unwrap_or(line.len());
+    &line[start..]
+}
+
+/// `/^\s*$/` or `/^\s*#/`.
+#[must_use]
+pub fn blank_or_comment(line: &[u8]) -> bool {
+    matches!(trim_start(line).first(), None | Some(b'#'))
+}
+
+/// `/^(\s*)#(\s*)(:token:)/`.
+fn nocov_marker(line: &[u8], token: &str) -> bool {
+    let Some(comment) = trim_start(line).strip_prefix(b"#") else {
+        return false;
+    };
+    let marker = trim_start(comment);
+    marker
+        .strip_prefix(b":")
+        .and_then(|rest| rest.strip_prefix(token.as_bytes()))
+        .is_some_and(|rest| rest.starts_with(b":"))
+}

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

@@ -0,0 +1,52 @@
+use super::*;
+
+const fn stats(covered: u64, missed: u64, hits: u64) -> Stats {
+    Stats { covered, missed, omitted: 0, hits }
+}
+
+#[test]
+fn percent_and_strength() {
+    const CASES: &[(Stats, f64, f64)] = &[
+        (stats(0, 0, 0), 100.0, 0.0),
+        (stats(3, 0, 6), 100.0, 2.0),
+        (stats(0, 4, 0), 0.0, 0.0),
+        (stats(2, 1, 9), 200.0 / 3.0, 3.0),
+    ];
+    for (stats, percent, strength) in CASES {
+        assert_eq!(stats.percent().to_bits(), percent.to_bits(), "{stats:?}");
+        assert_eq!(stats.strength().to_bits(), strength.to_bits(), "{stats:?}");
+    }
+}
+
+#[test]
+fn stats_sum() {
+    let total: Stats = [stats(1, 2, 3), stats(4, 5, 6)].into_iter().sum();
+    assert_eq!(total, stats(5, 7, 9));
+    assert_eq!(total.total(), 12);
+}
+
+/// Values from Ruby's `Float#floor(2)`.
+#[test]
+fn floor2_is_rubys_float_floor() {
+    const CASES: &[(f64, f64)] = &[
+        (0.29, 0.29),
+        (89.999, 89.99),
+        (100.0, 100.0),
+        (0.0, 0.0),
+        (200.0 / 3.0, 66.66),
+        (0.001, 0.0),
+        (57.142_857_142_857_14, 57.14),
+    ];
+    for (number, expected) in CASES {
+        assert_eq!(floor2(*number).to_bits(), expected.to_bits(), "number: {number}");
+    }
+}
+
+#[test]
+fn unmeasured_files_are_at_zero_until_covered() {
+    let mut file = FileStats { unmeasured_branches: true, ..FileStats::default() };
+    assert_eq!(file.percent(Criterion::Branch).to_bits(), 0.0_f64.to_bits());
+    assert_eq!(file.percent(Criterion::Line).to_bits(), 100.0_f64.to_bits());
+    file.unmeasured_branches = false;
+    assert_eq!(file.percent(Criterion::Branch).to_bits(), 100.0_f64.to_bits());
+}

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

@@ -0,0 +1,218 @@
+use std::iter::Sum;
+use std::ops::{Add, AddAssign};
+
+use super::FileReport;
+
+#[cfg(test)]
+mod tests;
+
+/// What coverage counts.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Criterion {
+    Line,
+    Branch,
+    Method,
+}
+
+impl Criterion {
+    /// `line`: its name in `.last_run.json` and in meta keys.
+    #[must_use]
+    pub const fn singular(self) -> &'static str {
+        match self {
+            Self::Line => "line",
+            Self::Branch => "branch",
+            Self::Method => "method",
+        }
+    }
+
+    /// `lines`: its name in `coverage.json`.
+    #[must_use]
+    pub const fn plural(self) -> &'static str {
+        match self {
+            Self::Line => "lines",
+            Self::Branch => "branches",
+            Self::Method => "methods",
+        }
+    }
+}
+
+/// The counts of one criterion, for a file, a group or a whole run.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct Stats {
+    pub covered: u64,
+    pub missed: u64,
+    /// Lines that are not code (lines only).
+    pub omitted: u64,
+    /// The hits of the covered items, summed.
+    pub hits: u64,
+}
+
+impl Stats {
+    /// What can be covered.
+    #[must_use]
+    pub const fn total(&self) -> u64 {
+        self.covered.strict_add(self.missed)
+    }
+
+    /// Covered, in percent. 100 when nothing was missed, nothing to cover
+    /// included.
+    #[must_use]
+    pub fn percent(&self) -> f64 {
+        if self.missed == 0 { 100.0 } else { float(self.covered) * 100.0 / float(self.total()) }
+    }
+
+    /// Hits per item that can be covered.
+    #[must_use]
+    pub fn strength(&self) -> f64 {
+        if self.total() == 0 { 0.0 } else { float(self.hits) / float(self.total()) }
+    }
+}
+
+impl Add for Stats {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        Self {
+            covered: self.covered.strict_add(other.covered),
+            missed: self.missed.strict_add(other.missed),
+            omitted: self.omitted.strict_add(other.omitted),
+            hits: self.hits.strict_add(other.hits),
+        }
+    }
+}
+
+impl AddAssign for Stats {
+    fn add_assign(&mut self, other: Self) {
+        *self = *self + other;
+    }
+}
+
+impl Sum for Stats {
+    fn sum<I: Iterator<Item = Self>>(stats: I) -> Self {
+        stats.fold(Self::default(), Add::add)
+    }
+}
+
+/// The counts of several files: a group, or a whole run. Its percents are
+/// computed from the summed counts.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct Totals {
+    pub line: Stats,
+    pub branch: Stats,
+    pub method: Stats,
+}
+
+impl Totals {
+    /// The totals of `files`.
+    #[must_use]
+    pub fn of_files<'r>(files: impl IntoIterator<Item = &'r FileReport<'r>>) -> Self {
+        Self::of(files.into_iter().map(|file| &file.stats.counts))
+    }
+
+    #[must_use]
+    pub fn of<'r>(files: impl IntoIterator<Item = &'r Self>) -> Self {
+        files.into_iter().fold(Self::default(), |totals, file| Self {
+            line: totals.line + file.line,
+            branch: totals.branch + file.branch,
+            method: totals.method + file.method,
+        })
+    }
+
+    #[must_use]
+    pub const fn get(&self, criterion: Criterion) -> Stats {
+        match criterion {
+            Criterion::Line => self.line,
+            Criterion::Branch => self.branch,
+            Criterion::Method => self.method,
+        }
+    }
+}
+
+/// The counts of a file.
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct FileStats {
+    pub counts: Totals,
+    /// A file never loaded, without branch data: its branch percent is 0
+    /// rather than 100.
+    unmeasured_branches: bool,
+    unmeasured_methods: bool,
+}
+
+impl FileStats {
+    pub(super) fn of(report: &FileReport<'_>) -> Self {
+        let mut stats = Self {
+            unmeasured_branches: !report.file.loaded && report.file.branches.is_none(),
+            unmeasured_methods: !report.file.loaded && report.methods.is_none(),
+            ..Self::default()
+        };
+        let counts = &mut stats.counts;
+        for line in report.lines() {
+            let hits = line.hits.unwrap_or(0);
+            count(&mut counts.line, line.covered(), line.missed(), hits);
+            counts.line.omitted = counts.line.omitted.strict_add(u64::from(line.never()));
+        }
+        for branch in report.branches() {
+            count(&mut counts.branch, branch.covered(), branch.missed(), branch.hits);
+        }
+        for method in report.methods() {
+            count(&mut counts.method, method.covered(), method.missed(), method.method.hits);
+        }
+        stats
+    }
+
+    #[must_use]
+    pub const fn get(&self, criterion: Criterion) -> Stats {
+        self.counts.get(criterion)
+    }
+
+    /// The counts of `criterion`, and the file's percent.
+    #[must_use]
+    pub fn with_percent(&self, criterion: Criterion) -> (Stats, f64) {
+        (self.get(criterion), self.percent(criterion))
+    }
+
+    /// The file's percent.
+    #[must_use]
+    pub fn percent(&self, criterion: Criterion) -> f64 {
+        let unmeasured = match criterion {
+            Criterion::Line => false,
+            Criterion::Branch => self.unmeasured_branches,
+            Criterion::Method => self.unmeasured_methods,
+        };
+        let stats = self.get(criterion);
+        if unmeasured && stats.covered == 0 { 0.0 } else { stats.percent() }
+    }
+}
+
+const fn count(stats: &mut Stats, covered: bool, missed: bool, hits: u64) {
+    if covered {
+        stats.covered = stats.covered.strict_add(1);
+        stats.hits = stats.hits.strict_add(hits);
+    } else if missed {
+        stats.missed = stats.missed.strict_add(1);
+    }
+}
+
+/// Ruby's `Float#floor(2)`, which thresholds compare with:
+/// 89.999 is 89.99, and 0.29 stays 0.29 although `0.29 * 100.0` is
+/// 28.999999999999996.
+#[must_use]
+pub fn floor2(number: f64) -> f64 {
+    floor_digits(number, 2)
+}
+
+/// Ruby's `Float#floor(digits)`: floors `number * 10^digits`, then takes
+/// the next step up when it does not exceed `number` (the product lost it).
+#[must_use]
+pub fn floor_digits(number: f64, digits: i32) -> f64 {
+    let scale = 10_f64.powi(digits);
+    let floored = (number * scale).floor();
+    let up = (floored + 1.0) / scale;
+    if up > number { floored / scale } else { up }
+}
+
+/// Counts are far below 2^53: the conversion is exact.
+#[expect(clippy::cast_precision_loss, reason = "counts stay far below 2^53")]
+const fn float(count: u64) -> f64 {
+    count as f64
+}

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

@@ -0,0 +1,93 @@
+use std::fs;
+
+use tempfile::TempDir;
+
+use super::stats::Criterion;
+use super::{
+    Arm, Condition, FileCoverage, FileReport, Meta, Method, Options, Span, Summary, Totals,
+    analyze_all,
+};
+
+const CALC: &str = "# frozen_string_literal: true
+
+class Calc
+  def sign(number)
+    if number.positive?
+      :positive
+    else
+      :other
+    end
+  end
+
+  # :nocov:
+  def debug = puts(1)
+  # :nocov:
+
+  def maybe(flag) = flag ? :yes : :no
+end
+";
+
+pub const fn span(start_line: u32, start_column: u32, end_line: u32, end_column: u32) -> Span {
+    Span { start_line, start_column, end_line, end_column }
+}
+
+pub fn arm(kind: &str, span: Span, hits: u64) -> Arm {
+    Arm { kind: kind.to_owned(), span, hits }
+}
+
+pub fn method(name: &str, span: Span, hits: u64) -> Method {
+    Method { owner: "Calc".to_owned(), name: name.to_owned(), span, hits }
+}
+
+/// Calc, run once with a positive number and once with `maybe(true)`.
+pub fn calc(dir: &TempDir) -> FileCoverage {
+    let path = dir.path().join("calc.rb");
+    fs::write(&path, CALC).unwrap();
+    let mut lines = vec![None; 17];
+    for (line, hits) in [(3, 1), (4, 1), (5, 2), (6, 1), (8, 1), (13, 1), (16, 1)] {
+        lines[line - 1] = Some(hits);
+    }
+    FileCoverage {
+        path,
+        name: "lib/calc.rb".to_owned(),
+        lines,
+        branches: Some(vec![
+            Condition {
+                kind: "if".to_owned(),
+                span: span(5, 4, 9, 7),
+                arms: vec![arm("then", span(6, 6, 6, 15), 1), arm("else", span(8, 6, 8, 12), 0)],
+            },
+            Condition {
+                kind: "if".to_owned(),
+                span: span(16, 20, 16, 37),
+                arms: vec![
+                    arm("then", span(16, 27, 16, 31), 1),
+                    arm("else", span(16, 34, 16, 37), 0),
+                ],
+            },
+        ]),
+        methods: Some(vec![
+            method("sign", span(4, 2, 10, 5), 2),
+            method("debug", span(13, 2, 13, 21), 0),
+            method("maybe", span(16, 2, 16, 37), 1),
+        ]),
+        loaded: true,
+    }
+}
+
+/// `files`, analyzed with the default options.
+pub fn reports(files: &[FileCoverage]) -> Vec<FileReport<'_>> {
+    analyze_all(files, &Options::default()).unwrap()
+}
+
+/// A run of `reports`, measuring `measured`, without groups or violations.
+pub fn summary<'a>(reports: &'a [FileReport<'a>], measured: &[Criterion]) -> Summary<'a> {
+    Summary {
+        files: reports,
+        measured: measured.to_vec(),
+        totals: Totals::of_files(reports),
+        groups: Vec::new(),
+        violations: Vec::new(),
+        meta: Meta { generator: "padded_cell 0.1.0".to_owned(), ..Meta::default() },
+    }
+}

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

@@ -0,0 +1,97 @@
+use std::fs;
+
+use tempfile::TempDir;
+
+use super::test_support::calc;
+use super::*;
+
+#[test]
+fn lines_branches_and_methods_classified() {
+    let dir = TempDir::new().unwrap();
+    let file = calc(&dir);
+    let report = analyze(&file, &Options::default()).unwrap();
+
+    let skipped: Vec<u32> =
+        report.lines().filter(|line| line.skipped).map(|line| line.number).collect();
+    assert_eq!(skipped, [12, 13, 14]);
+    let branches: Vec<(u32, bool, u64)> = report
+        .branches()
+        .map(|branch| (branch.report_line(), branch.inline, branch.hits))
+        .collect();
+    assert_eq!(branches, [(5, false, 1), (7, false, 0), (16, true, 1), (16, true, 0)]);
+    let methods: Vec<(&str, bool)> =
+        report.methods().map(|method| (method.method.name.as_str(), method.skipped)).collect();
+    assert_eq!(methods, [("sign", false), ("debug", true), ("maybe", false)]);
+
+    let stats = report.stats.counts;
+    assert_eq!(stats.line, Stats { covered: 6, missed: 0, omitted: 8, hits: 7 });
+    assert_eq!(stats.branch, Stats { covered: 2, missed: 2, omitted: 0, hits: 2 });
+    assert_eq!(stats.method, Stats { covered: 2, missed: 0, omitted: 0, hits: 3 });
+}
+
+#[test]
+fn lcov_tracefile_byte_for_byte() {
+    let dir = TempDir::new().unwrap();
+    let empty = dir.path().join("empty.rb");
+    fs::write(&empty, "# nothing\n").unwrap();
+    let files = [
+        calc(&dir),
+        FileCoverage {
+            path: empty,
+            name: "lib/empty.rb".to_owned(),
+            lines: vec![None],
+            branches: Some(vec![]),
+            methods: None,
+            loaded: true,
+        },
+    ];
+    let reports = analyze_all(&files, &Options::default()).unwrap();
+    let mut out = Vec::new();
+    write_lcov(&reports, &mut out).unwrap();
+
+    let expected = "SF:./lib/calc.rb
+DA:3,1
+DA:4,1
+DA:5,2
+DA:6,1
+DA:8,1
+DA:16,1
+LF:7
+LH:6
+BRDA:5,0,1,1
+BRDA:7,0,2,-
+BRDA:16,0,3,1
+BRDA:16,0,4,-
+end_of_record
+SF:./lib/empty.rb
+
+LF:0
+LH:0
+
+end_of_record
+";
+    assert_eq!(String::from_utf8(out).unwrap(), expected);
+}
+
+#[test]
+fn files_never_loaded_count_their_code_as_missed() {
+    let dir = TempDir::new().unwrap();
+    let mut file = calc(&dir);
+    file.loaded = false;
+    file.lines = vec![Some(0); 17];
+    file.branches = None;
+    file.methods = None;
+    let report = analyze(&file, &Options::default()).unwrap();
+
+    assert_eq!(report.stats.counts.line, Stats { covered: 0, missed: 10, omitted: 4, hits: 0 });
+    assert_eq!(report.stats.percent(Criterion::Branch).to_bits(), 0.0_f64.to_bits());
+}
+
+#[test]
+fn unreadable_sources_are_file_errors() {
+    let dir = TempDir::new().unwrap();
+    let mut file = calc(&dir);
+    file.path = dir.path().join("missing.rb");
+    let error = analyze(&file, &Options::default()).unwrap_err();
+    assert_eq!(error.path, file.path);
+}

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

@@ -0,0 +1,36 @@
+use tempfile::TempDir;
+
+use super::super::test_support::{calc, reports};
+use super::*;
+
+/// Calc: lines 100% (6/6), branches 50% (2/4).
+#[test]
+fn every_kind_of_threshold() {
+    let dir = TempDir::new().unwrap();
+    let files = [calc(&dir)];
+    let reports = reports(&files);
+    let totals = Totals::of_files(&reports);
+    let thresholds = Thresholds {
+        minimum: [Some(100.0), Some(60.0), Some(100.0)],
+        minimum_by_file: [None, Some(50.01), None],
+        minimum_by_group: vec![("Core".to_owned(), [Some(100.0), Some(49.99), None])],
+        maximum_drop: [Some(0.0), Some(5.0), None],
+        last_run: [Some(100.0), Some(60.0), None],
+    };
+    let groups = [("Core".to_owned(), totals), ("Other".to_owned(), Totals::default())];
+    let found =
+        violations(&thresholds, &[Criterion::Line, Criterion::Branch], &totals, &reports, &groups);
+
+    let violation =
+        |scope, limit, actual| Violation { scope, criterion: Criterion::Branch, limit, actual };
+    assert_eq!(
+        found,
+        [
+            violation(Scope::Total, 60.0, 50.0),
+            violation(Scope::File("lib/calc.rb".to_owned()), 50.01, 50.0),
+            // Dropped from 60% to 50%: more than 5 points. Methods were not
+            // measured: their minimum is not checked.
+            violation(Scope::Drop, 5.0, 10.0),
+        ]
+    );
+}