ferrisup 0.2.5

A versatile Rust project bootstrapping tool - start anywhere, scale anywhere
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

// Configuration management for FerrisUp
use serde::{Deserialize, Serialize};
use std::fs;
use std::path::{Path, PathBuf};

use super::error::{Error, Result};

/// Configuration for FerrisUp
#[derive(Debug, Serialize, Deserialize)]
pub struct Config {
    /// Path to templates directory
    pub templates_dir: PathBuf,
    /// User preferences
    pub preferences: Preferences,
}

/// User preferences for FerrisUp
#[derive(Debug, Serialize, Deserialize)]
pub struct Preferences {
    /// Whether to initialize git repositories for new projects
    #[serde(default = "default_git")]
    pub git: bool,
    /// Whether to build projects after creation
    #[serde(default = "default_build")]
    pub build: bool,
    /// Whether to use interactive mode
    #[serde(default = "default_interactive")]
    pub interactive: bool,
}

fn default_git() -> bool {
    true
}

fn default_build() -> bool {
    false
}

fn default_interactive() -> bool {
    true
}

impl Default for Config {
    fn default() -> Self {
        let mut templates_dir = dirs::home_dir()
            .expect("Failed to get home directory")
            .join(".ferrisup")
            .join("templates");

        // If running from a development environment, use the local templates directory
        if Path::new("templates").exists() {
            templates_dir = PathBuf::from("templates");
        }

        Self {
            templates_dir,
            preferences: Preferences::default(),
        }
    }
}

impl Default for Preferences {
    fn default() -> Self {
        Self {
            git: default_git(),
            build: default_build(),
            interactive: default_interactive(),
        }
    }
}

impl Config {
    /// Load configuration from a file
    pub fn load(path: &Path) -> Result<Self> {
        let content = fs::read_to_string(path).map_err(|e| Error::Config(format!("Failed to read config file: {}", e)))?;
        let config: Config = serde_json::from_str(&content).map_err(|e| Error::Config(format!("Invalid config format: {}", e)))?;
        Ok(config)
    }

    /// Save configuration to a file
    pub fn save(&self, path: &Path) -> Result<()> {
        let content = serde_json::to_string_pretty(self).map_err(|e| Error::Config(format!("Failed to serialize config: {}", e)))?;
        fs::write(path, content).map_err(|e| Error::Config(format!("Failed to write config file: {}", e)))?;
        Ok(())
    }

    /// Get the default configuration path
    pub fn default_path() -> PathBuf {
        dirs::config_dir()
            .expect("Failed to get config directory")
            .join("ferrisup")
            .join("config.json")
    }
    
    /// Get the config path to use for operations
    pub fn get_config_path() -> PathBuf {
        // First check if there's a local config file
        let local_config = Path::new("ferrisup.json");
        if local_config.exists() {
            return local_config.to_path_buf();
        }
        
        // Then check the default config path
        Self::default_path()
    }
    
    /// Get the default configuration
    pub fn get_default_config() -> Self {
        Self::default()
    }
}