9926c2d · helix · git.iko.soy

git.iko.soy/helix

on master help sign in

Remove Keymap(KeyTrie) and simply use KeyTrie.

9926c2dgibbz003 years ago

helix-term/src/config.rs+7−8

compare with master

unifiedsplit

@@ -1,5 +1,5 @@

1use crate::keymap;

2−use crate::keymap::{merge_keys, Keymap};

2+use crate::keymap::{merge_keys, KeyTrie};

3use helix_loader::merge_toml_values;

4use helix_view::document::Mode;

5use serde::Deserialize;

@@ -12,7 +12,7 @@ use toml::de::Error as TomlError;

12#[derive(Debug, Clone, PartialEq)]

13pub struct Config {

14 pub theme: Option<String>,

15− pub keys: HashMap<Mode, Keymap>,

15+ pub keys: HashMap<Mode, KeyTrie>,

16 pub editor: helix_view::editor::Config,

17}

@@ -20,7 +20,7 @@ pub struct Config {

20#[serde(deny_unknown_fields)]

21pub struct ConfigRaw {

22 pub theme: Option<String>,

23− pub keys: Option<HashMap<Mode, Keymap>>,

23+ pub keys: Option<HashMap<Mode, KeyTrie>>,

24 pub editor: Option<toml::Value>,

25}

@@ -138,7 +138,6 @@ mod tests {

138 #[test]

139 fn parsing_keymaps_config_file() {

140 use crate::keymap;

141− use crate::keymap::Keymap;

142 use helix_core::hashmap;

141 use helix_core::hashmap;

143 use helix_view::document::Mode;

142 use helix_view::document::Mode;

144

143

@@ -155,13 +154,13 @@ mod tests {

155 merge_keys(

154 merge_keys(

156 &mut keys,

155 &mut keys,

157 hashmap! {

156 hashmap! {

158− Mode::Insert => Keymap::new(keymap!({ "Insert mode"

157+ Mode::Insert => keymap!({ "Insert mode"

159 "y" => move_line_down,

158 "y" => move_line_down,

160 "S-C-a" => delete_selection,

159 "S-C-a" => delete_selection,

161− })),

160+ }),

162− Mode::Normal => Keymap::new(keymap!({ "Normal mode"

161+ Mode::Normal => keymap!({ "Normal mode"

163 "A-F12" => move_next_word_end,

162 "A-F12" => move_next_word_end,

164− })),

163+ }),

165 },

164 },

166 );

165 );

167

166

helix-term/src/keymap.rs+15−45

@@ -269,41 +269,11 @@ pub enum KeymapResult {

269 Cancelled(Vec<KeyEvent>),

270}

271

272−#[derive(Debug, Clone, PartialEq, Deserialize)]

273−#[serde(transparent)]

274−pub struct Keymap(KeyTrie);

275−

276/// A map of command names to keybinds that will execute the command.

272/// A map of command names to keybinds that will execute the command.

277pub type ReverseKeymap = HashMap<String, Vec<Vec<KeyEvent>>>;

273pub type ReverseKeymap = HashMap<String, Vec<Vec<KeyEvent>>>;

278

274

279−impl Keymap {

280− pub fn new(root: KeyTrie) -> Self {

281− Keymap(root)

282− }

283−}

284−

285−impl Deref for Keymap {

286− type Target = KeyTrie;

287−

288− fn deref(&self) -> &Self::Target {

289− &self.0

290− }

291−}

292−

293−impl DerefMut for Keymap {

294− fn deref_mut(&mut self) -> &mut Self::Target {

295− &mut self.0

296− }

297−}

298−

299−impl Default for Keymap {

300− fn default() -> Self {

301− Self(KeyTrie::Node(KeyTrieNode::default()))

302− }

303−}

304−

305pub struct Keymaps {

275pub struct Keymaps {

306− pub map: Box<dyn DynAccess<HashMap<Mode, Keymap>>>,

276+ pub map: Box<dyn DynAccess<HashMap<Mode, KeyTrie>>>,

307 /// Stores pending keys waiting for the next key. This is relative to a

277 /// Stores pending keys waiting for the next key. This is relative to a

308 /// sticky node if one is in use.

278 /// sticky node if one is in use.

309 state: Vec<KeyEvent>,

279 state: Vec<KeyEvent>,

@@ -312,7 +282,7 @@ pub struct Keymaps {

312}

282}

313

283

314impl Keymaps {

284impl Keymaps {

315− pub fn new(map: Box<dyn DynAccess<HashMap<Mode, Keymap>>>) -> Self {

285+ pub fn new(map: Box<dyn DynAccess<HashMap<Mode, KeyTrie>>>) -> Self {

316 Self {

286 Self {

317 map,

287 map,

318 state: Vec::new(),

288 state: Vec::new(),

@@ -320,7 +290,7 @@ impl Keymaps {

320 }

290 }

321 }

291 }

322

292

323− pub fn map(&self) -> DynGuard<HashMap<Mode, Keymap>> {

293+ pub fn map(&self) -> DynGuard<HashMap<Mode, KeyTrie>> {

324 self.map.load()

294 self.map.load()

325 }

295 }

326

296

@@ -352,7 +322,7 @@ impl Keymaps {

352 let first = self.state.get(0).unwrap_or(&key);

322 let first = self.state.get(0).unwrap_or(&key);

353 let trie_node = match self.sticky {

323 let trie_node = match self.sticky {

354 Some(ref trie) => Cow::Owned(KeyTrie::Node(trie.clone())),

324 Some(ref trie) => Cow::Owned(KeyTrie::Node(trie.clone())),

355− None => Cow::Borrowed(&keymap.0),

325+ None => Cow::Borrowed(keymap),

356 };

326 };

357

327

358 let trie = match trie_node.search(&[*first]) {

328 let trie = match trie_node.search(&[*first]) {

@@ -395,9 +365,13 @@ impl Default for Keymaps {

395}

365}

396

366

397/// Merge default config keys with user overwritten keys for custom user config.

367/// Merge default config keys with user overwritten keys for custom user config.

398−pub fn merge_keys(dst: &mut HashMap<Mode, Keymap>, mut delta: HashMap<Mode, Keymap>) {

368+pub fn merge_keys(dst: &mut HashMap<Mode, KeyTrie>, mut delta: HashMap<Mode, KeyTrie>) {

399 for (mode, keys) in dst {

369 for (mode, keys) in dst {

400− keys.merge_nodes(delta.remove(mode).unwrap_or_default().0)

370+ keys.merge_nodes(

371+ delta

372+ .remove(mode)

373+ .unwrap_or_else(|| KeyTrie::Node(KeyTrieNode::default())),

374+ )

401 }

375 }

402}

376}

403

377

@@ -426,8 +400,7 @@ mod tests {

426 #[test]

400 #[test]

427 fn merge_partial_keys() {

401 fn merge_partial_keys() {

428 let keymap = hashmap! {

402 let keymap = hashmap! {

429− Mode::Normal => Keymap::new(

430− keymap!({ "Normal mode"

403+ Mode::Normal => keymap!({ "Normal mode"

431 "i" => normal_mode,

404 "i" => normal_mode,

432 "无" => insert_mode,

405 "无" => insert_mode,

433 "z" => jump_backward,

406 "z" => jump_backward,

@@ -436,7 +409,6 @@ mod tests {

436 "g" => delete_char_forward,

409 "g" => delete_char_forward,

437 },

410 },

438 })

411 })

439− )

440 };

412 };

441 let mut merged_keyamp = default();

413 let mut merged_keyamp = default();

442 merge_keys(&mut merged_keyamp, keymap.clone());

414 merge_keys(&mut merged_keyamp, keymap.clone());

@@ -501,8 +473,7 @@ mod tests {

501 #[test]

473 #[test]

502 fn order_should_be_set() {

474 fn order_should_be_set() {

503 let keymap = hashmap! {

475 let keymap = hashmap! {

504− Mode::Normal => Keymap::new(

505− keymap!({ "Normal mode"

476+ Mode::Normal => keymap!({ "Normal mode"

506 "space" => { ""

477 "space" => { ""

507 "s" => { ""

478 "s" => { ""

508 "v" => vsplit,

479 "v" => vsplit,

@@ -510,7 +481,6 @@ mod tests {

510 },

481 },

511 },

482 },

512 })

483 })

513− )

514 };

484 };

515 let mut merged_keyamp = default();

485 let mut merged_keyamp = default();

516 merge_keys(&mut merged_keyamp, keymap.clone());

486 merge_keys(&mut merged_keyamp, keymap.clone());

@@ -553,7 +523,7 @@ mod tests {

553 },

523 },

554 "j" | "k" => move_line_down,

524 "j" | "k" => move_line_down,

555 });

525 });

556− let keymap = Keymap::new(normal_mode);

526+ let keymap = normal_mode;

557 let mut reverse_map = keymap.reverse_map();

527 let mut reverse_map = keymap.reverse_map();

558

528

559 // sort keybindings in order to have consistent tests

529 // sort keybindings in order to have consistent tests

@@ -601,7 +571,7 @@ mod tests {

601 modifiers: KeyModifiers::NONE,

571 modifiers: KeyModifiers::NONE,

602 };

572 };

603

573

604− let expectation = Keymap::new(KeyTrie::Node(KeyTrieNode::new(

574+ let expectation = KeyTrie::Node(KeyTrieNode::new(

605 "",

575 "",

606 hashmap! {

576 hashmap! {

607 key => KeyTrie::Sequence(vec!{

577 key => KeyTrie::Sequence(vec!{

@@ -618,7 +588,7 @@ mod tests {

618 })

588 })

619 },

589 },

620 vec![key],

590 vec![key],

621− )));

591+ ));

622

592

623 assert_eq!(toml::from_str(keys), Ok(expectation));

593 assert_eq!(toml::from_str(keys), Ok(expectation));

624 }

594 }

helix-term/src/keymap/default.rs+5−5

@@ -1,10 +1,10 @@

1use std::collections::HashMap;

3use super::macros::keymap;

4−use super::{Keymap, Mode};

4+use super::{KeyTrie, Mode};

5use helix_core::hashmap;

7−pub fn default() -> HashMap<Mode, Keymap> {

7+pub fn default() -> HashMap<Mode, KeyTrie> {

8 let normal = keymap!({ "Normal mode"

9 "h" | "left" => move_char_left,

10 "j" | "down" => move_visual_line_down,

@@ -380,8 +380,8 @@ pub fn default() -> HashMap<Mode, Keymap> {

380 "end" => goto_line_end_newline,

381 });

382 hashmap!(

383− Mode::Normal => Keymap::new(normal),

383+ Mode::Normal => normal,

384− Mode::Select => Keymap::new(select),

384+ Mode::Select => select,

385− Mode::Insert => Keymap::new(insert),

385+ Mode::Insert => insert,

386 )

387}

helix-term/src/keymap/macros.rs+2−3

@@ -62,12 +62,11 @@ macro_rules! alt {

62 };

63}

65−/// Macro for defining the root of a `Keymap` object. Example:

65+/// Macro for defining a `KeyTrie`. Example:

66///

67/// ```

68/// # use helix_core::hashmap;

69/// # use helix_term::keymap;

70−/// # use helix_term::keymap::Keymap;

71/// let normal_mode = keymap!({ "Normal mode"

70/// let normal_mode = keymap!({ "Normal mode"

72/// "i" => insert_mode,

71/// "i" => insert_mode,

73/// "g" => { "Goto"

72/// "g" => { "Goto"

@@ -76,7 +75,7 @@ macro_rules! alt {

76/// },

75/// },

77/// "j" | "down" => move_line_down,

76/// "j" | "down" => move_line_down,

78/// });

77/// });

79−/// let keymap = Keymap::new(normal_mode);

78+/// let keymap = normal_mode;

80/// ```

79/// ```

81#[macro_export]

80#[macro_export]

82macro_rules! keymap {

81macro_rules! keymap {