fixtures_proc 2.2.0

Run tests against fixtures
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

use proc_macro2::Span;
use syn::{
    parse::{Parse, ParseStream},
    Ident, LitStr, Token,
};

use super::paths::Paths;

pub enum OptionAssignment {
    Ignore(IgnoreOptionAssignment),
    IgnoreReason(IgnoreReasonOptionAssignment),
}

impl Parse for OptionAssignment {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        if let Some(ident) = input.parse::<Option<Ident>>()? {
            let ident_name = ident.to_string();
            return match ident_name.as_str() {
                "ignore" => Ok(OptionAssignment::Ignore(
                    IgnoreOptionAssignment::parse_from_ident(input, ident)?,
                )),
                "ignore_reason" => Ok(OptionAssignment::IgnoreReason(
                    IgnoreReasonOptionAssignment::parse_from_ident(input, ident)?,
                )),
                _ => Err(syn::Error::new(ident.span(), "Invalid option")),
            };
        }
        Err(syn::Error::new(input.span(), "Expected option identifier"))
    }
}

pub struct IgnoreOptionAssignment {
    span: Span,
    paths: Paths,
}

impl IgnoreOptionAssignment {
    pub fn span(&self) -> Span {
        self.span
    }

    pub fn into_paths(self) -> Paths {
        self.paths
    }

    fn parse_from_ident(input: ParseStream, ident: Ident) -> syn::Result<Self> {
        input.parse::<Token![=]>()?;
        let paths: Paths = input.parse()?;
        let span = ident
            .span()
            .join(paths.span())
            // On non-nightly compilers, join will always return None
            .unwrap_or_else(|| paths.span());
        Ok(IgnoreOptionAssignment { span, paths })
    }
}

pub struct IgnoreReasonOptionAssignment {
    span: Span,
    reason: LitStr,
}

impl IgnoreReasonOptionAssignment {
    pub fn span(&self) -> Span {
        self.span
    }

    pub fn into_lit_str(self) -> LitStr {
        self.reason
    }

    fn parse_from_ident(input: ParseStream, ident: Ident) -> syn::Result<Self> {
        input.parse::<Token![=]>()?;
        let lit_str: LitStr = input.parse()?;
        let span = ident
            .span()
            .join(lit_str.span())
            // On non-nightly compilers, join will always return None
            .unwrap_or_else(|| lit_str.span());
        Ok(IgnoreReasonOptionAssignment {
            span,
            reason: lit_str,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn correctly_parses_ignore_option_assignment_without_paths() {
        let input = r#"ignore = []"#;
        let option_assignment: OptionAssignment =
            syn::parse_str(input).expect("Failed to parse option assignment");

        assert!(matches!(option_assignment, OptionAssignment::Ignore(_)));
        let OptionAssignment::Ignore(ignore_option_assignment) = option_assignment else {
            unreachable!();
        };
        assert!(ignore_option_assignment.paths.paths().is_empty());
    }

    #[test]
    fn correctly_parses_ignore_option_assignment_with_one_path() {
        let input = r#"ignore = ["fixtures/*.ignore.txt"]"#;
        let option_assignment: OptionAssignment =
            syn::parse_str(input).expect("Failed to parse option assignment");

        assert!(matches!(option_assignment, OptionAssignment::Ignore(_)));
        let OptionAssignment::Ignore(ignore_option_assignment) = option_assignment else {
            unreachable!();
        };
        assert_eq!(ignore_option_assignment.paths.paths().len(), 1);
        assert_eq!(
            ignore_option_assignment.paths.paths()[0].value(),
            "fixtures/*.ignore.txt"
        );
    }

    #[test]
    fn correctly_parses_ignore_reason_option_assignment() {
        let input = r#"ignore_reason = "the provided reason""#;
        let option_assignment: OptionAssignment =
            syn::parse_str(input).expect("Failed to parse option assignment");

        assert!(matches!(
            option_assignment,
            OptionAssignment::IgnoreReason(_)
        ));
        let OptionAssignment::IgnoreReason(ignore_reason_option_assignment) = option_assignment
        else {
            unreachable!();
        };
        assert_eq!(
            ignore_reason_option_assignment.reason.value(),
            "the provided reason"
        );
    }
}