//! Settings commands: `settings.list`, `settings.get`, `settings.set` and //! `settings.reset`. Changes of an effective value emit `settingsChanged`. use serde::Deserialize; use serde_json::{Map, Value, json}; use crate::cmd::params::parse; use crate::settings::{self, DEFS, SetError}; use crate::{Command, CommandSpec, EngineError, Event, Outcome, State}; /// `settings.list`: describes every known setting. pub struct List; impl Command for List { fn spec(&self) -> &CommandSpec { &CommandSpec { id: "settings.list", label: "List Settings", menu_path: None, default_shortcut: None, params: "none; returns [{ key, type: enum|int, default, enumValues?, min?, max?, labelKey, descriptionKey, section }]", } } fn run(&self, _state: &mut State, _params: Value) -> Result { let list: Vec<_> = DEFS.iter().map(settings::Def::info).collect(); let value = serde_json::to_value(list).map_err(|e| EngineError::Internal(e.to_string()))?; Ok(Outcome::value(value)) } } /// Params of `settings.get`. #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct GetParams { /// Keys to read; every known key when absent. keys: Option>, } /// `settings.get`: effective values of known settings. pub struct Get; impl Command for Get { fn spec(&self) -> &CommandSpec { &CommandSpec { id: "settings.get", label: "Get Settings", menu_path: None, default_shortcut: None, params: "{ keys?: string[] }; returns { values: { key: value } }, every setting without keys", } } fn run(&self, state: &mut State, params: Value) -> Result { let id = self.spec().id; let p: GetParams = parse(id, params)?; let keys: Vec = match p.keys { Some(keys) => keys, None => DEFS.iter().map(|d| d.key.to_string()).collect(), }; let mut values = Map::new(); for key in keys { let value = state.settings.get(&key).ok_or_else(|| { EngineError::invalid_params(id, format!("unknown setting: {key}")) })?; values.insert(key, value); } Ok(Outcome::value(json!({ "values": values }))) } } /// Params of `settings.set`. #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct SetParams { /// Setting key. key: String, /// New value. value: Value, } /// `settings.set`: validates and stores a value. pub struct Set; impl Command for Set { fn spec(&self) -> &CommandSpec { &CommandSpec { id: "settings.set", label: "Change Setting", menu_path: None, default_shortcut: None, params: "{ key, value }; returns { value }; invalid_params for an unknown key or a bad value", } } fn run(&self, state: &mut State, params: Value) -> Result { let id = self.spec().id; let p: SetParams = parse(id, params)?; let changed = state .settings .set(&p.key, p.value) .map_err(|e| set_error(id, e))?; finish(state, &p.key, changed) } } /// Params of `settings.reset`. #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct ResetParams { /// Setting key. key: String, } /// `settings.reset`: returns a setting to its default. pub struct Reset; impl Command for Reset { fn spec(&self) -> &CommandSpec { &CommandSpec { id: "settings.reset", label: "Reset Setting", menu_path: None, default_shortcut: None, params: "{ key }; returns { value } (the default); invalid_params for an unknown key", } } fn run(&self, state: &mut State, params: Value) -> Result { let id = self.spec().id; let p: ResetParams = parse(id, params)?; let changed = state.settings.reset(&p.key).map_err(|e| set_error(id, e))?; finish(state, &p.key, changed) } } /// Maps a settings error to the command error. fn set_error(command: &str, error: SetError) -> EngineError { match error { SetError::Invalid(message) => EngineError::invalid_params(command, message), SetError::Save(message) => { EngineError::Failed(format!("cannot save the settings: {message}")) } } } /// Emits `settingsChanged` if the value changed and returns `{ value }`. fn finish(state: &mut State, key: &str, changed: bool) -> Result { if changed { state.emit(Event::SettingsChanged { keys: vec![key.to_string()], }); } let value = state .settings .get(key) .ok_or_else(|| EngineError::Internal(format!("setting vanished: {key}")))?; Ok(Outcome::value(json!({ "value": value }))) }