use iced::keyboard;
use iced::widget::canvas::Action;
use crate::canvas_editor::features::vim::VimMode;
use crate::canvas_editor::{CodeEditor, Message};
fn is_key_char(
key: &keyboard::Key,
modified_key: &keyboard::Key,
ch: &str,
) -> bool {
matches!(key, keyboard::Key::Character(c) if c.as_str() == ch)
|| matches!(modified_key, keyboard::Key::Character(c) if c.as_str() == ch)
}
pub(super) fn command_pressed(modifiers: &keyboard::Modifiers) -> bool {
modifiers.command() || modifiers.control()
}
fn vim_toggle_shortcut(
key: &keyboard::Key,
modified_key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
if command_pressed(modifiers)
&& modifiers.alt()
&& !modifiers.shift()
&& is_key_char(key, modified_key, "v")
{
return Some(Action::publish(Message::ToggleVimMode).and_capture());
}
None
}
fn write_shortcut(
key: &keyboard::Key,
modified_key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
if command_pressed(modifiers)
&& !modifiers.alt()
&& !modifiers.shift()
&& is_key_char(key, modified_key, "s")
{
return Some(Action::publish(Message::WriteRequested).and_capture());
}
None
}
fn clipboard_shortcut(
key: &keyboard::Key,
modified_key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
if (command_pressed(modifiers) && is_key_char(key, modified_key, "c"))
|| (modifiers.control()
&& matches!(
key,
keyboard::Key::Named(keyboard::key::Named::Insert)
))
{
return Some(Action::publish(Message::Copy).and_capture());
}
if command_pressed(modifiers) && is_key_char(key, modified_key, "x") {
return Some(Action::publish(Message::Cut).and_capture());
}
if command_pressed(modifiers) && is_key_char(key, modified_key, "a") {
return Some(Action::publish(Message::SelectAll).and_capture());
}
if (command_pressed(modifiers) && is_key_char(key, modified_key, "v"))
|| (modifiers.shift()
&& matches!(
key,
keyboard::Key::Named(keyboard::key::Named::Insert)
))
{
return Some(Action::publish(Message::Paste(String::new())));
}
None
}
fn multi_cursor_shortcut(
key: &keyboard::Key,
modified_key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
if command_pressed(modifiers) && is_key_char(key, modified_key, "d") {
return Some(
Action::publish(Message::SelectNextOccurrence).and_capture(),
);
}
if modifiers.control()
&& modifiers.alt()
&& matches!(key, keyboard::Key::Named(keyboard::key::Named::ArrowUp))
{
return Some(Action::publish(Message::AddCursorAbove).and_capture());
}
if modifiers.control()
&& modifiers.alt()
&& matches!(key, keyboard::Key::Named(keyboard::key::Named::ArrowDown))
{
return Some(Action::publish(Message::AddCursorBelow).and_capture());
}
None
}
fn editing_shortcut(
key: &keyboard::Key,
modified_key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
if command_pressed(modifiers) && is_key_char(key, modified_key, "/") {
return Some(Action::publish(Message::ToggleComment).and_capture());
}
if modifiers.shift()
&& matches!(key, keyboard::Key::Named(keyboard::key::Named::Delete))
{
return Some(Action::publish(Message::DeleteSelection).and_capture());
}
None
}
fn line_move_shortcut(
key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
if !modifiers.alt() || modifiers.control() {
return None;
}
if matches!(key, keyboard::Key::Named(keyboard::key::Named::ArrowUp)) {
let message = if modifiers.shift() {
Message::DuplicateLineUp
} else {
Message::MoveLineUp
};
return Some(Action::publish(message).and_capture());
}
if matches!(key, keyboard::Key::Named(keyboard::key::Named::ArrowDown)) {
let message = if modifiers.shift() {
Message::DuplicateLineDown
} else {
Message::MoveLineDown
};
return Some(Action::publish(message).and_capture());
}
None
}
fn word_modifier(modifiers: &keyboard::Modifiers) -> bool {
if cfg!(target_os = "macos") {
modifiers.alt() && !modifiers.control() && !modifiers.logo()
} else {
modifiers.control() && !modifiers.alt() && !modifiers.logo()
}
}
fn word_shortcut(
key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
use keyboard::key::Named;
if !word_modifier(modifiers) {
return None;
}
let keyboard::Key::Named(named) = key else {
return None;
};
let message = match named {
Named::ArrowLeft => Message::WordLeft(modifiers.shift()),
Named::ArrowRight => Message::WordRight(modifiers.shift()),
Named::Backspace if !modifiers.shift() => Message::DeleteWordBack,
Named::Delete if !modifiers.shift() => Message::DeleteWordForward,
_ => return None,
};
Some(Action::publish(message).and_capture())
}
fn navigation_shortcut(
key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
if command_pressed(modifiers)
&& matches!(key, keyboard::Key::Named(keyboard::key::Named::Home))
{
return Some(Action::publish(Message::CtrlHome).and_capture());
}
if command_pressed(modifiers)
&& matches!(key, keyboard::Key::Named(keyboard::key::Named::End))
{
return Some(Action::publish(Message::CtrlEnd).and_capture());
}
None
}
impl CodeEditor {
pub(super) fn handle_keyboard_shortcuts(
&self,
key: &keyboard::Key,
modified_key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
vim_toggle_shortcut(key, modified_key, modifiers)
.or_else(|| write_shortcut(key, modified_key, modifiers))
.or_else(|| self.focus_navigation_shortcut(key, modifiers))
.or_else(|| clipboard_shortcut(key, modified_key, modifiers))
.or_else(|| self.history_shortcut(key, modified_key, modifiers))
.or_else(|| self.dialog_shortcut(key, modified_key, modifiers))
.or_else(|| self.escape_shortcut(key))
.or_else(|| multi_cursor_shortcut(key, modified_key, modifiers))
.or_else(|| editing_shortcut(key, modified_key, modifiers))
.or_else(|| line_move_shortcut(key, modifiers))
.or_else(|| word_shortcut(key, modifiers))
.or_else(|| navigation_shortcut(key, modifiers))
.or_else(|| self.folding_shortcut(key, modified_key, modifiers))
}
fn focus_navigation_shortcut(
&self,
key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
if matches!(key, keyboard::Key::Named(keyboard::key::Named::Tab))
&& modifiers.shift()
&& !self.search_state.is_open
{
return Some(Action::publish(Message::Backtab).and_capture());
}
None
}
fn history_shortcut(
&self,
key: &keyboard::Key,
modified_key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
if command_pressed(modifiers)
&& !modifiers.shift()
&& is_key_char(key, modified_key, "z")
{
return Some(Action::publish(Message::Undo).and_capture());
}
if command_pressed(modifiers)
&& (is_key_char(key, modified_key, "y")
|| (modifiers.shift() && is_key_char(key, modified_key, "z")))
{
return Some(Action::publish(Message::Redo).and_capture());
}
if self.vim_enabled
&& self.vim_state.mode() == VimMode::Normal
&& modifiers.control()
&& !modifiers.shift()
&& is_key_char(key, modified_key, "r")
{
return Some(Action::publish(Message::Redo).and_capture());
}
None
}
fn dialog_shortcut(
&self,
key: &keyboard::Key,
modified_key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
if command_pressed(modifiers)
&& modifiers.shift()
&& is_key_char(key, modified_key, "p")
&& self.command_palette_enabled
{
return Some(
Action::publish(Message::OpenCommandPalette).and_capture(),
);
}
if command_pressed(modifiers)
&& is_key_char(key, modified_key, "f")
&& self.search_replace_enabled
{
return Some(Action::publish(Message::OpenSearch).and_capture());
}
if command_pressed(modifiers)
&& is_key_char(key, modified_key, "h")
&& self.search_replace_enabled
{
return Some(
Action::publish(Message::OpenSearchReplace).and_capture(),
);
}
if command_pressed(modifiers) && is_key_char(key, modified_key, "g") {
return Some(Action::publish(Message::OpenGotoLine).and_capture());
}
if matches!(key, keyboard::Key::Named(keyboard::key::Named::Tab))
&& self.search_state.is_open
{
let message = if modifiers.shift() {
Message::SearchDialogShiftTab
} else {
Message::SearchDialogTab
};
return Some(Action::publish(message).and_capture());
}
if matches!(key, keyboard::Key::Named(keyboard::key::Named::F3))
&& self.search_replace_enabled
{
let message = if modifiers.shift() {
Message::FindPrevious
} else {
Message::FindNext
};
return Some(Action::publish(message).and_capture());
}
None
}
fn escape_shortcut(&self, key: &keyboard::Key) -> Option<Action<Message>> {
if !matches!(key, keyboard::Key::Named(keyboard::key::Named::Escape)) {
return None;
}
let message = if self.command_palette_state.is_open {
Some(Message::CloseCommandPalette)
} else if self.goto_line_state.is_open {
Some(Message::CloseGotoLine)
} else if self.search_state.is_open {
Some(Message::CloseSearch)
} else if self.vim_enabled {
Some(Message::VimKey('\u{1b}'))
} else if self.cursors.is_multi() {
Some(Message::CloseSearch)
} else {
None
};
message.map(|message| Action::publish(message).and_capture())
}
fn folding_shortcut(
&self,
key: &keyboard::Key,
modified_key: &keyboard::Key,
modifiers: &keyboard::Modifiers,
) -> Option<Action<Message>> {
if !self.folding_enabled {
return None;
}
if modifiers.control() && is_key_char(key, modified_key, ".") {
return Some(
Action::publish(Message::ToggleFoldAtCursor).and_capture(),
);
}
if modifiers.control()
&& !modifiers.shift()
&& !modifiers.alt()
&& is_key_char(key, modified_key, "k")
{
return Some(Action::publish(Message::FoldAll).and_capture());
}
if modifiers.control()
&& !modifiers.shift()
&& !modifiers.alt()
&& is_key_char(key, modified_key, "j")
{
return Some(Action::publish(Message::UnfoldAll).and_capture());
}
None
}
}
#[cfg(test)]
mod tests {
use super::*;
use iced::event;
#[test]
fn test_command_pressed_accepts_either_command_or_control() {
assert!(command_pressed(&keyboard::Modifiers::CTRL));
assert!(command_pressed(&keyboard::Modifiers::COMMAND));
assert!(command_pressed(
&(keyboard::Modifiers::CTRL | keyboard::Modifiers::SHIFT)
));
assert!(!command_pressed(&keyboard::Modifiers::SHIFT));
assert!(!command_pressed(&keyboard::Modifiers::ALT));
assert!(!command_pressed(&keyboard::Modifiers::default()));
}
fn character(ch: &str) -> keyboard::Key {
keyboard::Key::Character(ch.into())
}
fn named(key: keyboard::key::Named) -> keyboard::Key {
keyboard::Key::Named(key)
}
fn shortcut(
editor: &CodeEditor,
key: &keyboard::Key,
modifiers: keyboard::Modifiers,
) -> Option<Message> {
editor
.handle_keyboard_shortcuts(key, key, &modifiers)
.and_then(|action| action.into_inner().0)
}
fn shortcut_status(
editor: &CodeEditor,
key: &keyboard::Key,
modifiers: keyboard::Modifiers,
) -> Option<event::Status> {
editor
.handle_keyboard_shortcuts(key, key, &modifiers)
.map(|action| action.into_inner().2)
}
#[test]
fn test_command_g_opens_goto_line_dialog() {
let editor = CodeEditor::new("one\ntwo", "rs");
let key = keyboard::Key::Character("g".into());
let message = editor
.handle_keyboard_shortcuts(
&key,
&key,
&keyboard::Modifiers::COMMAND,
)
.map(|action| action.into_inner().0);
assert!(matches!(message, Some(Some(Message::OpenGotoLine))));
}
#[test]
fn test_is_key_char_matches_base_or_modified_key() {
let dot = keyboard::Key::Character(".".into());
let semicolon = keyboard::Key::Character(";".into());
let g = keyboard::Key::Character("g".into());
assert!(is_key_char(&dot, &dot, "."));
assert!(is_key_char(&semicolon, &dot, "."));
assert!(!is_key_char(&g, &g, "."));
}
#[test]
fn test_ctrl_dot_toggles_fold_on_azerty_layout() {
let editor = CodeEditor::new("fn a() {\n}\n", "rs");
assert!(editor.folding_enabled);
let base_key = keyboard::Key::Character(";".into());
let modified_key = keyboard::Key::Character(".".into());
let message = editor
.handle_keyboard_shortcuts(
&base_key,
&modified_key,
&keyboard::Modifiers::CTRL,
)
.map(|action| action.into_inner().0);
assert!(matches!(message, Some(Some(Message::ToggleFoldAtCursor))));
}
#[test]
fn test_ctrl_slash_toggles_comment_on_azerty_layout() {
let editor = CodeEditor::new("fn a() {}\n", "rs");
let base_key = keyboard::Key::Character(":".into());
let modified_key = keyboard::Key::Character("/".into());
let message = editor
.handle_keyboard_shortcuts(
&base_key,
&modified_key,
&keyboard::Modifiers::CTRL,
)
.map(|action| action.into_inner().0);
assert!(matches!(message, Some(Some(Message::ToggleComment))));
}
#[test]
fn test_every_single_character_shortcut_consults_the_modified_key() {
let editor = CodeEditor::new("fn a() {\n}\n", "rs");
let ctrl = keyboard::Modifiers::CTRL;
let ctrl_alt = keyboard::Modifiers::CTRL | keyboard::Modifiers::ALT;
let unmatched = character("&");
type ShortcutCase =
(&'static str, keyboard::Modifiers, fn(&Message) -> bool);
let cases: [ShortcutCase; 15] = [
("v", ctrl_alt, |m| matches!(m, Message::ToggleVimMode)),
("s", ctrl, |m| matches!(m, Message::WriteRequested)),
("c", ctrl, |m| matches!(m, Message::Copy)),
("x", ctrl, |m| matches!(m, Message::Cut)),
("a", ctrl, |m| matches!(m, Message::SelectAll)),
("v", ctrl, |m| matches!(m, Message::Paste(_))),
("d", ctrl, |m| matches!(m, Message::SelectNextOccurrence)),
("z", ctrl, |m| matches!(m, Message::Undo)),
("y", ctrl, |m| matches!(m, Message::Redo)),
("f", ctrl, |m| matches!(m, Message::OpenSearch)),
("h", ctrl, |m| matches!(m, Message::OpenSearchReplace)),
("g", ctrl, |m| matches!(m, Message::OpenGotoLine)),
("k", ctrl, |m| matches!(m, Message::FoldAll)),
("j", ctrl, |m| matches!(m, Message::UnfoldAll)),
(".", ctrl, |m| matches!(m, Message::ToggleFoldAtCursor)),
];
for (ch, modifiers, expected) in cases {
let message = editor
.handle_keyboard_shortcuts(
&unmatched,
&character(ch),
&modifiers,
)
.and_then(|action| action.into_inner().0);
assert!(
message.as_ref().is_some_and(expected),
"shortcut for {ch:?} ignored `modified_key`, got {message:?}"
);
}
}
#[test]
fn test_ctrl_alt_k_does_not_fold_all() {
let editor = CodeEditor::new("fn a() {\n}\n", "rs");
assert!(editor.folding_enabled);
let key = keyboard::Key::Character("k".into());
let modifiers = keyboard::Modifiers::CTRL | keyboard::Modifiers::ALT;
let message = editor
.handle_keyboard_shortcuts(&key, &key, &modifiers)
.map(|action| action.into_inner().0);
assert!(!matches!(message, Some(Some(Message::FoldAll))));
}
#[test]
fn test_escape_with_nothing_to_close_is_not_captured() {
let editor = CodeEditor::new("abc", "txt");
assert!(!editor.goto_line_state.is_open);
assert!(!editor.search_state.is_open);
assert!(!editor.vim_enabled);
assert!(!editor.cursors.is_multi());
let key = keyboard::Key::Named(keyboard::key::Named::Escape);
let message = editor.handle_keyboard_shortcuts(
&key,
&key,
&keyboard::Modifiers::NONE,
);
assert!(message.is_none());
}
#[test]
fn test_escape_with_multi_cursor_and_nothing_else_open_is_captured() {
let mut editor = CodeEditor::new("one\ntwo\nthree", "txt");
editor.cursors.add_cursor((1, 0));
assert!(editor.cursors.is_multi());
let key = keyboard::Key::Named(keyboard::key::Named::Escape);
let message = editor
.handle_keyboard_shortcuts(&key, &key, &keyboard::Modifiers::NONE)
.map(|action| action.into_inner().0);
assert!(matches!(message, Some(Some(Message::CloseSearch))));
}
#[test]
fn test_clipboard_shortcuts_route_copy_cut_select_all_and_paste() {
let editor = CodeEditor::new("one\ntwo", "txt");
let ctrl = keyboard::Modifiers::CTRL;
assert!(matches!(
shortcut(&editor, &character("c"), ctrl),
Some(Message::Copy)
));
assert!(matches!(
shortcut(&editor, &character("x"), ctrl),
Some(Message::Cut)
));
assert!(matches!(
shortcut(&editor, &character("a"), ctrl),
Some(Message::SelectAll)
));
assert!(matches!(
shortcut(&editor, &character("v"), ctrl),
Some(Message::Paste(text)) if text.is_empty()
));
}
#[test]
fn test_clipboard_shortcuts_accept_the_insert_key_bindings() {
let editor = CodeEditor::new("one\ntwo", "txt");
let insert = named(keyboard::key::Named::Insert);
assert!(matches!(
shortcut(&editor, &insert, keyboard::Modifiers::CTRL),
Some(Message::Copy)
));
assert!(matches!(
shortcut(&editor, &insert, keyboard::Modifiers::SHIFT),
Some(Message::Paste(_))
));
}
#[test]
fn test_paste_is_the_only_clipboard_shortcut_left_uncaptured() {
let editor = CodeEditor::new("one", "txt");
let ctrl = keyboard::Modifiers::CTRL;
for ch in ["c", "x", "a"] {
assert!(
matches!(
shortcut_status(&editor, &character(ch), ctrl),
Some(event::Status::Captured)
),
"Ctrl+{ch} should capture the event"
);
}
assert!(matches!(
shortcut_status(&editor, &character("v"), ctrl),
Some(event::Status::Ignored)
));
}
#[test]
fn test_multi_cursor_shortcuts_select_occurrence_and_add_cursors() {
let editor = CodeEditor::new("one\ntwo\nthree", "txt");
let ctrl_alt = keyboard::Modifiers::CTRL | keyboard::Modifiers::ALT;
assert!(matches!(
shortcut(&editor, &character("d"), keyboard::Modifiers::CTRL),
Some(Message::SelectNextOccurrence)
));
assert!(matches!(
shortcut(&editor, &named(keyboard::key::Named::ArrowUp), ctrl_alt),
Some(Message::AddCursorAbove)
));
assert!(matches!(
shortcut(
&editor,
&named(keyboard::key::Named::ArrowDown),
ctrl_alt
),
Some(Message::AddCursorBelow)
));
}
#[test]
fn test_shift_delete_deletes_the_selection() {
let editor = CodeEditor::new("one\ntwo", "txt");
assert!(matches!(
shortcut(
&editor,
&named(keyboard::key::Named::Delete),
keyboard::Modifiers::SHIFT
),
Some(Message::DeleteSelection)
));
}
#[test]
fn test_line_move_shortcuts_move_and_duplicate_lines() {
let editor = CodeEditor::new("one\ntwo\nthree", "txt");
let alt = keyboard::Modifiers::ALT;
let shift_alt = keyboard::Modifiers::SHIFT | keyboard::Modifiers::ALT;
let up = named(keyboard::key::Named::ArrowUp);
let down = named(keyboard::key::Named::ArrowDown);
assert!(matches!(
shortcut(&editor, &up, alt),
Some(Message::MoveLineUp)
));
assert!(matches!(
shortcut(&editor, &down, alt),
Some(Message::MoveLineDown)
));
assert!(matches!(
shortcut(&editor, &up, shift_alt),
Some(Message::DuplicateLineUp)
));
assert!(matches!(
shortcut(&editor, &down, shift_alt),
Some(Message::DuplicateLineDown)
));
}
#[test]
fn test_control_alt_arrows_add_cursors_instead_of_moving_lines() {
let editor = CodeEditor::new("one\ntwo\nthree", "txt");
let ctrl_alt = keyboard::Modifiers::CTRL | keyboard::Modifiers::ALT;
assert!(!matches!(
shortcut(&editor, &named(keyboard::key::Named::ArrowUp), ctrl_alt),
Some(Message::MoveLineUp | Message::DuplicateLineUp)
));
assert!(!matches!(
shortcut(
&editor,
&named(keyboard::key::Named::ArrowDown),
ctrl_alt
),
Some(Message::MoveLineDown | Message::DuplicateLineDown)
));
}
#[test]
fn test_navigation_shortcuts_jump_to_document_bounds() {
let editor = CodeEditor::new("one\ntwo", "txt");
let ctrl = keyboard::Modifiers::CTRL;
assert!(matches!(
shortcut(&editor, &named(keyboard::key::Named::Home), ctrl),
Some(Message::CtrlHome)
));
assert!(matches!(
shortcut(&editor, &named(keyboard::key::Named::End), ctrl),
Some(Message::CtrlEnd)
));
}
#[test]
fn test_shift_tab_navigates_focus_unless_the_search_dialog_is_open() {
let mut editor = CodeEditor::new("one", "txt");
let tab = named(keyboard::key::Named::Tab);
let shift = keyboard::Modifiers::SHIFT;
assert!(!editor.search_state.is_open);
assert!(matches!(
shortcut(&editor, &tab, shift),
Some(Message::Backtab)
));
editor.search_state.is_open = true;
assert!(matches!(
shortcut(&editor, &tab, shift),
Some(Message::SearchDialogShiftTab)
));
assert!(matches!(
shortcut(&editor, &tab, keyboard::Modifiers::NONE),
Some(Message::SearchDialogTab)
));
}
#[test]
fn test_history_shortcuts_route_undo_and_both_redo_bindings() {
let editor = CodeEditor::new("one", "txt");
let ctrl = keyboard::Modifiers::CTRL;
let ctrl_shift = keyboard::Modifiers::CTRL | keyboard::Modifiers::SHIFT;
assert!(matches!(
shortcut(&editor, &character("z"), ctrl),
Some(Message::Undo)
));
assert!(matches!(
shortcut(&editor, &character("y"), ctrl),
Some(Message::Redo)
));
assert!(matches!(
shortcut(&editor, &character("z"), ctrl_shift),
Some(Message::Redo)
));
}
#[test]
fn test_dialog_shortcuts_open_dialogs_and_drive_find_next_previous() {
let editor = CodeEditor::new("one\ntwo", "txt");
let ctrl = keyboard::Modifiers::CTRL;
let f3 = named(keyboard::key::Named::F3);
assert!(editor.search_replace_enabled);
assert!(matches!(
shortcut(&editor, &character("f"), ctrl),
Some(Message::OpenSearch)
));
assert!(matches!(
shortcut(&editor, &character("h"), ctrl),
Some(Message::OpenSearchReplace)
));
assert!(matches!(
shortcut(&editor, &f3, keyboard::Modifiers::NONE),
Some(Message::FindNext)
));
assert!(matches!(
shortcut(&editor, &f3, keyboard::Modifiers::SHIFT),
Some(Message::FindPrevious)
));
}
#[test]
fn test_search_shortcuts_are_inert_when_search_replace_is_disabled() {
let mut editor = CodeEditor::new("one\ntwo", "txt");
editor.set_search_replace_enabled(false);
let ctrl = keyboard::Modifiers::CTRL;
assert!(shortcut(&editor, &character("f"), ctrl).is_none());
assert!(shortcut(&editor, &character("h"), ctrl).is_none());
assert!(
shortcut(
&editor,
&named(keyboard::key::Named::F3),
keyboard::Modifiers::NONE
)
.is_none()
);
assert!(matches!(
shortcut(&editor, &character("g"), ctrl),
Some(Message::OpenGotoLine)
));
}
#[test]
fn test_escape_closes_the_goto_line_dialog_before_the_search_dialog() {
let mut editor = CodeEditor::new("one\ntwo", "txt");
let escape = named(keyboard::key::Named::Escape);
let none = keyboard::Modifiers::NONE;
editor.goto_line_state.is_open = true;
assert!(matches!(
shortcut(&editor, &escape, none),
Some(Message::CloseGotoLine)
));
editor.search_state.is_open = true;
assert!(matches!(
shortcut(&editor, &escape, none),
Some(Message::CloseGotoLine)
));
editor.goto_line_state.is_open = false;
assert!(matches!(
shortcut(&editor, &escape, none),
Some(Message::CloseSearch)
));
}
#[test]
fn test_escape_reaches_vim_only_when_no_dialog_is_open() {
let mut editor = CodeEditor::new("one", "txt").with_vim_enabled(true);
let escape = named(keyboard::key::Named::Escape);
let none = keyboard::Modifiers::NONE;
assert!(matches!(
shortcut(&editor, &escape, none),
Some(Message::VimKey('\u{1b}'))
));
editor.search_state.is_open = true;
assert!(matches!(
shortcut(&editor, &escape, none),
Some(Message::CloseSearch)
));
}
#[test]
fn test_folding_shortcuts_toggle_fold_and_unfold_everything() {
let editor = CodeEditor::new("fn a() {\n}\n", "rs");
let ctrl = keyboard::Modifiers::CTRL;
assert!(editor.folding_enabled);
assert!(matches!(
shortcut(&editor, &character("."), ctrl),
Some(Message::ToggleFoldAtCursor)
));
assert!(matches!(
shortcut(&editor, &character("k"), ctrl),
Some(Message::FoldAll)
));
assert!(matches!(
shortcut(&editor, &character("j"), ctrl),
Some(Message::UnfoldAll)
));
}
#[test]
fn test_fold_all_and_unfold_all_exclude_shift() {
let editor = CodeEditor::new("fn a() {\n}\n", "rs");
let ctrl_shift = keyboard::Modifiers::CTRL | keyboard::Modifiers::SHIFT;
assert!(shortcut(&editor, &character("k"), ctrl_shift).is_none());
assert!(shortcut(&editor, &character("j"), ctrl_shift).is_none());
}
#[test]
fn test_folding_shortcuts_are_inert_when_folding_is_disabled() {
let editor =
CodeEditor::new("fn a() {\n}\n", "rs").with_folding_enabled(false);
let ctrl = keyboard::Modifiers::CTRL;
assert!(!editor.folding_enabled);
assert!(shortcut(&editor, &character("."), ctrl).is_none());
assert!(shortcut(&editor, &character("k"), ctrl).is_none());
assert!(shortcut(&editor, &character("j"), ctrl).is_none());
}
#[test]
fn test_word_shortcuts() {
use keyboard::key::Named;
let editor = CodeEditor::new("one", "rs");
let word = if cfg!(target_os = "macos") {
keyboard::Modifiers::ALT
} else {
keyboard::Modifiers::CTRL
};
let word_shift = word | keyboard::Modifiers::SHIFT;
assert!(matches!(
shortcut(&editor, &named(Named::ArrowLeft), word),
Some(Message::WordLeft(false))
));
assert!(matches!(
shortcut(&editor, &named(Named::ArrowRight), word_shift),
Some(Message::WordRight(true))
));
assert!(matches!(
shortcut(&editor, &named(Named::Backspace), word),
Some(Message::DeleteWordBack)
));
assert!(matches!(
shortcut(&editor, &named(Named::Delete), word),
Some(Message::DeleteWordForward)
));
assert!(
shortcut(
&editor,
&named(Named::ArrowLeft),
keyboard::Modifiers::empty()
)
.is_none()
);
assert!(
shortcut(
&editor,
&named(Named::ArrowLeft),
keyboard::Modifiers::CTRL | keyboard::Modifiers::ALT
)
.is_none()
);
assert!(matches!(
shortcut(
&editor,
&named(Named::Delete),
keyboard::Modifiers::SHIFT
),
Some(Message::DeleteSelection)
));
}
}