use-accessibility-check 0.0.1

Primitive accessibility issue filtering helpers
Documentation 
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

#![forbid(unsafe_code)]
//! Primitive accessibility issue filtering helpers.
//!
//! The crate stays generic and dependency-free so it can be reused across
//! different UI or document models.
//!
//! # Examples
//!
//! ```rust
//! use use_accessibility_check::{
//!     AccessibilityIssue, AccessibilitySeverity, filter_by_severity, has_errors, has_warnings,
//!     issue_count,
//! };
//!
//! let issues = [
//!     AccessibilityIssue {
//!         code: String::from("contrast"),
//!         message: String::from("Low contrast"),
//!         severity: AccessibilitySeverity::Warning,
//!     },
//!     AccessibilityIssue {
//!         code: String::from("label"),
//!         message: String::from("Missing label"),
//!         severity: AccessibilitySeverity::Error,
//!     },
//! ];
//!
//! assert!(has_warnings(&issues));
//! assert!(has_errors(&issues));
//! assert_eq!(filter_by_severity(&issues, AccessibilitySeverity::Warning).len(), 1);
//! assert_eq!(issue_count(&issues), 2);
//! ```

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AccessibilitySeverity {
    Info,
    Warning,
    Error,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AccessibilityIssue {
    pub code: String,
    pub message: String,
    pub severity: AccessibilitySeverity,
}

#[must_use]
pub fn has_errors(issues: &[AccessibilityIssue]) -> bool {
    issues
        .iter()
        .any(|issue| issue.severity == AccessibilitySeverity::Error)
}

#[must_use]
pub fn has_warnings(issues: &[AccessibilityIssue]) -> bool {
    issues
        .iter()
        .any(|issue| issue.severity == AccessibilitySeverity::Warning)
}

#[must_use]
pub fn filter_by_severity(
    issues: &[AccessibilityIssue],
    severity: AccessibilitySeverity,
) -> Vec<AccessibilityIssue> {
    issues
        .iter()
        .filter(|issue| issue.severity == severity)
        .cloned()
        .collect()
}

#[must_use]
pub fn issue_count(issues: &[AccessibilityIssue]) -> usize {
    issues.len()
}

#[cfg(test)]
mod tests {
    use super::{
        AccessibilityIssue, AccessibilitySeverity, filter_by_severity, has_errors, has_warnings,
        issue_count,
    };

    #[test]
    fn filters_issues_by_severity() {
        let issues = [
            AccessibilityIssue {
                code: String::from("contrast"),
                message: String::from("Low contrast"),
                severity: AccessibilitySeverity::Warning,
            },
            AccessibilityIssue {
                code: String::from("label"),
                message: String::from("Missing label"),
                severity: AccessibilitySeverity::Error,
            },
            AccessibilityIssue {
                code: String::from("info"),
                message: String::from("Informational"),
                severity: AccessibilitySeverity::Info,
            },
        ];

        assert!(has_warnings(&issues));
        assert!(has_errors(&issues));
        assert_eq!(
            filter_by_severity(&issues, AccessibilitySeverity::Warning).len(),
            1
        );
        assert_eq!(
            filter_by_severity(&issues, AccessibilitySeverity::Error).len(),
            1
        );
        assert_eq!(issue_count(&issues), 3);
    }
}