pkgs-cli 0.2.0

A simple cli tool to manage packages.
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

use std::fmt::{self, Formatter};
use std::marker::PhantomData;

use serde::de::{MapAccess, Visitor};
use serde::{Deserialize, Deserializer};

pub fn deserialize_map_as_vec<'de, D, K, V>(deserializer: D) -> Result<Vec<(K, V)>, D::Error>
where
    D: Deserializer<'de>,
    K: Deserialize<'de>,
    V: Deserialize<'de>,
{
    struct MapAsVecVisitor<K, V> {
        marker: PhantomData<Vec<(K, V)>>,
    }

    impl<'de, K, V> Visitor<'de> for MapAsVecVisitor<K, V>
    where
        K: Deserialize<'de>,
        V: Deserialize<'de>,
    {
        type Value = Vec<(K, V)>;

        fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
            formatter.write_str("a map to be deserialized as a vector of key-value pairs")
        }

        fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
        where
            M: MapAccess<'de>,
        {
            let mut vec = Vec::with_capacity(access.size_hint().unwrap_or(0));
            while let Some((key, value)) = access.next_entry()? {
                vec.push((key, value));
            }
            Ok(vec)
        }
    }

    deserializer.deserialize_map(MapAsVecVisitor {
        marker: PhantomData,
    })
}

#[cfg(test)]
mod tests {
    use indoc::indoc;

    use super::*;
    use crate::test_utils::prelude::*;

    #[derive(Debug, Deserialize)]
    struct My {
        #[serde(deserialize_with = "deserialize_map_as_vec")]
        items: Vec<(String, i32)>,
    }

    #[gtest]
    fn parse_toml() -> Result<()> {
        let toml = indoc! {r#"
            [items]
            a = 1
            d = 4
            g = -1
            b = 2
            c = 3
        "#};

        let my: My = toml::from_str(toml)?;

        expect_eq!(
            my.items,
            [
                ("a".into(), 1),
                ("d".into(), 4),
                ("g".into(), -1),
                ("b".into(), 2),
                ("c".into(), 3),
            ]
        );

        Ok(())
    }

    #[gtest]
    fn parse_yaml() -> Result<()> {
        let yaml = indoc! {r#"
            items:
              a: 1
              d: 4
              g: -1
              b: 2
              c: 3
        "#};

        let my: My = serde_yaml_ng::from_str(yaml)?;

        expect_eq!(
            my.items,
            [
                ("a".into(), 1),
                ("d".into(), 4),
                ("g".into(), -1),
                ("b".into(), 2),
                ("c".into(), 3),
            ]
        );

        Ok(())
    }
}