curlyconf 0.1.0

Configuration file parser
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

use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Config {
    peer: Vec<Peer>,
    logger: Logger,
    color: Vec<Color>,
    #[serde(default)]
    either: Option<Either>,
}

#[derive(Debug, Deserialize)]
struct Peer {
    #[serde(rename = "__label__")]
    name: String,
    hostname: String,
}

#[derive(Debug, Deserialize)]
struct Logger {
    #[serde(rename = "__label__")]
    name: String,
    target: std::net::IpAddr,
    tuple: (u32, String),
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "lowercase")]
enum Color {
    Red,
    Green,
    Blue,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "lowercase")]
enum Either {
    Peer(Peer),
    Logger(Logger),
    Users { name: String, id: u64 },
}

type Result<T, E = Box<dyn std::error::Error>> = std::result::Result<T, E>;

fn main() -> Result<()> {
    env_logger::init();

    let cfg = r#"
        # Peer.
        logger syslog {
            target 1.2.3.4;
            tuple 10, 12;
        }
        peer foo {
            hostname "host1";
        }
        peer bar {
            hostname "host2";
        }
        color red, blue;
        either peer baz {
            hostname "host3";
        }
"#;

    let cfg2 = r#"
        # Peer.
        peer foo {
            hostname "host1"
        }
        peer bar {
            hostname "host2"
        }
        logger syslog {
            target 1.2.3.4
            tuple 10, "12"
        }
        color blue
        either users {
            name "mikevs"
            id 1000
        }
"#;

    match curlyconf::from_str(cfg) {
        Err(e) => println!("{}", e),
        Ok(config @ Config { .. }) => println!("{:#?}", config),
    }

    let cfg_parser = curlyconf::Builder::new()
        .mode(curlyconf::Mode::Newline)
        .from_str(cfg2);

    match cfg_parser {
        Err(e) => println!("{}", e),
        Ok(config @ Config { .. }) => println!("{:#?}", config),
    }

    Ok(())
}