fontspector-checkapi 1.6.0

Library for developing checks for the fontspector font QA tool
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

use std::time::Duration;

use serde::{ser::SerializeStruct, Deserialize, Serialize};

use crate::{Check, CheckId, FixResult, Status, StatusCode};

#[derive(Debug, Clone, Deserialize)]
/// The result of a check on one or more font files.
///
/// This struct is used to store the results of a check on one or more font files.
/// A check may return multiple sub-results, as the test checks different aspects
/// of the font file(s). Additionally, fontspector can be used to fix problems
/// found in the font, either at the source or by applying a hotfix. The results
/// of these fixes are stored in the `hotfix_result` and `sourcefix_result` fields.
pub struct CheckResult {
    /// The ID of the check
    pub check_id: CheckId,
    /// A simple title for the check
    pub check_name: String,
    /// The rationale for the check
    pub check_rationale: String,
    /// The file which was checked; if None, the check was run on all files
    pub filename: Option<String>,
    /// The source where this file came from, if any
    #[serde(default)]
    pub source_filename: Option<String>,
    /// The section of the profile this check belongs to
    pub section: Option<String>,
    /// The individual results of the check
    pub subresults: Vec<Status>,
    /// If hotfixing was attempted, the result of the hotfix
    pub hotfix_result: Option<FixResult>,
    /// If source fixing was attempted, the result of the source fix
    pub sourcefix_result: Option<FixResult>,
    /// Time taken — not serialized over the wire, defaults to zero
    #[serde(default)]
    pub time: Duration,
    /// Whether or not a hotfix was available for this check
    pub hotfix_available: bool,
    /// Whether or not a source fix was available for this check
    pub sourcefix_available: bool,
}

impl Serialize for CheckResult {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let fields =
            7 + self.hotfix_result.is_some() as usize + self.sourcefix_result.is_some() as usize;
        let mut s = serializer.serialize_struct("CheckResult", fields)?;
        s.serialize_field("check_id", &self.check_id)?;
        s.serialize_field("check_name", &self.check_name)?;
        s.serialize_field("check_rationale", &self.check_rationale)?;
        s.serialize_field("filename", &self.filename)?;
        s.serialize_field("section", &self.section)?;
        s.serialize_field("subresults", &self.subresults)?;
        s.serialize_field("worst_status", &self.worst_status())?;
        // s.serialize_field("time", &self.time)?;
        s.serialize_field("hotfix_available", &self.hotfix_available)?;
        s.serialize_field("sourcefix_available", &self.sourcefix_available)?;
        if let Some(hotfix_result) = &self.hotfix_result {
            s.serialize_field("hotfix_result", hotfix_result)?;
        }
        if let Some(sourcefix_result) = &self.sourcefix_result {
            s.serialize_field("sourcefix_result", sourcefix_result)?;
        }
        s.end()
    }
}

impl CheckResult {
    /// Create a new CheckResult
    pub fn new(
        check: &Check,
        filename: Option<&str>,
        source_filename: Option<&str>,
        section: Option<&str>,
        subresults: Vec<Status>,
        duration: Duration,
    ) -> Self {
        Self {
            check_id: check.id.to_string(),
            check_name: check.title.to_string(),
            check_rationale: check.rationale.to_string(),
            filename: filename.map(|x| x.to_string()),
            source_filename: source_filename.map(|x| x.to_string()),
            section: section.map(|x| x.to_string()),
            subresults,
            hotfix_result: None,
            sourcefix_result: None,
            time: duration,
            hotfix_available: check.hotfix.is_some(),
            sourcefix_available: check.fix_source.is_some(),
        }
    }

    /// Get the worst status of all subresults
    pub fn worst_status(&self) -> StatusCode {
        self.subresults
            .iter()
            .map(|x| x.severity)
            .max()
            .unwrap_or(StatusCode::Pass)
    }

    /// If this check detected a critical font defect that would break infrastructure
    pub fn is_fatal(&self) -> bool {
        self.worst_status() == StatusCode::Fatal
    }

    /// If this check returned some kind of Rust error that we handled
    pub fn is_error(&self) -> bool {
        self.worst_status() == StatusCode::Error
    }
}