accessibility-rs 0.1.7

Web accessibility engine for Rust.
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use crate::engine::rules::techniques::Techniques;
use crate::engine::rules::wcag_base::{Guideline, IssueType, Principle};
use accessibility_scraper::ElementRef;

/// the validation response
#[derive(Default, Debug)]
pub struct Validation {
    /// is valid
    pub valid: bool,
    /// the sub-technique
    pub id: &'static str,
    /// elements that match the issue
    pub elements: Vec<String>,
    /// the message of the error
    pub message: String,
}

impl Validation {
    /// helper to create validation
    pub fn new(valid: bool, id: &'static str, elements: Vec<String>, message: String) -> Self {
        Self {
            valid,
            id,
            elements,
            message,
        }
    }
    /// basic validation
    pub fn new_issue(valid: bool, id: &'static str) -> Self {
        Self {
            valid,
            id,
            ..Default::default()
        }
    }

    /// basic validation with custom message
    pub fn new_custom_issue(valid: bool, id: &'static str, message: String) -> Self {
        Self {
            valid,
            id,
            message,
            ..Default::default()
        }
    }
}

#[derive(Debug, Clone)]
/// techniques for a rule
pub enum Technique {
    /// a single technique
    Single(Techniques),
    /// multiple techniques
    Multi(Vec<Techniques>),
}

impl Technique {
    /// technique(s) into string
    pub fn into_str(&self) -> String {
        match self {
            Technique::Multi(tech) => tech
                .iter()
                .map(|x| x.as_str())
                .collect::<Vec<_>>()
                .join(",")
                .into(),
            Technique::Single(tech) => tech.as_str().into(),
        }
    }
}

impl From<Techniques> for Technique {
    fn from(t: Techniques) -> Self {
        Technique::Single(t)
    }
}

impl From<Vec<Techniques>> for Technique {
    fn from(t: Vec<Techniques>) -> Self {
        Technique::Multi(t)
    }
}

/// validation rule(s) that should be handled
pub enum RuleValidation {
    /// a single rule for validation
    Single(Validation),
    /// multiple validation rules applied
    Multi(Vec<Validation>),
}

impl From<Validation> for RuleValidation {
    fn from(t: Validation) -> Self {
        RuleValidation::Single(t)
    }
}

impl From<Vec<Validation>> for RuleValidation {
    fn from(t: Vec<Validation>) -> Self {
        RuleValidation::Multi(t)
    }
}

type ValidateFn =
    fn(&Vec<(ElementRef<'_>, Option<taffy::NodeId>)>, &crate::Auditor<'_>) -> RuleValidation;

/// the rule validation method that should be performed.
#[derive(Debug)]
pub struct Rule {
    /// the message id of the rule to point to the locale
    pub rule_id: Technique,
    /// the type of rule
    pub issue_type: IssueType,
    /// validate a test returns (valid, rule, selectors)
    pub validate: ValidateFn,
    /// the principle type
    pub principle: Principle,
    /// the guideline to follow
    pub guideline: Guideline,
    /// the success criteria
    pub success_criteria: &'static str,
}

impl Rule {
    /// a new rule type
    pub fn new(
        rule_id: Technique,
        issue_type: IssueType,
        principle: Principle,
        guideline: Guideline,
        success_criteria: &'static str,
        validate: ValidateFn,
    ) -> Rule {
        Rule {
            rule_id,
            issue_type,
            guideline,
            principle,
            success_criteria,
            validate,
        }
    }
}