ui-cli 0.2.1

A CLI to add components to your app.
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

use std::io::Write;

use std::collections::HashSet;

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct MyComponent {
    pub name: String,
    pub registry_dependencies: Vec<String>,
    pub cargo_dependencies: Vec<String>,
    #[serde(rename = "type")]
    pub component_type: String,
    #[serde(rename = "parent_dir")]
    pub parent_dir: String,
}

#[derive(Debug)]
pub struct ResolvedComponent {
    pub component: MyComponent,
    pub resolved_registry_dependencies: HashSet<String>, // All dependencies including transitive ones
    pub resolved_cargo_dependencies: HashSet<String>, // All cargo dependencies including those from transitive dependencies
}

/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/*                     ✨ FUNCTIONS ✨                        */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

pub struct Components {}

impl Components {
    // TODO. Have instead all_resolved_parent_dirs instead of compomnents.
    pub fn create_components_mod_if_not_exists_with_pub_mods(user_config_path: String, parent_dirs: Vec<String>) {
        let components_mod_path = format!("{user_config_path}/mod.rs");

        // println!("Parent directories to add to components/mod.rs: {:?}", parent_dirs);

        // Create the directory if it doesn't exist
        let dir = std::path::Path::new(&components_mod_path)
            .parent()
            .expect("Failed to get parent directory");
        std::fs::create_dir_all(dir).expect("Failed to create directories");

        // Initialize mod_content
        let mut mod_content = String::new();

        // Check if the mod.rs file already exists
        if std::path::Path::new(&components_mod_path).exists() {
            mod_content = std::fs::read_to_string(&components_mod_path).expect("Failed to read mod.rs");
        }

        // Create or open the mod.rs file for writing
        let mut mod_rs_file = std::fs::OpenOptions::new()
            .append(true)
            .create(true)
            .open(components_mod_path)
            .expect("Failed to open mod.rs");

        // Add each parent directory as a module if it doesn't already exist
        for parent_dir in parent_dirs {
            if !mod_content.contains(&format!("pub mod {parent_dir};")) {
                writeln!(mod_rs_file, "pub mod {parent_dir};").expect("🔸 Failed to write to mod.rs");
            }
        }
    }

    pub fn register_components_in_application_entry(entry_file_path: &str) -> Result<(), Box<dyn std::error::Error>> {
        let file_content = std::fs::read_to_string(entry_file_path)?;

        const MOD_COMPONENTS: &str = "mod components;";

        if file_content.contains(MOD_COMPONENTS) {
            return Ok(());
        }
        let mod_components_import = format!("{MOD_COMPONENTS}\n{file_content}");
        std::fs::write(entry_file_path, mod_components_import.as_bytes())?;
        Ok(())
    }
}