fairjax 0.1.0

Fair join pattern matching
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

use syn::{Attribute, Meta, Result};

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum InputStrategy {
    Auto,
    StatefulTree,
    BruteForce,
}

impl InputStrategy {
    /// Parse a strategy from a vector of attributes.
    /// Checks that exactly 0 or 1 attribute is provided. Defaults to Auto when no attribute is provided.
    pub fn parse(input: Vec<Attribute>) -> Result<Self> {
        match input.len() {
            0 => Ok(InputStrategy::Auto),
            1 => {
                if let Meta::Path(strategy_ident) = &input[0].meta {
                    match strategy_ident.get_ident() {
                        Some(ident) if ident == "Auto" => Ok(InputStrategy::Auto),
                        Some(ident) if ident == "StatefulTree" => Ok(InputStrategy::StatefulTree),
                        Some(ident) if ident == "BruteForce" => Ok(InputStrategy::BruteForce),
                        _ => Err(syn::Error::new_spanned(
                            strategy_ident,
                            "Invalid strategy name",
                        )),
                    }
                } else {
                    Err(syn::Error::new_spanned(
                        &input[0],
                        "Invalid stratety declaration",
                    ))
                }
            }
            _ => Err(syn::Error::new_spanned(
                &input[1],
                "Only one attribute allowed",
            )),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use quote::format_ident;
    use syn::{Attribute, parse_quote};

    fn attr_from_ident(ident: &str) -> Attribute {
        let ident = format_ident!("{}", ident);
        // Create an attribute like #[Auto], #[StatefulTree], #[BruteForce]
        parse_quote!(#[#ident])
    }

    #[test]
    fn test_parse_empty_vec_returns_auto() {
        let attrs: Vec<Attribute> = vec![];
        let result = InputStrategy::parse(attrs).unwrap();
        assert_eq!(result, InputStrategy::Auto);
    }

    #[test]
    fn test_parse_auto() {
        let attrs = vec![attr_from_ident("Auto")];
        let result = InputStrategy::parse(attrs).unwrap();
        assert_eq!(result, InputStrategy::Auto);
    }

    #[test]
    fn test_parse_stateful_tree() {
        let attrs = vec![attr_from_ident("StatefulTree")];
        let result = InputStrategy::parse(attrs).unwrap();
        assert_eq!(result, InputStrategy::StatefulTree);
    }

    #[test]
    fn test_parse_brute_force() {
        let attrs = vec![attr_from_ident("BruteForce")];
        let result = InputStrategy::parse(attrs).unwrap();
        assert_eq!(result, InputStrategy::BruteForce);
    }

    #[test]
    fn test_parse_invalid_strategy_name() {
        let attrs = vec![attr_from_ident("UnknownStrategy")];
        let result = InputStrategy::parse(attrs);
        assert!(result.is_err());
        let err_msg = format!("{}", result.unwrap_err());
        assert!(err_msg.contains("Invalid strategy name"));
    }

    #[test]
    fn test_parse_invalid_meta_type() {
        // Create an attribute with a meta that is not a path (e.g., a name-value pair)
        let attr: Attribute = parse_quote!(#[strategy = "Auto"]);
        let attrs = vec![attr];
        let result = InputStrategy::parse(attrs);
        assert!(result.is_err());
        let err_msg = format!("{}", result.unwrap_err());
        assert!(err_msg.contains("Invalid stratety declaration"));
    }

    #[test]
    fn test_parse_multiple_attributes() {
        let attrs = vec![attr_from_ident("Auto"), attr_from_ident("StatefulTree")];
        let result = InputStrategy::parse(attrs);
        assert!(result.is_err());
        let err_msg = format!("{}", result.unwrap_err());
        assert!(err_msg.contains("Only one attribute allowed"));
    }
}