mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-16 22:14:30 +00:00
174 lines
8.6 KiB
Rust
174 lines
8.6 KiB
Rust
//! Integration tests of craft-keymap: keymap.
|
|
|
|
use craft_keymap::{
|
|
Active, Binding, Chord, CommandDef, CommandRef, DropReason, Keymap, Lookup, MAX_COMMANDS, Overrides, Platform, Problem, Scope, Scopes,
|
|
};
|
|
use serde_json::json;
|
|
|
|
fn chord(text: &str) -> Chord {
|
|
Chord::parse(text).unwrap_or_else(|e| panic!("{text}: {e}"))
|
|
}
|
|
|
|
fn scope(name: &str) -> Scope {
|
|
Scope::new(name).unwrap()
|
|
}
|
|
|
|
fn b(text: &str) -> Binding {
|
|
Binding::parse(text).unwrap_or_else(|e| panic!("{text}: {e}"))
|
|
}
|
|
|
|
fn cmd(id: &str) -> CommandRef {
|
|
CommandRef::new(id)
|
|
}
|
|
|
|
fn app(id: &str, keys: &[&str]) -> CommandDef {
|
|
keys.iter().fold(CommandDef::new(id, id, Scope::app()), |e, k| e.with_default(b(k)))
|
|
}
|
|
|
|
fn in_scope(id: &str, home: &str, keys: &[&str]) -> CommandDef {
|
|
keys.iter().fold(CommandDef::new(id, id, scope(home)), |e, k| e.with_default(b(k)))
|
|
}
|
|
|
|
fn run(id: &str) -> Lookup {
|
|
Lookup::Run(cmd(id))
|
|
}
|
|
|
|
fn scopes() -> Scopes {
|
|
Scopes::new().with_panel("Timeline").with_panel("Composition").with_share("Timeline", "Composition").with_context("Text")
|
|
}
|
|
|
|
fn press(km: &Keymap, text: &str, active: &Active) -> Lookup {
|
|
km.lookup(&chord(text), false, active)
|
|
}
|
|
|
|
#[test]
|
|
fn lookup_picks_the_nearest_scope() {
|
|
let catalog = vec![
|
|
app("edit.copy", &["Cmd+C"]),
|
|
in_scope("timeline.copy", "Timeline", &["Cmd+C"]),
|
|
app("file.bake", &["Cmd+B"]),
|
|
in_scope("text.bold", "Text", &["Cmd+B", "Cmd+I"]),
|
|
in_scope("timeline.loop", "Timeline", &["L"]),
|
|
];
|
|
let km = Keymap::new(catalog.clone(), scopes(), Platform::Mac);
|
|
let text = ["Text"];
|
|
assert_eq!(press(&km, "Cmd+C", &Active::NONE), run("edit.copy"));
|
|
assert_eq!(press(&km, "Cmd+C", &Active::panel("Timeline")), run("timeline.copy"));
|
|
assert_eq!(press(&km, "Cmd+C", &Active::panel("Composition")), run("timeline.copy"), "sharing panel");
|
|
assert_eq!(press(&km, "Cmd+C", &Active::panel("Effects")), run("edit.copy"));
|
|
assert_eq!(press(&km, "Cmd+B", &Active::panel("Timeline")), run("file.bake"));
|
|
assert_eq!(press(&km, "Cmd+B", &Active { panel: Some("Timeline"), contexts: &text, typing: false }), run("text.bold"));
|
|
assert_eq!(press(&km, "Cmd+I", &Active::NONE), Lookup::None, "inactive context");
|
|
assert_eq!(press(&km, "L", &Active::panel("Effects")), run("timeline.loop"), "fallthrough");
|
|
assert_eq!(km.lookup(&chord("L"), true, &Active::panel("Timeline")), Lookup::None, "double press is its own trigger");
|
|
|
|
let strict = Keymap::new(catalog, scopes().with_panel_fallthrough(false), Platform::Mac);
|
|
assert_eq!(press(&strict, "L", &Active::panel("Effects")), Lookup::None);
|
|
assert_eq!(press(&strict, "L", &Active::panel("Timeline")), run("timeline.loop"));
|
|
}
|
|
|
|
/// A command shows a chord only where the lookup runs it: of two application commands on one chord the catalog-first
|
|
/// one shows it and is its holder, the other shows its next key; a panel or context binding shows where it applies,
|
|
/// and a panel-only chord's holder is the panel's command.
|
|
#[test]
|
|
fn a_command_shows_only_the_chords_the_lookup_runs_it_for() {
|
|
let catalog = vec![
|
|
app("layer.hide", &["Cmd+,"]),
|
|
app("edit.settings", &["Cmd+,", "Cmd+Alt+,"]),
|
|
app("view.extras", &["Cmd+H"]),
|
|
in_scope("timeline.copy", "Timeline", &["Cmd+C"]),
|
|
app("edit.copy", &["Cmd+C"]),
|
|
in_scope("text.bold", "Text", &["Cmd+B"]),
|
|
in_scope("timeline.loop", "Timeline", &["Cmd+L"]),
|
|
];
|
|
let km = Keymap::new(catalog, scopes().with_panel_fallthrough(false), Platform::Mac);
|
|
assert_eq!(km.shown_chord(&cmd("layer.hide")), Some(chord("Cmd+,")));
|
|
assert_eq!(km.shown_chord(&cmd("edit.settings")), Some(chord("Cmd+Alt+,")), "the shadowed key is not shown");
|
|
assert_eq!(km.holder(&chord("Cmd+,")), Some(cmd("layer.hide")));
|
|
assert_eq!(km.shown_chord(&cmd("timeline.copy")), Some(chord("Cmd+C")), "in its panel the panel's command runs");
|
|
assert_eq!(km.shown_chord(&cmd("edit.copy")), Some(chord("Cmd+C")));
|
|
assert_eq!(km.holder(&chord("Cmd+C")), Some(cmd("edit.copy")), "with no panel focused");
|
|
assert_eq!(km.shown_chord(&cmd("text.bold")), Some(chord("Cmd+B")));
|
|
assert_eq!(km.holder(&chord("Cmd+L")), Some(cmd("timeline.loop")), "a panel-only chord");
|
|
assert_eq!(km.holder(&chord("Cmd+K")), None);
|
|
|
|
let alone = Keymap::new(vec![app("layer.hide", &["Cmd+,"]), app("edit.settings", &["Cmd+,"])], Scopes::new(), Platform::Mac);
|
|
assert_eq!(alone.shown_chord(&cmd("edit.settings")), None, "every key shadowed");
|
|
}
|
|
|
|
#[test]
|
|
fn overrides_write_the_map_form_unless_a_command_has_several_keys() {
|
|
let mut o = Overrides::new();
|
|
o.insert("edit.copy", vec!["Cmd+K".into()]);
|
|
o.insert("edit.paste", vec![]);
|
|
let text = serde_json::to_string(&o).unwrap();
|
|
assert_eq!(text, r#"{"edit.copy":"Cmd+K","edit.paste":""}"#, "older builds read one text per command");
|
|
assert_eq!(serde_json::from_str::<Overrides>(&text).unwrap(), o);
|
|
|
|
o.insert("edit.cut", vec!["Cmd+X".into(), "Shift+Delete".into()]);
|
|
let text = serde_json::to_string(&o).unwrap();
|
|
assert!(text.starts_with(r#"[{"command":"edit.copy","keys":["Cmd+K"]},"#), "{text}");
|
|
assert_eq!(serde_json::from_str::<Overrides>(&text).unwrap(), o);
|
|
|
|
// A blank text is kept verbatim (it loads as the defaults), which the map form cannot say.
|
|
let mut blank = Overrides::new();
|
|
blank.insert("edit.copy", vec![" ".into()]);
|
|
let text = serde_json::to_string(&blank).unwrap();
|
|
assert!(text.starts_with('['), "{text}");
|
|
assert_eq!(serde_json::from_str::<Overrides>(&text).unwrap(), blank);
|
|
|
|
#[derive(serde::Serialize)]
|
|
struct Prefs {
|
|
#[serde(with = "craft_keymap::keymap::overrides_list")]
|
|
shortcuts: Overrides,
|
|
}
|
|
let mut single = Overrides::new();
|
|
single.insert("edit.copy", vec!["Cmd+K".into()]);
|
|
let text = serde_json::to_string(&Prefs { shortcuts: single }).unwrap();
|
|
assert_eq!(text, r#"{"shortcuts":[{"command":"edit.copy","keys":["Cmd+K"]}]}"#);
|
|
}
|
|
|
|
#[test]
|
|
fn hostile_overrides_load_without_panic_and_report_problems() {
|
|
let mut doc = serde_json::Map::new();
|
|
for i in 0..(MAX_COMMANDS + 100) {
|
|
doc.insert(format!("junk.{i}"), json!(["Cmd+Z"]));
|
|
}
|
|
doc.insert("edit.copy".into(), json!(["Cmd+Nope", "x".repeat(10_000), 7, "Shift+C"]));
|
|
doc.insert("a".into(), json!(["Shift+A"]));
|
|
doc.insert("é".repeat(300), json!([]));
|
|
doc.insert("b".into(), json!({"deep": [[[[1]]]]}));
|
|
let o: Overrides = serde_json::from_value(serde_json::Value::Object(doc)).unwrap();
|
|
assert!(o.len() <= MAX_COMMANDS);
|
|
|
|
let km = Keymap::new(vec![app("edit.copy", &["Cmd+C"]), app("a", &[])], Scopes::new(), Platform::Linux).with_overrides(o.clone());
|
|
assert_eq!(km.bindings(&cmd("edit.copy")), vec![b("Shift+C")]);
|
|
assert_eq!(km.overrides().get("edit.copy"), Some(&["Cmd+Nope".to_string(), "Shift+C".to_string()][..]), "verbatim");
|
|
let problems = km.problems();
|
|
assert!(problems.iter().any(|p| matches!(p, Problem::TooManyCommands { .. })));
|
|
assert!(problems.contains(&Problem::Dropped { key: "edit.copy".into(), reason: DropReason::TextTooLong }));
|
|
assert!(problems.contains(&Problem::Dropped { key: "edit.copy".into(), reason: DropReason::NotText }));
|
|
assert!(problems.iter().any(|p| matches!(p, Problem::Dropped { reason: DropReason::KeyTooLong, .. })));
|
|
assert!(problems.iter().any(|p| matches!(p, Problem::BadBinding { text, .. } if text == "Cmd+Nope")));
|
|
assert!(problems.iter().any(|p| matches!(p, Problem::UnknownCommand { key } if key == "junk.0")));
|
|
|
|
let text = serde_json::to_string(&o).unwrap();
|
|
let again: Overrides = serde_json::from_str(&text).unwrap();
|
|
assert_eq!(again, o);
|
|
assert!(text.starts_with(r#"[{"command":"a","keys":["Shift+A"]},"#), "{}", &text[..80]);
|
|
assert!(serde_json::from_str::<Overrides>(r#"{"x": {"y": 1}, "z": true, "w": null, "v": "Cmd+V"}"#).is_ok());
|
|
let items: Overrides =
|
|
serde_json::from_str(r#"[{"command": "v", "keys": "Cmd+V"}, {"command": "x"}, {"keys": []}, 3, [], {"command": "y", "keys": [1]}]"#).unwrap();
|
|
assert_eq!(items.iter().collect::<Vec<_>>(), [("v", &["Cmd+V".to_string()][..]), ("y", &[][..])]);
|
|
assert_eq!(items.load_notes().len(), 5);
|
|
|
|
let twice: Overrides = serde_json::from_str(r#"[{"command": "v", "keys": ["Cmd+V"]}, {"command": "v", "keys": []}]"#).unwrap();
|
|
assert_eq!(twice.get("v"), Some(&["Cmd+V".to_string()][..]), "the first entry stays");
|
|
assert_eq!(twice.load_notes(), [Problem::DuplicateKey { key: "v".into() }]);
|
|
for text in [r#""x""#, "5", "true", "null"] {
|
|
let o: Overrides = serde_json::from_str(text).unwrap();
|
|
assert!(o.is_empty(), "{text}");
|
|
assert_eq!(o.load_notes(), [Problem::Dropped { key: String::new(), reason: DropReason::NotAList }], "{text}");
|
|
}
|
|
}
|