mercur 0.1.6

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

use flatbuffers::FlatBufferBuilder;

use crate::registry::compile::{
    authority::compile_authority,
    bloom::{build_bloom, compile_bloom},
    metadata::compile_metadata,
    package::compile_pkg_registry_entry,
    package_index::compile_package_index,
    parse::{
        AuthorityDefinition as AuthorityTomlDefinition,
        NamespaceDefinition as NamespaceTomlDefinition, PkgDefinition as PkgTomlDefinition,
    },
};

use crate::registry::schema::registry::{Registry, RegistryArgs};

pub fn compile_registry(
    authorities: Vec<&AuthorityTomlDefinition>,
    _namespaces: Vec<&NamespaceTomlDefinition>,
    pkgs: Vec<&PkgTomlDefinition>,
) -> Vec<u8> {
    let mut builder = FlatBufferBuilder::new();

    //
    // Metadata
    //

    let metadata = compile_metadata(&mut builder);

    //
    // Bloom filter
    //

    let bloom_runtime = build_bloom(&pkgs);
    let mut bloom = None;
    if let Some(bloom_runtime) = bloom_runtime {
        bloom = Some(compile_bloom(&mut builder, bloom_runtime));
    }

    //
    // Package index
    //

    let package_index = compile_package_index(&mut builder, &pkgs);

    //
    // Authorities
    //

    let authority_offsets = authorities
        .iter()
        .map(|a| compile_authority(&mut builder, a))
        .collect::<Vec<_>>();

    let authorities = builder.create_vector(&authority_offsets);

    //
    // Packages
    //

    let package_offsets = pkgs
        .iter()
        .map(|p| compile_pkg_registry_entry(&mut builder, p))
        .collect::<Vec<_>>();

    let packages = builder.create_vector(&package_offsets);

    let root = Registry::create(
        &mut builder,
        &RegistryArgs {
            metadata: Some(metadata),

            bloom: bloom,

            package_index: Some(package_index),

            namespace_routes: None,

            authorities: Some(authorities),

            packages: Some(packages),
        },
    );

    builder.finish(root, None);

    builder.finished_data().to_vec()
}