@@ -3,8 +3,6 @@ pub use crate::commands::Command;
3use anyhow::{anyhow, Error, Result};
3use anyhow::{anyhow, Error, Result};
4use helix_core::hashmap;
4use helix_core::hashmap;
5use helix_view::document::Mode;
5use helix_view::document::Mode;
6−use helix_view::input::{KeyCode, KeyEvent, KeyModifiers};
7−use serde::Deserialize;
9 collections::HashMap,
7 collections::HashMap,
10 fmt::Display,
8 fmt::Display,
@@ -101,6 +99,14 @@ use std::{
101// D] = last diagnostic
99// D] = last diagnostic
102+// #[cfg(feature = "term")]
103+pub use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
105+#[derive(Clone, Debug)]
106+pub struct Keymap(pub HashMap<KeyEvent, Command>);
107+#[derive(Clone, Debug)]
108+pub struct Keymaps(pub HashMap<Mode, Keymap>);
104#[macro_export]
110#[macro_export]
105macro_rules! key {
111macro_rules! key {
106 ($key:ident) => {
112 ($key:ident) => {
@@ -135,21 +141,9 @@ macro_rules! alt {
138−#[derive(Debug, PartialEq, Deserialize)]
139−#[serde(transparent)]
140−pub struct Keymaps(pub HashMap<Mode, HashMap<KeyEvent, Command>>);
142−impl Deref for Keymaps {
143− type Target = HashMap<Mode, HashMap<KeyEvent, Command>>;
145− fn deref(&self) -> &Self::Target {
150impl Default for Keymaps {
144impl Default for Keymaps {
151− fn default() -> Keymaps {
145+ fn default() -> Self {
152− let normal = hashmap!(
146+ let normal = Keymap(hashmap!(
153 key!('h') => Command::move_char_left,
147 key!('h') => Command::move_char_left,
154 key!('j') => Command::move_line_down,
148 key!('j') => Command::move_line_down,
155 key!('k') => Command::move_line_up,
149 key!('k') => Command::move_line_up,
@@ -202,9 +196,7 @@ impl Default for Keymaps {
202 key!(';') => Command::collapse_selection,
196 key!(';') => Command::collapse_selection,
203 alt!(';') => Command::flip_selections,
197 alt!(';') => Command::flip_selections,
204 key!('%') => Command::select_all,
198 key!('%') => Command::select_all,
205− key!('x') => Command::select_line,
199+ key!('x') => Command::extend_line,
206− key!('X') => Command::extend_line,
207− // or select mode X?
208 // extend_to_whole_line, crop_to_whole_line
200 // extend_to_whole_line, crop_to_whole_line
@@ -283,12 +275,12 @@ impl Default for Keymaps {
283 key!('z') => Command::view_mode,
275 key!('z') => Command::view_mode,
285 key!('"') => Command::select_register,
277 key!('"') => Command::select_register,
287 // TODO: decide whether we want normal mode to also be select mode (kakoune-like), or whether
279 // TODO: decide whether we want normal mode to also be select mode (kakoune-like), or whether
288 // we keep this separate select mode. More keys can fit into normal mode then, but it's weird
280 // we keep this separate select mode. More keys can fit into normal mode then, but it's weird
289 // because some selection operations can now be done from normal mode, some from select mode.
281 // because some selection operations can now be done from normal mode, some from select mode.
290 let mut select = normal.clone();
282 let mut select = normal.clone();
291− select.extend(
283+ select.0.extend(
292 hashmap!(
284 hashmap!(
293 key!('h') => Command::extend_char_left,
285 key!('h') => Command::extend_char_left,
294 key!('j') => Command::extend_line_down,
286 key!('j') => Command::extend_line_down,
@@ -321,7 +313,7 @@ impl Default for Keymaps {
321 // TODO: select could be normal mode with some bindings merged over
313 // TODO: select could be normal mode with some bindings merged over
322 Mode::Normal => normal,
314 Mode::Normal => normal,
323 Mode::Select => select,
315 Mode::Select => select,
324− Mode::Insert => hashmap!(
316+ Mode::Insert => Keymap(hashmap!(
325 key!(Esc) => Command::normal_mode as Command,
317 key!(Esc) => Command::normal_mode as Command,
326 key!(Backspace) => Command::delete_char_backward,
318 key!(Backspace) => Command::delete_char_backward,
327 key!(Delete) => Command::delete_char_forward,
319 key!(Delete) => Command::delete_char_forward,
@@ -333,9 +325,313 @@ impl Default for Keymaps {
333 key!(Right) => Command::move_char_right,
325 key!(Right) => Command::move_char_right,
334 key!(PageUp) => Command::page_up,
326 key!(PageUp) => Command::page_up,
335 key!(PageDown) => Command::page_down,
327 key!(PageDown) => Command::page_down,
328+ key!(Home) => Command::move_line_start,
329+ key!(End) => Command::move_line_end,
336 ctrl!('x') => Command::completion,
330 ctrl!('x') => Command::completion,
337 ctrl!('w') => Command::delete_word_backward,
331 ctrl!('w') => Command::delete_word_backward,
337+// Newtype wrapper over keys to allow toml serialization/parsing
338+#[derive(Debug, PartialEq, PartialOrd, Clone, Copy, Hash)]
339+pub struct RepresentableKeyEvent(pub KeyEvent);
340+impl Display for RepresentableKeyEvent {
341+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
342+ let Self(key) = self;
343+ f.write_fmt(format_args!(
345+ if key.modifiers.contains(KeyModifiers::SHIFT) {
350+ if key.modifiers.contains(KeyModifiers::ALT) {
355+ if key.modifiers.contains(KeyModifiers::CONTROL) {
362+ KeyCode::Backspace => f.write_str("backspace")?,
363+ KeyCode::Enter => f.write_str("ret")?,
364+ KeyCode::Left => f.write_str("left")?,
365+ KeyCode::Right => f.write_str("right")?,
366+ KeyCode::Up => f.write_str("up")?,
367+ KeyCode::Down => f.write_str("down")?,
368+ KeyCode::Home => f.write_str("home")?,
369+ KeyCode::End => f.write_str("end")?,
370+ KeyCode::PageUp => f.write_str("pageup")?,
371+ KeyCode::PageDown => f.write_str("pagedown")?,
372+ KeyCode::Tab => f.write_str("tab")?,
373+ KeyCode::BackTab => f.write_str("backtab")?,
374+ KeyCode::Delete => f.write_str("del")?,
375+ KeyCode::Insert => f.write_str("ins")?,
376+ KeyCode::Null => f.write_str("null")?,
377+ KeyCode::Esc => f.write_str("esc")?,
378+ KeyCode::Char('<') => f.write_str("lt")?,
379+ KeyCode::Char('>') => f.write_str("gt")?,
380+ KeyCode::Char('+') => f.write_str("plus")?,
381+ KeyCode::Char('-') => f.write_str("minus")?,
382+ KeyCode::Char(';') => f.write_str("semicolon")?,
383+ KeyCode::Char('%') => f.write_str("percent")?,
384+ KeyCode::F(i) => f.write_fmt(format_args!("F{}", i))?,
385+ KeyCode::Char(c) => f.write_fmt(format_args!("{}", c))?,
391+impl FromStr for RepresentableKeyEvent {
394+ fn from_str(s: &str) -> Result<Self, Self::Err> {
395+ let mut tokens: Vec<_> = s.split('-').collect();
396+ let code = match tokens.pop().ok_or_else(|| anyhow!("Missing key code"))? {
397+ "backspace" => KeyCode::Backspace,
398+ "space" => KeyCode::Char(' '),
399+ "ret" => KeyCode::Enter,
400+ "lt" => KeyCode::Char('<'),
401+ "gt" => KeyCode::Char('>'),
402+ "plus" => KeyCode::Char('+'),
403+ "minus" => KeyCode::Char('-'),
404+ "semicolon" => KeyCode::Char(';'),
405+ "percent" => KeyCode::Char('%'),
406+ "left" => KeyCode::Left,
407+ "right" => KeyCode::Right,
408+ "up" => KeyCode::Down,
409+ "home" => KeyCode::Home,
410+ "end" => KeyCode::End,
411+ "pageup" => KeyCode::PageUp,
412+ "pagedown" => KeyCode::PageDown,
413+ "tab" => KeyCode::Tab,
414+ "backtab" => KeyCode::BackTab,
415+ "del" => KeyCode::Delete,
416+ "ins" => KeyCode::Insert,
417+ "null" => KeyCode::Null,
418+ "esc" => KeyCode::Esc,
419+ single if single.len() == 1 => KeyCode::Char(single.chars().next().unwrap()),
420+ function if function.len() > 1 && function.starts_with('F') => {
421+ let function: String = function.chars().skip(1).collect();
422+ let function = str::parse::<u8>(&function)?;
423+ (function > 0 && function < 13)
424+ .then(|| KeyCode::F(function))
425+ .ok_or_else(|| anyhow!("Invalid function key '{}'", function))?
427+ invalid => return Err(anyhow!("Invalid key code '{}'", invalid)),
430+ let mut modifiers = KeyModifiers::empty();
431+ for token in tokens {
432+ let flag = match token {
433+ "S" => KeyModifiers::SHIFT,
434+ "A" => KeyModifiers::ALT,
435+ "C" => KeyModifiers::CONTROL,
436+ _ => return Err(anyhow!("Invalid key modifier '{}-'", token)),
439+ if modifiers.contains(flag) {
440+ return Err(anyhow!("Repeated key modifier '{}-'", token));
442+ modifiers.insert(flag);
445+ Ok(RepresentableKeyEvent(KeyEvent { code, modifiers }))
449+pub fn parse_keymaps(toml_keymaps: &HashMap<String, HashMap<String, String>>) -> Result<Keymaps> {
450+ let mut keymaps = Keymaps::default();
452+ for (mode, map) in toml_keymaps {
453+ let mode = Mode::from_str(&mode)?;
454+ for (key, command) in map {
455+ let key = str::parse::<RepresentableKeyEvent>(&key)?;
456+ let command = str::parse::<Command>(&command)?;
457+ keymaps.0.get_mut(&mode).unwrap().0.insert(key.0, command);
463+impl Deref for Keymap {
464+ type Target = HashMap<KeyEvent, Command>;
465+ fn deref(&self) -> &Self::Target {
470+impl Deref for Keymaps {
471+ type Target = HashMap<Mode, Keymap>;
472+ fn deref(&self) -> &Self::Target {
477+impl DerefMut for Keymap {
478+ fn deref_mut(&mut self) -> &mut Self::Target {
483+impl DerefMut for Keymaps {
484+ fn deref_mut(&mut self) -> &mut Self::Target {
491+ use crate::config::Config;
495+ impl PartialEq for Command {
496+ fn eq(&self, other: &Self) -> bool {
497+ self.name() == other.name()
502+ fn parsing_keymaps_config_file() {
503+ let sample_keymaps = r#"
505+ y = "move_line_down"
506+ S-C-a = "delete_selection"
509+ A-F12 = "move_next_word_end"
512+ let config: Config = toml::from_str(sample_keymaps).unwrap();
521+ code: KeyCode::Char('y'),
522+ modifiers: KeyModifiers::NONE
525+ Command::move_line_down
535+ code: KeyCode::Char('a'),
536+ modifiers: KeyModifiers::SHIFT | KeyModifiers::CONTROL
539+ Command::delete_selection
549+ code: KeyCode::F(12),
550+ modifiers: KeyModifiers::ALT
553+ Command::move_next_word_end
558+ fn parsing_unmodified_keys() {
560+ str::parse::<RepresentableKeyEvent>("backspace").unwrap(),
561+ RepresentableKeyEvent(KeyEvent {
562+ code: KeyCode::Backspace,
563+ modifiers: KeyModifiers::NONE
568+ str::parse::<RepresentableKeyEvent>("left").unwrap(),
569+ RepresentableKeyEvent(KeyEvent {
570+ code: KeyCode::Left,
571+ modifiers: KeyModifiers::NONE
576+ str::parse::<RepresentableKeyEvent>(",").unwrap(),
577+ RepresentableKeyEvent(KeyEvent {
578+ code: KeyCode::Char(','),
579+ modifiers: KeyModifiers::NONE
584+ str::parse::<RepresentableKeyEvent>("w").unwrap(),
585+ RepresentableKeyEvent(KeyEvent {
586+ code: KeyCode::Char('w'),
587+ modifiers: KeyModifiers::NONE
592+ str::parse::<RepresentableKeyEvent>("F12").unwrap(),
593+ RepresentableKeyEvent(KeyEvent {
594+ code: KeyCode::F(12),
595+ modifiers: KeyModifiers::NONE
600+ fn parsing_modified_keys() {
602+ str::parse::<RepresentableKeyEvent>("S-minus").unwrap(),
603+ RepresentableKeyEvent(KeyEvent {
604+ code: KeyCode::Char('-'),
605+ modifiers: KeyModifiers::SHIFT
610+ str::parse::<RepresentableKeyEvent>("C-A-S-F12").unwrap(),
611+ RepresentableKeyEvent(KeyEvent {
612+ code: KeyCode::F(12),
613+ modifiers: KeyModifiers::SHIFT | KeyModifiers::CONTROL | KeyModifiers::ALT
618+ str::parse::<RepresentableKeyEvent>("S-C-2").unwrap(),
619+ RepresentableKeyEvent(KeyEvent {
620+ code: KeyCode::F(2),
621+ modifiers: KeyModifiers::SHIFT | KeyModifiers::CONTROL
627+ fn parsing_nonsensical_keys_fails() {
628+ assert!(str::parse::<RepresentableKeyEvent>("F13").is_err());
629+ assert!(str::parse::<RepresentableKeyEvent>("F0").is_err());
630+ assert!(str::parse::<RepresentableKeyEvent>("aaa").is_err());
631+ assert!(str::parse::<RepresentableKeyEvent>("S-S-a").is_err());
632+ assert!(str::parse::<RepresentableKeyEvent>("C-A-S-C-1").is_err());
633+ assert!(str::parse::<RepresentableKeyEvent>("FU").is_err());
634+ assert!(str::parse::<RepresentableKeyEvent>("123").is_err());
635+ assert!(str::parse::<RepresentableKeyEvent>("S--").is_err());