muffy_validation_macro/
lib.rs

1//! Macros for document validation.
2
3extern crate alloc;
4
5mod attribute;
6mod compiler;
7mod content;
8mod definition;
9mod error;
10mod name;
11mod pattern;
12
13use self::{
14    attribute::AttributeSet,
15    compiler::Compiler,
16    content::{children, generate_content},
17    definition::load_definitions,
18    error::MacroError,
19    name::class_names,
20    pattern::Pattern,
21};
22use alloc::collections::BTreeMap;
23use itertools::Itertools;
24use muffy_rnc::{NameClass, Pattern as RncPattern};
25use proc_macro::TokenStream;
26use proc_macro2::Span;
27use quote::{format_ident, quote};
28
29/// Generates HTML validation functions.
30#[proc_macro]
31pub fn html(_input: TokenStream) -> TokenStream {
32    // TODO Include the MathML schema for foreign elements.
33    generate_validation("html", &["html.rnc"]).unwrap_or_else(|error| {
34        syn::Error::new(Span::call_site(), error)
35            .to_compile_error()
36            .into()
37    })
38}
39
40fn generate_validation(language: &str, files: &[&str]) -> Result<TokenStream, MacroError> {
41    let definitions = load_definitions(files)?;
42    let mut compiler = Compiler::new(&definitions);
43    let mut element_rules = BTreeMap::<String, Vec<(Vec<AttributeSet>, Pattern)>>::new();
44
45    for definition in definitions.values() {
46        for (name_class, pattern) in collect_elements(definition) {
47            let names = class_names(name_class, false);
48
49            if names.is_empty() {
50                continue;
51            }
52
53            for (attribute_sets, content_pattern) in compiler.compile(pattern)? {
54                for name in &names {
55                    let variants = element_rules.entry(name.clone()).or_default();
56                    let variant = (attribute_sets.clone(), content_pattern.clone());
57
58                    if !variants.contains(&variant) {
59                        variants.push(variant);
60                    }
61                }
62            }
63        }
64    }
65
66    let mut attribute_set_indexes = BTreeMap::<Vec<AttributeSet>, usize>::new();
67    let mut content_indexes = BTreeMap::<Pattern, usize>::new();
68    let mut element_matches = vec![];
69
70    for (name, variants) in &element_rules {
71        let attributes = variants
72            .iter()
73            .flat_map(|(sets, _)| sets)
74            .flat_map(|set| set.required.iter().chain(&set.optional))
75            .unique()
76            .sorted()
77            .map(|name| quote!(#name));
78        let children = variants
79            .iter()
80            .flat_map(|(_, content)| children(content))
81            .unique()
82            .sorted()
83            .map(|name| quote!(#name));
84
85        let variants = variants
86            .iter()
87            .map(|(sets, content)| {
88                let index = attribute_set_indexes.len();
89                let sets = format_ident!(
90                    "ATTRIBUTE_SETS_{}",
91                    *attribute_set_indexes.entry(sets.clone()).or_insert(index)
92                );
93
94                let index = content_indexes.len();
95                let content = format_ident!(
96                    "CONTENT_{}",
97                    *content_indexes.entry(content.clone()).or_insert(index)
98                );
99
100                quote!(Variant { attributes: #sets, content: &#content })
101            })
102            .collect::<Vec<_>>();
103
104        element_matches.push(quote! {
105            #name => {
106                const RULE: Rule = Rule {
107                    attributes: &[#(#attributes),*],
108                    children: &[#(#children),*],
109                    variants: &[#(#variants),*],
110                };
111
112                validate_rule(element, ignored_attributes, ignored_elements, &RULE)
113            }
114        });
115    }
116
117    let attribute_set_definitions = sort_by_index(attribute_set_indexes).map(|(sets, index)| {
118        let identifier = format_ident!("ATTRIBUTE_SETS_{index}");
119        let sets = sets.iter().map(|set| {
120            let required = set.required.iter().map(|name| quote!(#name));
121            let optional = set.optional.iter().map(|name| quote!(#name));
122
123            quote!(AttributeSet {
124                required: &[#(#required),*],
125                optional: &[#(#optional),*],
126            })
127        });
128
129        quote!(const #identifier: &[AttributeSet] = &[#(#sets),*];)
130    });
131    let content_definitions = sort_by_index(content_indexes)
132        .map(|(content, index)| {
133            let identifier = format_ident!("CONTENT_{index}");
134            let content = generate_content(&content)?;
135
136            Ok(quote!(const #identifier: Content = #content;))
137        })
138        .collect::<Result<Vec<_>, MacroError>>()?;
139
140    let function_name = format_ident!("validate_{language}_element");
141    let documentation = format!("Validates an {} element.", language.to_uppercase());
142
143    Ok(quote! {
144        #[doc = #documentation]
145        pub fn #function_name(
146            element: &Element,
147            ignored_attributes: &[::regex::Regex],
148            ignored_elements: &[::regex::Regex],
149        ) -> Result<(), MarkupError> {
150            #(#attribute_set_definitions)*
151            #(#content_definitions)*
152
153            match element.name() {
154                name if ignored_elements.iter().any(|pattern| pattern.is_match(name)) => Ok(()),
155                #(#element_matches)*
156                _ => Err(MarkupError::UnknownTag(element.name().to_string())),
157            }
158        }
159    }
160    .into())
161}
162
163fn sort_by_index<T>(indexes: BTreeMap<T, usize>) -> impl Iterator<Item = (T, usize)> {
164    let mut entries = indexes.into_iter().collect::<Vec<_>>();
165
166    entries.sort_by_key(|(_, index)| *index);
167
168    entries.into_iter()
169}
170
171// TODO Skip element definitions gated by not-allowed flag conjuncts.
172fn collect_elements(pattern: &RncPattern) -> Vec<(&NameClass, &RncPattern)> {
173    match pattern {
174        RncPattern::Element {
175            name_class,
176            pattern,
177        } => vec![(name_class, pattern)],
178        RncPattern::Choice(patterns)
179        | RncPattern::Group(patterns)
180        | RncPattern::Interleave(patterns) => patterns.iter().flat_map(collect_elements).collect(),
181        RncPattern::Many0(pattern) | RncPattern::Many1(pattern) | RncPattern::Optional(pattern) => {
182            collect_elements(pattern)
183        }
184        RncPattern::Attribute { .. }
185        | RncPattern::Data { .. }
186        | RncPattern::Empty
187        | RncPattern::External(_)
188        | RncPattern::Grammar(_)
189        | RncPattern::List(_)
190        | RncPattern::Name(_)
191        | RncPattern::NotAllowed
192        | RncPattern::Text
193        | RncPattern::Value { .. } => vec![],
194    }
195}
muffy_validation_macro/lib.rs

muffy_validation_macro/
lib.rs
