EngineConfig and Engine::with_config; the desktop resolves Tauri's app config and data dirs. Settings model (appearance.theme, editor.fontSize, ui.language) with typed validation, persistence in settings.json via write_atomic (1 MiB cap, unknown keys kept, corrupt file backed up with a warning notification), settings.list/get/set/reset, settingsChanged and notification events. Property test over random settings.json content, control-channel test for persistence and corrupt-file recovery. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
159 lines
4.9 KiB
Rust
159 lines
4.9 KiB
Rust
//! 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<Outcome, EngineError> {
|
|
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<Vec<String>>,
|
|
}
|
|
|
|
/// `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<Outcome, EngineError> {
|
|
let id = self.spec().id;
|
|
let p: GetParams = parse(id, params)?;
|
|
let keys: Vec<String> = 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<Outcome, EngineError> {
|
|
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<Outcome, EngineError> {
|
|
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<Outcome, EngineError> {
|
|
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 })))
|
|
}
|