f7df53c · helix · git.iko.soy

252

253#[derive(Debug, Clone, PartialEq, Deserialize)]

254#[serde(transparent)]

255−pub struct Keymap {

255+pub struct Keymap(KeyTrie);

256− /// Always a Node

257− root: KeyTrie,

258−}

259

256

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

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

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

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

262

259

263impl Keymap {

260impl Keymap {

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

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

265− Keymap { root }

262+ Keymap(root)

266 }

263 }

267

264

268 pub fn reverse_map(&self) -> ReverseKeymap {

265 pub fn reverse_map(&self) -> ReverseKeymap {

290 }

287 }

291

288

292 let mut res = HashMap::new();

289 let mut res = HashMap::new();

293− map_node(&mut res, &self.root, &mut Vec::new());

290+ map_node(&mut res, &self.0, &mut Vec::new());

294 res

291 res

295 }

292 }

296−

297− pub fn root(&self) -> &KeyTrie {

298− &self.root

299− }

300−

301− pub fn merge(&mut self, other: Self) {

302− self.root.merge_nodes(other.root);

303− }

304}

293}

305

294

306impl Deref for Keymap {

295impl Deref for Keymap {

307− type Target = KeyTrieNode;

296+ type Target = KeyTrie;

308

297

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

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

310− self.root.node().unwrap()

299+ &self.0

300+ }

301+}

302+

303+impl DerefMut for Keymap {

304+ fn deref_mut(&mut self) -> &mut Self::Target {

305+ &mut self.0

311 }

306 }

312}

307}

313

308

314impl Default for Keymap {

309impl Default for Keymap {

315 fn default() -> Self {

310 fn default() -> Self {

316− Self::new(KeyTrie::Node(KeyTrieNode::default()))

311+ Self(KeyTrie::Node(KeyTrieNode::default()))

317 }

312 }

318}

313}

319

314

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

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

368 let trie_node = match self.sticky {

363 let trie_node = match self.sticky {

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

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

370− None => Cow::Borrowed(&keymap.root),

365+ None => Cow::Borrowed(&keymap.0),

371 };

366 };

372

367

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

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

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

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

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

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

414 for (mode, keys) in dst {

409 for (mode, keys) in dst {

415− keys.merge(delta.remove(mode).unwrap_or_default())

410+ keys.merge_nodes(delta.remove(mode).unwrap_or_default().0)

416 }

411 }

417}

412}

418

413

478 let keymap = merged_keyamp.get_mut(&Mode::Normal).unwrap();

473 let keymap = merged_keyamp.get_mut(&Mode::Normal).unwrap();

479 // Assumes that `g` is a node in default keymap

474 // Assumes that `g` is a node in default keymap

480 assert_eq!(

475 assert_eq!(

481− keymap.root().search(&[key!('g'), key!('$')]).unwrap(),

476+ keymap.search(&[key!('g'), key!('$')]).unwrap(),

482 &KeyTrie::MappableCommand(MappableCommand::goto_line_end),

477 &KeyTrie::MappableCommand(MappableCommand::goto_line_end),

483 "Leaf should be present in merged subnode"

478 "Leaf should be present in merged subnode"

484 );

479 );

485 // Assumes that `gg` is in default keymap

480 // Assumes that `gg` is in default keymap

486 assert_eq!(

481 assert_eq!(

487− keymap.root().search(&[key!('g'), key!('g')]).unwrap(),

482+ keymap.search(&[key!('g'), key!('g')]).unwrap(),

488 &KeyTrie::MappableCommand(MappableCommand::delete_char_forward),

483 &KeyTrie::MappableCommand(MappableCommand::delete_char_forward),

489 "Leaf should replace old leaf in merged subnode"

484 "Leaf should replace old leaf in merged subnode"

490 );

485 );

491 // Assumes that `ge` is in default keymap

486 // Assumes that `ge` is in default keymap

492 assert_eq!(

487 assert_eq!(

493− keymap.root().search(&[key!('g'), key!('e')]).unwrap(),

488+ keymap.search(&[key!('g'), key!('e')]).unwrap(),

494 &KeyTrie::MappableCommand(MappableCommand::goto_last_line),

489 &KeyTrie::MappableCommand(MappableCommand::goto_last_line),

495 "Old leaves in subnode should be present in merged node"

490 "Old leaves in subnode should be present in merged node"

496 );

491 );

497

492

493+ assert!(

498− assert!(merged_keyamp.get(&Mode::Normal).unwrap().len() > 1);

494+ merged_keyamp

495+ .get(&Mode::Normal)

496+ .and_then(|key_trie| key_trie.node())

497+ .unwrap()

498+ .len()

499+ > 1

500+ );

501+ assert!(

499− assert!(merged_keyamp.get(&Mode::Insert).unwrap().len() > 0);

502+ merged_keyamp

503+ .get(&Mode::Insert)

504+ .and_then(|key_trie| key_trie.node())

505+ .unwrap()

506+ .len()

507+ > 0

508+ );

500 }

509 }

501

510

502 #[test]

511 #[test]

519 let keymap = merged_keyamp.get_mut(&Mode::Normal).unwrap();

528 let keymap = merged_keyamp.get_mut(&Mode::Normal).unwrap();

520 // Make sure mapping works

529 // Make sure mapping works

521 assert_eq!(

530 assert_eq!(

522− keymap

523− .root()

524− .search(&[key!(' '), key!('s'), key!('v')])

531+ keymap.search(&[key!(' '), key!('s'), key!('v')]).unwrap(),

525− .unwrap(),

526 &KeyTrie::MappableCommand(MappableCommand::vsplit),

532 &KeyTrie::MappableCommand(MappableCommand::vsplit),

527 "Leaf should be present in merged subnode"

533 "Leaf should be present in merged subnode"

528 );

534 );

529 // Make sure an order was set during merge

535 // Make sure an order was set during merge

530− let node = keymap.root().search(&[crate::key!(' ')]).unwrap();

536+ let node = keymap.search(&[crate::key!(' ')]).unwrap();

531 assert!(!node.node().unwrap().order().is_empty())

537 assert!(!node.node().unwrap().order().is_empty())

532 }

538 }

533

539

534 #[test]

540 #[test]

535 fn aliased_modes_are_same_in_default_keymap() {

541 fn aliased_modes_are_same_in_default_keymap() {

536 let keymaps = Keymaps::default().map();

542 let keymaps = Keymaps::default().map();

537− let root = keymaps.get(&Mode::Normal).unwrap().root();

543+ let root = keymaps.get(&Mode::Normal).unwrap();

538 assert_eq!(

544 assert_eq!(

539 root.search(&[key!(' '), key!('w')]).unwrap(),

545 root.search(&[key!(' '), key!('w')]).unwrap(),

540 root.search(&["C-w".parse::<KeyEvent>().unwrap()]).unwrap(),

546 root.search(&["C-w".parse::<KeyEvent>().unwrap()]).unwrap(),