afmt 0.1.1

Basic data structure parsing from strings
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

use crate::parse::{Fmt, Section};
use ::devise::proc_macro2::TokenStream as TokenStream2;
use ::devise::quote::quote;
use ::devise::syn;

/// Codegen for a matching a string literal
///
/// The code generated makes sure the string we are parsing matches the given
/// string literal, in which case it consumes it and continues, otherwise
/// it returns a parse error.
///
/// Example --
///
/// CODEGEN ARGS:
///   lit_str = "abc"
/// SCOPE IN:
///   s = "abcxyz"
/// SCOPE OUT:
///   s = "xyz"
fn str_match(lit: &syn::LitStr) -> TokenStream2 {
    quote! {
        if !s.starts_with(#lit) {
            return Err(format!("string literal '{}' not matched", #lit));
        }

        let (_, s) = s.split_at(#lit .as_bytes().len());
    }
}

/// Codegen for field member capture
///
/// The code generated attempts to parse a field value from the whole remainings
/// of the string in scope.
///
/// Example --
///
/// CODEGEN ARGS:
///   capture = 'v' (an integer)
/// SCOPE IN:
///   s = "65"
/// SCOPE OUT:
///   s = "65"
///   v = 65
fn capture(field: &syn::Ident) -> TokenStream2 {
    quote! {
        let #field = match s.parse() {
            Ok(v) => v,
            Err(e) => return Err(format!("{}", e)),
        };
    }
}

/// Codegen for field member capture with string literal lookahead
///
/// The code generated makes sure a certain string literal lookahead is valid,
/// then captures the string before it into a capture field.
///
/// Example --
///
/// CODEGEN ARGS:
///   capture = 'v' (an integer)
///   lookahead = "abc"
/// SCOPE IN:
///   s = "65abcxyz"
/// SCOPE OUT:
///   s = "xyz"
///   v = 65
fn capture_w_lookahead(field: &syn::Ident, lookahead: &syn::LitStr) -> TokenStream2 {
    quote! {
        let idx = match s.find(#lookahead) {
            Some(idx) => idx,
            None => return Err(format!("lookahead for '{}' not matched", #lookahead)),
        };
        let (left, s) = s.split_at(idx);
        let (_, s) = s.split_at(#lookahead .as_bytes().len());
        let #field = match left.parse() {
            Ok(value) => value,
            Err(e) => return Err(format!("{}", e)),
        };
    }
}

/// Codegen for a full chain of arguments
pub fn codegen(fmt: Fmt) -> TokenStream2 {
    let mut code = vec![];
    for s in fmt.sections.iter() {
        code.push(match s {
            Section::StrMatch(s) => str_match(&s.lit),
            Section::CaptureLookahead(s) => capture_w_lookahead(&s.field, &s.lookahead),
            Section::Capture(s) => capture(&s.field),
        });
    }

    quote! {
        #(#code)*
    }
}

/// Codegen for building a struct with default field names from a struct item
///
/// Example --
///
/// CODEGEN ARGS:
///   s = "struct Foo { v: u32, f: f64 }"
/// CODE OUT:
///   Foo { v, f, }
pub fn struct_builder(s: &syn::ItemStruct) -> TokenStream2 {
    let ident = &s.ident;
    let mut fields = vec![];
    for field in s.fields.iter() {
        let field = field.ident.clone();
        fields.push(field.unwrap());
    }
    quote! {
        #ident {
            #(#fields),*
        }
    }
}