dsktp 0.1.0

A utility for listing and interacting with .desktop files on unix systems
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

//! Low level parser for freedesktop .desktop specification

use lazy_static::lazy_static;
use regex::Regex;

pub type AST = Vec<(String, Vec<KeyValue>)>;

pub struct KeyValue {
    pub key: String,
    pub value: String,
}

enum Token {
    Section(String),
    KeyValue(String, String),
    Ignore,
}

pub fn parse(bits: Vec<u8>) -> AST {
    let txt = String::from_utf8_lossy(&bits);
    let tokens = txt
        .split("\n")
        .map(tokenize)
        // NOTE: how to continue as iterator?
        .collect();

    parse_tokens(tokens)
}

fn tokenize(line: &str) -> Token {
    lazy_static! {
        static ref SECTION_RE: Regex = Regex::new(r"^\[(.*)\]$").unwrap();
        static ref KEY_VALUE_RE: Regex = Regex::new(r"^(\w+)=(.*)$").unwrap();
    }
    if let Some(captures) = SECTION_RE.captures(line) {
        return Token::Section(captures[1].to_string());
    }
    if let Some(captures) = KEY_VALUE_RE.captures(line) {
        return Token::KeyValue(captures[1].to_string(), captures[2].to_string());
    }

    Token::Ignore
}

fn parse_tokens(tokens: Vec<Token>) -> AST {
    let mut acc: Vec<(String, Vec<KeyValue>)> = Vec::new();
    for token in tokens {
        match token {
            Token::Ignore => {
                continue;
            }
            Token::Section(name) => {
                acc.push((name, Vec::new()));
            }
            Token::KeyValue(key, value) => {
                if let Some(inner) = acc.last_mut() {
                    let (_, ref mut key_values) = inner;
                    key_values.push(KeyValue { key, value })
                }
            }
        }
    }

    acc
}