xdg-user 0.3.0

A library for accessing common user file directories according to `xdg-user-dirs`
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

pub struct LineParser<'a> {
    line: &'a mut Vec<u8>,
    pos: usize,
}

impl<'a> LineParser<'a> {
    pub fn new(line: &'a mut Vec<u8>) -> Self {
        Self { line, pos: 0 }
    }

    fn skip_whitespace(&mut self) -> Option<()> {
        while self.line.get(self.pos)? == &b' ' || self.line.get(self.pos)? == &b'\t' {
            self.pos += 1;
        }
        Some(())
    }

    fn parse_key(&mut self) -> Option<std::ops::Range<usize>> {
        let mut range = self.pos..0;
        while self.line.get(self.pos)? != &b' '
            && self.line.get(self.pos)? != &b'\t'
            && self.line.get(self.pos)? != &b'='
        {
            self.pos += 1;
        }
        range.end = self.pos;
        Some(range)
    }

    fn expect_byte(&mut self, b: u8) -> Option<()> {
        if self.line.get(self.pos)? == &b {
            self.pos += 1;
            Some(())
        } else {
            None
        }
    }

    fn parse_val(&mut self) -> Option<std::ops::Range<usize>> {
        self.expect_byte(b'"')?;

        let mut range = self.pos..0;

        // shamelessly ~~stolen~~ adapted from Vec::retain
        {
            let len = self.line.len();
            let mut del = 0;
            loop {
                match self.line.get(self.pos)? {
                    b'"' => break,
                    b'\\' => {
                        del += 1;
                        self.pos += 2;
                    }
                    _ => {
                        self.line.swap(self.pos - del, self.pos);
                        self.pos += 1;
                    }
                }
            }
            if del > 0 {
                self.line.truncate(len - del);
            }
        }

        range.end = self.pos;
        Some(range)
    }

    pub fn parse(mut self) -> Option<(&'a [u8], &'a [u8])> {
        self.skip_whitespace()?;
        let key = self.parse_key()?;
        self.skip_whitespace()?;
        self.expect_byte(b'=')?;
        self.skip_whitespace()?;
        let val = self.parse_val()?;

        Some((&self.line[key], &self.line[val]))
    }
}