rvy 0.1.2

A modular Rust CLI framework for generating services, tools, and project scaffolds.
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

use std::fs;
use std::path::Path;

use crate::context::Context;

pub mod service;
pub mod usecase;
pub mod repository;
pub mod data;
pub mod adapter;
pub mod handler;
pub mod project;
pub mod dispatch;


pub fn render(template: &str, name: &str) -> String {
    let pascal = to_pascal_case(name);
    let snake = to_snake_case(name);

    template
        .replace("{{package_name}}", name)  // For Cargo.toml (allows hyphens)
        .replace("{{name}}", &snake)        // For Rust code (underscores only)
        .replace("{{Name}}", &pascal)       // PascalCase
}

pub fn to_snake_case(s: &str) -> String {
    s.replace('-', "_")
}

pub fn to_pascal_case(s: &str) -> String {
    s.split(|c| c == '_' || c == '-')
        .map(|p| {
            let mut c = p.chars();
            match c.next() {
                None => String::new(),
                Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
            }
        })
        .collect()
}

pub fn write_file(ctx: &Context, path: &str, content: &str) {
    let path = Path::new(path);

    if path.exists() && !ctx.force {
        println!(
            "Skip {} (already exists, use --force to overwrite)",
            path.display()
        );
        return;
    }

    if ctx.dry_run {
        println!("[DRY RUN] Would write {}", path.display());
        return;
    }

    if let Some(parent) = path.parent() {
        fs::create_dir_all(parent).unwrap();
    }

    fs::write(path, content).unwrap();
    println!("Created {}", path.display());
}

pub fn update_module_exports(ctx: &Context, mod_path: &str, module_name: &str) {
    if ctx.dry_run {
        return;
    }
    
    let path = Path::new(mod_path);
    let current_content = fs::read_to_string(path).unwrap_or_else(|_| String::new());
    
    let export_line = format!("pub mod {};", module_name);
    if current_content.contains(&export_line) {
        return;
    }
    
    let new_content = if current_content.contains("// Add your modules here") {
        current_content.replace(
            "// Add your modules here",
            &format!("pub mod {};\n// Add your modules here", module_name)
        )
    } else {
        format!("{}\npub mod {};\n", current_content.trim(), module_name)
    };
    
    fs::write(path, new_content).unwrap();
}