mercur 0.1.2

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

use std::{io::Write, path::Path};

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

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

// compiles the registry
mod compile_registry;
mod parse;

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().unwrap() {
            authority_files.push(i.unwrap().path())
        }
    }
    let mut namespace_files = vec![];
    if namespace_dir.exists() {
        for i in namespace_dir.read_dir().unwrap() {
            namespace_files.push(i.unwrap().path())
        }
    }

    let mut pkg_files = vec![];
    if pkg_dir.exists() {
        for i in pkg_dir.read_dir().unwrap() {
            pkg_files.push(i.unwrap().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);
    let binding = binding.await;
    let authorities_parsed: Vec<&parse::AuthorityDefinition> = binding.iter().map(|x| x).collect();

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

    let binding = parse::parse_pkg_toml_files(pkg_files);
    let binding = binding.await;
    let pkgs_parsed: Vec<&parse::PkgDefinition> = binding.iter().map(|x| x).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.unwrap().write_buf(&mut registry.as_slice()).await.unwrap();

    return Ok(())
}