@ -1,7 +1,7 @@
pub use crate ::commands ::Command ;
use crate ::config ::Config ;
use helix_core ::hashmap ;
use helix_view ::{ document ::Mode , in put::KeyEvent } ;
use helix_view ::{ document ::Mode , in fo::Info , in put::KeyEvent } ;
use serde ::Deserialize ;
use std ::{
collections ::HashMap ,
@ -24,30 +24,276 @@ macro_rules! key {
} ;
}
macro_rules! ctrl {
( $( $ch :tt ) * ) = > {
KeyEvent {
code : ::helix_view ::keyboard ::KeyCode ::Char ( $( $ch ) * ) ,
modifiers : ::helix_view ::keyboard ::KeyModifiers ::CONTROL ,
/// Macro for defining the root of a `Keymap` object. Example:
///
/// ```
/// # use helix_core::hashmap;
/// # use helix_term::keymap;
/// # use helix_term::keymap::Keymap;
/// let normal_mode = keymap!({ "Normal mode"
/// "i" => insert_mode,
/// "g" => { "Goto"
/// "g" => goto_file_start,
/// "e" => goto_file_end,
/// },
/// "j" | "down" => move_line_down,
/// });
/// let keymap = Keymap::new(normal_mode);
/// ```
#[ macro_export ]
macro_rules! keymap {
( @ trie $cmd :ident ) = > {
$crate ::keymap ::KeyTrie ::Leaf ( $crate ::commands ::Command ::$cmd )
} ;
( @ trie
{ $label :literal $( $( $key :literal ) | + = > $value :tt , ) + }
) = > {
keymap ! ( { $label $( $( $key ) | + = > $value , ) + } )
} ;
(
{ $label :literal $( $( $key :literal ) | + = > $value :tt , ) + }
) = > {
// modified from the hashmap! macro
{
let _cap = hashmap ! ( @ count $( $( $key ) , + ) , * ) ;
let mut _map = ::std ::collections ::HashMap ::with_capacity ( _cap ) ;
let mut _order = ::std ::vec ::Vec ::with_capacity ( _cap ) ;
$(
$(
let _key = $key . parse ::< ::helix_view ::input ::KeyEvent > ( ) . unwrap ( ) ;
_map . insert (
_key ,
keymap ! ( @ trie $value )
) ;
_order . push ( _key ) ;
) +
) *
$crate ::keymap ::KeyTrie ::Node ( $crate ::keymap ::KeyTrieNode ::new ( $label , _map , _order ) )
}
} ;
}
macro_rules! alt {
( $( $ch :tt ) * ) = > {
KeyEvent {
code : ::helix_view ::keyboard ::KeyCode ::Char ( $( $ch ) * ) ,
modifiers : ::helix_view ::keyboard ::KeyModifiers ::ALT ,
#[ derive(Debug, Clone, Deserialize) ]
pub struct KeyTrieNode {
/// A label for keys coming under this node, like "Goto mode"
#[ serde(skip) ]
name : String ,
#[ serde(flatten) ]
map : HashMap < KeyEvent , KeyTrie > ,
#[ serde(skip) ]
order : Vec < KeyEvent > ,
}
impl KeyTrieNode {
pub fn new ( name : & str , map : HashMap < KeyEvent , KeyTrie > , order : Vec < KeyEvent > ) -> Self {
Self {
name : name . to_string ( ) ,
map ,
order ,
}
} ;
}
pub fn name ( & self ) -> & str {
& self . name
}
/// Merge another Node in. Leaves and subnodes from the other node replace
/// corresponding keyevent in self, except when both other and self have
/// subnodes for same key. In that case the merge is recursive.
pub fn merge ( & mut self , mut other : Self ) {
for ( key , trie ) in std ::mem ::take ( & mut other . map ) {
if let Some ( KeyTrie ::Node ( node ) ) = self . map . get_mut ( & key ) {
if let KeyTrie ::Node ( other_node ) = trie {
node . merge ( other_node ) ;
continue ;
}
}
self . map . insert ( key , trie ) ;
}
for & key in self . map . keys ( ) {
if ! self . order . contains ( & key ) {
self . order . push ( key ) ;
}
}
}
}
impl From < KeyTrieNode > for Info {
fn from ( node : KeyTrieNode ) -> Self {
let mut body : Vec < ( & str , Vec < KeyEvent > ) > = Vec ::with_capacity ( node . len ( ) ) ;
for ( & key , trie ) in node . iter ( ) {
let desc = match trie {
KeyTrie ::Leaf ( cmd ) = > cmd . doc ( ) ,
KeyTrie ::Node ( n ) = > n . name ( ) ,
} ;
match body . iter ( ) . position ( | ( d , _ ) | d = = & desc ) {
// FIXME: multiple keys are ordered randomly (use BTreeSet)
Some ( pos ) = > body [ pos ] . 1. push ( key ) ,
None = > body . push ( ( desc , vec! [ key ] ) ) ,
}
}
body . sort_unstable_by_key ( | ( _ , keys ) | {
node . order . iter ( ) . position ( | & k | k = = keys [ 0 ] ) . unwrap ( )
} ) ;
let prefix = format! ( "{} " , node . name ( ) ) ;
if body . iter ( ) . all ( | ( desc , _ ) | desc . starts_with ( & prefix ) ) {
body = body
. into_iter ( )
. map ( | ( desc , keys ) | ( desc . strip_prefix ( & prefix ) . unwrap ( ) , keys ) )
. collect ( ) ;
}
Info ::key ( node . name ( ) , body )
}
}
impl Default for KeyTrieNode {
fn default ( ) -> Self {
Self ::new ( "" , HashMap ::new ( ) , Vec ::new ( ) )
}
}
impl PartialEq for KeyTrieNode {
fn eq ( & self , other : & Self ) -> bool {
self . map = = other . map
}
}
impl Deref for KeyTrieNode {
type Target = HashMap < KeyEvent , KeyTrie > ;
fn deref ( & self ) -> & Self ::Target {
& self . map
}
}
impl DerefMut for KeyTrieNode {
fn deref_mut ( & mut self ) -> & mut Self ::Target {
& mut self . map
}
}
#[ derive(Debug, Clone, PartialEq, Deserialize) ]
#[ serde(untagged) ]
pub enum KeyTrie {
Leaf ( Command ) ,
Node ( KeyTrieNode ) ,
}
impl KeyTrie {
pub fn node ( & self ) -> Option < & KeyTrieNode > {
match * self {
KeyTrie ::Node ( ref node ) = > Some ( node ) ,
KeyTrie ::Leaf ( _ ) = > None ,
}
}
pub fn node_mut ( & mut self ) -> Option < & mut KeyTrieNode > {
match * self {
KeyTrie ::Node ( ref mut node ) = > Some ( node ) ,
KeyTrie ::Leaf ( _ ) = > None ,
}
}
/// Merge another KeyTrie in, assuming that this KeyTrie and the other
/// are both Nodes. Panics otherwise.
pub fn merge_nodes ( & mut self , mut other : Self ) {
let node = std ::mem ::take ( other . node_mut ( ) . unwrap ( ) ) ;
self . node_mut ( ) . unwrap ( ) . merge ( node ) ;
}
pub fn search ( & self , keys : & [ KeyEvent ] ) -> Option < & KeyTrie > {
let mut trie = self ;
for key in keys {
trie = match trie {
KeyTrie ::Node ( map ) = > map . get ( key ) ,
// leaf encountered while keys left to process
KeyTrie ::Leaf ( _ ) = > None ,
} ?
}
Some ( trie )
}
}
#[ derive(Debug, Clone, PartialEq) ]
pub enum KeymapResult {
/// Needs more keys to execute a command. Contains valid keys for next keystroke.
Pending ( KeyTrieNode ) ,
Matched ( Command ) ,
/// Key was not found in the root keymap
NotFound ,
/// Key is invalid in combination with previous keys. Contains keys leading upto
/// and including current (invalid) key.
Cancelled ( Vec < KeyEvent > ) ,
}
#[ derive(Debug, Clone, PartialEq, Deserialize) ]
pub struct Keymap {
/// Always a Node
#[ serde(flatten) ]
root : KeyTrie ,
#[ serde(skip) ]
state : Vec < KeyEvent > ,
}
impl Keymap {
pub fn new ( root : KeyTrie ) -> Self {
Keymap {
root ,
state : Vec ::new ( ) ,
}
}
pub fn root ( & self ) -> & KeyTrie {
& self . root
}
/// Lookup `key` in the keymap to try and find a command to execute
pub fn get ( & mut self , key : KeyEvent ) -> KeymapResult {
let & first = self . state . get ( 0 ) . unwrap_or ( & key ) ;
let trie = match self . root . search ( & [ first ] ) {
Some ( & KeyTrie ::Leaf ( cmd ) ) = > return KeymapResult ::Matched ( cmd ) ,
None = > return KeymapResult ::NotFound ,
Some ( t ) = > t ,
} ;
self . state . push ( key ) ;
match trie . search ( & self . state [ 1 .. ] ) {
Some ( & KeyTrie ::Node ( ref map ) ) = > KeymapResult ::Pending ( map . clone ( ) ) ,
Some ( & KeyTrie ::Leaf ( command ) ) = > {
self . state . clear ( ) ;
KeymapResult ::Matched ( command )
}
None = > KeymapResult ::Cancelled ( self . state . drain ( .. ) . collect ( ) ) ,
}
}
pub fn merge ( & mut self , other : Self ) {
self . root . merge_nodes ( other . root ) ;
}
}
impl Deref for Keymap {
type Target = KeyTrieNode ;
fn deref ( & self ) -> & Self ::Target {
& self . root . node ( ) . unwrap ( )
}
}
impl Default for Keymap {
fn default ( ) -> Self {
Self ::new ( KeyTrie ::Node ( KeyTrieNode ::default ( ) ) )
}
}
#[ derive(Debug, Clone, PartialEq, Deserialize) ]
#[ serde(transparent) ]
pub struct Keymaps ( pub HashMap < Mode , HashMap < KeyEvent , Command > > ) ;
pub struct Keymaps ( pub HashMap < Mode , Keymap > ) ;
impl Deref for Keymaps {
type Target = HashMap < Mode , HashMap < KeyEvent , Command > > ;
type Target = HashMap < Mode , Keymap > ;
fn deref ( & self ) -> & Self ::Target {
& self . 0
@ -62,252 +308,298 @@ impl DerefMut for Keymaps {
impl Default for Keymaps {
fn default ( ) -> Keymaps {
let normal = hashmap ! (
key ! ( 'h' ) = > Command ::move_char_left ,
key ! ( 'j' ) = > Command ::move_line_down ,
key ! ( 'k' ) = > Command ::move_line_up ,
key ! ( 'l' ) = > Command ::move_char_right ,
key ! ( Left ) = > Command ::move_char_left ,
key ! ( Down ) = > Command ::move_line_down ,
key ! ( Up ) = > Command ::move_line_up ,
key ! ( Right ) = > Command ::move_char_right ,
key ! ( 't' ) = > Command ::find_till_char ,
key ! ( 'f' ) = > Command ::find_next_char ,
key ! ( 'T' ) = > Command ::till_prev_char ,
key ! ( 'F' ) = > Command ::find_prev_char ,
// and matching set for select mode (extend)
//
key ! ( 'r' ) = > Command ::replace ,
key ! ( 'R' ) = > Command ::replace_with_yanked ,
key ! ( '~' ) = > Command ::switch_case ,
alt ! ( '`' ) = > Command ::switch_to_uppercase ,
key ! ( '`' ) = > Command ::switch_to_lowercase ,
key ! ( Home ) = > Command ::goto_line_start ,
key ! ( End ) = > Command ::goto_line_end ,
key ! ( 'w' ) = > Command ::move_next_word_start ,
key ! ( 'b' ) = > Command ::move_prev_word_start ,
key ! ( 'e' ) = > Command ::move_next_word_end ,
key ! ( 'W' ) = > Command ::move_next_long_word_start ,
key ! ( 'B' ) = > Command ::move_prev_long_word_start ,
key ! ( 'E' ) = > Command ::move_next_long_word_end ,
key ! ( 'v' ) = > Command ::select_mode ,
key ! ( 'g' ) = > Command ::goto_mode ,
key ! ( ':' ) = > Command ::command_mode ,
key ! ( 'i' ) = > Command ::insert_mode ,
key ! ( 'I' ) = > Command ::prepend_to_line ,
key ! ( 'a' ) = > Command ::append_mode ,
key ! ( 'A' ) = > Command ::append_to_line ,
key ! ( 'o' ) = > Command ::open_below ,
key ! ( 'O' ) = > Command ::open_above ,
let normal = keymap ! ( { "Normal mode"
"h" | "left" = > move_char_left ,
"j" | "down" = > move_line_down ,
"k" | "up" = > move_line_up ,
"l" | "right" = > move_char_right ,
"t" = > find_till_char ,
"f" = > find_next_char ,
"T" = > till_prev_char ,
"F" = > find_prev_char ,
"r" = > replace ,
"R" = > replace_with_yanked ,
"~" = > switch_case ,
"`" = > switch_to_lowercase ,
"A-`" = > switch_to_uppercase ,
"home" = > goto_line_start ,
"end" = > goto_line_end ,
"w" = > move_next_word_start ,
"b" = > move_prev_word_start ,
"e" = > move_next_word_end ,
"W" = > move_next_long_word_start ,
"B" = > move_prev_long_word_start ,
"E" = > move_next_long_word_end ,
"v" = > select_mode ,
"g" = > { "Goto"
"g" = > goto_file_start ,
"e" = > goto_file_end ,
"h" = > goto_line_start ,
"l" = > goto_line_end ,
"s" = > goto_first_nonwhitespace ,
"d" = > goto_definition ,
"y" = > goto_type_definition ,
"r" = > goto_reference ,
"i" = > goto_implementation ,
"t" = > goto_window_top ,
"m" = > goto_window_middle ,
"b" = > goto_window_bottom ,
"a" = > goto_last_accessed_file ,
} ,
":" = > command_mode ,
"i" = > insert_mode ,
"I" = > prepend_to_line ,
"a" = > append_mode ,
"A" = > append_to_line ,
"o" = > open_below ,
"O" = > open_above ,
// [<space> ]<space> equivalents too (add blank new line, no edit)
key ! ( 'd' ) = > Command ::delete_selection ,
"d" = > delete_selection ,
// TODO: also delete without yanking
key ! ( 'c' ) = > Command ::change_selection ,
"c" = > change_selection ,
// TODO: also change delete without yanking
// key!('r') => Command::replace_with_char,
key ! ( 's' ) = > Command ::select_regex ,
alt ! ( 's' ) = > Command ::split_selection_on_newline ,
key ! ( 'S' ) = > Command ::split_selection ,
key ! ( ';' ) = > Command ::collapse_selection ,
alt ! ( ';' ) = > Command ::flip_selections ,
key ! ( '%' ) = > Command ::select_all ,
key ! ( 'x' ) = > Command ::extend_line ,
key ! ( 'X' ) = > Command ::extend_to_line_bounds ,
"s" = > select_regex ,
"A-s" = > split_selection_on_newline ,
"S" = > split_selection ,
";" = > collapse_selection ,
"A-;" = > flip_selections ,
"%" = > select_all ,
"x" = > extend_line ,
"X" = > extend_to_line_bounds ,
// crop_to_whole_line
"m" = > { "Match"
"m" = > match_brackets ,
"s" = > surround_add ,
"r" = > surround_replace ,
"d" = > surround_delete ,
"a" = > select_textobject_around ,
"i" = > select_textobject_inner ,
} ,
"[" = > { "Left bracket"
"d" = > goto_prev_diag ,
"D" = > goto_first_diag ,
} ,
"]" = > { "Right bracket"
"d" = > goto_next_diag ,
"D" = > goto_last_diag ,
} ,
key ! ( 'm' ) = > Command ::match_mode ,
key ! ( '[' ) = > Command ::left_bracket_mode ,
key ! ( ']' ) = > Command ::right_bracket_mode ,
key ! ( '/' ) = > Command ::search ,
"/" = > search ,
// ? for search_reverse
key ! ( 'n' ) = > Command ::search_next ,
key ! ( 'N' ) = > Command ::extend_search_next ,
"n" = > search_next ,
"N" = > extend_search_next ,
// N for search_prev
key ! ( '*' ) = > Command ::search_selection ,
"*" = > search_selection ,
key ! ( 'u' ) = > Command ::undo ,
key ! ( 'U' ) = > Command ::redo ,
"u" = > undo ,
"U" = > redo ,
key ! ( 'y' ) = > Command ::yank ,
"y" = > yank ,
// yank_all
key ! ( 'p' ) = > Command ::paste_after ,
"p" = > paste_after ,
// paste_all
key ! ( 'P' ) = > Command ::paste_before ,
"P" = > paste_before ,
key ! ( '>' ) = > Command ::indent ,
key ! ( '<' ) = > Command ::unindent ,
key ! ( '=' ) = > Command ::format_selections ,
key ! ( 'J' ) = > Command ::join_selections ,
">" = > indent ,
"<" = > unindent ,
"=" = > format_selections ,
"J" = > join_selections ,
// TODO: conflicts hover/doc
key ! ( 'K' ) = > Command ::keep_selections ,
"K" = > keep_selections ,
// TODO: and another method for inverse
// TODO: clashes with space mode
key ! ( ' ' ) = > Command ::keep_primary_selection ,
"space" = > keep_primary_selection ,
// key!('q') => Command:: record_macro,
// key!('Q') => Command:: replay_macro,
// "q" => record_macro,
// "Q" => replay_macro,
// ~ / apostrophe => change case
// & align selections
// _ trim selections
// C / altC = copy (repeat) selections on prev/next lines
key ! ( Esc ) = > Command ::normal_mode ,
key ! ( PageUp ) = > Command ::page_up ,
key ! ( PageDown ) = > Command ::page_down ,
ctrl ! ( 'b' ) = > Command ::page_up ,
ctrl ! ( 'f' ) = > Command ::page_down ,
ctrl ! ( 'u' ) = > Command ::half_page_up ,
ctrl ! ( 'd' ) = > Command ::half_page_down ,
ctrl ! ( 'w' ) = > Command ::window_mode ,
"esc" = > normal_mode ,
"C-b" | "pageup" = > page_up ,
"C-f" | "pagedown" = > page_down ,
"C-u" = > half_page_up ,
"C-d" = > half_page_down ,
"C-w" = > { "Window"
"C-w" | "w" = > rotate_view ,
"C-h" | "h" = > hsplit ,
"C-v" | "v" = > vsplit ,
"C-q" | "q" = > wclose ,
} ,
// move under <space>c
ctrl ! ( 'c' ) = > Command ::toggle_comments ,
key ! ( 'K' ) = > Command ::hover ,
"C-c" = > toggle_comments ,
"K" = > hover ,
// z family for save/restore/combine from/to sels from register
// supposedly ctrl!('i') but did not work
key ! ( Tab ) = > Command ::jump_forward ,
ctrl ! ( 'o' ) = > Command ::jump_backward ,
// ctrl!('s') => Command::save_selection,
key ! ( ' ' ) = > Command ::space_mode ,
key ! ( 'z' ) = > Command ::view_mode ,
// supposedly "C-i" but did not work
"tab" = > jump_forward ,
"C-o" = > jump_backward ,
// "C-s" => save_selection,
"space" = > { "Space"
"f" = > file_picker ,
"b" = > buffer_picker ,
"s" = > symbol_picker ,
"a" = > code_action ,
"'" = > last_picker ,
"w" = > { "Window"
"C-w" | "w" = > rotate_view ,
"C-h" | "h" = > hsplit ,
"C-v" | "v" = > vsplit ,
"C-q" | "q" = > wclose ,
} ,
"y" = > yank_joined_to_clipboard ,
"Y" = > yank_main_selection_to_clipboard ,
"p" = > paste_clipboard_after ,
"P" = > paste_clipboard_before ,
"R" = > replace_selections_with_clipboard ,
"space" = > keep_primary_selection ,
} ,
"z" = > { "View"
"z" | "c" = > align_view_center ,
"t" = > align_view_top ,
"b" = > align_view_bottom ,
"m" = > align_view_middle ,
"k" = > scroll_up ,
"j" = > scroll_down ,
} ,
key ! ( '"' ) = > Command ::select_register ,
) ;
"\"" = > select_register ,
} );
// TODO: decide whether we want normal mode to also be select mode (kakoune-like), or whether
// we keep this separate select mode. More keys can fit into normal mode then, but it's weird
// because some selection operations can now be done from normal mode, some from select mode.
let mut select = normal . clone ( ) ;
select . extend (
hashmap ! (
key ! ( 'h' ) = > Command ::extend_char_left ,
key ! ( 'j' ) = > Command ::extend_line_down ,
key ! ( 'k' ) = > Command ::extend_line_up ,
key ! ( 'l' ) = > Command ::extend_char_right ,
key ! ( Left ) = > Command ::extend_char_left ,
key ! ( Down ) = > Command ::extend_line_down ,
key ! ( Up ) = > Command ::extend_line_up ,
key ! ( Right ) = > Command ::extend_char_right ,
key ! ( 'w' ) = > Command ::extend_next_word_start ,
key ! ( 'b' ) = > Command ::extend_prev_word_start ,
key ! ( 'e' ) = > Command ::extend_next_word_end ,
key ! ( 't' ) = > Command ::extend_till_char ,
key ! ( 'f' ) = > Command ::extend_next_char ,
key ! ( 'T' ) = > Command ::extend_till_prev_char ,
key ! ( 'F' ) = > Command ::extend_prev_char ,
key ! ( Home ) = > Command ::goto_line_start ,
key ! ( End ) = > Command ::goto_line_end ,
key ! ( Esc ) = > Command ::exit_select_mode ,
)
. into_iter ( ) ,
) ;
select . merge_nodes ( keymap ! ( { "Select mode"
"h" | "left" = > extend_char_left ,
"j" | "down" = > extend_line_down ,
"k" | "up" = > extend_line_up ,
"l" | "right" = > extend_char_right ,
"w" = > extend_next_word_start ,
"b" = > extend_prev_word_start ,
"e" = > extend_next_word_end ,
"t" = > extend_till_char ,
"f" = > extend_next_char ,
"T" = > extend_till_prev_char ,
"F" = > extend_prev_char ,
"home" = > goto_line_start ,
"end" = > goto_line_end ,
"esc" = > exit_select_mode ,
} ) ) ;
let insert = keymap ! ( { "Insert mode"
"esc" = > normal_mode ,
"backspace" = > delete_char_backward ,
"del" = > delete_char_forward ,
"ret" = > insert_newline ,
"tab" = > insert_tab ,
"C-w" = > delete_word_backward ,
"left" = > move_char_left ,
"down" = > move_line_down ,
"up" = > move_line_up ,
"right" = > move_char_right ,
"pageup" = > page_up ,
"pagedown" = > page_down ,
"home" = > goto_line_start ,
"end" = > goto_line_end_newline ,
"C-x" = > completion ,
} ) ;
Keymaps ( hashmap ! (
// as long as you cast the first item, rust is able to infer the other cases
// TODO: select could be normal mode with some bindings merged over
Mode ::Normal = > normal ,
Mode ::Select = > select ,
Mode ::Insert = > hashmap ! (
key ! ( Esc ) = > Command ::normal_mode as Command ,
key ! ( Backspace ) = > Command ::delete_char_backward ,
key ! ( Delete ) = > Command ::delete_char_forward ,
key ! ( Enter ) = > Command ::insert_newline ,
key ! ( Tab ) = > Command ::insert_tab ,
key ! ( Left ) = > Command ::move_char_left ,
key ! ( Down ) = > Command ::move_line_down ,
key ! ( Up ) = > Command ::move_line_up ,
key ! ( Right ) = > Command ::move_char_right ,
key ! ( PageUp ) = > Command ::page_up ,
key ! ( PageDown ) = > Command ::page_down ,
key ! ( Home ) = > Command ::goto_line_start ,
key ! ( End ) = > Command ::goto_line_end_newline ,
ctrl ! ( 'x' ) = > Command ::completion ,
ctrl ! ( 'w' ) = > Command ::delete_word_backward ,
) ,
Mode ::Normal = > Keymap ::new ( normal ) ,
Mode ::Select = > Keymap ::new ( select ) ,
Mode ::Insert = > Keymap ::new ( insert ) ,
) )
}
}
/// Merge default config keys with user overwritten keys for custom
/// user config.
/// Merge default config keys with user overwritten keys for custom user config.
pub fn merge_keys ( mut config : Config ) -> Config {
let mut delta = std ::mem ::take ( & mut config . keys ) ;
for ( mode , keys ) in & mut * config . keys {
keys . extend ( delta . remove ( mode ) . unwrap_or_default ( ) ) ;
keys . merge ( delta . remove ( mode ) . unwrap_or_default ( ) )
}
config
}
#[ test ]
fn merge_partial_keys ( ) {
use helix_view ::keyboard ::{ KeyCode , KeyModifiers } ;
let config = Config {
keys : Keymaps ( hashmap ! {
Mode ::Normal = > hashmap ! {
KeyEvent {
code : KeyCode ::Char ( 'i' ) ,
modifiers : KeyModifiers ::NONE ,
} = > Command ::normal_mode ,
KeyEvent { // key that does not exist
code : KeyCode ::Char ( '无' ) ,
modifiers : KeyModifiers ::NONE ,
} = > Command ::insert_mode ,
} ,
Mode ::Normal = > Keymap ::new (
keymap ! ( { "Normal mode"
"i" = > normal_mode ,
"无" = > insert_mode ,
"z" = > jump_backward ,
"g" = > { "Merge into goto mode"
"$" = > goto_line_end ,
"g" = > delete_char_forward ,
} ,
} )
)
} ) ,
.. Default ::default ( )
} ;
let merged_config = merge_keys ( config . clone ( ) ) ;
let mut merged_config = merge_keys ( config . clone ( ) ) ;
assert_ne! ( config , merged_config ) ;
let keymap = merged_config . keys . 0. get_mut ( & Mode ::Normal ) . unwrap ( ) ;
assert_eq! (
* merged_config
. keys
. 0
. get ( & Mode ::Normal )
. unwrap ( )
. get ( & KeyEvent {
code : KeyCode ::Char ( 'i' ) ,
modifiers : KeyModifiers ::NONE
} )
. unwrap ( ) ,
Command ::normal_mode
keymap . get ( key ! ( 'i' ) ) ,
KeymapResult ::Matched ( Command ::normal_mode ) ,
"Leaf should replace leaf"
) ;
assert_eq! (
* merged_config
. keys
. 0
. get ( & Mode ::Normal )
. unwrap ( )
. get ( & KeyEvent {
code : KeyCode ::Char ( '无' ) ,
modifiers : KeyModifiers ::NONE
} )
. unwrap ( ) ,
Command ::insert_mode
keymap . get ( key ! ( '无' ) ) ,
KeymapResult ::Matched ( Command ::insert_mode ) ,
"New leaf should be present in merged keymap"
) ;
// Assumes that z is a node in the default keymap
assert_eq! (
keymap . get ( key ! ( 'z' ) ) ,
KeymapResult ::Matched ( Command ::jump_backward ) ,
"Leaf should replace node"
) ;
// Assumes that `g` is a node in default keymap
assert_eq! (
keymap . root ( ) . search ( & [ key ! ( 'g' ) , key ! ( '$' ) ] ) . unwrap ( ) ,
& KeyTrie ::Leaf ( Command ::goto_line_end ) ,
"Leaf should be present in merged subnode"
) ;
// Assumes that `gg` is in default keymap
assert_eq! (
keymap . root ( ) . search ( & [ key ! ( 'g' ) , key ! ( 'g' ) ] ) . unwrap ( ) ,
& KeyTrie ::Leaf ( Command ::delete_char_forward ) ,
"Leaf should replace old leaf in merged subnode"
) ;
// Assumes that `ge` is in default keymap
assert_eq! (
keymap . root ( ) . search ( & [ key ! ( 'g' ) , key ! ( 'e' ) ] ) . unwrap ( ) ,
& KeyTrie ::Leaf ( Command ::goto_file_end ) ,
"Old leaves in subnode should be present in merged node"
) ;
assert! ( merged_config . keys . 0. get ( & Mode ::Normal ) . unwrap ( ) . len ( ) > 1 ) ;
assert! ( merged_config . keys . 0. get ( & Mode ::Insert ) . unwrap ( ) . len ( ) > 0 ) ;
}
Gokul Soumya
3 years ago
committed by
GitHub