//! Named sets of overrides: the app's built-in sets (read only) and the user's own. //! //! ``` //! use craft_keymap::{Overrides, Profiles}; //! //! let mut classic = Overrides::new(); //! classic.insert("edit.copy", vec!["Cmd+Shift+C".into()]); //! let builtins = [("Craft", Overrides::new()), ("Classic", classic)]; //! let mut sets = Profiles::default(); //! assert_eq!(sets.active_name(&builtins), "Craft"); //! //! sets.duplicate("Classic", "Mine", &builtins).unwrap(); //! let text = sets.export("Mine", &builtins).unwrap(); //! assert_eq!(sets.import(&text, &builtins), Ok("Mine 2".into())); //! assert_eq!(sets.active_overrides(&builtins), sets.get("Mine", &builtins).unwrap()); //! ``` use std::collections::BTreeMap; use std::fmt; use serde::de::{self, IgnoredAny, MapAccess, SeqAccess, Visitor}; use serde::ser::SerializeStruct; use serde::{Deserialize, Deserializer, Serialize, Serializer}; use serde_json::{Value, json}; use crate::import::{ImportPlan, ImportReport}; use crate::keymap::{Keymap, Overrides}; /// Most user sets. pub const MAX_SETS: usize = 64; /// Longest set name, in chars. pub const MAX_SET_NAME: usize = 64; /// Largest export document [`Profiles::import`] reads, in bytes. pub const MAX_EXPORT_BYTES: usize = 4 << 20; const FORMAT: &str = "craft-keymap"; const VERSION: u64 = 1; /// The version stored [`Profiles`] carry; stored profiles without one read as version 1. const STORE_VERSION: u64 = 1; // Load notes are kept for `Profiles::problems`; a hostile file must not grow them without bound. const MAX_NOTES: usize = 64; const IMPORTED: &str = "Imported"; /// The app's built-in sets: name and overrides against the catalog defaults. pub type Builtins<'a> = [(&'a str, Overrides)]; /// Why a set operation was refused. #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] #[non_exhaustive] pub enum ProfileError { /// Empty, over [`MAX_SET_NAME`] chars, or with control characters. BadName, NameTaken, NotFound, /// Built-in sets cannot be changed, renamed or deleted. BuiltIn, /// [`MAX_SETS`] user sets exist. TooMany, /// Not a JSON export document. BadFile, /// A `format` other than `craft-keymap`. WrongFormat, /// A `version` newer than this crate reads. NewerVersion(u64), /// Over [`MAX_EXPORT_BYTES`]. TooLarge, } impl fmt::Display for ProfileError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let s = match self { ProfileError::BadName => "bad set name", ProfileError::NameTaken => "a set with this name exists", ProfileError::NotFound => "no such set", ProfileError::BuiltIn => "built-in sets are read only", ProfileError::TooMany => "too many sets", ProfileError::BadFile => "not a shortcut set file", ProfileError::WrongFormat => "not a craft-keymap file", ProfileError::NewerVersion(v) => return write!(f, "shortcut set file version {v} is newer than this app reads"), ProfileError::TooLarge => "shortcut set file too large", }; f.write_str(s) } } impl std::error::Error for ProfileError {} /// Something loading dropped from stored [`Profiles`]; [`Profiles::problems`] lists them. #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] #[non_exhaustive] pub enum SetProblem { /// A set without a valid name: none, empty, over [`MAX_SET_NAME`] chars, with control /// characters or with spaces around it. `name` is what was stored, cut to [`MAX_SET_NAME`] /// chars. BadName { name: String }, /// A second set of this name; the first one stays. Duplicate { name: String }, /// Overrides that are neither a list nor a map. BadOverrides { name: String }, /// Sets past [`MAX_SETS`]. TooMany { ignored: usize }, /// Stored by a newer craft-keymap; what this version reads is loaded. NewerVersion(u64), } /// The user's sets and which set is active. The built-in sets are passed to each call. /// /// An active name that matches no set means the first built-in set (or no overrides when the app /// has none). /// /// A user set may carry a built-in's name, for instance after an update adds that built-in. Until /// [`Profiles::reconcile`] renames it, the user set is the one that name reads and writes. Call /// `reconcile` after loading; every method that changes the profiles calls it first. /// /// Stored as `{ version, active, sets }`. Loading never fails: what it drops is listed by /// [`Profiles::problems`], and the next save writes the profiles without it. #[derive(Clone, Debug, Default)] pub struct Profiles { active: String, sets: BTreeMap, notes: Vec, } impl PartialEq for Profiles { fn eq(&self, other: &Profiles) -> bool { self.active == other.active && self.sets == other.sets } } impl Eq for Profiles {} static NO_OVERRIDES: Overrides = Overrides::new(); /// A name as given, trimmed; `None` when empty, too long or with control characters. pub fn set_name(name: &str) -> Option { let n = name.trim(); let ok = !n.is_empty() && n.chars().count() <= MAX_SET_NAME && !n.chars().any(char::is_control); ok.then(|| n.to_string()) } impl Profiles { /// The stored active name, which may match no set; [`active_name`](Self::active_name) is the /// set in use. pub fn active(&self) -> &str { &self.active } /// The user's sets. pub fn sets(&self) -> &BTreeMap { &self.sets } /// What loading dropped. pub fn problems(&self) -> &[SetProblem] { &self.notes } /// Built-in names first, then the user's sets. pub fn names(&self, builtins: &Builtins) -> Vec { builtins.iter().map(|(n, _)| n.to_string()).chain(self.sets.keys().cloned()).collect() } pub fn is_builtin(name: &str, builtins: &Builtins) -> bool { builtins.iter().any(|(n, _)| *n == name) } /// The name of the set in use. pub fn active_name<'a>(&'a self, builtins: &'a Builtins) -> &'a str { if self.sets.contains_key(&self.active) || Self::is_builtin(&self.active, builtins) { &self.active } else { builtins.first().map_or("", |(n, _)| n) } } /// The overrides of the set in use, to hand to [`Keymap::set_overrides`](crate::Keymap::set_overrides). pub fn active_overrides<'a>(&'a self, builtins: &'a Builtins) -> &'a Overrides { self.get(self.active_name(builtins), builtins).unwrap_or(&NO_OVERRIDES) } pub fn get<'a>(&'a self, name: &str, builtins: &'a Builtins) -> Option<&'a Overrides> { self.sets.get(name).or_else(|| builtins.iter().find(|(n, _)| *n == name).map(|(_, o)| o)) } /// Renames user sets whose name matches a built-in's (ignoring case) to a free name; `active` /// follows. Returns whether anything was renamed. pub fn reconcile(&mut self, builtins: &Builtins) -> bool { let clashing: Vec = self.sets.keys().filter(|k| self.builtin_like(k, builtins)).cloned().collect(); let mut renamed = false; for old in clashing { let Some(set) = self.sets.remove(&old) else { continue }; // `unique` cannot fail here: a set was just removed, so there is room and the // candidate names outnumber the sets. let name = self.unique(&old, builtins).unwrap_or_else(|_| old.clone()); if self.active == old { self.active = name.clone(); } renamed |= name != old; self.sets.insert(name, set); } renamed } pub fn select(&mut self, name: &str, builtins: &Builtins) -> Result<(), ProfileError> { self.reconcile(builtins); if self.get(name, builtins).is_none() { return Err(ProfileError::NotFound); } self.active = name.to_string(); Ok(()) } /// Saves edited overrides to the set in use. A built-in set is not changed: the edit goes to a /// new set named after `copy_name` (made unique), which becomes active and is returned. The /// new name is returned too when [`Profiles::reconcile`] renamed the set in use. pub fn store(&mut self, overrides: Overrides, builtins: &Builtins, copy_name: &str) -> Result, ProfileError> { let was = self.active_name(builtins).to_string(); self.reconcile(builtins); let active = self.active_name(builtins).to_string(); if let Some(set) = self.sets.get_mut(&active) { *set = overrides; return Ok((active != was).then_some(active)); } if self.get(&active, builtins) == Some(&overrides) || (active.is_empty() && overrides.is_empty()) { return Ok(None); } let base = set_name(copy_name).ok_or(ProfileError::BadName)?; self.add(&base, overrides, builtins).map(Some) } /// Saves `overrides` as a user set (replacing one of that name) and makes it active. pub fn save_as(&mut self, name: &str, overrides: Overrides, builtins: &Builtins) -> Result { self.reconcile(builtins); let name = set_name(name).ok_or(ProfileError::BadName)?; if self.builtin_like(&name, builtins) { return Err(ProfileError::BuiltIn); } if !self.sets.contains_key(&name) { if self.sets.keys().any(|k| k.to_lowercase() == name.to_lowercase()) { return Err(ProfileError::NameTaken); } if self.sets.len() >= MAX_SETS { return Err(ProfileError::TooMany); } } self.sets.insert(name.clone(), overrides); self.active = name.clone(); Ok(name) } pub fn rename(&mut self, from: &str, to: &str, builtins: &Builtins) -> Result { self.reconcile(builtins); if Self::is_builtin(from, builtins) { return Err(ProfileError::BuiltIn); } let to = set_name(to).ok_or(ProfileError::BadName)?; if !self.sets.contains_key(from) { return Err(ProfileError::NotFound); } // A settings file can hold names that differ only in case, so a case-only rename still // checks the other sets. let lower = to.to_lowercase(); let clash = self.sets.keys().any(|k| k != from && k.to_lowercase() == lower); if to != from && (clash || (self.builtin_like(&to, builtins) && lower != from.to_lowercase())) { return Err(ProfileError::NameTaken); } if let Some(set) = self.sets.remove(from) { self.sets.insert(to.clone(), set); } if self.active == from { self.active = to.clone(); } Ok(to) } pub fn delete(&mut self, name: &str, builtins: &Builtins) -> Result<(), ProfileError> { self.reconcile(builtins); if Self::is_builtin(name, builtins) { return Err(ProfileError::BuiltIn); } self.sets.remove(name).ok_or(ProfileError::NotFound)?; if self.active == name { self.active = builtins.first().map_or(String::new(), |(n, _)| n.to_string()); } Ok(()) } /// Copies a set (built-in or user) to a new user set named `to` (made unique), which becomes /// active. Returns its name. pub fn duplicate(&mut self, from: &str, to: &str, builtins: &Builtins) -> Result { self.reconcile(builtins); let overrides = self.get(from, builtins).ok_or(ProfileError::NotFound)?.clone(); let base = set_name(to).ok_or(ProfileError::BadName)?; self.add(&base, overrides, builtins) } /// A set as a JSON document: `{"format":"craft-keymap","version":1,"name":…,"overrides":…}`, /// overrides as [`Overrides`] serializes them. pub fn export(&self, name: &str, builtins: &Builtins) -> Result { let overrides = self.get(name, builtins).ok_or(ProfileError::NotFound)?; let doc = json!({"format": FORMAT, "version": VERSION, "name": name, "overrides": overrides}); serde_json::to_string_pretty(&doc).map_err(|_| ProfileError::BadFile) } /// Reads an exported set into a new user set (renamed when the name is taken) and makes it /// active. Returns its name. pub fn import(&mut self, text: &str, builtins: &Builtins) -> Result { if text.len() > MAX_EXPORT_BYTES { return Err(ProfileError::TooLarge); } let doc: Value = serde_json::from_str(text).map_err(|_| ProfileError::BadFile)?; if doc.get("format").and_then(Value::as_str) != Some(FORMAT) { return Err(ProfileError::WrongFormat); } match doc.get("version").and_then(Value::as_u64) { Some(VERSION) => {} Some(v) if v > VERSION => return Err(ProfileError::NewerVersion(v)), _ => return Err(ProfileError::BadFile), } let overrides = match doc.get("overrides") { Some(v @ (Value::Object(_) | Value::Array(_))) => Overrides::deserialize(v).map_err(|_| ProfileError::BadFile)?, None => Overrides::new(), Some(_) => return Err(ProfileError::BadFile), }; self.reconcile(builtins); let base = doc.get("name").and_then(Value::as_str).and_then(set_name).unwrap_or_else(|| IMPORTED.to_string()); self.add(&base, overrides, builtins) } /// Applies an import plan to a copy of `keymap` (the keymap the plan was made from) and keeps /// the resulting overrides as a new user set, which becomes active; `keymap` is not changed. /// The set is named `name`, else the foreign set's name, else `Imported`, made unique. /// Returns its name and the report of [`ImportPlan::apply`]. pub fn import_plan( &mut self, plan: &ImportPlan, keymap: &Keymap, name: Option<&str>, builtins: &Builtins, ) -> Result<(String, ImportReport), ProfileError> { self.reconcile(builtins); if self.sets.len() >= MAX_SETS { return Err(ProfileError::TooMany); } let mut copy = keymap.clone(); let report = plan.apply(&mut copy); let base = name.or(plan.report.set.as_deref()).and_then(set_name).unwrap_or_else(|| IMPORTED.to_string()); let name = self.add(&base, copy.overrides().clone(), builtins)?; Ok((name, report)) } /// Adds a user set under a unique name from `base` and makes it active. fn add(&mut self, base: &str, overrides: Overrides, builtins: &Builtins) -> Result { let name = self.unique(base, builtins)?; self.sets.insert(name.clone(), overrides); self.active = name.clone(); Ok(name) } fn builtin_like(&self, name: &str, builtins: &Builtins) -> bool { let lower = name.to_lowercase(); builtins.iter().any(|(n, _)| n.to_lowercase() == lower) } /// Whether `name` matches a built-in or user set, ignoring case. pub(crate) fn taken(&self, name: &str, builtins: &Builtins) -> bool { let lower = name.to_lowercase(); self.builtin_like(name, builtins) || self.sets.keys().any(|k| k.to_lowercase() == lower) } /// `base`, or `base 2`, `base 3`… cut to fit [`MAX_SET_NAME`]. fn unique(&self, base: &str, builtins: &Builtins) -> Result { if self.sets.len() >= MAX_SETS { return Err(ProfileError::TooMany); } if !self.taken(base, builtins) { return Ok(base.to_string()); } // `Custom 2` taken: try `Custom 3`, not `Custom 2 2`. let base = match base.rsplit_once(' ') { Some((stem, n)) if !stem.is_empty() && (1..=3).contains(&n.len()) && n.bytes().all(|b| b.is_ascii_digit()) => stem, _ => base, }; for n in 2..(MAX_SETS + builtins.len() + 3) { let suffix = format!(" {n}"); let keep = MAX_SET_NAME.saturating_sub(suffix.chars().count()); let name: String = base.chars().take(keep).collect::().trim_end().to_string() + &suffix; if !self.taken(&name, builtins) { return Ok(name); } } Err(ProfileError::NameTaken) } } impl Serialize for Profiles { fn serialize(&self, serializer: S) -> Result { let mut s = serializer.serialize_struct("Profiles", 3)?; s.serialize_field("version", &STORE_VERSION)?; s.serialize_field("active", &self.active)?; s.serialize_field("sets", &SetList(&self.sets))?; s.end() } } impl<'de> Deserialize<'de> for Profiles { fn deserialize>(deserializer: D) -> Result { #[derive(Deserialize, Default)] #[serde(default)] struct Stored { #[serde(deserialize_with = "lenient_version")] version: Option, #[serde(deserialize_with = "lenient_name")] active: String, #[serde(deserialize_with = "capped_sets")] sets: Loaded, } let Stored { version, active, sets: Loaded { sets, mut notes, .. } } = Stored::deserialize(deserializer)?; if let Some(v) = version.filter(|v| *v > STORE_VERSION) { notes.insert(0, SetProblem::NewerVersion(v)); notes.truncate(MAX_NOTES); } Ok(Profiles { active, sets, notes }) } } fn lenient_name<'de, D: Deserializer<'de>>(deserializer: D) -> Result { let v = Value::deserialize(deserializer)?; Ok(v.as_str().and_then(set_name).unwrap_or_default()) } fn lenient_version<'de, D: Deserializer<'de>>(deserializer: D) -> Result, D::Error> { Ok(Value::deserialize(deserializer)?.as_u64()) } // An array of `{ name, overrides }` rather than a table, and each set's overrides in their array // form, so that craft-settings (which replaces arrays whole) drops a deleted set or entry from the // file. struct SetList<'a>(&'a BTreeMap); impl Serialize for SetList<'_> { fn serialize(&self, serializer: S) -> Result { #[derive(Serialize)] struct Set<'a> { name: &'a str, #[serde(serialize_with = "crate::keymap::overrides_list::serialize")] overrides: &'a Overrides, } serializer.collect_seq(self.0.iter().map(|(name, overrides)| Set { name, overrides })) } } /// The sets that loaded, and notes on the ones that did not. #[derive(Default)] struct Loaded { sets: BTreeMap, notes: Vec, ignored: usize, } impl Loaded { fn note(&mut self, problem: SetProblem) { if self.notes.len() < MAX_NOTES { self.notes.push(problem); } } /// Keeps a set with a valid name, stored as written, that is new and fits under [`MAX_SETS`]; /// notes why not otherwise. fn add(&mut self, name: &str, overrides: Option) { let shown = || name.chars().take(MAX_SET_NAME).collect::(); if set_name(name).is_none_or(|n| n != name) { self.note(SetProblem::BadName { name: shown() }); } else if self.sets.contains_key(name) { self.note(SetProblem::Duplicate { name: shown() }); } else if self.sets.len() >= MAX_SETS { self.ignored += 1; } else if let Some(o) = overrides { self.sets.insert(name.to_string(), o); } else { self.note(SetProblem::BadOverrides { name: shown() }); } } fn done(mut self) -> Loaded { if self.ignored > 0 { let ignored = std::mem::take(&mut self.ignored); self.note(SetProblem::TooMany { ignored }); } self } } fn capped_sets<'de, D: Deserializer<'de>>(deserializer: D) -> Result { deserializer.deserialize_any(SetsVisitor) } struct SetsVisitor; // Anything other than a list or a map loads as no sets, so the rest of `Profiles` still loads. macro_rules! no_sets { ($($name:ident: $t:ty),*) => { $(fn $name(self, _: $t) -> Result { Ok(Loaded::default()) })* }; } impl<'de> Visitor<'de> for SetsVisitor { type Value = Loaded; fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("a list of `{ name, overrides }` items or a map of set names to overrides") } no_sets!(visit_bool: bool, visit_i64: i64, visit_u64: u64, visit_i128: i128, visit_u128: u128, visit_f64: f64, visit_str: &str, visit_bytes: &[u8], visit_char: char); fn visit_unit(self) -> Result { Ok(Loaded::default()) } fn visit_none(self) -> Result { Ok(Loaded::default()) } fn visit_some>(self, deserializer: D) -> Result { deserializer.deserialize_any(SetsVisitor) } fn visit_seq>(self, mut access: A) -> Result { let mut out = Loaded::default(); while let Some(item) = access.next_element::()? { let name = item.get("name").and_then(Value::as_str).unwrap_or_default(); out.add(name, item.get("overrides").and_then(overrides_of)); } Ok(out.done()) } fn visit_map>(self, mut access: A) -> Result { let mut out = Loaded::default(); while let Some(key) = access.next_key::()? { if out.sets.len() >= MAX_SETS && !out.sets.contains_key(&key) { access.next_value::()?; out.ignored += 1; } else { let overrides = overrides_of(&access.next_value::()?); out.add(&key, overrides); } } Ok(out.done()) } } /// A set's overrides: a list or a map, anything else is no set. fn overrides_of(v: &Value) -> Option { match v { Value::Object(_) | Value::Array(_) => Overrides::deserialize(v).ok(), _ => None, } }