# pylint: disable=function-redefined import codecs import string from enum import Enum from itertools import accumulate from typing import Callable, Iterable, List, Optional, Tuple, TypeVar, Union from prompt_toolkit.application.current import get_app from prompt_toolkit.buffer import Buffer, indent, reshape_text, unindent from prompt_toolkit.clipboard import ClipboardData from prompt_toolkit.document import Document from prompt_toolkit.filters import ( Always, Condition, Filter, has_arg, is_read_only, is_searching, ) from prompt_toolkit.filters.app import ( in_paste_mode, is_multiline, vi_digraph_mode, vi_insert_mode, vi_insert_multiple_mode, vi_mode, vi_navigation_mode, vi_recording_macro, vi_replace_mode, vi_replace_single_mode, vi_search_direction_reversed, vi_selection_mode, vi_waiting_for_text_object_mode, ) from prompt_toolkit.input.vt100_parser import Vt100Parser from prompt_toolkit.key_binding.digraphs import DIGRAPHS from prompt_toolkit.key_binding.key_processor import KeyPress, KeyPressEvent from prompt_toolkit.key_binding.vi_state import CharacterFind, InputMode from prompt_toolkit.keys import Keys from prompt_toolkit.search import SearchDirection from prompt_toolkit.selection import PasteMode, SelectionState, SelectionType from ..key_bindings import ConditionalKeyBindings, KeyBindings, KeyBindingsBase from .named_commands import get_by_name __all__ = [ "load_vi_bindings", "load_vi_search_bindings", ] E = KeyPressEvent ascii_lowercase = string.ascii_lowercase vi_register_names = ascii_lowercase + "0123456789" class TextObjectType(Enum): EXCLUSIVE = "EXCLUSIVE" INCLUSIVE = "INCLUSIVE" LINEWISE = "LINEWISE" BLOCK = "BLOCK" class TextObject: """ Return struct for functions wrapped in ``text_object``. Both `start` and `end` are relative to the current cursor position. """ def __init__( self, start: int, end: int = 0, type: TextObjectType = TextObjectType.EXCLUSIVE ): self.start = start self.end = end self.type = type @property def selection_type(self) -> SelectionType: if self.type == TextObjectType.LINEWISE: return SelectionType.LINES if self.type == TextObjectType.BLOCK: return SelectionType.BLOCK else: return SelectionType.CHARACTERS def sorted(self) -> Tuple[int, int]: """ Return a (start, end) tuple where start <= end. """ if self.start < self.end: return self.start, self.end else: return self.end, self.start def operator_range(self, document: Document) -> Tuple[int, int]: """ Return a (start, end) tuple with start <= end that indicates the range operators should operate on. `buffer` is used to get start and end of line positions. This should return something that can be used in a slice, so the `end` position is *not* included. """ start, end = self.sorted() doc = document if ( self.type == TextObjectType.EXCLUSIVE and doc.translate_index_to_position(end + doc.cursor_position)[1] == 0 ): # If the motion is exclusive and the end of motion is on the first # column, the end position becomes end of previous line. end -= 1 if self.type == TextObjectType.INCLUSIVE: end += 1 if self.type == TextObjectType.LINEWISE: # Select whole lines row, col = doc.translate_index_to_position(start + doc.cursor_position) start = doc.translate_row_col_to_index(row, 0) - doc.cursor_position row, col = doc.translate_index_to_position(end + doc.cursor_position) end = ( doc.translate_row_col_to_index(row, len(doc.lines[row])) - doc.cursor_position ) return start, end def get_line_numbers(self, buffer: Buffer) -> Tuple[int, int]: """ Return a (start_line, end_line) pair. """ # Get absolute cursor positions from the text object. from_, to = self.operator_range(buffer.document) from_ += buffer.cursor_position to += buffer.cursor_position # Take the start of the lines. from_, _ = buffer.document.translate_index_to_position(from_) to, _ = buffer.document.translate_index_to_position(to) return from_, to def cut(self, buffer: Buffer) -> Tuple[Document, ClipboardData]: """ Turn text object into `ClipboardData` instance. """ from_, to = self.operator_range(buffer.document) from_ += buffer.cursor_position to += buffer.cursor_position # For Vi mode, the SelectionState does include the upper position, # while `self.operator_range` does not. So, go one to the left, unless # we're in the line mode, then we don't want to risk going to the # previous line, and missing one line in the selection. if self.type != TextObjectType.LINEWISE: to -= 1 document = Document( buffer.text, to, SelectionState(original_cursor_position=from_, type=self.selection_type), ) new_document, clipboard_data = document.cut_selection() return new_document, clipboard_data # Typevar for any text object function: TextObjectFunction = Callable[[E], TextObject] _TOF = TypeVar("_TOF", bound=TextObjectFunction) def create_text_object_decorator( key_bindings: KeyBindings, ) -> Callable[..., Callable[[_TOF], _TOF]]: """ Create a decorator that can be used to register Vi text object implementations. """ def text_object_decorator( *keys: Union[Keys, str], filter: Filter = Always(), no_move_handler: bool = False, no_selection_handler: bool = False, eager: bool = False, ) -> Callable[[_TOF], _TOF]: """ Register a text object function. Usage:: @text_object('w', filter=..., no_move_handler=False) def handler(event): # Return a text object for this key. return TextObject(...) :param no_move_handler: Disable the move handler in navigation mode. (It's still active in selection mode.) """ def decorator(text_object_func: _TOF) -> _TOF: @key_bindings.add( *keys, filter=vi_waiting_for_text_object_mode & filter, eager=eager ) def _apply_operator_to_text_object(event: E) -> None: # Arguments are multiplied. vi_state = event.app.vi_state event._arg = str((vi_state.operator_arg or 1) * (event.arg or 1)) # Call the text object handler. text_obj = text_object_func(event) # Get the operator function. # (Should never be None here, given the # `vi_waiting_for_text_object_mode` filter state.) operator_func = vi_state.operator_func if text_obj is not None and operator_func is not None: # Call the operator function with the text object. operator_func(event, text_obj) # Clear operator. event.app.vi_state.operator_func = None event.app.vi_state.operator_arg = None # Register a move operation. (Doesn't need an operator.) if not no_move_handler: @key_bindings.add( *keys, filter=~vi_waiting_for_text_object_mode & filter & vi_navigation_mode, eager=eager, ) def _move_in_navigation_mode(event: E) -> None: """ Move handler for navigation mode. """ text_object = text_object_func(event) event.current_buffer.cursor_position += text_object.start # Register a move selection operation. if not no_selection_handler: @key_bindings.add( *keys, filter=~vi_waiting_for_text_object_mode & filter & vi_selection_mode, eager=eager, ) def _move_in_selection_mode(event: E) -> None: """ Move handler for selection mode. """ text_object = text_object_func(event) buff = event.current_buffer selection_state = buff.selection_state if selection_state is None: return # Should not happen, because of the `vi_selection_mode` filter. # When the text object has both a start and end position, like 'i(' or 'iw', # Turn this into a selection, otherwise the cursor. if text_object.end: # Take selection positions from text object. start, end = text_object.operator_range(buff.document) start += buff.cursor_position end += buff.cursor_position selection_state.original_cursor_position = start buff.cursor_position = end # Take selection type from text object. if text_object.type == TextObjectType.LINEWISE: selection_state.type = SelectionType.LINES else: selection_state.type = SelectionType.CHARACTERS else: event.current_buffer.cursor_position += text_object.start # Make it possible to chain @text_object decorators. return text_object_func return decorator return text_object_decorator # Typevar for any operator function: OperatorFunction = Callable[[E, TextObject], None] _OF = TypeVar("_OF", bound=OperatorFunction) def create_operator_decorator( key_bindings: KeyBindings, ) -> Callable[..., Callable[[_OF], _OF]]: """ Create a decorator that can be used for registering Vi operators. """ def operator_decorator( *keys: Union[Keys, str], filter: Filter = Always(), eager: bool = False ) -> Callable[[_OF], _OF]: """ Register a Vi operator. Usage:: @operator('d', filter=...) def handler(event, text_object): # Do something with the text object here. """ def decorator(operator_func: _OF) -> _OF: @key_bindings.add( *keys, filter=~vi_waiting_for_text_object_mode & filter & vi_navigation_mode, eager=eager, ) def _operator_in_navigation(event: E) -> None: """ Handle operator in navigation mode. """ # When this key binding is matched, only set the operator # function in the ViState. We should execute it after a text # object has been received. event.app.vi_state.operator_func = operator_func event.app.vi_state.operator_arg = event.arg @key_bindings.add( *keys, filter=~vi_waiting_for_text_object_mode & filter & vi_selection_mode, eager=eager, ) def _operator_in_selection(event: E) -> None: """ Handle operator in selection mode. """ buff = event.current_buffer selection_state = buff.selection_state if selection_state is not None: # Create text object from selection. if selection_state.type == SelectionType.LINES: text_obj_type = TextObjectType.LINEWISE elif selection_state.type == SelectionType.BLOCK: text_obj_type = TextObjectType.BLOCK else: text_obj_type = TextObjectType.INCLUSIVE text_object = TextObject( selection_state.original_cursor_position - buff.cursor_position, type=text_obj_type, ) # Execute operator. operator_func(event, text_object) # Quit selection mode. buff.selection_state = None return operator_func return decorator return operator_decorator def load_vi_bindings() -> KeyBindingsBase: """ Vi extensions. # Overview of Readline Vi commands: # http://www.catonmat.net/download/bash-vi-editing-mode-cheat-sheet.pdf """ # Note: Some key bindings have the "~IsReadOnly()" filter added. This # prevents the handler to be executed when the focus is on a # read-only buffer. # This is however only required for those that change the ViState to # INSERT mode. The `Buffer` class itself throws the # `EditReadOnlyBuffer` exception for any text operations which is # handled correctly. There is no need to add "~IsReadOnly" to all key # bindings that do text manipulation. key_bindings = KeyBindings() handle = key_bindings.add # (Note: Always take the navigation bindings in read-only mode, even when # ViState says different.) TransformFunction = Tuple[Tuple[str, ...], Filter, Callable[[str], str]] vi_transform_functions: List[TransformFunction] = [ # Rot 13 transformation ( ("g", "?"), Always(), lambda string: codecs.encode(string, "rot_13"), ), # To lowercase (("g", "u"), Always(), lambda string: string.lower()), # To uppercase. (("g", "U"), Always(), lambda string: string.upper()), # Swap case. (("g", "~"), Always(), lambda string: string.swapcase()), ( ("~",), Condition(lambda: get_app().vi_state.tilde_operator), lambda string: string.swapcase(), ), ] # Insert a character literally (quoted insert). handle("c-v", filter=vi_insert_mode)(get_by_name("quoted-insert")) @handle("escape") def _back_to_navigation(event: E) -> None: """ Escape goes to vi navigation mode. """ buffer = event.current_buffer vi_state = event.app.vi_state if vi_state.input_mode in (InputMode.INSERT, InputMode.REPLACE): buffer.cursor_position += buffer.document.get_cursor_left_position() vi_state.input_mode = InputMode.NAVIGATION if bool(buffer.selection_state): buffer.exit_selection() @handle("k", filter=vi_selection_mode) def _up_in_selection(event: E) -> None: """ Arrow up in selection mode. """ event.current_buffer.cursor_up(count=event.arg) @handle("j", filter=vi_selection_mode) def _down_in_selection(event: E) -> None: """ Arrow down in selection mode. """ event.current_buffer.cursor_down(count=event.arg) @handle("up", filter=vi_navigation_mode) @handle("c-p", filter=vi_navigation_mode) def _up_in_navigation(event: E) -> None: """ Arrow up and ControlP in navigation mode go up. """ event.current_buffer.auto_up(count=event.arg) @handle("k", filter=vi_navigation_mode) def _go_up(event: E) -> None: """ Go up, but if we enter a new history entry, move to the start of the line. """ event.current_buffer.auto_up( count=event.arg, go_to_start_of_line_if_history_changes=True ) @handle("down", filter=vi_navigation_mode) @handle("c-n", filter=vi_navigation_mode) def _go_down(event: E) -> None: """ Arrow down and Control-N in navigation mode. """ event.current_buffer.auto_down(count=event.arg) @handle("j", filter=vi_navigation_mode) def _go_down2(event: E) -> None: """ Go down, but if we enter a new history entry, go to the start of the line. """ event.current_buffer.auto_down( count=event.arg, go_to_start_of_line_if_history_changes=True ) @handle("backspace", filter=vi_navigation_mode) def _go_left(event: E) -> None: """ In navigation-mode, move cursor. """ event.current_buffer.cursor_position += ( event.current_buffer.document.get_cursor_left_position(count=event.arg) ) @handle("c-n", filter=vi_insert_mode) def _complete_next(event: E) -> None: b = event.current_buffer if b.complete_state: b.complete_next() else: b.start_completion(select_first=True) @handle("c-p", filter=vi_insert_mode) def _complete_prev(event: E) -> None: """ Control-P: To previous completion. """ b = event.current_buffer if b.complete_state: b.complete_previous() else: b.start_completion(select_last=True) @handle("c-g", filter=vi_insert_mode) @handle("c-y", filter=vi_insert_mode) def _accept_completion(event: E) -> None: """ Accept current completion. """ event.current_buffer.complete_state = None @handle("c-e", filter=vi_insert_mode) def _cancel_completion(event: E) -> None: """ Cancel completion. Go back to originally typed text. """ event.current_buffer.cancel_completion() @Condition def is_returnable() -> bool: return get_app().current_buffer.is_returnable # In navigation mode, pressing enter will always return the input. handle("enter", filter=vi_navigation_mode & is_returnable)( get_by_name("accept-line") ) # In insert mode, also accept input when enter is pressed, and the buffer # has been marked as single line. handle("enter", filter=is_returnable & ~is_multiline)(get_by_name("accept-line")) @handle("enter", filter=~is_returnable & vi_navigation_mode) def _start_of_next_line(event: E) -> None: """ Go to the beginning of next line. """ b = event.current_buffer b.cursor_down(count=event.arg) b.cursor_position += b.document.get_start_of_line_position( after_whitespace=True ) # ** In navigation mode ** # List of navigation commands: http://hea-www.harvard.edu/~fine/Tech/vi.html @handle("insert", filter=vi_navigation_mode) def _insert_mode(event: E) -> None: """ Pressing the Insert key. """ event.app.vi_state.input_mode = InputMode.INSERT @handle("insert", filter=vi_insert_mode) def _navigation_mode(event: E) -> None: """ Pressing the Insert key. """ event.app.vi_state.input_mode = InputMode.NAVIGATION @handle("a", filter=vi_navigation_mode & ~is_read_only) # ~IsReadOnly, because we want to stay in navigation mode for # read-only buffers. def _a(event: E) -> None: event.current_buffer.cursor_position += ( event.current_buffer.document.get_cursor_right_position() ) event.app.vi_state.input_mode = InputMode.INSERT @handle("A", filter=vi_navigation_mode & ~is_read_only) def _A(event: E) -> None: event.current_buffer.cursor_position += ( event.current_buffer.document.get_end_of_line_position() ) event.app.vi_state.input_mode = InputMode.INSERT @handle("C", filter=vi_navigation_mode & ~is_read_only) def _change_until_end_of_line(event: E) -> None: """ Change to end of line. Same as 'c$' (which is implemented elsewhere.) """ buffer = event.current_buffer deleted = buffer.delete(count=buffer.document.get_end_of_line_position()) event.app.clipboard.set_text(deleted) event.app.vi_state.input_mode = InputMode.INSERT @handle("c", "c", filter=vi_navigation_mode & ~is_read_only) @handle("S", filter=vi_navigation_mode & ~is_read_only) def _change_current_line(event: E) -> None: # TODO: implement 'arg' """ Change current line """ buffer = event.current_buffer # We copy the whole line. data = ClipboardData(buffer.document.current_line, SelectionType.LINES) event.app.clipboard.set_data(data) # But we delete after the whitespace buffer.cursor_position += buffer.document.get_start_of_line_position( after_whitespace=True ) buffer.delete(count=buffer.document.get_end_of_line_position()) event.app.vi_state.input_mode = InputMode.INSERT @handle("D", filter=vi_navigation_mode) def _delete_until_end_of_line(event: E) -> None: """ Delete from cursor position until the end of the line. """ buffer = event.current_buffer deleted = buffer.delete(count=buffer.document.get_end_of_line_position()) event.app.clipboard.set_text(deleted) @handle("d", "d", filter=vi_navigation_mode) def _delete_line(event: E) -> None: """ Delete line. (Or the following 'n' lines.) """ buffer = event.current_buffer # Split string in before/deleted/after text. lines = buffer.document.lines before = "\n".join(lines[: buffer.document.cursor_position_row]) deleted = "\n".join( lines[ buffer.document.cursor_position_row : buffer.document.cursor_position_row + event.arg ] ) after = "\n".join(lines[buffer.document.cursor_position_row + event.arg :]) # Set new text. if before and after: before = before + "\n" # Set text and cursor position. buffer.document = Document( text=before + after, # Cursor At the start of the first 'after' line, after the leading whitespace. cursor_position=len(before) + len(after) - len(after.lstrip(" ")), ) # Set clipboard data event.app.clipboard.set_data(ClipboardData(deleted, SelectionType.LINES)) @handle("x", filter=vi_selection_mode) def _cut(event: E) -> None: """ Cut selection. ('x' is not an operator.) """ clipboard_data = event.current_buffer.cut_selection() event.app.clipboard.set_data(clipboard_data) @handle("i", filter=vi_navigation_mode & ~is_read_only) def _i(event: E) -> None: event.app.vi_state.input_mode = InputMode.INSERT @handle("I", filter=vi_navigation_mode & ~is_read_only) def _I(event: E) -> None: event.app.vi_state.input_mode = InputMode.INSERT event.current_buffer.cursor_position += ( event.current_buffer.document.get_start_of_line_position( after_whitespace=True ) ) @Condition def in_block_selection() -> bool: buff = get_app().current_buffer return bool( buff.selection_state and buff.selection_state.type == SelectionType.BLOCK ) @handle("I", filter=in_block_selection & ~is_read_only) def insert_in_block_selection(event: E, after: bool = False) -> None: """ Insert in block selection mode. """ buff = event.current_buffer # Store all cursor positions. positions = [] if after: def get_pos(from_to: Tuple[int, int]) -> int: return from_to[1] else: def get_pos(from_to: Tuple[int, int]) -> int: return from_to[0] for i, from_to in enumerate(buff.document.selection_ranges()): positions.append(get_pos(from_to)) if i == 0: buff.cursor_position = get_pos(from_to) buff.multiple_cursor_positions = positions # Go to 'INSERT_MULTIPLE' mode. event.app.vi_state.input_mode = InputMode.INSERT_MULTIPLE buff.exit_selection() @handle("A", filter=in_block_selection & ~is_read_only) def _append_after_block(event: E) -> None: insert_in_block_selection(event, after=True) @handle("J", filter=vi_navigation_mode & ~is_read_only) def _join(event: E) -> None: """ Join lines. """ for i in range(event.arg): event.current_buffer.join_next_line() @handle("g", "J", filter=vi_navigation_mode & ~is_read_only) def _join_nospace(event: E) -> None: """ Join lines without space. """ for i in range(event.arg): event.current_buffer.join_next_line(separator="") @handle("J", filter=vi_selection_mode & ~is_read_only) def _join_selection(event: E) -> None: """ Join selected lines. """ event.current_buffer.join_selected_lines() @handle("g", "J", filter=vi_selection_mode & ~is_read_only) def _join_selection_nospace(event: E) -> None: """ Join selected lines without space. """ event.current_buffer.join_selected_lines(separator="") @handle("p", filter=vi_navigation_mode) def _paste(event: E) -> None: """ Paste after """ event.current_buffer.paste_clipboard_data( event.app.clipboard.get_data(), count=event.arg, paste_mode=PasteMode.VI_AFTER, ) @handle("P", filter=vi_navigation_mode) def _paste_before(event: E) -> None: """ Paste before """ event.current_buffer.paste_clipboard_data( event.app.clipboard.get_data(), count=event.arg, paste_mode=PasteMode.VI_BEFORE, ) @handle('"', Keys.Any, "p", filter=vi_navigation_mode) def _paste_register(event: E) -> None: """ Paste from named register. """ c = event.key_sequence[1].data if c in vi_register_names: data = event.app.vi_state.named_registers.get(c) if data: event.current_buffer.paste_clipboard_data( data, count=event.arg, paste_mode=PasteMode.VI_AFTER ) @handle('"', Keys.Any, "P", filter=vi_navigation_mode) def _paste_register_before(event: E) -> None: """ Paste (before) from named register. """ c = event.key_sequence[1].data if c in vi_register_names: data = event.app.vi_state.named_registers.get(c) if data: event.current_buffer.paste_clipboard_data( data, count=event.arg, paste_mode=PasteMode.VI_BEFORE ) @handle("r", filter=vi_navigation_mode) def _replace(event: E) -> None: """ Go to 'replace-single'-mode. """ event.app.vi_state.input_mode = InputMode.REPLACE_SINGLE @handle("R", filter=vi_navigation_mode) def _replace_mode(event: E) -> None: """ Go to 'replace'-mode. """ event.app.vi_state.input_mode = InputMode.REPLACE @handle("s", filter=vi_navigation_mode & ~is_read_only) def _substitute(event: E) -> None: """ Substitute with new text (Delete character(s) and go to insert mode.) """ text = event.current_buffer.delete(count=event.arg) event.app.clipboard.set_text(text) event.app.vi_state.input_mode = InputMode.INSERT @handle("u", filter=vi_navigation_mode, save_before=(lambda e: False)) def _undo(event: E) -> None: for i in range(event.arg): event.current_buffer.undo() @handle("V", filter=vi_navigation_mode) def _visual_line(event: E) -> None: """ Start lines selection. """ event.current_buffer.start_selection(selection_type=SelectionType.LINES) @handle("c-v", filter=vi_navigation_mode) def _visual_block(event: E) -> None: """ Enter block selection mode. """ event.current_buffer.start_selection(selection_type=SelectionType.BLOCK) @handle("V", filter=vi_selection_mode) def _visual_line2(event: E) -> None: """ Exit line selection mode, or go from non line selection mode to line selection mode. """ selection_state = event.current_buffer.selection_state if selection_state is not None: if selection_state.type != SelectionType.LINES: selection_state.type = SelectionType.LINES else: event.current_buffer.exit_selection() @handle("v", filter=vi_navigation_mode) def _visual(event: E) -> None: """ Enter character selection mode. """ event.current_buffer.start_selection(selection_type=SelectionType.CHARACTERS) @handle("v", filter=vi_selection_mode) def _visual2(event: E) -> None: """ Exit character selection mode, or go from non-character-selection mode to character selection mode. """ selection_state = event.current_buffer.selection_state if selection_state is not None: if selection_state.type != SelectionType.CHARACTERS: selection_state.type = SelectionType.CHARACTERS else: event.current_buffer.exit_selection() @handle("c-v", filter=vi_selection_mode) def _visual_block2(event: E) -> None: """ Exit block selection mode, or go from non block selection mode to block selection mode. """ selection_state = event.current_buffer.selection_state if selection_state is not None: if selection_state.type != SelectionType.BLOCK: selection_state.type = SelectionType.BLOCK else: event.current_buffer.exit_selection() @handle("a", "w", filter=vi_selection_mode) @handle("a", "W", filter=vi_selection_mode) def _visual_auto_word(event: E) -> None: """ Switch from visual linewise mode to visual characterwise mode. """ buffer = event.current_buffer if ( buffer.selection_state and buffer.selection_state.type == SelectionType.LINES ): buffer.selection_state.type = SelectionType.CHARACTERS @handle("x", filter=vi_navigation_mode) def _delete(event: E) -> None: """ Delete character. """ buff = event.current_buffer count = min(event.arg, len(buff.document.current_line_after_cursor)) if count: text = event.current_buffer.delete(count=count) event.app.clipboard.set_text(text) @handle("X", filter=vi_navigation_mode) def _delete_before_cursor(event: E) -> None: buff = event.current_buffer count = min(event.arg, len(buff.document.current_line_before_cursor)) if count: text = event.current_buffer.delete_before_cursor(count=count) event.app.clipboard.set_text(text) @handle("y", "y", filter=vi_navigation_mode) @handle("Y", filter=vi_navigation_mode) def _yank_line(event: E) -> None: """ Yank the whole line. """ text = "\n".join(event.current_buffer.document.lines_from_current[: event.arg]) event.app.clipboard.set_data(ClipboardData(text, SelectionType.LINES)) @handle("+", filter=vi_navigation_mode) def _next_line(event: E) -> None: """ Move to first non whitespace of next line """ buffer = event.current_buffer buffer.cursor_position += buffer.document.get_cursor_down_position( count=event.arg ) buffer.cursor_position += buffer.document.get_start_of_line_position( after_whitespace=True ) @handle("-", filter=vi_navigation_mode) def _prev_line(event: E) -> None: """ Move to first non whitespace of previous line """ buffer = event.current_buffer buffer.cursor_position += buffer.document.get_cursor_up_position( count=event.arg ) buffer.cursor_position += buffer.document.get_start_of_line_position( after_whitespace=True ) @handle(">", ">", filter=vi_navigation_mode) def _indent(event: E) -> None: """ Indent lines. """ buffer = event.current_buffer current_row = buffer.document.cursor_position_row indent(buffer, current_row, current_row + event.arg) @handle("<", "<", filter=vi_navigation_mode) def _unindent(event: E) -> None: """ Unindent lines. """ current_row = event.current_buffer.document.cursor_position_row unindent(event.current_buffer, current_row, current_row + event.arg) @handle("O", filter=vi_navigation_mode & ~is_read_only) def _open_above(event: E) -> None: """ Open line above and enter insertion mode """ event.current_buffer.insert_line_above(copy_margin=not in_paste_mode()) event.app.vi_state.input_mode = InputMode.INSERT @handle("o", filter=vi_navigation_mode & ~is_read_only) def _open_below(event: E) -> None: """ Open line below and enter insertion mode """ event.current_buffer.insert_line_below(copy_margin=not in_paste_mode()) event.app.vi_state.input_mode = InputMode.INSERT @handle("~", filter=vi_navigation_mode) def _reverse_case(event: E) -> None: """ Reverse case of current character and move cursor forward. """ buffer = event.current_buffer c = buffer.document.current_char if c is not None and c != "\n": buffer.insert_text(c.swapcase(), overwrite=True) @handle("g", "u", "u", filter=vi_navigation_mode & ~is_read_only) def _lowercase_line(event: E) -> None: """ Lowercase current line. """ buff = event.current_buffer buff.transform_current_line(lambda s: s.lower()) @handle("g", "U", "U", filter=vi_navigation_mode & ~is_read_only) def _uppercase_line(event: E) -> None: """ Uppercase current line. """ buff = event.current_buffer buff.transform_current_line(lambda s: s.upper()) @handle("g", "~", "~", filter=vi_navigation_mode & ~is_read_only) def _swapcase_line(event: E) -> None: """ Swap case of the current line. """ buff = event.current_buffer buff.transform_current_line(lambda s: s.swapcase()) @handle("#", filter=vi_navigation_mode) def _prev_occurence(event: E) -> None: """ Go to previous occurrence of this word. """ b = event.current_buffer search_state = event.app.current_search_state search_state.text = b.document.get_word_under_cursor() search_state.direction = SearchDirection.BACKWARD b.apply_search(search_state, count=event.arg, include_current_position=False) @handle("*", filter=vi_navigation_mode) def _next_occurance(event: E) -> None: """ Go to next occurrence of this word. """ b = event.current_buffer search_state = event.app.current_search_state search_state.text = b.document.get_word_under_cursor() search_state.direction = SearchDirection.FORWARD b.apply_search(search_state, count=event.arg, include_current_position=False) @handle("(", filter=vi_navigation_mode) def _begin_of_sentence(event: E) -> None: # TODO: go to begin of sentence. # XXX: should become text_object. pass @handle(")", filter=vi_navigation_mode) def _end_of_sentence(event: E) -> None: # TODO: go to end of sentence. # XXX: should become text_object. pass operator = create_operator_decorator(key_bindings) text_object = create_text_object_decorator(key_bindings) @handle(Keys.Any, filter=vi_waiting_for_text_object_mode) def _unknown_text_object(event: E) -> None: """ Unknown key binding while waiting for a text object. """ event.app.output.bell() # # *** Operators *** # def create_delete_and_change_operators( delete_only: bool, with_register: bool = False ) -> None: """ Delete and change operators. :param delete_only: Create an operator that deletes, but doesn't go to insert mode. :param with_register: Copy the deleted text to this named register instead of the clipboard. """ handler_keys: Iterable[str] if with_register: handler_keys = ('"', Keys.Any, "cd"[delete_only]) else: handler_keys = "cd"[delete_only] @operator(*handler_keys, filter=~is_read_only) def delete_or_change_operator(event: E, text_object: TextObject) -> None: clipboard_data = None buff = event.current_buffer if text_object: new_document, clipboard_data = text_object.cut(buff) buff.document = new_document # Set deleted/changed text to clipboard or named register. if clipboard_data and clipboard_data.text: if with_register: reg_name = event.key_sequence[1].data if reg_name in vi_register_names: event.app.vi_state.named_registers[reg_name] = clipboard_data else: event.app.clipboard.set_data(clipboard_data) # Only go back to insert mode in case of 'change'. if not delete_only: event.app.vi_state.input_mode = InputMode.INSERT create_delete_and_change_operators(False, False) create_delete_and_change_operators(False, True) create_delete_and_change_operators(True, False) create_delete_and_change_operators(True, True) def create_transform_handler( filter: Filter, transform_func: Callable[[str], str], *a: str ) -> None: @operator(*a, filter=filter & ~is_read_only) def _(event: E, text_object: TextObject) -> None: """ Apply transformation (uppercase, lowercase, rot13, swap case). """ buff = event.current_buffer start, end = text_object.operator_range(buff.document) if start < end: # Transform. buff.transform_region( buff.cursor_position + start, buff.cursor_position + end, transform_func, ) # Move cursor buff.cursor_position += text_object.end or text_object.start for k, f, func in vi_transform_functions: create_transform_handler(f, func, *k) @operator("y") def _yank(event: E, text_object: TextObject) -> None: """ Yank operator. (Copy text.) """ _, clipboard_data = text_object.cut(event.current_buffer) if clipboard_data.text: event.app.clipboard.set_data(clipboard_data) @operator('"', Keys.Any, "y") def _yank_to_register(event: E, text_object: TextObject) -> None: """ Yank selection to named register. """ c = event.key_sequence[1].data if c in vi_register_names: _, clipboard_data = text_object.cut(event.current_buffer) event.app.vi_state.named_registers[c] = clipboard_data @operator(">") def _indent_text_object(event: E, text_object: TextObject) -> None: """ Indent. """ buff = event.current_buffer from_, to = text_object.get_line_numbers(buff) indent(buff, from_, to + 1, count=event.arg) @operator("<") def _unindent_text_object(event: E, text_object: TextObject) -> None: """ Unindent. """ buff = event.current_buffer from_, to = text_object.get_line_numbers(buff) unindent(buff, from_, to + 1, count=event.arg) @operator("g", "q") def _reshape(event: E, text_object: TextObject) -> None: """ Reshape text. """ buff = event.current_buffer from_, to = text_object.get_line_numbers(buff) reshape_text(buff, from_, to) # # *** Text objects *** # @text_object("b") def _b(event: E) -> TextObject: """ Move one word or token left. """ return TextObject( event.current_buffer.document.find_start_of_previous_word(count=event.arg) or 0 ) @text_object("B") def _B(event: E) -> TextObject: """ Move one non-blank word left """ return TextObject( event.current_buffer.document.find_start_of_previous_word( count=event.arg, WORD=True ) or 0 ) @text_object("$") def _dollar(event: E) -> TextObject: """ 'c$', 'd$' and '$': Delete/change/move until end of line. """ return TextObject(event.current_buffer.document.get_end_of_line_position()) @text_object("w") def _word_forward(event: E) -> TextObject: """ 'word' forward. 'cw', 'dw', 'w': Delete/change/move one word. """ return TextObject( event.current_buffer.document.find_next_word_beginning(count=event.arg) or event.current_buffer.document.get_end_of_document_position() ) @text_object("W") def _WORD_forward(event: E) -> TextObject: """ 'WORD' forward. 'cW', 'dW', 'W': Delete/change/move one WORD. """ return TextObject( event.current_buffer.document.find_next_word_beginning( count=event.arg, WORD=True ) or event.current_buffer.document.get_end_of_document_position() ) @text_object("e") def _end_of_word(event: E) -> TextObject: """ End of 'word': 'ce', 'de', 'e' """ end = event.current_buffer.document.find_next_word_ending(count=event.arg) return TextObject(end - 1 if end else 0, type=TextObjectType.INCLUSIVE) @text_object("E") def _end_of_WORD(event: E) -> TextObject: """ End of 'WORD': 'cE', 'dE', 'E' """ end = event.current_buffer.document.find_next_word_ending( count=event.arg, WORD=True ) return TextObject(end - 1 if end else 0, type=TextObjectType.INCLUSIVE) @text_object("i", "w", no_move_handler=True) def _inner_word(event: E) -> TextObject: """ Inner 'word': ciw and diw """ start, end = event.current_buffer.document.find_boundaries_of_current_word() return TextObject(start, end) @text_object("a", "w", no_move_handler=True) def _a_word(event: E) -> TextObject: """ A 'word': caw and daw """ start, end = event.current_buffer.document.find_boundaries_of_current_word( include_trailing_whitespace=True ) return TextObject(start, end) @text_object("i", "W", no_move_handler=True) def _inner_WORD(event: E) -> TextObject: """ Inner 'WORD': ciW and diW """ start, end = event.current_buffer.document.find_boundaries_of_current_word( WORD=True ) return TextObject(start, end) @text_object("a", "W", no_move_handler=True) def _a_WORD(event: E) -> TextObject: """ A 'WORD': caw and daw """ start, end = event.current_buffer.document.find_boundaries_of_current_word( WORD=True, include_trailing_whitespace=True ) return TextObject(start, end) @text_object("a", "p", no_move_handler=True) def _paragraph(event: E) -> TextObject: """ Auto paragraph. """ start = event.current_buffer.document.start_of_paragraph() end = event.current_buffer.document.end_of_paragraph(count=event.arg) return TextObject(start, end) @text_object("^") def _start_of_line(event: E) -> TextObject: """'c^', 'd^' and '^': Soft start of line, after whitespace.""" return TextObject( event.current_buffer.document.get_start_of_line_position( after_whitespace=True ) ) @text_object("0") def _hard_start_of_line(event: E) -> TextObject: """ 'c0', 'd0': Hard start of line, before whitespace. (The move '0' key is implemented elsewhere, because a '0' could also change the `arg`.) """ return TextObject( event.current_buffer.document.get_start_of_line_position( after_whitespace=False ) ) def create_ci_ca_handles( ci_start: str, ci_end: str, inner: bool, key: Optional[str] = None ) -> None: # TODO: 'dat', 'dit', (tags (like xml) """ Delete/Change string between this start and stop character. But keep these characters. This implements all the ci", ci<, ci{, ci(, di", di<, ca", ca<, ... combinations. """ def handler(event: E) -> TextObject: if ci_start == ci_end: # Quotes start = event.current_buffer.document.find_backwards( ci_start, in_current_line=False ) end = event.current_buffer.document.find(ci_end, in_current_line=False) else: # Brackets start = event.current_buffer.document.find_enclosing_bracket_left( ci_start, ci_end ) end = event.current_buffer.document.find_enclosing_bracket_right( ci_start, ci_end ) if start is not None and end is not None: offset = 0 if inner else 1 return TextObject(start + 1 - offset, end + offset) else: # Nothing found. return TextObject(0) if key is None: text_object("ai"[inner], ci_start, no_move_handler=True)(handler) text_object("ai"[inner], ci_end, no_move_handler=True)(handler) else: text_object("ai"[inner], key, no_move_handler=True)(handler) for inner in (False, True): for ci_start, ci_end in [ ('"', '"'), ("'", "'"), ("`", "`"), ("[", "]"), ("<", ">"), ("{", "}"), ("(", ")"), ]: create_ci_ca_handles(ci_start, ci_end, inner) create_ci_ca_handles("(", ")", inner, "b") # 'dab', 'dib' create_ci_ca_handles("{", "}", inner, "B") # 'daB', 'diB' @text_object("{") def _previous_section(event: E) -> TextObject: """ Move to previous blank-line separated section. Implements '{', 'c{', 'd{', 'y{' """ index = event.current_buffer.document.start_of_paragraph( count=event.arg, before=True ) return TextObject(index) @text_object("}") def _next_section(event: E) -> TextObject: """ Move to next blank-line separated section. Implements '}', 'c}', 'd}', 'y}' """ index = event.current_buffer.document.end_of_paragraph( count=event.arg, after=True ) return TextObject(index) @text_object("f", Keys.Any) def _next_occurence(event: E) -> TextObject: """ Go to next occurrence of character. Typing 'fx' will move the cursor to the next occurrence of character. 'x'. """ event.app.vi_state.last_character_find = CharacterFind(event.data, False) match = event.current_buffer.document.find( event.data, in_current_line=True, count=event.arg ) if match: return TextObject(match, type=TextObjectType.INCLUSIVE) else: return TextObject(0) @text_object("F", Keys.Any) def _previous_occurance(event: E) -> TextObject: """ Go to previous occurrence of character. Typing 'Fx' will move the cursor to the previous occurrence of character. 'x'. """ event.app.vi_state.last_character_find = CharacterFind(event.data, True) return TextObject( event.current_buffer.document.find_backwards( event.data, in_current_line=True, count=event.arg ) or 0 ) @text_object("t", Keys.Any) def _t(event: E) -> TextObject: """ Move right to the next occurrence of c, then one char backward. """ event.app.vi_state.last_character_find = CharacterFind(event.data, False) match = event.current_buffer.document.find( event.data, in_current_line=True, count=event.arg ) if match: return TextObject(match - 1, type=TextObjectType.INCLUSIVE) else: return TextObject(0) @text_object("T", Keys.Any) def _T(event: E) -> TextObject: """ Move left to the previous occurrence of c, then one char forward. """ event.app.vi_state.last_character_find = CharacterFind(event.data, True) match = event.current_buffer.document.find_backwards( event.data, in_current_line=True, count=event.arg ) return TextObject(match + 1 if match else 0) def repeat(reverse: bool) -> None: """ Create ',' and ';' commands. """ @text_object("," if reverse else ";") def _(event: E) -> TextObject: """ Repeat the last 'f'/'F'/'t'/'T' command. """ pos: Optional[int] = 0 vi_state = event.app.vi_state type = TextObjectType.EXCLUSIVE if vi_state.last_character_find: char = vi_state.last_character_find.character backwards = vi_state.last_character_find.backwards if reverse: backwards = not backwards if backwards: pos = event.current_buffer.document.find_backwards( char, in_current_line=True, count=event.arg ) else: pos = event.current_buffer.document.find( char, in_current_line=True, count=event.arg ) type = TextObjectType.INCLUSIVE if pos: return TextObject(pos, type=type) else: return TextObject(0) repeat(True) repeat(False) @text_object("h") @text_object("left") def _left(event: E) -> TextObject: """ Implements 'ch', 'dh', 'h': Cursor left. """ return TextObject( event.current_buffer.document.get_cursor_left_position(count=event.arg) ) @text_object("j", no_move_handler=True, no_selection_handler=True) # Note: We also need `no_selection_handler`, because we in # selection mode, we prefer the other 'j' binding that keeps # `buffer.preferred_column`. def _down(event: E) -> TextObject: """ Implements 'cj', 'dj', 'j', ... Cursor up. """ return TextObject( event.current_buffer.document.get_cursor_down_position(count=event.arg), type=TextObjectType.LINEWISE, ) @text_object("k", no_move_handler=True, no_selection_handler=True) def _up(event: E) -> TextObject: """ Implements 'ck', 'dk', 'k', ... Cursor up. """ return TextObject( event.current_buffer.document.get_cursor_up_position(count=event.arg), type=TextObjectType.LINEWISE, ) @text_object("l") @text_object(" ") @text_object("right") def _right(event: E) -> TextObject: """ Implements 'cl', 'dl', 'l', 'c ', 'd ', ' '. Cursor right. """ return TextObject( event.current_buffer.document.get_cursor_right_position(count=event.arg) ) @text_object("H") def _top_of_screen(event: E) -> TextObject: """ Moves to the start of the visible region. (Below the scroll offset.) Implements 'cH', 'dH', 'H'. """ w = event.app.layout.current_window b = event.current_buffer if w and w.render_info: # When we find a Window that has BufferControl showing this window, # move to the start of the visible area. pos = ( b.document.translate_row_col_to_index( w.render_info.first_visible_line(after_scroll_offset=True), 0 ) - b.cursor_position ) else: # Otherwise, move to the start of the input. pos = -len(b.document.text_before_cursor) return TextObject(pos, type=TextObjectType.LINEWISE) @text_object("M") def _middle_of_screen(event: E) -> TextObject: """ Moves cursor to the vertical center of the visible region. Implements 'cM', 'dM', 'M'. """ w = event.app.layout.current_window b = event.current_buffer if w and w.render_info: # When we find a Window that has BufferControl showing this window, # move to the center of the visible area. pos = ( b.document.translate_row_col_to_index( w.render_info.center_visible_line(), 0 ) - b.cursor_position ) else: # Otherwise, move to the start of the input. pos = -len(b.document.text_before_cursor) return TextObject(pos, type=TextObjectType.LINEWISE) @text_object("L") def _end_of_screen(event: E) -> TextObject: """ Moves to the end of the visible region. (Above the scroll offset.) """ w = event.app.layout.current_window b = event.current_buffer if w and w.render_info: # When we find a Window that has BufferControl showing this window, # move to the end of the visible area. pos = ( b.document.translate_row_col_to_index( w.render_info.last_visible_line(before_scroll_offset=True), 0 ) - b.cursor_position ) else: # Otherwise, move to the end of the input. pos = len(b.document.text_after_cursor) return TextObject(pos, type=TextObjectType.LINEWISE) @text_object("n", no_move_handler=True) def _search_next(event: E) -> TextObject: """ Search next. """ buff = event.current_buffer search_state = event.app.current_search_state cursor_position = buff.get_search_position( search_state, include_current_position=False, count=event.arg ) return TextObject(cursor_position - buff.cursor_position) @handle("n", filter=vi_navigation_mode) def _search_next2(event: E) -> None: """ Search next in navigation mode. (This goes through the history.) """ search_state = event.app.current_search_state event.current_buffer.apply_search( search_state, include_current_position=False, count=event.arg ) @text_object("N", no_move_handler=True) def _search_previous(event: E) -> TextObject: """ Search previous. """ buff = event.current_buffer search_state = event.app.current_search_state cursor_position = buff.get_search_position( ~search_state, include_current_position=False, count=event.arg ) return TextObject(cursor_position - buff.cursor_position) @handle("N", filter=vi_navigation_mode) def _search_previous2(event: E) -> None: """ Search previous in navigation mode. (This goes through the history.) """ search_state = event.app.current_search_state event.current_buffer.apply_search( ~search_state, include_current_position=False, count=event.arg ) @handle("z", "+", filter=vi_navigation_mode | vi_selection_mode) @handle("z", "t", filter=vi_navigation_mode | vi_selection_mode) @handle("z", "enter", filter=vi_navigation_mode | vi_selection_mode) def _scroll_top(event: E) -> None: """ Scrolls the window to makes the current line the first line in the visible region. """ b = event.current_buffer event.app.layout.current_window.vertical_scroll = b.document.cursor_position_row @handle("z", "-", filter=vi_navigation_mode | vi_selection_mode) @handle("z", "b", filter=vi_navigation_mode | vi_selection_mode) def _scroll_bottom(event: E) -> None: """ Scrolls the window to makes the current line the last line in the visible region. """ # We can safely set the scroll offset to zero; the Window will make # sure that it scrolls at least enough to make the cursor visible # again. event.app.layout.current_window.vertical_scroll = 0 @handle("z", "z", filter=vi_navigation_mode | vi_selection_mode) def _scroll_center(event: E) -> None: """ Center Window vertically around cursor. """ w = event.app.layout.current_window b = event.current_buffer if w and w.render_info: info = w.render_info # Calculate the offset that we need in order to position the row # containing the cursor in the center. scroll_height = info.window_height // 2 y = max(0, b.document.cursor_position_row - 1) height = 0 while y > 0: line_height = info.get_height_for_line(y) if height + line_height < scroll_height: height += line_height y -= 1 else: break w.vertical_scroll = y @text_object("%") def _goto_corresponding_bracket(event: E) -> TextObject: """ Implements 'c%', 'd%', '%, 'y%' (Move to corresponding bracket.) If an 'arg' has been given, go this this % position in the file. """ buffer = event.current_buffer if event._arg: # If 'arg' has been given, the meaning of % is to go to the 'x%' # row in the file. if 0 < event.arg <= 100: absolute_index = buffer.document.translate_row_col_to_index( int((event.arg * buffer.document.line_count - 1) / 100), 0 ) return TextObject( absolute_index - buffer.document.cursor_position, type=TextObjectType.LINEWISE, ) else: return TextObject(0) # Do nothing. else: # Move to the corresponding opening/closing bracket (()'s, []'s and {}'s). match = buffer.document.find_matching_bracket_position() if match: return TextObject(match, type=TextObjectType.INCLUSIVE) else: return TextObject(0) @text_object("|") def _to_column(event: E) -> TextObject: """ Move to the n-th column (you may specify the argument n by typing it on number keys, for example, 20|). """ return TextObject( event.current_buffer.document.get_column_cursor_position(event.arg - 1) ) @text_object("g", "g") def _goto_first_line(event: E) -> TextObject: """ Go to the start of the very first line. Implements 'gg', 'cgg', 'ygg' """ d = event.current_buffer.document if event._arg: # Move to the given line. return TextObject( d.translate_row_col_to_index(event.arg - 1, 0) - d.cursor_position, type=TextObjectType.LINEWISE, ) else: # Move to the top of the input. return TextObject( d.get_start_of_document_position(), type=TextObjectType.LINEWISE ) @text_object("g", "_") def _goto_last_line(event: E) -> TextObject: """ Go to last non-blank of line. 'g_', 'cg_', 'yg_', etc.. """ return TextObject( event.current_buffer.document.last_non_blank_of_current_line_position(), type=TextObjectType.INCLUSIVE, ) @text_object("g", "e") def _ge(event: E) -> TextObject: """ Go to last character of previous word. 'ge', 'cge', 'yge', etc.. """ prev_end = event.current_buffer.document.find_previous_word_ending( count=event.arg ) return TextObject( prev_end - 1 if prev_end is not None else 0, type=TextObjectType.INCLUSIVE ) @text_object("g", "E") def _gE(event: E) -> TextObject: """ Go to last character of previous WORD. 'gE', 'cgE', 'ygE', etc.. """ prev_end = event.current_buffer.document.find_previous_word_ending( count=event.arg, WORD=True ) return TextObject( prev_end - 1 if prev_end is not None else 0, type=TextObjectType.INCLUSIVE ) @text_object("g", "m") def _gm(event: E) -> TextObject: """ Like g0, but half a screenwidth to the right. (Or as much as possible.) """ w = event.app.layout.current_window buff = event.current_buffer if w and w.render_info: width = w.render_info.window_width start = buff.document.get_start_of_line_position(after_whitespace=False) start += int(min(width / 2, len(buff.document.current_line))) return TextObject(start, type=TextObjectType.INCLUSIVE) return TextObject(0) @text_object("G") def _last_line(event: E) -> TextObject: """ Go to the end of the document. (If no arg has been given.) """ buf = event.current_buffer return TextObject( buf.document.translate_row_col_to_index(buf.document.line_count - 1, 0) - buf.cursor_position, type=TextObjectType.LINEWISE, ) # # *** Other *** # @handle("G", filter=has_arg) def _to_nth_history_line(event: E) -> None: """ If an argument is given, move to this line in the history. (for example, 15G) """ event.current_buffer.go_to_history(event.arg - 1) for n in "123456789": @handle( n, filter=vi_navigation_mode | vi_selection_mode | vi_waiting_for_text_object_mode, ) def _arg(event: E) -> None: """ Always handle numerics in navigation mode as arg. """ event.append_to_arg_count(event.data) @handle( "0", filter=( vi_navigation_mode | vi_selection_mode | vi_waiting_for_text_object_mode ) & has_arg, ) def _0_arg(event: E) -> None: """ Zero when an argument was already give. """ event.append_to_arg_count(event.data) @handle(Keys.Any, filter=vi_replace_mode) def _insert_text(event: E) -> None: """ Insert data at cursor position. """ event.current_buffer.insert_text(event.data, overwrite=True) @handle(Keys.Any, filter=vi_replace_single_mode) def _replace_single(event: E) -> None: """ Replace single character at cursor position. """ event.current_buffer.insert_text(event.data, overwrite=True) event.current_buffer.cursor_position -= 1 event.app.vi_state.input_mode = InputMode.NAVIGATION @handle( Keys.Any, filter=vi_insert_multiple_mode, save_before=(lambda e: not e.is_repeat), ) def _insert_text_multiple_cursors(event: E) -> None: """ Insert data at multiple cursor positions at once. (Usually a result of pressing 'I' or 'A' in block-selection mode.) """ buff = event.current_buffer original_text = buff.text # Construct new text. text = [] p = 0 for p2 in buff.multiple_cursor_positions: text.append(original_text[p:p2]) text.append(event.data) p = p2 text.append(original_text[p:]) # Shift all cursor positions. new_cursor_positions = [ pos + i + 1 for i, pos in enumerate(buff.multiple_cursor_positions) ] # Set result. buff.text = "".join(text) buff.multiple_cursor_positions = new_cursor_positions buff.cursor_position += 1 @handle("backspace", filter=vi_insert_multiple_mode) def _delete_before_multiple_cursors(event: E) -> None: """ Backspace, using multiple cursors. """ buff = event.current_buffer original_text = buff.text # Construct new text. deleted_something = False text = [] p = 0 for p2 in buff.multiple_cursor_positions: if p2 > 0 and original_text[p2 - 1] != "\n": # Don't delete across lines. text.append(original_text[p : p2 - 1]) deleted_something = True else: text.append(original_text[p:p2]) p = p2 text.append(original_text[p:]) if deleted_something: # Shift all cursor positions. lengths = [len(part) for part in text[:-1]] new_cursor_positions = list(accumulate(lengths)) # Set result. buff.text = "".join(text) buff.multiple_cursor_positions = new_cursor_positions buff.cursor_position -= 1 else: event.app.output.bell() @handle("delete", filter=vi_insert_multiple_mode) def _delete_after_multiple_cursors(event: E) -> None: """ Delete, using multiple cursors. """ buff = event.current_buffer original_text = buff.text # Construct new text. deleted_something = False text = [] new_cursor_positions = [] p = 0 for p2 in buff.multiple_cursor_positions: text.append(original_text[p:p2]) if p2 >= len(original_text) or original_text[p2] == "\n": # Don't delete across lines. p = p2 else: p = p2 + 1 deleted_something = True text.append(original_text[p:]) if deleted_something: # Shift all cursor positions. lengths = [len(part) for part in text[:-1]] new_cursor_positions = list(accumulate(lengths)) # Set result. buff.text = "".join(text) buff.multiple_cursor_positions = new_cursor_positions else: event.app.output.bell() @handle("left", filter=vi_insert_multiple_mode) def _left_multiple(event: E) -> None: """ Move all cursors to the left. (But keep all cursors on the same line.) """ buff = event.current_buffer new_positions = [] for p in buff.multiple_cursor_positions: if buff.document.translate_index_to_position(p)[1] > 0: p -= 1 new_positions.append(p) buff.multiple_cursor_positions = new_positions if buff.document.cursor_position_col > 0: buff.cursor_position -= 1 @handle("right", filter=vi_insert_multiple_mode) def _right_multiple(event: E) -> None: """ Move all cursors to the right. (But keep all cursors on the same line.) """ buff = event.current_buffer new_positions = [] for p in buff.multiple_cursor_positions: row, column = buff.document.translate_index_to_position(p) if column < len(buff.document.lines[row]): p += 1 new_positions.append(p) buff.multiple_cursor_positions = new_positions if not buff.document.is_cursor_at_the_end_of_line: buff.cursor_position += 1 @handle("up", filter=vi_insert_multiple_mode) @handle("down", filter=vi_insert_multiple_mode) def _updown_multiple(event: E) -> None: """ Ignore all up/down key presses when in multiple cursor mode. """ @handle("c-x", "c-l", filter=vi_insert_mode) def _complete_line(event: E) -> None: """ Pressing the ControlX - ControlL sequence in Vi mode does line completion based on the other lines in the document and the history. """ event.current_buffer.start_history_lines_completion() @handle("c-x", "c-f", filter=vi_insert_mode) def _complete_filename(event: E) -> None: """ Complete file names. """ # TODO pass @handle("c-k", filter=vi_insert_mode | vi_replace_mode) def _digraph(event: E) -> None: """ Go into digraph mode. """ event.app.vi_state.waiting_for_digraph = True @Condition def digraph_symbol_1_given() -> bool: return get_app().vi_state.digraph_symbol1 is not None @handle(Keys.Any, filter=vi_digraph_mode & ~digraph_symbol_1_given) def _digraph1(event: E) -> None: """ First digraph symbol. """ event.app.vi_state.digraph_symbol1 = event.data @handle(Keys.Any, filter=vi_digraph_mode & digraph_symbol_1_given) def _create_digraph(event: E) -> None: """ Insert digraph. """ try: # Lookup. code: Tuple[str, str] = ( event.app.vi_state.digraph_symbol1 or "", event.data, ) if code not in DIGRAPHS: code = code[::-1] # Try reversing. symbol = DIGRAPHS[code] except KeyError: # Unknown digraph. event.app.output.bell() else: # Insert digraph. overwrite = event.app.vi_state.input_mode == InputMode.REPLACE event.current_buffer.insert_text(chr(symbol), overwrite=overwrite) event.app.vi_state.waiting_for_digraph = False finally: event.app.vi_state.waiting_for_digraph = False event.app.vi_state.digraph_symbol1 = None @handle("c-o", filter=vi_insert_mode | vi_replace_mode) def _quick_normal_mode(event: E) -> None: """ Go into normal mode for one single action. """ event.app.vi_state.temporary_navigation_mode = True @handle("q", Keys.Any, filter=vi_navigation_mode & ~vi_recording_macro) def _start_macro(event: E) -> None: """ Start recording macro. """ c = event.key_sequence[1].data if c in vi_register_names: vi_state = event.app.vi_state vi_state.recording_register = c vi_state.current_recording = "" @handle("q", filter=vi_navigation_mode & vi_recording_macro) def _stop_macro(event: E) -> None: """ Stop recording macro. """ vi_state = event.app.vi_state # Store and stop recording. if vi_state.recording_register: vi_state.named_registers[vi_state.recording_register] = ClipboardData( vi_state.current_recording ) vi_state.recording_register = None vi_state.current_recording = "" @handle("@", Keys.Any, filter=vi_navigation_mode, record_in_macro=False) def _execute_macro(event: E) -> None: """ Execute macro. Notice that we pass `record_in_macro=False`. This ensures that the `@x` keys don't appear in the recording itself. This function inserts the body of the called macro back into the KeyProcessor, so these keys will be added later on to the macro of their handlers have `record_in_macro=True`. """ # Retrieve macro. c = event.key_sequence[1].data try: macro = event.app.vi_state.named_registers[c] except KeyError: return # Expand macro (which is a string in the register), in individual keys. # Use vt100 parser for this. keys: List[KeyPress] = [] parser = Vt100Parser(keys.append) parser.feed(macro.text) parser.flush() # Now feed keys back to the input processor. for _ in range(event.arg): event.app.key_processor.feed_multiple(keys, first=True) return ConditionalKeyBindings(key_bindings, vi_mode) def load_vi_search_bindings() -> KeyBindingsBase: key_bindings = KeyBindings() handle = key_bindings.add from . import search @Condition def search_buffer_is_empty() -> bool: "Returns True when the search buffer is empty." return get_app().current_buffer.text == "" # Vi-style forward search. handle( "/", filter=(vi_navigation_mode | vi_selection_mode) & ~vi_search_direction_reversed, )(search.start_forward_incremental_search) handle( "?", filter=(vi_navigation_mode | vi_selection_mode) & vi_search_direction_reversed, )(search.start_forward_incremental_search) handle("c-s")(search.start_forward_incremental_search) # Vi-style backward search. handle( "?", filter=(vi_navigation_mode | vi_selection_mode) & ~vi_search_direction_reversed, )(search.start_reverse_incremental_search) handle( "/", filter=(vi_navigation_mode | vi_selection_mode) & vi_search_direction_reversed, )(search.start_reverse_incremental_search) handle("c-r")(search.start_reverse_incremental_search) # Apply the search. (At the / or ? prompt.) handle("enter", filter=is_searching)(search.accept_search) handle("c-r", filter=is_searching)(search.reverse_incremental_search) handle("c-s", filter=is_searching)(search.forward_incremental_search) handle("c-c")(search.abort_search) handle("c-g")(search.abort_search) handle("backspace", filter=search_buffer_is_empty)(search.abort_search) # Handle escape. This should accept the search, just like readline. # `abort_search` would be a meaningful alternative. handle("escape")(search.accept_search) return ConditionalKeyBindings(key_bindings, vi_mode)