cnctd_cli 0.3.0

CLI for scaffolding and managing projects
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
132
133
134
135
136
137
138
139
140
141
142
143
144

extern crate walkdir;
extern crate toml;
extern crate serde_json;
extern crate regex;


use walkdir::{WalkDir, DirEntry};

use std::fs::File;
use std::io::Read;
use toml::Value as TomlValue;
use serde_json::Value as JsonValue;
use regex::Regex;

pub fn print_project_versions(root_path: &str) -> std::io::Result<()> {
    for entry in WalkDir::new(root_path)
        .into_iter()
        .filter_entry(|e| !is_ignored(e))
    {
        let entry = entry?;
        let path = entry.path();
        let file_name = path.file_name().unwrap_or_default();

        if path.is_file() {
            match file_name.to_str().unwrap() {
                // For Rust
                "Cargo.toml" => {
                    let mut file = File::open(path)?;
                    let mut contents = String::new();
                    file.read_to_string(&mut contents)?;
                    let toml: TomlValue = contents.parse().unwrap();
                    if let Some(package) = toml.get("package") {
                        if let Some(name) = package.get("name").and_then(TomlValue::as_str) {
                            if let Some(version) = package.get("version").and_then(TomlValue::as_str) {
                                println!("Rust Project: {}, Version: {}", name, version);
                            }
                        }
                    }
                },
                // For npm
                "package.json" => {
                    let mut file = File::open(path)?;
                    let mut contents = String::new();
                    file.read_to_string(&mut contents)?;
                    let json: JsonValue = serde_json::from_str(&contents).unwrap();
                    if let Some(name) = json["name"].as_str() {
                        if let Some(version) = json["version"].as_str() {
                            println!("NPM Project: {}, Version: {}", name, version);
                        }
                    }
                },
                // For Go
                "go.mod" => {
                    let mut file = File::open(path)?;
                    let mut contents = String::new();
                    file.read_to_string(&mut contents)?;
                    let re = Regex::new(r"module\s+(?P<name>\S+)\s+go\s+(?P<version>\S+)").unwrap();
                    if let Some(caps) = re.captures(&contents) {
                        let name = &caps["name"];
                        let version = &caps["version"];
                        println!("Go Project: {}, Version: {}", name, version);
                    }
                },
                // For iOS
                file_name if file_name.ends_with(".xcodeproj") || file_name.ends_with(".xcworkspace") => {
                    println!("iOS Project: Located at {}", path.display());
                },
                // For Android
                "build.gradle" => {
                    let mut file = File::open(path)?;
                    let mut contents = String::new();
                    file.read_to_string(&mut contents)?;
                    let re = Regex::new(r#"applicationId\s+['"](?P<name>[^"]+)['"]"#).unwrap();
                    if let Some(caps) = re.captures(&contents) {
                        let name = &caps["name"];
                        println!("Android Project: {}, Located at {}", name, path.display());
                    }
                },
                _ => {}
            }
        }
    }
    Ok(())
}

// pub fn update_rust_project_versions(root_path: &str) -> std::io::Result<()> {
    // let mut project_versions: HashMap<String, String> = HashMap::new();
    
    // for entry in WalkDir::new(root_path)
    //     .into_iter()
    //     .filter_entry(|e| !is_ignored(e))
    // {
    //     let entry = entry?;
    //     let path = entry.path();
    //     let file_name = path.file_name().unwrap_or_default();

    //     if path.is_file() && file_name.to_str().unwrap() == "Cargo.toml" {
    //         let contents = std::fs::read_to_string(path)?;
    //         let toml: TomlValue = contents.parse().unwrap();
            
    //         if let Some(package) = toml.get("package") {
    //             if let Some(name) = package.get("name").and_then(TomlValue::as_str) {
    //                 if let Some(version) = package.get("version").and_then(TomlValue::as_str) {
    //                     project_versions.insert(name.to_string(), version.to_string());
    //                 }
    //             }
    //         }
    //     }
    // }

    // for entry in WalkDir::new(root_path)
    //     .into_iter()
    //     .filter_entry(|e| !is_ignored(e))
    // {
    //     let entry = entry?;
    //     let path = entry.path();
    //     let file_name = path.file_name().unwrap_or_default();

    //     if path.is_file() && file_name.to_str().unwrap() == "Cargo.toml" {
    //         let mut contents = std::fs::read_to_string(path)?;
    //         let mut doc = contents.parse::<Document>().unwrap();

    //         if let Some(table) = doc.as_table_mut().entry("dependencies").as_table_mut() {
    //             for (name, version) in project_versions.iter() {
    //                 if let Some(dep) = table.get(name) {
    //                     if let Item::Table(dep_table) = dep {
    //                         if dep_table.contains_key("version") && dep_table.contains_key("path") {
    //                             dep_table.get_mut("version").unwrap().as_value_mut().unwrap().as_str_mut().unwrap().replace_range(.., version);
    //                         }
    //                     }
    //                 }
    //             }
    //         }

    //         std::fs::write(path, doc.to_string_in_original_order())?;
    //     }
    // }

    // Ok(())
// }

fn is_ignored(entry: &DirEntry) -> bool {
    entry.file_name().to_str().map(|s| s == "target" || s == "node_modules").unwrap_or(false)
}