uci_rs 0.1.2

an openwrt's UCI (Unified Configuration Interface) parser and serializer.
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

use std::fmt;

#[derive(PartialEq, Eq, Debug, Clone)]
pub struct TokenItem {
    pub typ: TokenItemType,
    pub val: String,
    pub pos: usize,
}

#[derive(PartialEq, Eq, Debug, Clone, Copy)]
pub enum TokenItemType {
   Error = 0,
   Eof,
   Package,
   Config,
   Option,
   List,
   Ident,
   String,
}

impl fmt::Display for TokenItemType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Error => {
                write!(f, "Error")
            }
            Self::Eof => {
                write!(f, "EOF")
            }
            Self::Package => {
                write!(f, "Package")
            }
            Self::Config => {
                write!(f, "Config")
            }
            Self::Option => {
                write!(f, "Option")
            }
            Self::List => {
                write!(f, "List")
            }
            Self::Ident => {
                write!(f, "Ident")
            }
            Self::String => {
                write!(f, "String")
            }
        }
    }
}

pub struct KeyWord {}

impl KeyWord {
    pub const KW_PACKAGE: &'static str = "package";
    pub const KW_CONFIG: &'static str = "config";
    pub const KW_OPTION: &'static str = "option";
    pub const KW_LIST: &'static str = "list";
}

impl fmt::Display for TokenItem {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.typ != TokenItemType::Error && self.val.len() > 25 {
            return write!(
                f,
                "({} {:?} {})",
                self.typ,
                self.val.get(0..25).unwrap(),
                self.pos
            );
        }
        write!(f, "({} {:?} {})", self.typ, self.val, self.pos)
    }
}

#[derive(PartialEq, Eq, Debug)]
pub enum ScanTokenType {
    Error = 0,
    Package,
    Section,
    Option,
    List,
}

impl fmt::Display for ScanTokenType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Error => {
                write!(f, "error")
            }
            Self::List => {
                write!(f, "list")
            }
            Self::Option => {
                write!(f, "option")
            }
            Self::Package => {
                write!(f, "package")
            }
            Self::Section => {
                write!(f, "config")
            }
        }
    }
}

#[derive(Debug)]
pub struct Token {
    pub typ: ScanTokenType,
    pub items: Vec<TokenItem>,
}

impl fmt::Display for Token {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} {:?}", self.typ, self.items)
    }
}

#[cfg(test)]
mod test;