M1.9a: engine dirs and settings backend

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>
This commit is contained in:
danny 2026-10-16 15:23:43 +02:00
parent 851d438e2a
commit f9357ee4b5
17 changed files with 1406 additions and 41 deletions

View file

@ -0,0 +1,159 @@
//! 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 })))
}