mercur 0.1.5

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

use std::path::Path;

use anyhow::anyhow;
use tokio::{
    fs::{self, File},
    io::AsyncWriteExt,
};

// compiles the registry
mod authority;
mod bloom;
mod compile_registry;
mod hash;
mod metadata;
mod model;
mod namespace;
mod optimize;
mod package;
mod package_index;
mod parse;
mod version;

pub use version::SemVersion;

use crate::registry::schema::registry::root_as_registry;

pub async fn proj2fb(proj_path: &Path, out_path: &Path) -> anyhow::Result<()> {
    if !proj_path.is_dir() {
        return Err(anyhow!("Path is not a directory"));
    }

    let binding = proj_path.join("authorities");
    let authority_dir = binding.as_path();
    let binding = proj_path.join("namespaces");
    let namespace_dir = binding.as_path();
    let binding = proj_path.join("pkgs");
    let pkg_dir = binding.as_path();

    let mut authority_files = vec![];
    if authority_dir.exists() {
        for i in authority_dir.read_dir()? {
            authority_files.push(i?.path())
        }
    }
    let mut namespace_files = vec![];
    if namespace_dir.exists() {
        for i in namespace_dir.read_dir()? {
            namespace_files.push(i?.path())
        }
    }

    let mut pkg_files = vec![];
    if pkg_dir.exists() {
        for i in pkg_dir.read_dir()? {
            pkg_files.push(i?.path())
        }
    }
    let authority_files: Vec<&Path> = authority_files.iter().map(|x| x.as_path()).collect();
    let namespace_files: Vec<&Path> = namespace_files.iter().map(|x| x.as_path()).collect();
    let pkg_files: Vec<&Path> = pkg_files.iter().map(|x| x.as_path()).collect();

    let binding = parse::parse_authority_toml_files(authority_files).await?;
    let authorities_parsed: Vec<&parse::AuthorityDefinition> = binding.iter().collect();

    let binding = parse::parse_namespace_toml_files(namespace_files).await?;
    let namespaces_parsed: Vec<&parse::NamespaceDefinition> = binding.iter().collect();

    let binding = parse::parse_pkg_toml_files(pkg_files).await?;
    let pkgs_parsed: Vec<&parse::PkgDefinition> = binding.iter().collect();

    let registry =
        compile_registry::compile_registry(authorities_parsed, namespaces_parsed, pkgs_parsed);

    let _ = fs::create_dir_all(out_path).await;

    File::create(out_path.join("registry.mreg"))
        .await?
        .write_buf(&mut registry.as_slice())
        .await?;

    Ok(())
}