solverforge-cli 1.1.2

CLI for scaffolding and managing SolverForge constraint solver 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

use std::path::PathBuf;

use crate::error::CliResult;

// Persistent preferences loaded from `.solverforgerc` in home dir or project root.
// Project root takes precedence over home directory.
#[derive(Debug, Default)]
pub struct RcConfig {
    // Default template name (e.g. "standard" or "list")
    pub default_template: Option<String>,
    // Default server port
    pub port: Option<u16>,
    // Disable colored output
    pub no_color: bool,
    // Suppress all output except errors
    pub quiet: bool,
}

impl RcConfig {
    // Returns true if no preferences were set.
    #[cfg(test)]
    pub fn is_empty(&self) -> bool {
        self.default_template.is_none() && self.port.is_none() && !self.no_color && !self.quiet
    }
}

// Locate the rc file to use: project root `.solverforgerc` takes precedence over `~/.solverforgerc`.
fn find_rc_path() -> Option<PathBuf> {
    let project_path = PathBuf::from(".solverforgerc");
    if project_path.exists() {
        return Some(project_path);
    }

    if let Some(home) = home_dir() {
        let home_path = home.join(".solverforgerc");
        if home_path.exists() {
            return Some(home_path);
        }
    }

    None
}

// Resolve the user home directory via the `HOME` environment variable.
fn home_dir() -> Option<PathBuf> {
    std::env::var_os("HOME").map(PathBuf::from)
}

// Load `RcConfig` from the first `.solverforgerc` found (project root or home dir).
// Returns a default `RcConfig` if no file is found or parsing fails silently.
pub fn load_rc() -> CliResult<RcConfig> {
    let Some(path) = find_rc_path() else {
        return Ok(RcConfig::default());
    };

    let contents = match std::fs::read_to_string(&path) {
        Ok(s) => s,
        Err(_) => return Ok(RcConfig::default()),
    };

    parse_rc(&contents)
}

fn parse_rc(contents: &str) -> CliResult<RcConfig> {
    let table: toml::Table = match toml::from_str(contents) {
        Ok(t) => t,
        Err(_) => return Ok(RcConfig::default()),
    };

    let mut cfg = RcConfig::default();

    if let Some(toml::Value::String(s)) = table.get("default_template") {
        cfg.default_template = Some(s.clone());
    }

    if let Some(toml::Value::Integer(n)) = table.get("port") {
        if *n > 0 && *n <= 65535 {
            cfg.port = Some(*n as u16);
        }
    }

    if let Some(toml::Value::Boolean(b)) = table.get("no_color") {
        cfg.no_color = *b;
    }

    if let Some(toml::Value::Boolean(b)) = table.get("quiet") {
        cfg.quiet = *b;
    }

    Ok(cfg)
}

#[cfg(test)]
#[path = "rc_tests.rs"]
mod tests;