diff-coverage 0.6.1

Diff-coverage, supercharged in Rust. Fast, memory-efficient coverage on changed lines for CI.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use std::io::IsTerminal;
use std::path::Path;

use crate::report::ReportGenerator;
use crate::{cli, report};

use super::error::AppError;
use super::output::OutputPlan;

pub(crate) fn write_reports(
    report: &report::CoverageReport,
    output_plan: &OutputPlan,
) -> Result<(), AppError> {
    for format in output_plan.order() {
        match format {
            cli::OutputFormat::Cli => {
                let mut stdout = std::io::stdout();
                let use_color = stdout.is_terminal();
                let generator = report::CliReportGenerator { use_color };
                if let Err(err) = generator.write_report(report, &mut stdout) {
                    return Err(AppError::usage(format!(
                        "Failed to write CLI report: {err}"
                    )));
                }
                eprintln!("Success: CLI report generated.");
            }
            cli::OutputFormat::Summary => {
                let mut stdout = std::io::stdout();
                let use_color = stdout.is_terminal();
                let generator = report::SummaryReportGenerator { use_color };
                if let Err(err) = generator.write_report(report, &mut stdout) {
                    return Err(AppError::usage(format!(
                        "Failed to write summary report: {err}"
                    )));
                }
                eprintln!("Success: summary report generated.");
            }
            cli::OutputFormat::Gitlab => {
                let path = output_plan
                    .path_for(format)
                    .expect("gitlab output path present");
                let generator = report::GitlabReportGenerator;
                write_report_to_path(&generator, report, path, "GitLab code quality")
                    .map_err(AppError::usage)?;
                eprintln!("Success: GitLab report written to {}.", path.display());
            }
            cli::OutputFormat::Json => {
                let path = output_plan
                    .path_for(format)
                    .expect("json output path present");
                let generator = report::JsonReportGenerator;
                write_report_to_path(&generator, report, path, "JSON").map_err(AppError::usage)?;
                eprintln!("Success: JSON report written to {}.", path.display());
            }
        }
    }

    Ok(())
}

fn write_report_to_path<G: ReportGenerator>(
    generator: &G,
    report: &report::CoverageReport,
    path: &Path,
    label: &str,
) -> Result<(), String> {
    let mut file = std::fs::File::create(path)
        .map_err(|err| format!("Failed to write {label} report {}: {err}", path.display()))?;
    generator
        .write_report(report, &mut file)
        .map_err(|err| format!("Failed to write {label} report {}: {err}", path.display()))
}