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

use flatbuffers::{FlatBufferBuilder, WIPOffset};

use crate::registry::compile::{
    hash::{package_id, parse_hash},
    parse::{PkgDefinition as PkgTomlDefinition, PkgVersion as PkgTomlVersion},
    version::{SemVersion, parse_date, sort_versions},
};

use crate::registry::schema::registry::{
    PkgRegistryEntry, PkgRegistryEntryArgs, RegistryRefType, Version, VersionArgs,
};

pub fn compile_pkg_registry_entry<'a>(
    builder: &mut FlatBufferBuilder<'a>,
    pkg: &PkgTomlDefinition,
) -> WIPOffset<PkgRegistryEntry<'a>> {
    let name = builder.create_string(&pkg.metadata.name);

    let reference = builder.create_string(&pkg.metadata.reference);

    let versions = pkg
        .versions
        .iter()
        .map(|v| compile_version(builder, v))
        .collect::<Vec<_>>();

    let versions = builder.create_vector(&versions);
    let authority = builder.create_string(&pkg.metadata.authority);
    // xxh3(authority#package)
    let mut key = Vec::with_capacity(pkg.metadata.authority.len() + pkg.metadata.name.len() + 1);

    key.extend_from_slice(pkg.metadata.authority.as_bytes());
    key.push(b'#');
    key.extend_from_slice(pkg.metadata.name.as_bytes());

    let id = xxh3_64(&key);
    PkgRegistryEntry::create(
        builder,
        &PkgRegistryEntryArgs {
            id,
            name: Some(name),
            authority: Some(authority),
            ref_type: RegistryRefType::NoRef,
            ref_: Some(reference),
            versions: Some(versions),
        },
    )
}

fn compile_version<'a>(
    builder: &mut FlatBufferBuilder<'a>,
    version: &PkgTomlVersion,
) -> WIPOffset<Version<'a>> {
    let semver = SemVersion::parse(&version.version);

    let tag = semver.tag.as_ref().map(|t| builder.create_string(t));

    let hash = parse_hash(&version.hash);

    Version::create(
        builder,
        &VersionArgs {
            major: semver.major,

            minor: semver.minor,

            patch: semver.patch,

            tag,

            hash: Some(&hash),

            date: parse_date(&version.date),
        },
    )
}

use xxhash_rust::xxh3::xxh3_64;