padded_cell 0.1.0 → 0.2.0

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

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

@@ -0,0 +1,116 @@
+use super::stats::{Criterion, Totals, floor_digits};
+use super::{FileReport, floor2};
+
+#[cfg(test)]
+mod tests;
+
+/// A limit per criterion: line, branch, method.
+pub type Limits = [Option<f64>; 3];
+
+pub const CRITERIA: [Criterion; 3] = [Criterion::Line, Criterion::Branch, Criterion::Method];
+
+/// What a run must reach.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct Thresholds {
+    /// The whole run.
+    pub minimum: Limits,
+    /// Every file.
+    pub minimum_by_file: Limits,
+    /// Groups, by name.
+    pub minimum_by_group: Vec<(String, Limits)>,
+    /// How far coverage may fall since the previous run (`.last_run.json`).
+    pub maximum_drop: Limits,
+    /// The previous run's percents.
+    pub last_run: Limits,
+}
+
+/// Where a threshold was missed.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Scope {
+    Total,
+    File(String),
+    Group(String),
+    /// Coverage fell since the previous run.
+    Drop,
+}
+
+/// A threshold missed. For a drop, `limit` is the maximum and `actual` the
+/// drop; otherwise `limit` is the minimum and `actual` the percent.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Violation {
+    pub scope: Scope,
+    pub criterion: Criterion,
+    pub limit: f64,
+    pub actual: f64,
+}
+
+/// Every threshold `totals`, `files` and `groups` miss, for the criteria
+/// `measured`.
+#[must_use]
+pub fn violations(
+    thresholds: &Thresholds,
+    measured: &[Criterion],
+    totals: &Totals,
+    files: &[FileReport<'_>],
+    groups: &[(String, Totals)],
+) -> Vec<Violation> {
+    let mut found = Vec::new();
+    let total = |criterion| totals.get(criterion).percent();
+    below(&mut found, || Scope::Total, &thresholds.minimum, measured, total);
+    for file in files {
+        let scope = || Scope::File(file.file.name.clone());
+        below(&mut found, scope, &thresholds.minimum_by_file, measured, |c| file.stats.percent(c));
+    }
+    for (name, limits) in &thresholds.minimum_by_group {
+        if let Some((_, group)) = groups.iter().find(|(group, _)| group == name) {
+            let scope = || Scope::Group(name.clone());
+            below(&mut found, scope, limits, measured, |criterion| group.get(criterion).percent());
+        }
+    }
+    for (criterion, maximum) in limits_of(&thresholds.maximum_drop, measured) {
+        let Some(previous) = thresholds.last_run[index(criterion)] else {
+            continue;
+        };
+        let drop = floor_digits(previous - floor2(totals.get(criterion).percent()), 10);
+        if drop > maximum {
+            found.push(Violation { scope: Scope::Drop, criterion, limit: maximum, actual: drop });
+        }
+    }
+    found
+}
+
+/// The percents, floored, under their minimum.
+fn below(
+    found: &mut Vec<Violation>,
+    scope: impl Fn() -> Scope,
+    limits: &Limits,
+    measured: &[Criterion],
+    percent: impl Fn(Criterion) -> f64,
+) {
+    for (criterion, limit) in limits_of(limits, measured) {
+        let actual = floor2(percent(criterion));
+        if actual < limit {
+            found.push(Violation { scope: scope(), criterion, limit, actual });
+        }
+    }
+}
+
+/// The limits set, for the criteria measured.
+fn limits_of<'l>(
+    limits: &'l Limits,
+    measured: &'l [Criterion],
+) -> impl Iterator<Item = (Criterion, f64)> + 'l {
+    CRITERIA
+        .into_iter()
+        .zip(limits)
+        .filter(|(criterion, _)| measured.contains(criterion))
+        .filter_map(|(criterion, limit)| limit.map(|limit| (criterion, limit)))
+}
+
+const fn index(criterion: Criterion) -> usize {
+    match criterion {
+        Criterion::Line => 0,
+        Criterion::Branch => 1,
+        Criterion::Method => 2,
+    }
+}