microcad 0.2.9

µcad Command Line Interface
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

// Copyright © 2025 The µcad authors <info@ucad.xyz>
// SPDX-License-Identifier: AGPL-3.0-or-later

//! µcad CLI build script.

use anyhow::{Context, Result};

use std::{env, fs};
use walkdir::WalkDir;

/// Generate Rust HashMap that contain the standard library.
fn generate_builtin_std_library() -> Result<()> {
    use std::path::PathBuf;
    let manifest_dir = env::var("CARGO_MANIFEST_DIR")
        .map(PathBuf::from)
        .expect("Manifest dir");

    let std_dir = env::var("MICROCAD_STD_DIR")
        .map(PathBuf::from)
        .unwrap_or_else(|_| manifest_dir.join("../../lib/std"));

    let dest_path = env::var("OUT_DIR")
        .map(PathBuf::from)
        .expect("Output dir")
        .join("microcad_std.rs");

    // Collect all .µcad sources recursively
    let sources = WalkDir::new(&std_dir)
        .into_iter()
        .filter_map(|e| e.ok())
        .filter(|e| e.path().extension().is_some_and(|ext| ext == "µcad"))
        .map(|entry| {
            let path = entry.path();
            let rel_path = path
                .strip_prefix(&std_dir)
                .expect("Some prefix")
                .to_path_buf();
            let content = fs::read_to_string(path).expect("Unable to read file");
            (rel_path, content)
        })
        .collect::<Vec<_>>();

    assert!(
        !sources.is_empty(),
        "{std_dir:?} does not contain a µcad std library!"
    );

    // Generate the Rust code
    let mut code = String::new();
    code.push_str(
        "
        mod microcad_std {

        use std::path::PathBuf;
        use std::collections::HashMap;

        lazy_static::lazy_static! {
            pub static ref FILES: HashMap<PathBuf, String> = {
                let mut m = HashMap::new();
    ",
    );

    for (path, content) in sources {
        let path_str = path.to_string_lossy();
        code.push_str(&format!(
            "        m.insert(PathBuf::from(r#\"{path_str}\"#), r#\"{content}\"#.to_string());\n"
        ));
    }

    code.push_str(
        "
                m
            };
        }
    }
    ",
    );
    // reformat code and write into file
    match rustfmt_wrapper::rustfmt(code) {
        Ok(code) =>
        // write all rust code at once
        {
            fs::write(&dest_path, code).context(format!("cannot create file '{dest_path:?}'"))?;
            println!(
                "cargo:rerun-if-changed={std_dir}",
                std_dir = std_dir.display()
            );
            Ok(())
        }
        Err(rustfmt_wrapper::Error::Rustfmt(msg)) => {
            Err(anyhow::Error::msg(msg.clone())).context(msg)
        }
        Err(err) => Err(anyhow::Error::new(err)),
    }
}

fn main() {
    generate_builtin_std_library().expect("No error");
}