beru-cli 0.3.0

Beru 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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use anyhow::{Context, Result};
use clap::Args;
use console::style;

/// Arguments for `beru init`.
#[derive(Debug, Args)]
pub struct InitArgs {
    /// Project type
    #[arg(long, default_value = "executable", value_parser = ["executable", "library", "header-only"])]
    pub r#type: String,

    /// C++ standard to use
    #[arg(long, default_value = "c++17")]
    pub cxx_std: String,
}

pub fn exec(args: InitArgs) -> Result<()> {
    let cwd = std::env::current_dir().context("failed to get current directory")?;
    let raw_name = cwd
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or("my-project");

    // Sanitize into a valid Beru package name:
    // lowercase, replace underscores/spaces with hyphens, strip invalid chars
    let name: String = raw_name
        .to_lowercase()
        .chars()
        .map(|c| match c {
            '_' | ' ' => '-',
            c if c.is_ascii_alphanumeric() || c == '-' => c,
            _ => '-',
        })
        .collect();

    // Ensure the name starts with a letter and is at least 2 chars
    let name = if name.is_empty()
        || !name.chars().next().unwrap_or('0').is_ascii_lowercase()
        || name.len() < 2
    {
        "my-project".to_string()
    } else {
        name
    };

    if cwd.join("Beru.toml").exists() {
        println!(
            "{} Beru.toml already exists in this directory.",
            style("Warning:").yellow().bold()
        );
        return Ok(());
    }

    println!(
        "{} Beru in existing directory ({})",
        style("Initializing").green().bold(),
        name,
    );

    // Create directories if they don't exist
    let _ = std::fs::create_dir_all(cwd.join("src"));
    let _ = std::fs::create_dir_all(cwd.join("tests"));

    if args.r#type == "library" || args.r#type == "header-only" {
        let _ = std::fs::create_dir_all(cwd.join("include").join(&name));
    }

    // Write Beru.toml
    let manifest = super::new::generate_manifest(&name, &args.r#type, &args.cxx_std);
    std::fs::write(cwd.join("Beru.toml"), manifest).context("failed to write Beru.toml")?;

    // Write CMakeLists.txt if it doesn't exist
    if !cwd.join("CMakeLists.txt").exists() {
        let cmake = super::new::generate_cmakelists(&name, &args.r#type);
        let _ = std::fs::write(cwd.join("CMakeLists.txt"), cmake);
    }

    // Write source files if they don't exist
    match args.r#type.as_str() {
        "executable" => {
            let main_path = cwd.join("src").join("main.cpp");
            if !main_path.exists() {
                let _ = std::fs::write(main_path, super::new::EXECUTABLE_MAIN);
            }
        }
        "library" => {
            let header_path = cwd
                .join("include")
                .join(&name)
                .join(format!("{}.hpp", name));
            if !header_path.exists() {
                let header = super::new::library_header(&name);
                let _ = std::fs::write(header_path, header);
            }
            let source_path = cwd.join("src").join(format!("{}.cpp", name));
            if !source_path.exists() {
                let source = super::new::library_source(&name);
                let _ = std::fs::write(source_path, source);
            }
        }
        "header-only" => {
            let header_path = cwd
                .join("include")
                .join(&name)
                .join(format!("{}.hpp", name));
            if !header_path.exists() {
                let header = super::new::header_only_lib(&name);
                let _ = std::fs::write(header_path, header);
            }
        }
        _ => {}
    }

    let gitignore_path = cwd.join(".gitignore");
    if !gitignore_path.exists() {
        let _ = std::fs::write(gitignore_path, super::new::GITIGNORE);
    }

    let test_path = cwd.join("tests").join("test_main.cpp");
    if !test_path.exists() {
        let test = super::new::generate_test(&name, &args.r#type);
        let _ = std::fs::write(test_path, test);
    }

    println!(
        "{} Beru project created. Run `beru build` to build your project.",
        style("Done:").green().bold()
    );

    Ok(())
}