accio 0.1.0

Retrieves code blocks distributed to multiple sites
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

use accio::*;

/*
this example demonstrates populating a struct's
fields from different places in the code.
*/

fn main() {
    println!(
        "{:?}",
        CmdArgs::parse(&["test", "-flag1", "test_val", "-flag2",])
    );
}

#[accio_body(fields)]
#[derive(Debug, Default)]
pub struct CmdArgs {
    // fields are populated here
}

impl CmdArgs {
    /*
    for non-exhaustive match statements of this kind;
    we MUST have a final "_ => {}," block. since accio
    does not guarantee order within a given scope; we
    should use multiple scopes delimited with +; which
    are ordered within themselves.
    here, the lastCheck scope contains only one item that
    is guaranteed to come after everything in flagChecks.
    */
    #[accio_body(flagChecks + lastCheck)]
    fn parse(args: &[&str]) -> Self {
        let mut c = Self::default();
        let mut it = args.iter().skip(1);
        while let Some(f) = it.next() {
            if let Some(k) = f.strip_prefix("-") {
                match k {}
            }
        }
        c
    }
}

accio_emit! {
    lastCheck{
        // insert the fallback case here
        _ => {}
    }
}

accio_emit! {
    fields {
        pub flag1: Option<String>,
    }
    flagChecks{
        "flag1" => {
            if let Some(v) = it.next() {
                c.flag1 = Some(v.to_string());
            }
        },
    }
}

accio_emit! {
    fields {
        pub flag2: bool,
    }
    flagChecks{
        "flag2" => {
            c.flag2 = true;
        },
    }
}