rkit 0.1.8

Rust CLI Toolkit for Git Repo Management
Documentation 
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

use crate::error::{RkitError, RkitResult};
use serde::{Deserialize, Serialize};
use std::fs;
use std::path::PathBuf;

#[derive(Debug, Serialize, Deserialize)]
pub struct RViewCmd {
    pub command: String,
    pub label: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Config {
    pub project_root: String,
    pub rview: Option<Vec<RViewCmd>>,
}

impl Config {
    fn get_default_config() -> RkitResult<Config> {
        let default_config_path = if cfg!(windows) {
            "etc/default_config_windows.yaml"
        } else {
            "etc/default_config_linux.yaml"
        };

        let config_str =
            fs::read_to_string(default_config_path).map_err(|e| RkitError::FileReadError {
                path: PathBuf::from(default_config_path),
                source: e,
            })?;

        let config: Config = serde_yaml::from_str(&config_str)?;
        Ok(config)
    }

    pub fn load_or_create() -> RkitResult<Self> {
        // Use platform-specific config directory
        let config_dir = if cfg!(windows) {
            // On Windows, use %APPDATA%\rkit
            dirs::config_dir()
                .ok_or_else(|| {
                    RkitError::ConfigError("Could not find config directory".to_string())
                })?
                .join("rkit")
        } else {
            // On Unix-like systems, use ~/.config/rkit
            PathBuf::from(shellexpand::tilde("~/.config/rkit").as_ref())
        };

        fs::create_dir_all(&config_dir).map_err(|e| RkitError::DirectoryCreationError {
            path: config_dir.clone(),
            source: e,
        })?;

        let config_path = config_dir.join("config.yaml");

        if !config_path.exists() {
            let default_config = Self::get_default_config()?;
            let yaml = serde_yaml::to_string(&default_config)?;
            fs::write(&config_path, yaml).map_err(|e| RkitError::FileWriteError {
                path: config_path.clone(),
                source: e,
            })?;
        }

        let config_str =
            fs::read_to_string(&config_path).map_err(|e| RkitError::FileReadError {
                path: config_path,
                source: e,
            })?;
        let config: Config = serde_yaml::from_str(&config_str)?;

        Ok(config)
    }

    pub fn expand_project_root(&self) -> RkitResult<PathBuf> {
        let expanded = if cfg!(windows) {
            // On Windows, expand %USERPROFILE% environment variable
            std::env::var("USERPROFILE")
                .map_err(|_| RkitError::EnvVarError("USERPROFILE".to_string()))?
                + &self.project_root.replace("%USERPROFILE%", "")
        } else {
            // On Unix-like systems, expand ~
            shellexpand::tilde(&self.project_root).to_string()
        };
        Ok(PathBuf::from(expanded))
    }
}