Skip to main content

acp_utils/
config_option_id.rs

1use std::fmt;
2use std::str::FromStr;
3
4pub const THEME_CONFIG_ID: &str = "__theme";
5
6#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
7pub enum ConfigOptionId {
8    Mode,
9    Model,
10    ReasoningEffort,
11}
12
13impl ConfigOptionId {
14    pub fn as_str(&self) -> &'static str {
15        match self {
16            Self::Mode => "mode",
17            Self::Model => "model",
18            Self::ReasoningEffort => "reasoning_effort",
19        }
20    }
21}
22
23impl fmt::Display for ConfigOptionId {
24    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
25        f.write_str(self.as_str())
26    }
27}
28
29#[derive(Debug, thiserror::Error)]
30#[error("Unknown config option: {0}")]
31pub struct UnknownConfigOptionId(pub String);
32
33impl FromStr for ConfigOptionId {
34    type Err = UnknownConfigOptionId;
35
36    fn from_str(s: &str) -> Result<Self, Self::Err> {
37        match s {
38            "mode" => Ok(Self::Mode),
39            "model" => Ok(Self::Model),
40            "reasoning_effort" => Ok(Self::ReasoningEffort),
41            _ => Err(UnknownConfigOptionId(s.to_string())),
42        }
43    }
44}
45
46#[cfg(test)]
47mod tests {
48    use super::*;
49
50    #[test]
51    fn round_trip_all_variants() {
52        for id in [ConfigOptionId::Mode, ConfigOptionId::Model, ConfigOptionId::ReasoningEffort] {
53            let parsed: ConfigOptionId = id.as_str().parse().unwrap();
54            assert_eq!(parsed, id);
55        }
56    }
57
58    #[test]
59    fn display_matches_as_str() {
60        for id in [ConfigOptionId::Mode, ConfigOptionId::Model, ConfigOptionId::ReasoningEffort] {
61            assert_eq!(id.to_string(), id.as_str());
62        }
63    }
64
65    #[test]
66    fn unknown_string_returns_error() {
67        let err = "unknown_option".parse::<ConfigOptionId>().unwrap_err();
68        assert_eq!(err.0, "unknown_option");
69        assert!(err.to_string().contains("unknown_option"));
70    }
71}