rngo-cli 0.22.0

Data simulation CLI using api.rngo.dev
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

use anyhow::{Context, Result, anyhow};
use clap::ValueEnum;
use directories::ProjectDirs;
use serde::{Deserialize, Serialize};
use std::fs::{self, File};
use std::io::Write;
use std::path::PathBuf;

#[derive(Debug, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct Config {
    pub key: Option<String>,
    pub api_key: Option<String>,
    #[serde(default = "default_api_url")]
    pub api_url: String,
    #[serde(default = "default_docs_url")]
    pub docs_url: String,
    #[serde(default = "default_seed")]
    pub seed: u64,
    pub start: Option<String>,
    pub end: Option<String>,
}

#[derive(Debug, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct UserConfig {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub api_key: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub api_url: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub docs_url: Option<String>,
}

#[derive(Debug, Clone, Deserialize, Serialize, ValueEnum)]
#[serde(rename_all = "camelCase")]
pub enum AiAgent {
    Claude,
    Codex,
    Copilot,
}

fn default_api_url() -> String {
    "https://api.rngo.dev".into()
}

fn default_docs_url() -> String {
    "https://rngo.dev/docs".into()
}

fn default_seed() -> u64 {
    1
}

pub fn get_config() -> Result<Config> {
    let user_config = config::Config::builder()
        .add_source(config::File::from(user_config_file_path()?).required(false))
        .build()?;

    let project_config = config::Config::builder()
        .add_source(config::File::from(project_config_file_path()?).required(false))
        .build()?;

    let config = config::Config::builder()
        .add_source(user_config)
        .add_source(project_config)
        .add_source(config::Environment::with_prefix("RNGO").convert_case(config::Case::Camel))
        .build()?;

    config
        .try_deserialize::<Config>()
        .with_context(|| "Failed to deserialize config")
}

pub fn set_user_config<F>(f: F) -> Result<()>
where
    F: FnOnce(&mut UserConfig),
{
    let user_config_builder = config::Config::builder()
        .add_source(config::File::from(user_config_file_path()?).required(false))
        .build()?;

    let mut config = user_config_builder
        .try_deserialize::<UserConfig>()
        .unwrap_or_default();

    f(&mut config);

    let mut file_base_path = user_config_file_path()?;
    file_base_path.set_extension("yml");

    if let Some(parent) = file_base_path.parent() {
        fs::create_dir_all(parent)?;
    }

    let mut file = File::create(file_base_path).with_context(|| "Failed to open config file")?;
    let yaml = serde_yaml::to_string(&config).with_context(|| "Failed to serialize config")?;
    file.write_all(yaml.as_bytes())
        .with_context(|| "Failed to write config")
}

fn user_config_file_path() -> Result<PathBuf> {
    let mut config_path = ProjectDirs::from("dev", "rngo", "cli")
        .map(|project_dirs| project_dirs.config_dir().to_path_buf())
        .ok_or_else(|| anyhow!("Could not determine home directory"))?;

    config_path.push("config");
    Ok(config_path)
}

fn project_config_file_path() -> Result<PathBuf> {
    let path: PathBuf = [".", ".rngo", "config.yml"].iter().collect();
    Ok(path)
}