@@ -3,8 +3,6 @@ pub use crate::commands::Command;
33use anyhow::{anyhow, Error, Result};
44use helix_core::hashmap;
55use helix_view::document::Mode;
6−use helix_view::input::{KeyCode, KeyEvent, KeyModifiers};
7−use serde::Deserialize;
86use std::{
97 collections::HashMap,
108 fmt::Display,
@@ -101,6 +99,14 @@ use std::{
10199// D] = last diagnostic
102100// }
103101
102+// #[cfg(feature = "term")]
103+pub use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
104+
105+#[derive(Clone, Debug)]
106+pub struct Keymap(pub HashMap<KeyEvent, Command>);
107+#[derive(Clone, Debug)]
108+pub struct Keymaps(pub HashMap<Mode, Keymap>);
109+
104110#[macro_export]
105111macro_rules! key {
106112 ($key:ident) => {
@@ -135,21 +141,9 @@ macro_rules! alt {
135141 };
136142}
137143
138−#[derive(Debug, PartialEq, Deserialize)]
139−#[serde(transparent)]
140−pub struct Keymaps(pub HashMap<Mode, HashMap<KeyEvent, Command>>);
141−
142−impl Deref for Keymaps {
143− type Target = HashMap<Mode, HashMap<KeyEvent, Command>>;
144−
145− fn deref(&self) -> &Self::Target {
146− &self.0
147− }
148−}
149−
150144impl Default for Keymaps {
151− fn default() -> Keymaps {
152− let normal = hashmap!(
145+ fn default() -> Self {
146+ let normal = Keymap(hashmap!(
153147 key!('h') => Command::move_char_left,
154148 key!('j') => Command::move_line_down,
155149 key!('k') => Command::move_line_up,
@@ -283,12 +277,12 @@ impl Default for Keymaps {
283277 key!('z') => Command::view_mode,
284278
285279 key!('"') => Command::select_register,
286− );
280+ ));
287281 // TODO: decide whether we want normal mode to also be select mode (kakoune-like), or whether
288282 // we keep this separate select mode. More keys can fit into normal mode then, but it's weird
289283 // because some selection operations can now be done from normal mode, some from select mode.
290284 let mut select = normal.clone();
291− select.extend(
285+ select.0.extend(
292286 hashmap!(
293287 key!('h') => Command::extend_char_left,
294288 key!('j') => Command::extend_line_down,
@@ -321,7 +315,7 @@ impl Default for Keymaps {
321315 // TODO: select could be normal mode with some bindings merged over
322316 Mode::Normal => normal,
323317 Mode::Select => select,
324− Mode::Insert => hashmap!(
318+ Mode::Insert => Keymap(hashmap!(
325319 key!(Esc) => Command::normal_mode as Command,
326320 key!(Backspace) => Command::delete_char_backward,
327321 key!(Delete) => Command::delete_char_forward,
@@ -337,7 +331,309 @@ impl Default for Keymaps {
337331 key!(End) => Command::move_line_end,
338332 ctrl!('x') => Command::completion,
339333 ctrl!('w') => Command::delete_word_backward,
340− ),
334+ )),
341335 ))
342336 }
343337}
338+
339+// Newtype wrapper over keys to allow toml serialization/parsing
340+#[derive(Debug, PartialEq, PartialOrd, Clone, Copy, Hash)]
341+pub struct RepresentableKeyEvent(pub KeyEvent);
342+impl Display for RepresentableKeyEvent {
343+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
344+ let Self(key) = self;
345+ f.write_fmt(format_args!(
346+ "{}{}{}",
347+ if key.modifiers.contains(KeyModifiers::SHIFT) {
348+ "S-"
349+ } else {
350+ ""
351+ },
352+ if key.modifiers.contains(KeyModifiers::ALT) {
353+ "A-"
354+ } else {
355+ ""
356+ },
357+ if key.modifiers.contains(KeyModifiers::CONTROL) {
358+ "C-"
359+ } else {
360+ ""
361+ },
362+ ))?;
363+ match key.code {
364+ KeyCode::Backspace => f.write_str("backspace")?,
365+ KeyCode::Enter => f.write_str("ret")?,
366+ KeyCode::Left => f.write_str("left")?,
367+ KeyCode::Right => f.write_str("right")?,
368+ KeyCode::Up => f.write_str("up")?,
369+ KeyCode::Down => f.write_str("down")?,
370+ KeyCode::Home => f.write_str("home")?,
371+ KeyCode::End => f.write_str("end")?,
372+ KeyCode::PageUp => f.write_str("pageup")?,
373+ KeyCode::PageDown => f.write_str("pagedown")?,
374+ KeyCode::Tab => f.write_str("tab")?,
375+ KeyCode::BackTab => f.write_str("backtab")?,
376+ KeyCode::Delete => f.write_str("del")?,
377+ KeyCode::Insert => f.write_str("ins")?,
378+ KeyCode::Null => f.write_str("null")?,
379+ KeyCode::Esc => f.write_str("esc")?,
380+ KeyCode::Char('<') => f.write_str("lt")?,
381+ KeyCode::Char('>') => f.write_str("gt")?,
382+ KeyCode::Char('+') => f.write_str("plus")?,
383+ KeyCode::Char('-') => f.write_str("minus")?,
384+ KeyCode::Char(';') => f.write_str("semicolon")?,
385+ KeyCode::Char('%') => f.write_str("percent")?,
386+ KeyCode::F(i) => f.write_fmt(format_args!("F{}", i))?,
387+ KeyCode::Char(c) => f.write_fmt(format_args!("{}", c))?,
388+ };
389+ Ok(())
390+ }
391+}
392+
393+impl FromStr for RepresentableKeyEvent {
394+ type Err = Error;
395+
396+ fn from_str(s: &str) -> Result<Self, Self::Err> {
397+ let mut tokens: Vec<_> = s.split('-').collect();
398+ let code = match tokens.pop().ok_or_else(|| anyhow!("Missing key code"))? {
399+ "backspace" => KeyCode::Backspace,
400+ "space" => KeyCode::Char(' '),
401+ "ret" => KeyCode::Enter,
402+ "lt" => KeyCode::Char('<'),
403+ "gt" => KeyCode::Char('>'),
404+ "plus" => KeyCode::Char('+'),
405+ "minus" => KeyCode::Char('-'),
406+ "semicolon" => KeyCode::Char(';'),
407+ "percent" => KeyCode::Char('%'),
408+ "left" => KeyCode::Left,
409+ "right" => KeyCode::Right,
410+ "up" => KeyCode::Down,
411+ "home" => KeyCode::Home,
412+ "end" => KeyCode::End,
413+ "pageup" => KeyCode::PageUp,
414+ "pagedown" => KeyCode::PageDown,
415+ "tab" => KeyCode::Tab,
416+ "backtab" => KeyCode::BackTab,
417+ "del" => KeyCode::Delete,
418+ "ins" => KeyCode::Insert,
419+ "null" => KeyCode::Null,
420+ "esc" => KeyCode::Esc,
421+ single if single.len() == 1 => KeyCode::Char(single.chars().next().unwrap()),
422+ function if function.len() > 1 && function.starts_with('F') => {
423+ let function: String = function.chars().skip(1).collect();
424+ let function = str::parse::<u8>(&function)?;
425+ (function > 0 && function < 13)
426+ .then(|| KeyCode::F(function))
427+ .ok_or_else(|| anyhow!("Invalid function key '{}'", function))?
428+ }
429+ invalid => return Err(anyhow!("Invalid key code '{}'", invalid)),
430+ };
431+
432+ let mut modifiers = KeyModifiers::empty();
433+ for token in tokens {
434+ let flag = match token {
435+ "S" => KeyModifiers::SHIFT,
436+ "A" => KeyModifiers::ALT,
437+ "C" => KeyModifiers::CONTROL,
438+ _ => return Err(anyhow!("Invalid key modifier '{}-'", token)),
439+ };
440+
441+ if modifiers.contains(flag) {
442+ return Err(anyhow!("Repeated key modifier '{}-'", token));
443+ }
444+ modifiers.insert(flag);
445+ }
446+
447+ Ok(RepresentableKeyEvent(KeyEvent { code, modifiers }))
448+ }
449+}
450+
451+pub fn parse_keymaps(toml_keymaps: &HashMap<String, HashMap<String, String>>) -> Result<Keymaps> {
452+ let mut keymaps = Keymaps::default();
453+
454+ for (mode, map) in toml_keymaps {
455+ let mode = Mode::from_str(&mode)?;
456+ for (key, command) in map {
457+ let key = str::parse::<RepresentableKeyEvent>(&key)?;
458+ let command = str::parse::<Command>(&command)?;
459+ keymaps.0.get_mut(&mode).unwrap().0.insert(key.0, command);
460+ }
461+ }
462+ Ok(keymaps)
463+}
464+
465+impl Deref for Keymap {
466+ type Target = HashMap<KeyEvent, Command>;
467+ fn deref(&self) -> &Self::Target {
468+ &self.0
469+ }
470+}
471+
472+impl Deref for Keymaps {
473+ type Target = HashMap<Mode, Keymap>;
474+ fn deref(&self) -> &Self::Target {
475+ &self.0
476+ }
477+}
478+
479+impl DerefMut for Keymap {
480+ fn deref_mut(&mut self) -> &mut Self::Target {
481+ &mut self.0
482+ }
483+}
484+
485+impl DerefMut for Keymaps {
486+ fn deref_mut(&mut self) -> &mut Self::Target {
487+ &mut self.0
488+ }
489+}
490+
491+#[cfg(test)]
492+mod test {
493+ use crate::config::Config;
494+
495+ use super::*;
496+
497+ impl PartialEq for Command {
498+ fn eq(&self, other: &Self) -> bool {
499+ self.name() == other.name()
500+ }
501+ }
502+
503+ #[test]
504+ fn parsing_keymaps_config_file() {
505+ let sample_keymaps = r#"
506+ [keys.insert]
507+ y = "move_line_down"
508+ S-C-a = "delete_selection"
509+
510+ [keys.normal]
511+ A-F12 = "move_next_word_end"
512+ "#;
513+
514+ let config: Config = toml::from_str(sample_keymaps).unwrap();
515+ assert_eq!(
516+ *config
517+ .keymaps
518+ .0
519+ .get(&Mode::Insert)
520+ .unwrap()
521+ .0
522+ .get(&KeyEvent {
523+ code: KeyCode::Char('y'),
524+ modifiers: KeyModifiers::NONE
525+ })
526+ .unwrap(),
527+ Command::move_line_down
528+ );
529+ assert_eq!(
530+ *config
531+ .keymaps
532+ .0
533+ .get(&Mode::Insert)
534+ .unwrap()
535+ .0
536+ .get(&KeyEvent {
537+ code: KeyCode::Char('a'),
538+ modifiers: KeyModifiers::SHIFT | KeyModifiers::CONTROL
539+ })
540+ .unwrap(),
541+ Command::delete_selection
542+ );
543+ assert_eq!(
544+ *config
545+ .keymaps
546+ .0
547+ .get(&Mode::Normal)
548+ .unwrap()
549+ .0
550+ .get(&KeyEvent {
551+ code: KeyCode::F(12),
552+ modifiers: KeyModifiers::ALT
553+ })
554+ .unwrap(),
555+ Command::move_next_word_end
556+ );
557+ }
558+
559+ #[test]
560+ fn parsing_unmodified_keys() {
561+ assert_eq!(
562+ str::parse::<RepresentableKeyEvent>("backspace").unwrap(),
563+ RepresentableKeyEvent(KeyEvent {
564+ code: KeyCode::Backspace,
565+ modifiers: KeyModifiers::NONE
566+ })
567+ );
568+
569+ assert_eq!(
570+ str::parse::<RepresentableKeyEvent>("left").unwrap(),
571+ RepresentableKeyEvent(KeyEvent {
572+ code: KeyCode::Left,
573+ modifiers: KeyModifiers::NONE
574+ })
575+ );
576+
577+ assert_eq!(
578+ str::parse::<RepresentableKeyEvent>(",").unwrap(),
579+ RepresentableKeyEvent(KeyEvent {
580+ code: KeyCode::Char(','),
581+ modifiers: KeyModifiers::NONE
582+ })
583+ );
584+
585+ assert_eq!(
586+ str::parse::<RepresentableKeyEvent>("w").unwrap(),
587+ RepresentableKeyEvent(KeyEvent {
588+ code: KeyCode::Char('w'),
589+ modifiers: KeyModifiers::NONE
590+ })
591+ );
592+
593+ assert_eq!(
594+ str::parse::<RepresentableKeyEvent>("F12").unwrap(),
595+ RepresentableKeyEvent(KeyEvent {
596+ code: KeyCode::F(12),
597+ modifiers: KeyModifiers::NONE
598+ })
599+ );
600+ }
601+
602+ fn parsing_modified_keys() {
603+ assert_eq!(
604+ str::parse::<RepresentableKeyEvent>("S-minus").unwrap(),
605+ RepresentableKeyEvent(KeyEvent {
606+ code: KeyCode::Char('-'),
607+ modifiers: KeyModifiers::SHIFT
608+ })
609+ );
610+
611+ assert_eq!(
612+ str::parse::<RepresentableKeyEvent>("C-A-S-F12").unwrap(),
613+ RepresentableKeyEvent(KeyEvent {
614+ code: KeyCode::F(12),
615+ modifiers: KeyModifiers::SHIFT | KeyModifiers::CONTROL | KeyModifiers::ALT
616+ })
617+ );
618+
619+ assert_eq!(
620+ str::parse::<RepresentableKeyEvent>("S-C-2").unwrap(),
621+ RepresentableKeyEvent(KeyEvent {
622+ code: KeyCode::F(2),
623+ modifiers: KeyModifiers::SHIFT | KeyModifiers::CONTROL
624+ })
625+ );
626+ }
627+
628+ #[test]
629+ fn parsing_nonsensical_keys_fails() {
630+ assert!(str::parse::<RepresentableKeyEvent>("F13").is_err());
631+ assert!(str::parse::<RepresentableKeyEvent>("F0").is_err());
632+ assert!(str::parse::<RepresentableKeyEvent>("aaa").is_err());
633+ assert!(str::parse::<RepresentableKeyEvent>("S-S-a").is_err());
634+ assert!(str::parse::<RepresentableKeyEvent>("C-A-S-C-1").is_err());
635+ assert!(str::parse::<RepresentableKeyEvent>("FU").is_err());
636+ assert!(str::parse::<RepresentableKeyEvent>("123").is_err());
637+ assert!(str::parse::<RepresentableKeyEvent>("S--").is_err());
638+ }
639+}