kamo-macros 0.1.2

A macro for parsing s-expressions into kamo Values.
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

use pest::iterators::Pair;
use proc_macro2::TokenStream;
use quote::quote;

use crate::sexpr::{emitter::emit_datum, error::Error, parser::Rule};

pub fn emit_vector<'a>(
    mutator: syn::Ident,
    pair: Pair<'a, Rule>,
    out: &mut TokenStream,
) -> Result<(), Error<'a>> {
    if pair.as_rule() == Rule::vector {
        let mut pairs = pair.into_inner();

        if let Some(pair) = pairs.next() {
            let mut values = TokenStream::new();

            emit_datum(Some(mutator.to_owned()), pair.to_owned(), &mut values)?;
            for pair in pairs {
                values.extend(quote! {, });
                emit_datum(Some(mutator.to_owned()), pair.to_owned(), &mut values)?;
            }
            out.extend(quote! { Value::new_vector(#mutator.clone(), vec![#values]) });
        } else {
            out.extend(quote! { Value::new_vector(#mutator.clone(), vec![]) });
        }
        Ok(())
    } else {
        Err(Error::ExpectedVector(pair.as_span()))
    }
}

#[cfg(test)]
mod tests {
    use pest::Parser;
    use proc_macro2::Span;
    use quote::quote;

    use crate::sexpr::parser::SExpr;

    use super::*;

    #[test]
    fn emit_vector_success() {
        let exprs = [
            ("#()", quote! { Value::new_vector(m.clone(), vec![]) }),
            ("#( )", quote! { Value::new_vector(m.clone(), vec![]) }),
            (
                "#(1)",
                quote! { Value::new_vector(m.clone(), vec![Value::new_int(1i64)]) },
            ),
            (
                "#( 1 )",
                quote! { Value::new_vector(m.clone(), vec![Value::new_int(1i64)]) },
            ),
            (
                "#(1 2)",
                quote! { Value::new_vector(m.clone(), vec![Value::new_int(1i64), Value::new_int(2i64)]) },
            ),
            (
                "#( 1 2 )",
                quote! { Value::new_vector(m.clone(), vec![Value::new_int(1i64), Value::new_int(2i64)]) },
            ),
            (
                "#(1 2 3)",
                quote! { Value::new_vector(m.clone(), vec![Value::new_int(1i64), Value::new_int(2i64), Value::new_int(3i64)]) },
            ),
        ];

        for (input, expected) in &exprs {
            let pair = SExpr::parse(Rule::datum, input).unwrap().next().unwrap();
            let mut out = TokenStream::new();

            emit_vector(syn::Ident::new("m", Span::call_site()), pair, &mut out).unwrap();
            assert_eq!(out.to_string(), expected.to_string());
        }
    }

    #[test]
    fn emit_vector_failure() {
        let exprs = ["#t", "#f", "#\\a"];
        for input in &exprs {
            let pair = SExpr::parse(Rule::datum, input).unwrap().next().unwrap();
            let mut out = TokenStream::new();

            assert!(emit_vector(syn::Ident::new("m", Span::call_site()), pair, &mut out).is_err());
        }
    }
}