coverio 0.0.2

Better code coverage reporting for Rust
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use serde_json::{Map, Value};

/// Badge styles as defined by `shields.io`.
pub enum BadgeStyle {
  Flat,
  FlatSquare,
  Plastic,
  ForTheBadge,
  Social,
}

impl BadgeStyle {
  fn query_parameter(&self) -> &'static str {
    match self {
      BadgeStyle::Flat => "",
      BadgeStyle::FlatSquare => "flat-square",
      BadgeStyle::Plastic => "plastic",
      BadgeStyle::ForTheBadge => "for-the-badge",
      BadgeStyle::Social => "social",
    }
  }
}

pub struct CoverageReport {
  regions_percent: f64,
  functions_percent: f64,
  lines_percent: f64,
  threshold_green: f64,
  threshold_red: f64,
  color_green: String,
  color_yellow: String,
  color_red: String,
  badge_style: BadgeStyle,
}

impl CoverageReport {
  pub fn new() -> Self {
    Self {
      regions_percent: 0.0,
      functions_percent: 0.0,
      lines_percent: 0.0,
      threshold_green: 80.0,
      threshold_red: 50.0,
      color_green: "21b577".to_string(),
      color_yellow: "f4b01b".to_string(),
      color_red: "f52020".to_string(),
      badge_style: BadgeStyle::Flat,
    }
  }

  pub fn regions_percent(&self) -> f64 {
    self.regions_percent
  }

  pub fn functions_percent(&self) -> f64 {
    self.functions_percent
  }

  pub fn lines_percent(&self) -> f64 {
    self.lines_percent
  }

  pub fn analyze(&mut self, value: &Value) {
    let Value::Object(map) = value else {
      panic!("expected object");
    };
    let Some(data) = map.get("data") else {
      panic!("expected field 'data'");
    };
    let Value::Array(array) = data else {
      panic!("expected 'data' array");
    };
    if array.len() != 1 {
      panic!("expected single element in 'data' array");
    }
    let Some(Value::Object(map)) = array.first() else {
      panic!("expected single object in 'data' array");
    };
    let Some(totals) = map.get("totals") else {
      panic!("expected field 'totals' in 'data");
    };
    let Value::Object(totals) = totals else {
      panic!("expected 'totals' object");
    };
    self.regions_percent = self.read_percent(totals, "regions");
    self.functions_percent = self.read_percent(totals, "functions");
    self.lines_percent = self.read_percent(totals, "lines");
  }

  fn read_percent(&self, map: &Map<String, Value>, key: &str) -> f64 {
    let Some(Value::Object(map)) = map.get(key) else {
      panic!("expected '{key}' object");
    };
    let Some(Value::Number(percent_number)) = map.get("percent") else {
      panic!("expected percent field");
    };
    let Some(percent) = percent_number.as_f64() else {
      panic!("expected percent value");
    };
    percent
  }

  /// Returns a link of the `shields.io` badge reporting the coverage.
  pub fn badge(&self) -> String {
    let regions = self.regions_percent.trunc();
    let functions = self.functions_percent.trunc();
    let lines = self.lines_percent.trunc();
    let mut min = f64::MAX;
    for percent in [regions, functions, lines] {
      if percent < min {
        min = percent;
      }
    }
    let color = if min >= self.threshold_green {
      &self.color_green
    } else if min < self.threshold_red {
      &self.color_red
    } else {
      &self.color_yellow
    };
    let space = "%20";
    let separator = format!("{space}%E2%94%82{space}");
    let prefix = "https://img.shields.io/badge/coverage";
    let query_parameter = self.badge_style.query_parameter();
    let style = if query_parameter.is_empty() {
      "".to_string()
    } else {
      format!("?style={query_parameter}")
    };
    format!("{prefix}-{regions}%25{separator}{functions}%25{separator}{lines}%25-{color}.svg{style}")
  }
}