mise 2024.12.18

The front-end to your dev env
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
115
116
117
118
119
120
121
122
123
124
125

use crate::config::config_file::mise_toml::MiseToml;
use crate::config::settings::{SettingsType, SETTINGS_META};
use crate::config::top_toml_config;
use clap::ValueEnum;
use eyre::bail;
use std::path::PathBuf;

/// Set the value of a setting in a mise.toml file
#[derive(Debug, clap::Args)]
#[clap(after_long_help = AFTER_LONG_HELP, verbatim_doc_comment)]
pub struct ConfigSet {
    /// The path of the config to display
    pub key: String,

    /// The value to set the key to
    pub value: String,

    /// The path to the mise.toml file to edit
    ///
    /// If not provided, the nearest mise.toml file will be used
    #[clap(short, long)]
    pub file: Option<PathBuf>,

    #[clap(value_enum, short, long, default_value_t)]
    pub type_: TomlValueTypes,
}

#[derive(ValueEnum, Default, Clone, Debug)]
pub enum TomlValueTypes {
    #[default]
    Infer,
    #[value()]
    String,
    #[value()]
    Integer,
    #[value()]
    Float,
    #[value()]
    Bool,
    #[value()]
    List,
}

impl ConfigSet {
    pub fn run(self) -> eyre::Result<()> {
        let mut file = self.file;
        if file.is_none() {
            file = top_toml_config();
        }
        if let Some(file) = file {
            let mut config: toml_edit::DocumentMut = std::fs::read_to_string(&file)?.parse()?;
            let mut container = config.as_item_mut();
            let parts = self.key.split('.').collect::<Vec<&str>>();
            for key in parts.iter().take(parts.len() - 1) {
                container = container.as_table_mut().unwrap().entry(key).or_insert({
                    let mut t = toml_edit::Table::new();
                    t.set_implicit(true);
                    toml_edit::Item::Table(t)
                });
            }
            let last_key = parts.last().unwrap();

            let type_to_use = match self.type_ {
                TomlValueTypes::Infer => {
                    let expected_type = if !self.key.starts_with("settings.") {
                        None
                    } else {
                        SETTINGS_META.get(&(*last_key).to_string())
                    };
                    match expected_type {
                        Some(meta) => match meta.type_ {
                            SettingsType::Bool => TomlValueTypes::Bool,
                            SettingsType::String => TomlValueTypes::String,
                            SettingsType::Integer => TomlValueTypes::Integer,
                            SettingsType::Duration => TomlValueTypes::String,
                            SettingsType::Path => TomlValueTypes::String,
                            SettingsType::Url => TomlValueTypes::String,
                            SettingsType::ListString => TomlValueTypes::List,
                            SettingsType::ListPath => TomlValueTypes::List,
                        },
                        None => TomlValueTypes::String,
                    }
                }
                _ => self.type_,
            };

            let value = match type_to_use {
                TomlValueTypes::String => toml_edit::value(self.value),
                TomlValueTypes::Integer => toml_edit::value(self.value.parse::<i64>()?),
                TomlValueTypes::Float => toml_edit::value(self.value.parse::<f64>()?),
                TomlValueTypes::Bool => toml_edit::value(self.value.parse::<bool>()?),
                TomlValueTypes::List => {
                    let mut list = toml_edit::Array::new();
                    for item in self.value.split(',').map(|s| s.trim()) {
                        list.push(item);
                    }
                    toml_edit::Item::Value(toml_edit::Value::Array(list))
                }
                TomlValueTypes::Infer => bail!("Type not found"),
            };

            container.as_table_mut().unwrap().insert(last_key, value);

            let raw = config.to_string();
            MiseToml::from_str(&raw, &file)?;
            std::fs::write(&file, raw)?;
        } else {
            bail!("No mise.toml file found");
        }
        Ok(())
    }
}

static AFTER_LONG_HELP: &str = color_print::cstr!(
    r#"<bold><underline>Examples:</underline></bold>

    $ <bold>mise config set tools.python 3.12</bold>
    $ <bold>mise config set settings.always_keep_download true</bold>
    $ <bold>mise config set env.TEST_ENV_VAR ABC</bold>
    $ <bold>mise config set settings.disable_tools --type list node,rust</bold>

    # Type for `settings` is inferred
    $ <bold>mise config set settings.jobs 4</bold>
"#
);