posy 0.0.1

[wip] Python installer and package manager
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

use crate::prelude::*;

#[derive(Debug, Clone, DeserializeFromStr, Derivative)]
#[derivative(Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct PackageName {
    #[derivative(Hash = "ignore", PartialEq = "ignore", PartialOrd = "ignore")]
    as_given: String,
    normalized: String,
}

impl PackageName {
    pub fn as_given(&self) -> &str {
        &self.as_given
    }

    pub fn normalized(&self) -> &str {
        &self.normalized
    }
}

impl TryFrom<&str> for PackageName {
    type Error = eyre::Report;

    fn try_from(as_given: &str) -> Result<Self, Self::Error> {
        // https://packaging.python.org/specifications/core-metadata/#name
        static NAME_VALIDATE: Lazy<Regex> = Lazy::new(|| {
            Regex::new(r"(?i-u)^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$").unwrap()
        });
        // https://www.python.org/dev/peps/pep-0503/#normalized-names
        static NAME_NORMALIZE: Lazy<Regex> =
            Lazy::new(|| Regex::new(r"[-_.]").unwrap());

        if !NAME_VALIDATE.is_match(as_given) {
            return Err(eyre!("Invalid package name {:?}", as_given));
        }
        let as_given = as_given.to_owned();

        let mut normalized = NAME_NORMALIZE.replace_all(&as_given, "-").to_string();
        normalized.make_ascii_lowercase();

        Ok(PackageName {
            as_given,
            normalized,
        })
    }
}

try_from_str_boilerplate!(PackageName);

impl Serialize for PackageName {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_given())
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_packagename_basics() {
        let name1: PackageName = "Foo-Bar-Baz".try_into().unwrap();
        assert_eq!(name1.as_given(), "Foo-Bar-Baz");
        assert_eq!(name1.normalized(), "foo-bar-baz");

        let name2: PackageName = "foo_bar.baz".try_into().unwrap();
        assert_eq!(name2.as_given(), "foo_bar.baz");
        assert_eq!(name2.normalized(), "foo-bar-baz");

        assert_eq!(name1, name2);

        let name3: PackageName = "foo-barbaz".try_into().unwrap();
        assert_ne!(name1, name3);
    }

    #[test]
    fn test_packagename_validation() {
        let name: Result<PackageName> = "foobar baz".try_into();
        assert!(name.is_err());

        let name: Result<PackageName> = "foobarbaz!".parse();
        assert!(name.is_err());
    }

    #[test]
    fn test_packagename_serde() {
        let direct: PackageName = "foo-bar_baz".try_into().unwrap();
        let via_serde: Vec<PackageName> =
            serde_json::from_str(r#"["foo_bar.baz"]"#).unwrap();
        assert_eq!(via_serde[0], direct);
        assert_eq!(via_serde[0].as_given(), "foo_bar.baz");
        assert_eq!(via_serde[0].normalized(), "foo-bar-baz");

        let bad: serde_json::Result<PackageName> =
            serde_json::from_str(r#" "foo bar" "#);
        assert!(bad.is_err());
    }

    #[test]
    fn test_packagename_hash() {
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};

        fn calculate_hash<T: Hash>(t: &T) -> u64 {
            let mut s = DefaultHasher::new();
            t.hash(&mut s);
            s.finish()
        }

        let name1: PackageName = "foo_bar".try_into().unwrap();
        let name2: PackageName = "foo.bar".try_into().unwrap();

        let name_other: PackageName = "foobar".try_into().unwrap();

        assert_eq!(calculate_hash(&name1), calculate_hash(&name2));
        // Technically there's a very small chance of this failing due to an unlucky
        // collision, but it's 1/2**64 assuming we have a good hash function, and only
        // re-sampled when Rust changes their hash function. So I think we're safe.
        assert_ne!(calculate_hash(&name1), calculate_hash(&name_other));
    }
}