hglib-rs 0.1.1

Rust implementation of python-hglib
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

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at http://mozilla.org/MPL/2.0/.

use std::collections::HashMap;

use crate::client::{Client, HglibError, Runner};
use crate::runcommand;

pub struct Arg<'a> {
    pub name: &'a str,
}

impl<'a> Default for Arg<'a> {
    fn default() -> Self {
        Self { name: "" }
    }
}

impl<'a> Arg<'a> {
    fn run(&self, client: &mut Client) -> Result<(Vec<u8>, i32), HglibError> {
        runcommand!(client, "paths", &[self.name])
    }
}

#[derive(Debug)]
pub enum Paths {
    Map(HashMap<String, String>),
    Value(String),
}

impl Client {
    pub fn paths(&mut self, x: Arg) -> Result<Paths, HglibError> {
        let (data, _) = x.run(self)?;
        if x.name.is_empty() {
            let mut map = HashMap::new();
            for line in data.split(|c| *c == b'\n') {
                if let Some(eq_pos) = line.iter().position(|c| *c == b' ') {
                    if let Some(two) = line.get(eq_pos + 1..eq_pos + 3) {
                        if two == b"= " {
                            map.insert(
                                String::from_utf8(unsafe {
                                    line.get_unchecked(..eq_pos).to_vec()
                                })?,
                                String::from_utf8(unsafe {
                                    line.get_unchecked(eq_pos + 3..).to_vec()
                                })?,
                            );
                        }
                    }
                }
            }
            Ok(Paths::Map(map))
        } else {
            Ok(Paths::Value(String::from_utf8({
                let pos = data
                    .iter()
                    .rposition(|x| *x != b' ' && *x != b'\n')
                    .map_or(data.len(), |p| p + 1);
                data[..pos].to_vec()
            })?))
        }
    }
}