mercur 0.1.4

mercur - junolang 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

use xxhash_rust::xxh3::xxh3_64;

/// Computes the runtime ID used by Mercur.
///
/// This ID is stored inside the registry and used for
/// fast lookups.
///
/// NOTE:
/// XXH3 is NOT used for security.
/// It is only used as a fast lookup key.
#[inline]
pub fn runtime_id(s: &str) -> u64 {
    xxh3_64(s.as_bytes())
}

/// Hash of an authority.
///
/// Example:
///
/// "mercur"
/// "core"
#[inline]
pub fn authority_id(authority: &str) -> u64 {
    runtime_id(authority)
}

/// Hash of a package.
///
/// Example:
///
/// "http"
/// "serde"
#[inline]
pub fn package_id(package: &str) -> u64 {
    runtime_id(package)
}

/// Hash of a namespace.

#[inline]
pub fn namespace_id(namespace: &str) -> u64 {
    runtime_id(&normalize_namespace(namespace))
}

/// Converts
///
/// //////foo///bar///
///
/// into
///
/// /foo/bar
pub fn normalize_namespace(namespace: &str) -> String {
    if namespace.is_empty() {
        return "/".to_string();
    }

    let mut out = String::with_capacity(namespace.len());

    out.push('/');

    let mut first = true;

    for part in namespace.split('/') {
        if part.is_empty() {
            continue;
        }

        if !first {
            out.push('/');
        }

        out.push_str(part);

        first = false;
    }

    out
}

use crate::registry::schema::registry::Hash;

/// Parses a SHA-256 hex string into the FlatBuffers Hash struct.
///
/// Input:
///
/// 5514287c8e82766136b3239df81be8e0...
///
/// Output:
///
/// Hash {
///     a,
///     b,
///     c,
///     d,
/// }
pub fn parse_hash(hash: &str) -> Hash {
    let mut parts = [0u64; 4];

    for (i, chunk) in hash.trim().as_bytes().chunks(16).take(4).enumerate() {
        let s = std::str::from_utf8(chunk).unwrap_or("0");

        parts[i] = u64::from_str_radix(s, 16).unwrap_or(0);
    }

    Hash::new(parts[0], parts[1], parts[2], parts[3])
}