padded_cell 0.1.0 → 0.2.0

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

@@ -0,0 +1,302 @@
+mod directives;
+mod json;
+mod lcov;
+mod markdown;
+mod methods;
+mod output;
+mod results;
+mod source;
+mod stats;
+mod thresholds;
+
+#[cfg(test)]
+mod test_support;
+#[cfg(test)]
+mod tests;
+
+use std::borrow::Cow;
+use std::ops::RangeInclusive;
+use std::path::PathBuf;
+
+pub use directives::{Blocks, Skipped};
+pub use json::Json;
+pub use lcov::write_lcov;
+pub use markdown::write_markdown;
+pub use methods::static_methods;
+pub use output::{Format, UnknownFormat, write, write_last_run_file};
+pub use results::{Meta, Summary, write_coverage_json, write_last_run, write_resultset};
+pub use source::{Source, chomp};
+pub use stats::{Criterion, FileStats, Stats, Totals, floor_digits, floor2};
+pub use thresholds::{CRITERIA, Limits, Scope, Thresholds, Violation, violations};
+
+use crate::FileError;
+use crate::parallel::fill;
+
+/// A range of source: 1-based lines, 0-based columns, as Ruby reports them.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Span {
+    pub start_line: u32,
+    pub start_column: u32,
+    pub end_line: u32,
+    pub end_column: u32,
+}
+
+impl Span {
+    const fn overlaps(&self, lines: &RangeInclusive<u32>) -> bool {
+        self.start_line <= *lines.end() && self.end_line >= *lines.start()
+    }
+}
+
+/// One way through a [`Condition`]: `then`, `else`, `when`, `in`, `body`...
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Arm {
+    pub kind: String,
+    pub span: Span,
+    pub hits: u64,
+}
+
+/// A branching construct (`if`, `unless`, `case`, `while`, `&.`...) and its
+/// arms.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Condition {
+    pub kind: String,
+    pub span: Span,
+    pub arms: Vec<Arm>,
+}
+
+/// A method definition, and how many times it was called.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Method {
+    /// The class or module it was defined in, as Ruby names it.
+    pub owner: String,
+    pub name: String,
+    pub span: Span,
+    pub hits: u64,
+}
+
+/// What was measured for one file.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FileCoverage {
+    /// Where to read the source.
+    pub path: PathBuf,
+    /// The path reports show: relative to the project root.
+    pub name: String,
+    /// Hits by line, index 0 for line 1; `None` where there is no code.
+    pub lines: Vec<Option<u64>>,
+    /// `None` when branches were not measured for this file.
+    pub branches: Option<Vec<Condition>>,
+    /// `None` when methods were not measured for this file.
+    pub methods: Option<Vec<Method>>,
+    /// False for a tracked file the suite never loaded: Ruby compiled it
+    /// without running it. Blank and comment lines are dropped from its
+    /// lines, and its methods (which only exist once run) are found in its
+    /// source.
+    pub loaded: bool,
+}
+
+/// How sources are read.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Options {
+    /// The word between colons that opens and closes a block of lines
+    /// coverage ignores: `# :nocov:`.
+    pub nocov_token: String,
+    /// Methods were measured: files never loaded get theirs from the source.
+    pub methods: bool,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Self { nocov_token: "nocov".to_owned(), methods: false }
+    }
+}
+
+/// A file, read and classified.
+#[derive(Debug)]
+pub struct FileReport<'a> {
+    pub file: &'a FileCoverage,
+    pub source: Source,
+    pub stats: FileStats,
+    lines: Cow<'a, [Option<u64>]>,
+    methods: Option<Cow<'a, [Method]>>,
+    skipped: Skipped,
+}
+
+/// A source line and its coverage.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Line<'r> {
+    pub number: u32,
+    pub text: &'r [u8],
+    /// `None` where there is no code. A skipped line keeps its hits.
+    pub hits: Option<u64>,
+    pub skipped: bool,
+}
+
+impl Line<'_> {
+    /// Not code.
+    #[must_use]
+    pub const fn never(&self) -> bool {
+        !self.skipped && self.hits.is_none()
+    }
+
+    #[must_use]
+    pub const fn covered(&self) -> bool {
+        !self.skipped && matches!(self.hits, Some(hits) if hits > 0)
+    }
+
+    /// Code that never ran.
+    #[must_use]
+    pub const fn missed(&self) -> bool {
+        !self.skipped && matches!(self.hits, Some(0))
+    }
+}
+
+/// An arm of a condition, as reports show it.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Branch<'r> {
+    pub kind: &'r str,
+    pub start_line: u32,
+    pub end_line: u32,
+    pub hits: u64,
+    /// The arm starts on the line of its condition (`x ? a : b`).
+    pub inline: bool,
+    pub skipped: bool,
+    /// Where its condition starts.
+    pub condition_line: u32,
+}
+
+impl Branch<'_> {
+    /// The line a branch is shown on: its own when inline, else the line
+    /// before it (the `if` or `else` above a block).
+    #[must_use]
+    pub const fn report_line(&self) -> u32 {
+        if self.inline { self.start_line } else { self.start_line.saturating_sub(1) }
+    }
+
+    #[must_use]
+    pub const fn covered(&self) -> bool {
+        !self.skipped && self.hits > 0
+    }
+
+    #[must_use]
+    pub const fn missed(&self) -> bool {
+        !self.skipped && self.hits == 0
+    }
+}
+
+/// A method and its coverage.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct MethodReport<'r> {
+    pub method: &'r Method,
+    pub skipped: bool,
+}
+
+impl MethodReport<'_> {
+    #[must_use]
+    pub const fn covered(&self) -> bool {
+        !self.skipped && self.method.hits > 0
+    }
+
+    #[must_use]
+    pub const fn missed(&self) -> bool {
+        !self.skipped && self.method.hits == 0
+    }
+}
+
+/// Reads `file`'s source and classifies what was measured.
+///
+/// # Errors
+///
+/// [`FileError`] when the source cannot be read.
+pub fn analyze<'a>(file: &'a FileCoverage, options: &Options) -> Result<FileReport<'a>, FileError> {
+    let source = Source::read(&file.path)?;
+    let skipped = Skipped::of(&source, &options.nocov_token);
+    let lines = if file.loaded {
+        Cow::Borrowed(file.lines.as_slice())
+    } else {
+        Cow::Owned(source.relevant(&file.lines, &skipped.line))
+    };
+    let methods = match &file.methods {
+        Some(methods) => Some(Cow::Borrowed(methods.as_slice())),
+        None if !file.loaded && options.methods => static_methods(&source).map(Cow::Owned),
+        None => None,
+    };
+    let mut report =
+        FileReport { file, source, stats: FileStats::default(), lines, methods, skipped };
+    report.stats = FileStats::of(&report);
+    Ok(report)
+}
+
+/// [`analyze`] for every file, spread over the available cores. Reports keep
+/// the order of `files`.
+///
+/// # Errors
+///
+/// The [`FileError`] of the first unreadable source, in input order.
+pub fn analyze_all<'a>(
+    files: &'a [FileCoverage],
+    options: &Options,
+) -> Result<Vec<FileReport<'a>>, FileError> {
+    let mut reports: Vec<Option<FileReport<'a>>> = files.iter().map(|_| None).collect();
+    fill(files, &mut reports, |file| analyze(file, options).map(Some))?;
+    Ok(reports.into_iter().flatten().collect())
+}
+
+impl<'a> FileReport<'a> {
+    /// Hits by line, as measured (index 0 for line 1): for a file never
+    /// loaded, its code lines only.
+    #[must_use]
+    pub fn raw_lines(&self) -> &[Option<u64>] {
+        &self.lines
+    }
+
+    /// Every line of the source, in order.
+    pub fn lines(&self) -> impl Iterator<Item = Line<'_>> {
+        self.source.lines().zip(1..).enumerate().map(|(index, (text, number))| Line {
+            number,
+            text,
+            hits: self.lines.get(index).copied().flatten(),
+            skipped: self.skipped.line.iter().any(|block| block.contains(&number)),
+        })
+    }
+
+    /// Every arm of every condition, in Ruby's order. Empty when branches
+    /// were not measured.
+    pub fn branches(&self) -> impl Iterator<Item = Branch<'a>> + '_ {
+        self.file.branches.iter().flatten().flat_map(move |condition| {
+            condition.arms.iter().map(move |arm| {
+                let inline = arm.span.start_line == condition.span.start_line;
+                let mut branch = Branch {
+                    kind: &arm.kind,
+                    start_line: arm.span.start_line,
+                    end_line: arm.span.end_line,
+                    hits: arm.hits,
+                    inline,
+                    skipped: false,
+                    condition_line: condition.span.start_line,
+                };
+                branch.skipped =
+                    self.skipped.branch.iter().any(|block| {
+                        arm.span.overlaps(block) || block.contains(&branch.report_line())
+                    });
+                branch
+            })
+        })
+    }
+
+    /// The branches outside skipped blocks: what reports show.
+    pub fn reported_branches(&self) -> impl Iterator<Item = Branch<'a>> + '_ {
+        self.branches().filter(|branch| !branch.skipped)
+    }
+
+    /// Every method, in the order measured. Empty when methods were not
+    /// measured.
+    pub fn methods(&self) -> impl Iterator<Item = MethodReport<'_>> {
+        let lines = self.source.len();
+        self.methods.iter().flat_map(|methods| methods.iter()).map(move |method| MethodReport {
+            method,
+            // A method past the end of the source has no lines to show.
+            skipped: usize::try_from(method.span.start_line).is_ok_and(|start| start > lines)
+                || self.skipped.method.iter().any(|block| method.span.overlaps(block)),
+        })
+    }
+}

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

@@ -1,5 +1,7 @@
 use std::assert_matches;
+use std::fs;
 use std::io::ErrorKind;
+use std::path::PathBuf;
 
 use super::*;
 

data/ext/padded_cell_native/core/src/discover.rs

@@ -6,14 +6,16 @@
 //! `test "name"` declarations. Nothing is evaluated.
 
 use std::iter::FusedIterator;
-use std::num::NonZeroUsize;
-use std::path::{Path, PathBuf};
-use std::{fs, io, slice, thread};
+use std::path::Path;
+use std::slice;
 
 use ruby_prism::{
     CallNode, ClassNode, DefNode, Location, ModuleNode, Node, SingletonClassNode, Visit,
 };
 
+use crate::FileError;
+use crate::parallel::fill;
+
 #[cfg(test)]
 mod tests;
 
@@ -121,17 +123,6 @@ impl ExactSizeIterator for Iter<'_> {}
 
 impl FusedIterator for Iter<'_> {}
 
-/// A test file that could not be read.
-#[derive(Debug, thiserror::Error)]
-#[error("{}: {source}", path.display())]
-pub struct FileError {
-    /// The file.
-    pub path: PathBuf,
-    /// Why it could not be read.
-    #[source]
-    pub source: io::Error,
-}
-
 /// The tests defined in `source`, in source order. Syntax errors do not
 /// stop discovery: what Prism recovers is reported.
 #[must_use]
@@ -160,7 +151,7 @@ pub fn discover_many<S: AsRef<[u8]> + Sync>(sources: &[S]) -> Vec<Discovery> {
 /// [`FileError`] when the file cannot be read.
 pub fn discover_file(path: impl AsRef<Path>) -> Result<Discovery, FileError> {
     let path = path.as_ref();
-    let source = fs::read(path).map_err(|source| FileError { path: path.to_owned(), source })?;
+    let source = FileError::read(path)?;
     Ok(discover(&source))
 }
 
@@ -172,47 +163,10 @@ pub fn discover_file(path: impl AsRef<Path>) -> Result<Discovery, FileError> {
 /// The [`FileError`] of the first unreadable file, in input order.
 pub fn discover_files<P: AsRef<Path> + Sync>(paths: &[P]) -> Result<Vec<Discovery>, FileError> {
     let mut found = vec![Discovery::default(); paths.len()];
-    fill(paths, &mut found, |path| discover_file(path))?;
+    fill(paths, &mut found, discover_file)?;
     Ok(found)
 }
 
-/// Runs `f` over `items` on scoped threads, each writing its own slots of
-/// `out`. Returns the first error in input order.
-///
-/// Scoped threads: none outlives the call, so a process may fork right after
-/// (a pool such as rayon's would leave its threads behind in the parent and
-/// a broken pool in the child).
-fn fill<T, R, E>(items: &[T], out: &mut [R], f: impl Fn(&T) -> Result<R, E> + Sync) -> Result<(), E>
-where
-    T: Sync,
-    R: Send,
-    E: Send,
-{
-    let run = |items: &[T], out: &mut [R]| -> Result<(), E> {
-        for (item, slot) in items.iter().zip(out) {
-            *slot = f(item)?;
-        }
-        Ok(())
-    };
-    let run = &run;
-    let threads = thread::available_parallelism().map_or(1, NonZeroUsize::get).min(items.len());
-    if threads <= 1 {
-        return run(items, out);
-    }
-    let chunk = items.len().div_ceil(threads);
-    thread::scope(|scope| {
-        let workers: Vec<_> = items
-            .chunks(chunk)
-            .zip(out.chunks_mut(chunk))
-            .map(|(items, out)| scope.spawn(move || run(items, out)))
-            .collect();
-        // Chunks are in input order and each stops at its first error.
-        workers.into_iter().try_for_each(|worker| {
-            worker.join().unwrap_or_else(|panic| std::panic::resume_unwind(panic))
-        })
-    })
-}
-
 /// Walks the tree. Names are borrowed from the parse result until a test
 /// class needs its full name.
 struct Visitor<'pr> {

data/ext/padded_cell_native/core/src/error.rs

@@ -0,0 +1,24 @@
+use std::path::{Path, PathBuf};
+use std::{fs, io};
+
+/// A file that could not be read or written.
+#[derive(Debug, thiserror::Error)]
+#[error("{}: {source}", path.display())]
+pub struct FileError {
+    /// The file.
+    pub path: PathBuf,
+    /// Why it failed.
+    #[source]
+    pub source: io::Error,
+}
+
+impl FileError {
+    /// The bytes of `path`.
+    ///
+    /// # Errors
+    ///
+    /// A [`FileError`] for `path` when it cannot be read.
+    pub fn read(path: &Path) -> Result<Vec<u8>, Self> {
+        fs::read(path).map_err(|source| Self { path: path.to_owned(), source })
+    }
+}

data/ext/padded_cell_native/core/src/lib.rs

@@ -13,14 +13,18 @@
 //! # Ok::<(), Box<dyn std::error::Error>>(())
 //! ```
 
+pub mod chart;
 mod discover;
+mod error;
 mod hash;
+mod parallel;
 mod plan;
 mod rng;
 
 pub use discover::{
-    Discovery, FileError, Iter, TestDef, discover, discover_file, discover_files, discover_many,
+    Discovery, Iter, TestDef, discover, discover_file, discover_files, discover_many,
 };
+pub use error::FileError;
 pub use hash::fnv1a64;
 pub use plan::plan;
 pub use rng::SplitMix64;

data/ext/padded_cell_native/core/src/parallel.rs

@@ -0,0 +1,43 @@
+use std::num::NonZeroUsize;
+use std::thread;
+
+/// Runs `f` over `items` on scoped threads, each writing its own slots of
+/// `out`. Returns the first error in input order.
+///
+/// Scoped threads: none outlives the call, so a process may fork right after
+/// (a pool such as rayon's would leave its threads behind in the parent and
+/// a broken pool in the child).
+pub fn fill<'a, T, R, E>(
+    items: &'a [T],
+    out: &mut [R],
+    f: impl Fn(&'a T) -> Result<R, E> + Sync,
+) -> Result<(), E>
+where
+    T: Sync,
+    R: Send,
+    E: Send,
+{
+    let run = |items: &'a [T], out: &mut [R]| -> Result<(), E> {
+        for (item, slot) in items.iter().zip(out) {
+            *slot = f(item)?;
+        }
+        Ok(())
+    };
+    let run = &run;
+    let threads = thread::available_parallelism().map_or(1, NonZeroUsize::get).min(items.len());
+    if threads <= 1 {
+        return run(items, out);
+    }
+    let chunk = items.len().div_ceil(threads);
+    thread::scope(|scope| {
+        let workers: Vec<_> = items
+            .chunks(chunk)
+            .zip(out.chunks_mut(chunk))
+            .map(|(items, out)| scope.spawn(move || run(items, out)))
+            .collect();
+        // Chunks are in input order and each stops at its first error.
+        workers.into_iter().try_for_each(|worker| {
+            worker.join().unwrap_or_else(|panic| std::panic::resume_unwind(panic))
+        })
+    })
+}

data/ext/padded_cell_native/ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "padded_cell_native"
-version = "0.1.0"
+version = "0.2.0"
 description = "Ruby bindings for the padded_cell crate"
 publish = false
 edition.workspace = true