hoster 0.1.1

Small parser and lexer library for Hosts file format
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use std::{fmt::Display, ops::RangeBounds};

use smallvec::SmallVec;

use crate::tokens::Tokens;

#[derive(Debug, Eq, PartialEq)]
pub enum CstNode {
    Host(String),
    IP(std::net::IpAddr),
    Comment(String),
    Space,
    Tab,
    CarriageReturn,
    NewLine,
}

impl From<Tokens> for CstNode {
    fn from(token: Tokens) -> Self {
        match token {
            Tokens::Comment(c) => CstNode::Comment(c),
            Tokens::Space => CstNode::Space,
            Tokens::Tab => CstNode::Tab,
            Tokens::CarriageReturn => CstNode::CarriageReturn,
            Tokens::NewLine => CstNode::NewLine,
            _ => unreachable!("This should not happen"),
        }
    }
}

impl Display for CstNode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            CstNode::Host(host) => write!(f, "{}", host),
            CstNode::IP(ip) => write!(f, "{}", ip),
            CstNode::Comment(comment) => write!(f, "#{}", comment),
            CstNode::Space => write!(f, " "),
            CstNode::Tab => write!(f, "\t"),
            CstNode::CarriageReturn => write!(f, "\r"),
            CstNode::NewLine => writeln!(f),
        }
    }
}

#[derive(Debug)]
pub struct Cst<const LENGTH: usize> {
    pub nodes: SmallVec<[CstNode; LENGTH]>,
}

impl<const LENGTH: usize> Cst<LENGTH> {
    pub fn remove_nodes<R>(&mut self, range: R)
    where
        R: RangeBounds<usize>,
    {
        self.nodes.drain(range);
    }

    pub fn add_nodes<T, const OTHER: usize>(&mut self, nodes: T)
    where
        T: Into<SmallVec<[CstNode; OTHER]>>,
    {
        self.nodes.extend(nodes.into().into_iter());
    }

    pub fn add_node<T>(&mut self, node: T)
    where
        T: Into<CstNode>,
    {
        self.nodes.push(node.into());
    }
}

impl<const LENGTH: usize> ToString for Cst<LENGTH> {
    fn to_string(&self) -> String {
        self.nodes
            .iter()
            .map(|node| node.to_string())
            .collect::<Vec<String>>()
            .join("")
    }
}

#[cfg(test)]
mod tests {
    use std::net::IpAddr;

    use smallvec::smallvec_inline;

    use super::*;

    #[test]
    fn test_to_string() {
        let expected = "\
# localhost name resolution is handled within DNS itself.
# Added by Docker Desktop
192.168.0.17\thost.docker.internal
192.168.0.17 gateway.docker.internal
# To allow the same kube context to work on the host and the container:
\t127.0.0.1\tkubernetes.docker.internal


# End of section
";

        let cst = smallvec_inline![
            CstNode::Comment(
                " localhost name resolution is handled within DNS itself.".to_string(),
            ),
            CstNode::NewLine,
            CstNode::Comment(" Added by Docker Desktop".to_string()),
            CstNode::NewLine,
            CstNode::IP("192.168.0.17".parse::<IpAddr>().unwrap()),
            CstNode::Tab,
            CstNode::Host("host.docker.internal".to_string()),
            CstNode::NewLine,
            CstNode::IP("192.168.0.17".parse::<IpAddr>().unwrap()),
            CstNode::Space,
            CstNode::Host("gateway.docker.internal".to_string()),
            CstNode::NewLine,
            CstNode::Comment(
                " To allow the same kube context to work on the host and the container:"
                    .to_string(),
            ),
            CstNode::NewLine,
            CstNode::Tab,
            CstNode::IP("127.0.0.1".parse::<IpAddr>().unwrap()),
            CstNode::Tab,
            CstNode::Host("kubernetes.docker.internal".to_string()),
            CstNode::NewLine,
            CstNode::NewLine,
            CstNode::NewLine,
            CstNode::Comment(" End of section".to_string()),
            CstNode::NewLine,
        ];

        assert_eq!(expected, Cst { nodes: cst }.to_string());
    }
}