qlty/qlty-coverage/src/publish/processor.rs at f302dc4a4a2bc0653d8086c95a73edcbd63d493d · qltysh/qlty · GitHub

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
use crate::git::get_git_tracking_info;
use crate::publish::{metrics::CoverageMetrics, Plan, Report, Results};
use anyhow::Result;
use qlty_types::tests::v1::FileCoverage;
use std::collections::HashSet;
use std::path::PathBuf;

pub struct Processor {
    plan: Plan,
    results: Results,
}

impl Processor {
    pub fn new(plan: &Plan, results: Results) -> Self {
        Self {
            plan: plan.clone(),
            results,
        }
    }

    pub fn compute(&self) -> Result<Report> {
        let mut report_files = self.results.report_files.clone();

        report_files.iter_mut().for_each(|f| {
            f.build_id = self.plan.metadata.build_id.clone();
            f.tag = self.plan.metadata.tag.clone();
        });

        let pre_transform_file_coverages_count = self.results.file_coverages.len();

        let mut transformed_file_coverages = self
            .results
            .file_coverages
            .iter()
            .filter_map(|file_coverage| self.transform(file_coverage.to_owned()))
            .collect::<Vec<_>>();

        let git_tracking = get_git_tracking_info();
        let git_repo_path = git_tracking.as_ref().map(|info| info.repo_root.clone());

        let mut found_files = HashSet::new();
        let mut missing_files = HashSet::new();
        let mut untracked_files = HashSet::new();

        if self.plan.skip_missing_files {
            transformed_file_coverages.retain(|file_coverage| {
                match PathBuf::from(&file_coverage.path).try_exists() {
                    Ok(true) => {
                        found_files.insert(file_coverage.path.clone());
                        if let Some(ref tracking) = git_tracking {
                            if !tracking.is_tracked(&file_coverage.path) {
                                untracked_files.insert(file_coverage.path.clone());
                            }
                        }
                        true
                    }
                    _ => {
                        missing_files.insert(file_coverage.path.clone());
                        false
                    }
                }
            });
        } else {
            for file_coverage in &transformed_file_coverages {
                match PathBuf::from(&file_coverage.path).try_exists() {
                    Ok(true) => {
                        found_files.insert(file_coverage.path.clone());
                        if let Some(ref tracking) = git_tracking {
                            if !tracking.is_tracked(&file_coverage.path) {
                                untracked_files.insert(file_coverage.path.clone());
                            }
                        }
                    }
                    _ => {
                        missing_files.insert(file_coverage.path.clone());
                    }
                }
            }
        }

        let totals = CoverageMetrics::calculate(&transformed_file_coverages);
        let ignored_paths_count =
            pre_transform_file_coverages_count - transformed_file_coverages.len();

        Ok(Report {
            metadata: self.plan.metadata.clone(),
            report_files,
            file_coverages: transformed_file_coverages,
            totals,
            missing_files,
            found_files,
            untracked_files,
            git_repo_path,
            excluded_files_count: ignored_paths_count,
            auto_path_fixing_enabled: self.plan.auto_path_fixing_enabled,
        })
    }

    fn transform(&self, file_coverage: FileCoverage) -> Option<FileCoverage> {
        let mut file_coverage: Option<FileCoverage> = Some(file_coverage.clone());

        for transformer in self.plan.transformers.iter() {
            if file_coverage.is_some() {
                file_coverage = transformer.transform(file_coverage.unwrap());
            } else {
                return None;
            }
        }

        file_coverage
    }
}