ruchy/quality/

coverage.rs

//! Test coverage measurement and integration

use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fmt::Write as _;
use std::path::Path;
use std::process::Command;

/// Test coverage metrics for individual files
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileCoverage {
    pub path: String,
    pub lines_total: usize,
    pub lines_covered: usize,
    pub branches_total: usize,
    pub branches_covered: usize,
    pub functions_total: usize,
    pub functions_covered: usize,
}

impl FileCoverage {
    #[allow(clippy::cast_precision_loss)]
    pub fn line_coverage_percentage(&self) -> f64 {
        if self.lines_total == 0 {
            100.0
        } else {
            (self.lines_covered as f64 / self.lines_total as f64) * 100.0
        }
    }

    #[allow(clippy::cast_precision_loss)]
    pub fn branch_coverage_percentage(&self) -> f64 {
        if self.branches_total == 0 {
            100.0
        } else {
            (self.branches_covered as f64 / self.branches_total as f64) * 100.0
        }
    }

    #[allow(clippy::cast_precision_loss)]
    pub fn function_coverage_percentage(&self) -> f64 {
        if self.functions_total == 0 {
            100.0
        } else {
            (self.functions_covered as f64 / self.functions_total as f64) * 100.0
        }
    }
}

/// Overall test coverage report
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CoverageReport {
    pub files: HashMap<String, FileCoverage>,
    pub total_lines: usize,
    pub covered_lines: usize,
    pub total_branches: usize,
    pub covered_branches: usize,
    pub total_functions: usize,
    pub covered_functions: usize,
}

impl CoverageReport {
    pub fn new() -> Self {
        Self {
            files: HashMap::new(),
            total_lines: 0,
            covered_lines: 0,
            total_branches: 0,
            covered_branches: 0,
            total_functions: 0,
            covered_functions: 0,
        }
    }

    #[allow(clippy::cast_precision_loss)]
    pub fn line_coverage_percentage(&self) -> f64 {
        if self.total_lines == 0 {
            100.0
        } else {
            (self.covered_lines as f64 / self.total_lines as f64) * 100.0
        }
    }

    #[allow(clippy::cast_precision_loss)]
    pub fn branch_coverage_percentage(&self) -> f64 {
        if self.total_branches == 0 {
            100.0
        } else {
            (self.covered_branches as f64 / self.total_branches as f64) * 100.0
        }
    }

    #[allow(clippy::cast_precision_loss)]
    pub fn function_coverage_percentage(&self) -> f64 {
        if self.total_functions == 0 {
            100.0
        } else {
            (self.covered_functions as f64 / self.total_functions as f64) * 100.0
        }
    }

    pub fn add_file(&mut self, file_coverage: FileCoverage) {
        self.total_lines += file_coverage.lines_total;
        self.covered_lines += file_coverage.lines_covered;
        self.total_branches += file_coverage.branches_total;
        self.covered_branches += file_coverage.branches_covered;
        self.total_functions += file_coverage.functions_total;
        self.covered_functions += file_coverage.functions_covered;

        self.files.insert(file_coverage.path.clone(), file_coverage);
    }
}

impl Default for CoverageReport {
    fn default() -> Self {
        Self::new()
    }
}

/// Coverage collector that integrates with various coverage tools
pub struct CoverageCollector {
    tool: CoverageTool,
    source_dir: String,
}

#[derive(Debug, Clone)]
pub enum CoverageTool {
    Tarpaulin,
    Llvm,
    Grcov,
}

impl CoverageCollector {
    pub fn new(tool: CoverageTool) -> Self {
        Self {
            tool,
            source_dir: "src".to_string(),
        }
    }

    /// Set the source directory for coverage collection
    ///
    /// # Examples
    ///
    /// ```
    /// use ruchy::quality::{CoverageCollector, CoverageTool};
    ///
    /// let collector = CoverageCollector::new(CoverageTool::Tarpaulin)
    ///     .with_source_dir("src");
    /// ```
    #[must_use]
    pub fn with_source_dir<P: AsRef<Path>>(mut self, path: P) -> Self {
        self.source_dir = path.as_ref().to_string_lossy().to_string();
        self
    }

    /// Collect test coverage by running the appropriate tool
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use ruchy::quality::{CoverageCollector, CoverageTool};
    ///
    /// let collector = CoverageCollector::new(CoverageTool::Tarpaulin);
    /// let report = collector.collect().expect("Failed to collect coverage");
    /// println!("Line coverage: {:.1}%", report.line_coverage_percentage());
    /// ```
    ///
    /// # Errors
    ///
    /// Returns an error if:
    /// - The coverage tool is not installed
    /// - The coverage tool fails to run
    /// - The output cannot be parsed
    pub fn collect(&self) -> Result<CoverageReport> {
        match self.tool {
            CoverageTool::Tarpaulin => Self::collect_tarpaulin(),
            CoverageTool::Llvm => Self::collect_llvm(),
            CoverageTool::Grcov => Self::collect_grcov(),
        }
    }

    fn collect_tarpaulin() -> Result<CoverageReport> {
        // Run cargo tarpaulin with JSON output
        let output = Command::new("cargo")
            .args([
                "tarpaulin",
                "--out",
                "Json",
                "--output-dir",
                "target/coverage",
            ])
            .output()
            .context("Failed to run cargo tarpaulin")?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            return Err(anyhow::anyhow!("Tarpaulin failed: {}", stderr));
        }

        let stdout = String::from_utf8_lossy(&output.stdout);
        Self::parse_tarpaulin_json(&stdout)
    }

    #[allow(clippy::unnecessary_wraps)]
    fn collect_llvm() -> Result<CoverageReport> {
        // LLVM-cov workflow would go here
        // For now, return a placeholder
        let mut report = CoverageReport::new();

        // Add some example coverage data
        let file_coverage = FileCoverage {
            path: "src/lib.rs".to_string(),
            lines_total: 100,
            lines_covered: 85,
            branches_total: 20,
            branches_covered: 16,
            functions_total: 10,
            functions_covered: 9,
        };

        report.add_file(file_coverage);
        Ok(report)
    }

    #[allow(clippy::unnecessary_wraps)]
    fn collect_grcov() -> Result<CoverageReport> {
        // Grcov workflow would go here
        // For now, return a placeholder
        let mut report = CoverageReport::new();

        // Add some example coverage data
        let file_coverage = FileCoverage {
            path: "src/lib.rs".to_string(),
            lines_total: 100,
            lines_covered: 90,
            branches_total: 20,
            branches_covered: 18,
            functions_total: 10,
            functions_covered: 10,
        };

        report.add_file(file_coverage);
        Ok(report)
    }

    #[allow(clippy::unnecessary_wraps)]
    fn parse_tarpaulin_json(_json_output: &str) -> Result<CoverageReport> {
        // Parse tarpaulin JSON output format
        // This is a simplified parser - real implementation would be more robust
        let mut report = CoverageReport::new();

        // For now, return a mock report
        // Real implementation would parse the actual tarpaulin JSON format
        let file_coverage = FileCoverage {
            path: "src/lib.rs".to_string(),
            lines_total: 100,
            lines_covered: 82,
            branches_total: 20,
            branches_covered: 15,
            functions_total: 10,
            functions_covered: 8,
        };

        report.add_file(file_coverage);
        Ok(report)
    }

    /// Check if the coverage tool is available
    pub fn is_available(&self) -> bool {
        match self.tool {
            CoverageTool::Tarpaulin => Command::new("cargo")
                .args(["tarpaulin", "--help"])
                .output()
                .map(|output| output.status.success())
                .unwrap_or(false),
            CoverageTool::Llvm => Command::new("llvm-profdata")
                .arg("--help")
                .output()
                .map(|output| output.status.success())
                .unwrap_or(false),
            CoverageTool::Grcov => Command::new("grcov")
                .arg("--help")
                .output()
                .map(|output| output.status.success())
                .unwrap_or(false),
        }
    }
}

/// HTML coverage report generator
pub struct HtmlReportGenerator {
    output_dir: String,
}

impl HtmlReportGenerator {
    pub fn new<P: AsRef<Path>>(output_dir: P) -> Self {
        Self {
            output_dir: output_dir.as_ref().to_string_lossy().to_string(),
        }
    }

    /// Generate HTML coverage report
    ///
    /// # Errors
    ///
    /// Returns an error if directory creation or file writing fails
    pub fn generate(&self, report: &CoverageReport) -> Result<()> {
        std::fs::create_dir_all(&self.output_dir).context("Failed to create output directory")?;

        let html_content = Self::generate_html(report)?;
        let output_path = format!("{}/coverage.html", self.output_dir);

        std::fs::write(&output_path, html_content).context("Failed to write HTML report")?;

        tracing::info!("Coverage report generated: {output_path}");
        Ok(())
    }

    fn generate_html(report: &CoverageReport) -> Result<String> {
        let mut html = String::new();

        html.push_str("<!DOCTYPE html>\n<html>\n<head>\n");
        html.push_str("<title>Ruchy Test Coverage Report</title>\n");
        html.push_str("<style>\n");
        html.push_str("body { font-family: Arial, sans-serif; margin: 20px; }\n");
        html.push_str("table { border-collapse: collapse; width: 100%; }\n");
        html.push_str("th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }\n");
        html.push_str("th { background-color: #f2f2f2; }\n");
        html.push_str(".high { color: green; }\n");
        html.push_str(".medium { color: orange; }\n");
        html.push_str(".low { color: red; }\n");
        html.push_str("</style>\n");
        html.push_str("</head>\n<body>\n");

        html.push_str("<h1>Ruchy Test Coverage Report</h1>\n");

        // Overall coverage
        html.push_str("<h2>Overall Coverage</h2>\n");
        html.push_str("<table>\n");
        html.push_str("<tr><th>Metric</th><th>Coverage</th></tr>\n");
        writeln!(
            html,
            "<tr><td>Lines</td><td class=\"{}\">{:.1}% ({}/{})</td></tr>",
            Self::coverage_class(report.line_coverage_percentage()),
            report.line_coverage_percentage(),
            report.covered_lines,
            report.total_lines
        )?;
        write!(
            html,
            "<tr><td>Functions</td><td class=\"{}\">{:.1}% ({}/{})</td></tr>",
            Self::coverage_class(report.function_coverage_percentage()),
            report.function_coverage_percentage(),
            report.covered_functions,
            report.total_functions
        )?;
        html.push_str("</table>\n");

        // File-by-file coverage
        html.push_str("<h2>File Coverage</h2>\n");
        html.push_str("<table>\n");
        html.push_str("<tr><th>File</th><th>Line Coverage</th><th>Function Coverage</th></tr>\n");

        for (path, file_coverage) in &report.files {
            write!(
                html,
                "<tr><td>{}</td><td class=\"{}\">{:.1}%</td><td class=\"{}\">{:.1}%</td></tr>",
                path,
                Self::coverage_class(file_coverage.line_coverage_percentage()),
                file_coverage.line_coverage_percentage(),
                Self::coverage_class(file_coverage.function_coverage_percentage()),
                file_coverage.function_coverage_percentage()
            )?;
        }

        html.push_str("</table>\n");
        html.push_str("</body>\n</html>\n");

        Ok(html)
    }

    fn coverage_class(percentage: f64) -> &'static str {
        if percentage >= 80.0 {
            "high"
        } else if percentage >= 60.0 {
            "medium"
        } else {
            "low"
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_file_coverage_percentages() {
        let coverage = FileCoverage {
            path: "test.rs".to_string(),
            lines_total: 100,
            lines_covered: 80,
            branches_total: 20,
            branches_covered: 16,
            functions_total: 10,
            functions_covered: 9,
        };

        assert!((coverage.line_coverage_percentage() - 80.0).abs() < f64::EPSILON);
        assert!((coverage.branch_coverage_percentage() - 80.0).abs() < f64::EPSILON);
        assert!((coverage.function_coverage_percentage() - 90.0).abs() < f64::EPSILON);
    }

    #[test]
    fn test_coverage_report_aggregation() {
        let mut report = CoverageReport::new();

        let file1 = FileCoverage {
            path: "file1.rs".to_string(),
            lines_total: 100,
            lines_covered: 80,
            branches_total: 20,
            branches_covered: 16,
            functions_total: 10,
            functions_covered: 8,
        };

        let file2 = FileCoverage {
            path: "file2.rs".to_string(),
            lines_total: 50,
            lines_covered: 45,
            branches_total: 10,
            branches_covered: 9,
            functions_total: 5,
            functions_covered: 5,
        };

        report.add_file(file1);
        report.add_file(file2);

        assert_eq!(report.total_lines, 150);
        assert_eq!(report.covered_lines, 125);
        let expected = 83.333_333_333_333_34;
        assert!((report.line_coverage_percentage() - expected).abs() < f64::EPSILON);
    }

    #[test]
    fn test_coverage_collector_creation() {
        let collector = CoverageCollector::new(CoverageTool::Tarpaulin).with_source_dir("src");

        assert_eq!(collector.source_dir, "src");
        assert!(matches!(collector.tool, CoverageTool::Tarpaulin));
    }

    #[test]
    fn test_html_report_generator() -> Result<(), Box<dyn std::error::Error>> {
        let mut report = CoverageReport::new();
        let file_coverage = FileCoverage {
            path: "src/lib.rs".to_string(),
            lines_total: 100,
            lines_covered: 85,
            branches_total: 20,
            branches_covered: 17,
            functions_total: 10,
            functions_covered: 9,
        };
        report.add_file(file_coverage);

        let _generator = HtmlReportGenerator::new("target/coverage");
        let html = HtmlReportGenerator::generate_html(&report)?;

        assert!(html.contains("Ruchy Test Coverage Report"));
        assert!(html.contains("85.0%"));
        assert!(html.contains("src/lib.rs"));
        Ok(())
    }
}