generate-readme 0.1.2

A command-line utlity to help you generate README.md files.
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

use crate::ui;
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Debug)]
struct Config {
    email: String,
    github_username: String,
}

pub fn load_user_config() {
    match dirs::config_dir() {
        Some(config_dir) => {
            let app_config_dir = config_dir.join("generate-readme");
            std::fs::create_dir_all(&app_config_dir).expect("Failed to create config directory");

            let config_file_path = app_config_dir.join("config.toml");

            if !config_file_path.exists() {
                println!("Config file does not exist. Creating one...");

                let config = Config {
                    email: "user@example.com".to_string(),
                    github_username: "username".to_string(),
                };

                let toml = toml::to_string(&config).unwrap();

                if let Some(edited) = ui::editor(&toml) {
                    println!("Edited: {:?}", edited);

                    // match std::fs::write(&config_file_path, &toml) {
                    //     Ok(_) => println!("Config file created successfully"),
                    //     Err(err) => println!("Error creating config file: {}", err),
                    // }
                } else {
                    println!("No changes made to config file");
                }

                match std::fs::write(&config_file_path, &toml) {
                    Ok(_) => println!("Config file created successfully"),
                    Err(err) => eprintln!("Error creating config file: {}", err),
                }
            } else {
                let contents = match std::fs::read_to_string(&config_file_path) {
                    Ok(contents) => contents,
                    Err(err) => {
                        eprintln!("Error reading config file: {}", err);
                        return;
                    }
                };

                let config: Config = match toml::from_str(&contents) {
                    Ok(config) => config,
                    Err(err) => {
                        eprintln!("Error parsing config file: {}", err);
                        return;
                    }
                };

                println!("Config loaded successfully: {:?}", config);
            }
        }
        None => println!("Failed to load config directory"),
    }
}

pub fn read_global_git_info(arg: &str) -> Option<String> {
    let cmd = std::process::Command::new("git")
        .arg("config")
        .arg("--global")
        .arg("--get")
        .arg(arg)
        .output()
        .ok()?;

    match cmd.status.success() {
        true => Option::from(String::from_utf8_lossy(&cmd.stdout).to_string()),
        false => Option::from(None),
    }
}

pub fn read_local_git_info(arg: &str) -> Option<String> {
    let cmd = std::process::Command::new("git")
        .arg("config")
        .arg("--get")
        .arg(arg)
        .output()
        .ok()?;

    match cmd.status.success() {
        true => Option::from(String::from_utf8_lossy(&cmd.stdout).to_string()),
        false => Option::from(None),
    }
}