Restoring authorship annotation for Ivan Blinkov <ivan@blinkov.ru>. Commit 1 of 2.

1 files changed, 928 insertions, 928 deletions

diff --git a/contrib/python/prompt-toolkit/py2/prompt_toolkit/key_binding/bindings/vi.py b/contrib/python/prompt-toolkit/py2/prompt_toolkit/key_binding/bindings/vi.py
index 72568ee273..a436edf3a7 100644
--- a/contrib/python/prompt-toolkit/py2/prompt_toolkit/key_binding/bindings/vi.py
+++ b/contrib/python/prompt-toolkit/py2/prompt_toolkit/key_binding/bindings/vi.py
@@ -1,26 +1,26 @@
-# pylint: disable=function-redefined
-from __future__ import unicode_literals
+# pylint: disable=function-redefined 
+from __future__ import unicode_literals 
 from prompt_toolkit.buffer import ClipboardData, indent, unindent, reshape_text
-from prompt_toolkit.document import Document
-from prompt_toolkit.enums import IncrementalSearchDirection, SEARCH_BUFFER, SYSTEM_BUFFER
+from prompt_toolkit.document import Document 
+from prompt_toolkit.enums import IncrementalSearchDirection, SEARCH_BUFFER, SYSTEM_BUFFER 
 from prompt_toolkit.filters import Filter, Condition, HasArg, Always, IsReadOnly
 from prompt_toolkit.filters.cli import ViNavigationMode, ViInsertMode, ViInsertMultipleMode, ViReplaceMode, ViSelectionMode, ViWaitingForTextObjectMode, ViDigraphMode, ViMode
 from prompt_toolkit.key_binding.digraphs import DIGRAPHS
-from prompt_toolkit.key_binding.vi_state import CharacterFind, InputMode
-from prompt_toolkit.keys import Keys
-from prompt_toolkit.layout.utils import find_window_for_buffer_name
+from prompt_toolkit.key_binding.vi_state import CharacterFind, InputMode 
+from prompt_toolkit.keys import Keys 
+from prompt_toolkit.layout.utils import find_window_for_buffer_name 
 from prompt_toolkit.selection import SelectionType, SelectionState, PasteMode
-
-from .scroll import scroll_forward, scroll_backward, scroll_half_page_up, scroll_half_page_down, scroll_one_line_up, scroll_one_line_down, scroll_page_up, scroll_page_down
+ 
+from .scroll import scroll_forward, scroll_backward, scroll_half_page_up, scroll_half_page_down, scroll_one_line_up, scroll_one_line_down, scroll_page_up, scroll_page_down 
 from .named_commands import get_by_name
 from ..registry import Registry, ConditionalRegistry, BaseRegistry
-
-import prompt_toolkit.filters as filters
+ 
+import prompt_toolkit.filters as filters 
 from six.moves import range
-import codecs
+import codecs 
 import six
 import string
-
+ 
 try:
     from itertools import accumulate
 except ImportError: # < Python 3.2
@@ -31,38 +31,38 @@ except ImportError: # < Python 3.2
             total += item
             yield total
 
-__all__ = (
-    'load_vi_bindings',
-    'load_vi_search_bindings',
-    'load_vi_system_bindings',
-    'load_extra_vi_page_navigation_bindings',
-)
-
+__all__ = ( 
+    'load_vi_bindings', 
+    'load_vi_search_bindings', 
+    'load_vi_system_bindings', 
+    'load_extra_vi_page_navigation_bindings', 
+) 
+ 
 if six.PY2:
     ascii_lowercase = string.ascii_lowercase.decode('ascii')
 else:
     ascii_lowercase = string.ascii_lowercase
-
+ 
 vi_register_names = ascii_lowercase + '0123456789'
-
-
+ 
+ 
 class TextObjectType(object):
     EXCLUSIVE = 'EXCLUSIVE'
     INCLUSIVE = 'INCLUSIVE'
     LINEWISE = 'LINEWISE'
     BLOCK = 'BLOCK'
-
-
+ 
+ 
 class TextObject(object):
-    """
+    """ 
     Return struct for functions wrapped in ``text_object``.
-    Both `start` and `end` are relative to the current cursor position.
-    """
+    Both `start` and `end` are relative to the current cursor position. 
+    """ 
     def __init__(self, start, end=0, type=TextObjectType.EXCLUSIVE):
-        self.start = start
-        self.end = end
+        self.start = start 
+        self.end = end 
         self.type = type
-
+ 
     @property
     def selection_type(self):
         if self.type == TextObjectType.LINEWISE:
@@ -72,15 +72,15 @@ class TextObject(object):
         else:
             return SelectionType.CHARACTERS
 
-    def sorted(self):
-        """
-        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 sorted(self): 
+        """ 
+        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):
         """
         Return a (start, end) tuple with start <= end that indicates the range
@@ -89,7 +89,7 @@ class TextObject(object):
         """
         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
@@ -138,7 +138,7 @@ class TextObject(object):
 
 
 def create_text_object_decorator(registry):
-    """
+    """ 
     Create a decorator that can be used to register Vi text object implementations.
     """
     assert isinstance(registry, BaseRegistry)
@@ -299,30 +299,30 @@ def create_operator_decorator(registry):
 
 def load_vi_bindings(get_search_state=None):
     """
-    Vi extensions.
-
-    # Overview of Readline Vi commands:
-    # http://www.catonmat.net/download/bash-vi-editing-mode-cheat-sheet.pdf
-
+    Vi extensions. 
+ 
+    # Overview of Readline Vi commands: 
+    # http://www.catonmat.net/download/bash-vi-editing-mode-cheat-sheet.pdf 
+ 
      :param get_search_state: None or a callable that takes a
         CommandLineInterface and returns a SearchState.
-    """
-    # 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.
-
+    """ 
+    # 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. 
+ 
     registry = ConditionalRegistry(Registry(), ViMode())
     handle = registry.add_binding
-
-    # Default get_search_state.
-    if get_search_state is None:
-        def get_search_state(cli): return cli.search_state
-
+ 
+    # Default get_search_state. 
+    if get_search_state is None: 
+        def get_search_state(cli): return cli.search_state 
+ 
     # (Note: Always take the navigation bindings in read-only mode, even when
     #  ViState says different.)
     navigation_mode = ViNavigationMode()
@@ -332,63 +332,63 @@ def load_vi_bindings(get_search_state=None):
     selection_mode = ViSelectionMode()
     operator_given = ViWaitingForTextObjectMode()
     digraph_mode = ViDigraphMode()
-
-    vi_transform_functions = [
-        # Rot 13 transformation
+ 
+    vi_transform_functions = [ 
+        # Rot 13 transformation 
         (('g', '?'), Always(), lambda string: codecs.encode(string, 'rot_13')),
-
-        # To lowercase
+ 
+        # To lowercase 
         (('g', 'u'), Always(), lambda string: string.lower()),
-
-        # To uppercase.
+ 
+        # To uppercase. 
         (('g', 'U'), Always(), lambda string: string.upper()),
-
-        # Swap case.
+ 
+        # Swap case. 
         (('g', '~'), Always(), lambda string: string.swapcase()),
         (('~', ), Condition(lambda cli: cli.vi_state.tilde_operator), lambda string: string.swapcase()),
-    ]
-
+    ] 
+ 
     # Insert a character literally (quoted insert).
     handle(Keys.ControlV, filter=insert_mode)(get_by_name('quoted-insert'))
 
-    @handle(Keys.Escape)
-    def _(event):
-        """
-        Escape goes to vi navigation mode.
-        """
-        buffer = event.current_buffer
+    @handle(Keys.Escape) 
+    def _(event): 
+        """ 
+        Escape goes to vi navigation mode. 
+        """ 
+        buffer = event.current_buffer 
         vi_state = event.cli.vi_state
-
-        if vi_state.input_mode in (InputMode.INSERT, InputMode.REPLACE):
-            buffer.cursor_position += buffer.document.get_cursor_left_position()
-
+ 
+        if vi_state.input_mode in (InputMode.INSERT, InputMode.REPLACE): 
+            buffer.cursor_position += buffer.document.get_cursor_left_position() 
+ 
         vi_state.reset(InputMode.NAVIGATION)
-
-        if bool(buffer.selection_state):
-            buffer.exit_selection()
-
-    @handle('k', filter=selection_mode)
-    def _(event):
-        """
-        Arrow up in selection mode.
-        """
-        event.current_buffer.cursor_up(count=event.arg)
-
-    @handle('j', filter=selection_mode)
-    def _(event):
-        """
-        Arrow down in selection mode.
-        """
-        event.current_buffer.cursor_down(count=event.arg)
-
-    @handle(Keys.Up, filter=navigation_mode)
-    @handle(Keys.ControlP, filter=navigation_mode)
-    def _(event):
-        """
-        Arrow up and ControlP in navigation mode go up.
-        """
+ 
+        if bool(buffer.selection_state): 
+            buffer.exit_selection() 
+ 
+    @handle('k', filter=selection_mode) 
+    def _(event): 
+        """ 
+        Arrow up in selection mode. 
+        """ 
+        event.current_buffer.cursor_up(count=event.arg) 
+ 
+    @handle('j', filter=selection_mode) 
+    def _(event): 
+        """ 
+        Arrow down in selection mode. 
+        """ 
+        event.current_buffer.cursor_down(count=event.arg) 
+ 
+    @handle(Keys.Up, filter=navigation_mode) 
+    @handle(Keys.ControlP, filter=navigation_mode) 
+    def _(event): 
+        """ 
+        Arrow up and ControlP in navigation mode go up. 
+        """ 
         event.current_buffer.auto_up(count=event.arg)
-
+ 
     @handle('k', filter=navigation_mode)
     def _(event):
         """
@@ -398,14 +398,14 @@ def load_vi_bindings(get_search_state=None):
         event.current_buffer.auto_up(
             count=event.arg, go_to_start_of_line_if_history_changes=True)
 
-    @handle(Keys.Down, filter=navigation_mode)
-    @handle(Keys.ControlN, filter=navigation_mode)
-    def _(event):
-        """
-        Arrow down and Control-N in navigation mode.
-        """
+    @handle(Keys.Down, filter=navigation_mode) 
+    @handle(Keys.ControlN, filter=navigation_mode) 
+    def _(event): 
+        """ 
+        Arrow down and Control-N in navigation mode. 
+        """ 
         event.current_buffer.auto_down(count=event.arg)
-
+ 
     @handle('j', filter=navigation_mode)
     def _(event):
         """
@@ -415,143 +415,143 @@ def load_vi_bindings(get_search_state=None):
             count=event.arg, go_to_start_of_line_if_history_changes=True)
 
     @handle(Keys.ControlH, filter=navigation_mode)
-    @handle(Keys.Backspace, filter=navigation_mode)
-    def _(event):
-        """
-        In navigation-mode, move cursor.
-        """
-        event.current_buffer.cursor_position += \
-            event.current_buffer.document.get_cursor_left_position(count=event.arg)
-
-    @handle(Keys.ControlN, filter=insert_mode)
-    def _(event):
-        b = event.current_buffer
-
-        if b.complete_state:
-            b.complete_next()
-        else:
-            event.cli.start_completion(select_first=True)
-
-    @handle(Keys.ControlP, filter=insert_mode)
-    def _(event):
-        """
-        Control-P: To previous completion.
-        """
-        b = event.current_buffer
-
-        if b.complete_state:
-            b.complete_previous()
-        else:
-            event.cli.start_completion(select_last=True)
-
-    @handle(Keys.ControlY, filter=insert_mode)
-    def _(event):
-        """
-        Accept current completion.
-        """
-        event.current_buffer.complete_state = None
-
-    @handle(Keys.ControlE, filter=insert_mode)
-    def _(event):
-        """
-        Cancel completion. Go back to originally typed text.
-        """
-        event.current_buffer.cancel_completion()
-
+    @handle(Keys.Backspace, filter=navigation_mode) 
+    def _(event): 
+        """ 
+        In navigation-mode, move cursor. 
+        """ 
+        event.current_buffer.cursor_position += \ 
+            event.current_buffer.document.get_cursor_left_position(count=event.arg) 
+ 
+    @handle(Keys.ControlN, filter=insert_mode) 
+    def _(event): 
+        b = event.current_buffer 
+ 
+        if b.complete_state: 
+            b.complete_next() 
+        else: 
+            event.cli.start_completion(select_first=True) 
+ 
+    @handle(Keys.ControlP, filter=insert_mode) 
+    def _(event): 
+        """ 
+        Control-P: To previous completion. 
+        """ 
+        b = event.current_buffer 
+ 
+        if b.complete_state: 
+            b.complete_previous() 
+        else: 
+            event.cli.start_completion(select_last=True) 
+ 
+    @handle(Keys.ControlY, filter=insert_mode) 
+    def _(event): 
+        """ 
+        Accept current completion. 
+        """ 
+        event.current_buffer.complete_state = None 
+ 
+    @handle(Keys.ControlE, filter=insert_mode) 
+    def _(event): 
+        """ 
+        Cancel completion. Go back to originally typed text. 
+        """ 
+        event.current_buffer.cancel_completion() 
+ 
     @handle(Keys.ControlJ, filter=navigation_mode)   # XXX: only if the selected buffer has a return handler.
-    def _(event):
-        """
-        In navigation mode, pressing enter will always return the input.
-        """
-        b = event.current_buffer
-
-        if b.accept_action.is_returnable:
-            b.accept_action.validate_and_handle(event.cli, b)
-
-    # ** In navigation mode **
-
-    # List of navigation commands: http://hea-www.harvard.edu/~fine/Tech/vi.html
-
-    @handle(Keys.Insert, filter=navigation_mode)
-    def _(event):
-        " Presing the Insert key. "
+    def _(event): 
+        """ 
+        In navigation mode, pressing enter will always return the input. 
+        """ 
+        b = event.current_buffer 
+ 
+        if b.accept_action.is_returnable: 
+            b.accept_action.validate_and_handle(event.cli, b) 
+ 
+    # ** In navigation mode ** 
+ 
+    # List of navigation commands: http://hea-www.harvard.edu/~fine/Tech/vi.html 
+ 
+    @handle(Keys.Insert, filter=navigation_mode) 
+    def _(event): 
+        " Presing the Insert key. " 
         event.cli.vi_state.input_mode = InputMode.INSERT
-
-    @handle('a', filter=navigation_mode & ~IsReadOnly())
-            # ~IsReadOnly, because we want to stay in navigation mode for
-            # read-only buffers.
-    def _(event):
-        event.current_buffer.cursor_position += event.current_buffer.document.get_cursor_right_position()
+ 
+    @handle('a', filter=navigation_mode & ~IsReadOnly()) 
+            # ~IsReadOnly, because we want to stay in navigation mode for 
+            # read-only buffers. 
+    def _(event): 
+        event.current_buffer.cursor_position += event.current_buffer.document.get_cursor_right_position() 
         event.cli.vi_state.input_mode = InputMode.INSERT
-
-    @handle('A', filter=navigation_mode & ~IsReadOnly())
-    def _(event):
-        event.current_buffer.cursor_position += event.current_buffer.document.get_end_of_line_position()
+ 
+    @handle('A', filter=navigation_mode & ~IsReadOnly()) 
+    def _(event): 
+        event.current_buffer.cursor_position += event.current_buffer.document.get_end_of_line_position() 
         event.cli.vi_state.input_mode = InputMode.INSERT
-
-    @handle('C', filter=navigation_mode & ~IsReadOnly())
-    def _(event):
-        """
-        # 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.cli.clipboard.set_text(deleted)
+ 
+    @handle('C', filter=navigation_mode & ~IsReadOnly()) 
+    def _(event): 
+        """ 
+        # 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.cli.clipboard.set_text(deleted) 
         event.cli.vi_state.input_mode = InputMode.INSERT
-
-    @handle('c', 'c', filter=navigation_mode & ~IsReadOnly())
-    @handle('S', filter=navigation_mode & ~IsReadOnly())
-    def _(event):  # TODO: implement 'arg'
-        """
-        Change current line
-        """
-        buffer = event.current_buffer
-
-        # We copy the whole line.
-        data = ClipboardData(buffer.document.current_line, SelectionType.LINES)
-        event.cli.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())
+ 
+    @handle('c', 'c', filter=navigation_mode & ~IsReadOnly()) 
+    @handle('S', filter=navigation_mode & ~IsReadOnly()) 
+    def _(event):  # TODO: implement 'arg' 
+        """ 
+        Change current line 
+        """ 
+        buffer = event.current_buffer 
+ 
+        # We copy the whole line. 
+        data = ClipboardData(buffer.document.current_line, SelectionType.LINES) 
+        event.cli.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.cli.vi_state.input_mode = InputMode.INSERT
-
-    @handle('D', filter=navigation_mode)
-    def _(event):
-        buffer = event.current_buffer
-        deleted = buffer.delete(count=buffer.document.get_end_of_line_position())
-        event.cli.clipboard.set_text(deleted)
-
-    @handle('d', 'd', filter=navigation_mode)
-    def _(event):
-        """
-        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])
+ 
+    @handle('D', filter=navigation_mode) 
+    def _(event): 
+        buffer = event.current_buffer 
+        deleted = buffer.delete(count=buffer.document.get_end_of_line_position()) 
+        event.cli.clipboard.set_text(deleted) 
+ 
+    @handle('d', 'd', filter=navigation_mode) 
+    def _(event): 
+        """ 
+        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.cli.clipboard.set_data(ClipboardData(deleted, SelectionType.LINES))
-
+        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.cli.clipboard.set_data(ClipboardData(deleted, SelectionType.LINES)) 
+ 
     @handle('x', filter=selection_mode)
     def _(event):
         """
@@ -561,16 +561,16 @@ def load_vi_bindings(get_search_state=None):
         clipboard_data = event.current_buffer.cut_selection()
         event.cli.clipboard.set_data(clipboard_data)
 
-    @handle('i', filter=navigation_mode & ~IsReadOnly())
-    def _(event):
+    @handle('i', filter=navigation_mode & ~IsReadOnly()) 
+    def _(event): 
         event.cli.vi_state.input_mode = InputMode.INSERT
-
-    @handle('I', filter=navigation_mode & ~IsReadOnly())
-    def _(event):
+ 
+    @handle('I', filter=navigation_mode & ~IsReadOnly()) 
+    def _(event): 
         event.cli.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(cli):
         buff = cli.current_buffer
@@ -603,17 +603,17 @@ def load_vi_bindings(get_search_state=None):
         buff.exit_selection()
 
     @handle('A', filter=in_block_selection & ~IsReadOnly())
-    def _(event):
+    def _(event): 
         go_to_block_selection(event, after=True)
 
     @handle('J', filter=navigation_mode & ~IsReadOnly())
     def _(event):
         " Join lines. "
-        for i in range(event.arg):
-            event.current_buffer.join_next_line()
-
+        for i in range(event.arg): 
+            event.current_buffer.join_next_line() 
+ 
     @handle('g', 'J', filter=navigation_mode & ~IsReadOnly())
-    def _(event):
+    def _(event): 
         " Join lines without space. "
         for i in range(event.arg):
             event.current_buffer.join_next_line(separator='')
@@ -621,33 +621,33 @@ def load_vi_bindings(get_search_state=None):
     @handle('J', filter=selection_mode & ~IsReadOnly())
     def _(event):
         " Join selected lines. "
-        event.current_buffer.join_selected_lines()
-
+        event.current_buffer.join_selected_lines() 
+ 
     @handle('g', 'J', filter=selection_mode & ~IsReadOnly())
     def _(event):
         " Join selected lines without space. "
         event.current_buffer.join_selected_lines(separator='')
-
-    @handle('p', filter=navigation_mode)
-    def _(event):
-        """
-        Paste after
-        """
-        event.current_buffer.paste_clipboard_data(
-            event.cli.clipboard.get_data(),
+ 
+    @handle('p', filter=navigation_mode) 
+    def _(event): 
+        """ 
+        Paste after 
+        """ 
+        event.current_buffer.paste_clipboard_data( 
+            event.cli.clipboard.get_data(), 
             count=event.arg,
             paste_mode=PasteMode.VI_AFTER)
-
-    @handle('P', filter=navigation_mode)
-    def _(event):
-        """
-        Paste before
-        """
-        event.current_buffer.paste_clipboard_data(
-            event.cli.clipboard.get_data(),
+ 
+    @handle('P', filter=navigation_mode) 
+    def _(event): 
+        """ 
+        Paste before 
+        """ 
+        event.current_buffer.paste_clipboard_data( 
+            event.cli.clipboard.get_data(), 
             count=event.arg,
             paste_mode=PasteMode.VI_BEFORE)
-
+ 
     @handle('"', Keys.Any, 'p', filter=navigation_mode)
     def _(event):
         " Paste from named register. "
@@ -668,190 +668,190 @@ def load_vi_bindings(get_search_state=None):
                 event.current_buffer.paste_clipboard_data(
                     data, count=event.arg, paste_mode=PasteMode.VI_BEFORE)
 
-    @handle('r', Keys.Any, filter=navigation_mode)
-    def _(event):
-        """
-        Replace single character under cursor
-        """
-        event.current_buffer.insert_text(event.data * event.arg, overwrite=True)
-        event.current_buffer.cursor_position -= 1
-
-    @handle('R', filter=navigation_mode)
-    def _(event):
-        """
-        Go to 'replace'-mode.
-        """
+    @handle('r', Keys.Any, filter=navigation_mode) 
+    def _(event): 
+        """ 
+        Replace single character under cursor 
+        """ 
+        event.current_buffer.insert_text(event.data * event.arg, overwrite=True) 
+        event.current_buffer.cursor_position -= 1 
+ 
+    @handle('R', filter=navigation_mode) 
+    def _(event): 
+        """ 
+        Go to 'replace'-mode. 
+        """ 
         event.cli.vi_state.input_mode = InputMode.REPLACE
-
-    @handle('s', filter=navigation_mode & ~IsReadOnly())
-    def _(event):
-        """
-        Substitute with new text
-        (Delete character(s) and go to insert mode.)
-        """
-        text = event.current_buffer.delete(count=event.arg)
-        event.cli.clipboard.set_text(text)
+ 
+    @handle('s', filter=navigation_mode & ~IsReadOnly()) 
+    def _(event): 
+        """ 
+        Substitute with new text 
+        (Delete character(s) and go to insert mode.) 
+        """ 
+        text = event.current_buffer.delete(count=event.arg) 
+        event.cli.clipboard.set_text(text) 
         event.cli.vi_state.input_mode = InputMode.INSERT
-
-    @handle('u', filter=navigation_mode, save_before=(lambda e: False))
-    def _(event):
-        for i in range(event.arg):
-            event.current_buffer.undo()
-
-    @handle('V', filter=navigation_mode)
-    def _(event):
-        """
-        Start lines selection.
-        """
-        event.current_buffer.start_selection(selection_type=SelectionType.LINES)
-
-    @handle(Keys.ControlV, filter=navigation_mode)
-    def _(event):
-        " Enter block selection mode. "
-        event.current_buffer.start_selection(selection_type=SelectionType.BLOCK)
-
-    @handle('V', filter=selection_mode)
-    def _(event):
-        """
-        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.type != SelectionType.LINES:
-            selection_state.type = SelectionType.LINES
-        else:
-            event.current_buffer.exit_selection()
-
+ 
+    @handle('u', filter=navigation_mode, save_before=(lambda e: False)) 
+    def _(event): 
+        for i in range(event.arg): 
+            event.current_buffer.undo() 
+ 
+    @handle('V', filter=navigation_mode) 
+    def _(event): 
+        """ 
+        Start lines selection. 
+        """ 
+        event.current_buffer.start_selection(selection_type=SelectionType.LINES) 
+ 
+    @handle(Keys.ControlV, filter=navigation_mode) 
+    def _(event): 
+        " Enter block selection mode. " 
+        event.current_buffer.start_selection(selection_type=SelectionType.BLOCK) 
+ 
+    @handle('V', filter=selection_mode) 
+    def _(event): 
+        """ 
+        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.type != SelectionType.LINES: 
+            selection_state.type = SelectionType.LINES 
+        else: 
+            event.current_buffer.exit_selection() 
+ 
     @handle('v', filter=navigation_mode)
-    def _(event):
-        " Enter character selection mode. "
-        event.current_buffer.start_selection(selection_type=SelectionType.CHARACTERS)
-
-    @handle('v', filter=selection_mode)
-    def _(event):
-        """
-        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.type != SelectionType.CHARACTERS:
-            selection_state.type = SelectionType.CHARACTERS
-        else:
-            event.current_buffer.exit_selection()
-
-    @handle(Keys.ControlV, filter=selection_mode)
-    def _(event):
-        """
-        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.type != SelectionType.BLOCK:
-            selection_state.type = SelectionType.BLOCK
-        else:
-            event.current_buffer.exit_selection()
-
-
-    @handle('a', 'w', filter=selection_mode)
-    @handle('a', 'W', filter=selection_mode)
-    def _(event):
-        """
-        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=navigation_mode)
-    def _(event):
-        """
-        Delete character.
-        """
-        text = event.current_buffer.delete(count=event.arg)
-        event.cli.clipboard.set_text(text)
-
-    @handle('X', filter=navigation_mode)
-    def _(event):
-        text = event.current_buffer.delete_before_cursor()
-        event.cli.clipboard.set_text(text)
-
-    @handle('y', 'y', filter=navigation_mode)
-    @handle('Y', filter=navigation_mode)
-    def _(event):
-        """
-        Yank the whole line.
-        """
-        text = '\n'.join(event.current_buffer.document.lines_from_current[:event.arg])
-        event.cli.clipboard.set_data(ClipboardData(text, SelectionType.LINES))
-
-    @handle('+', filter=navigation_mode)
-    def _(event):
-        """
-        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=navigation_mode)
-    def _(event):
-        """
-        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=navigation_mode)
-    def _(event):
-        """
-        Indent lines.
-        """
-        buffer = event.current_buffer
-        current_row = buffer.document.cursor_position_row
-        indent(buffer, current_row, current_row + event.arg)
-
-    @handle('<', '<', filter=navigation_mode)
-    def _(event):
-        """
-        Unindent lines.
-        """
-        current_row = event.current_buffer.document.cursor_position_row
-        unindent(event.current_buffer, current_row, current_row + event.arg)
-
-    @handle('O', filter=navigation_mode & ~IsReadOnly())
-    def _(event):
-        """
-        Open line above and enter insertion mode
-        """
-        event.current_buffer.insert_line_above(
-                copy_margin=not event.cli.in_paste_mode)
+    def _(event): 
+        " Enter character selection mode. " 
+        event.current_buffer.start_selection(selection_type=SelectionType.CHARACTERS) 
+ 
+    @handle('v', filter=selection_mode) 
+    def _(event): 
+        """ 
+        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.type != SelectionType.CHARACTERS: 
+            selection_state.type = SelectionType.CHARACTERS 
+        else: 
+            event.current_buffer.exit_selection() 
+ 
+    @handle(Keys.ControlV, filter=selection_mode) 
+    def _(event): 
+        """ 
+        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.type != SelectionType.BLOCK: 
+            selection_state.type = SelectionType.BLOCK 
+        else: 
+            event.current_buffer.exit_selection() 
+ 
+ 
+    @handle('a', 'w', filter=selection_mode) 
+    @handle('a', 'W', filter=selection_mode) 
+    def _(event): 
+        """ 
+        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=navigation_mode) 
+    def _(event): 
+        """ 
+        Delete character. 
+        """ 
+        text = event.current_buffer.delete(count=event.arg) 
+        event.cli.clipboard.set_text(text) 
+ 
+    @handle('X', filter=navigation_mode) 
+    def _(event): 
+        text = event.current_buffer.delete_before_cursor() 
+        event.cli.clipboard.set_text(text) 
+ 
+    @handle('y', 'y', filter=navigation_mode) 
+    @handle('Y', filter=navigation_mode) 
+    def _(event): 
+        """ 
+        Yank the whole line. 
+        """ 
+        text = '\n'.join(event.current_buffer.document.lines_from_current[:event.arg]) 
+        event.cli.clipboard.set_data(ClipboardData(text, SelectionType.LINES)) 
+ 
+    @handle('+', filter=navigation_mode) 
+    def _(event): 
+        """ 
+        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=navigation_mode) 
+    def _(event): 
+        """ 
+        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=navigation_mode) 
+    def _(event): 
+        """ 
+        Indent lines. 
+        """ 
+        buffer = event.current_buffer 
+        current_row = buffer.document.cursor_position_row 
+        indent(buffer, current_row, current_row + event.arg) 
+ 
+    @handle('<', '<', filter=navigation_mode) 
+    def _(event): 
+        """ 
+        Unindent lines. 
+        """ 
+        current_row = event.current_buffer.document.cursor_position_row 
+        unindent(event.current_buffer, current_row, current_row + event.arg) 
+ 
+    @handle('O', filter=navigation_mode & ~IsReadOnly()) 
+    def _(event): 
+        """ 
+        Open line above and enter insertion mode 
+        """ 
+        event.current_buffer.insert_line_above( 
+                copy_margin=not event.cli.in_paste_mode) 
         event.cli.vi_state.input_mode = InputMode.INSERT
-
-    @handle('o', filter=navigation_mode & ~IsReadOnly())
-    def _(event):
-        """
-        Open line below and enter insertion mode
-        """
-        event.current_buffer.insert_line_below(
-                copy_margin=not event.cli.in_paste_mode)
+ 
+    @handle('o', filter=navigation_mode & ~IsReadOnly()) 
+    def _(event): 
+        """ 
+        Open line below and enter insertion mode 
+        """ 
+        event.current_buffer.insert_line_below( 
+                copy_margin=not event.cli.in_paste_mode) 
         event.cli.vi_state.input_mode = InputMode.INSERT
-
-    @handle('~', filter=navigation_mode)
-    def _(event):
-        """
-        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':
+ 
+    @handle('~', filter=navigation_mode) 
+    def _(event): 
+        """ 
+        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=navigation_mode & ~IsReadOnly())
     def _(event):
         " Lowercase current line. "
@@ -870,64 +870,64 @@ def load_vi_bindings(get_search_state=None):
         buff = event.current_buffer
         buff.transform_current_line(lambda s: s.swapcase())
 
-    @handle('#', filter=navigation_mode)
-    def _(event):
-        """
-        Go to previous occurence of this word.
-        """
-        b = event.cli.current_buffer
-
-        search_state = get_search_state(event.cli)
-        search_state.text = b.document.get_word_under_cursor()
-        search_state.direction = IncrementalSearchDirection.BACKWARD
-
-        b.apply_search(search_state, count=event.arg,
-                       include_current_position=False)
-
-    @handle('*', filter=navigation_mode)
-    def _(event):
-        """
-        Go to next occurence of this word.
-        """
-        b = event.cli.current_buffer
-
-        search_state = get_search_state(event.cli)
-        search_state.text = b.document.get_word_under_cursor()
-        search_state.direction = IncrementalSearchDirection.FORWARD
-
-        b.apply_search(search_state, count=event.arg,
-                       include_current_position=False)
-
-    @handle('(', filter=navigation_mode)
-    def _(event):
-        # TODO: go to begin of sentence.
+    @handle('#', filter=navigation_mode) 
+    def _(event): 
+        """ 
+        Go to previous occurence of this word. 
+        """ 
+        b = event.cli.current_buffer 
+ 
+        search_state = get_search_state(event.cli) 
+        search_state.text = b.document.get_word_under_cursor() 
+        search_state.direction = IncrementalSearchDirection.BACKWARD 
+ 
+        b.apply_search(search_state, count=event.arg, 
+                       include_current_position=False) 
+ 
+    @handle('*', filter=navigation_mode) 
+    def _(event): 
+        """ 
+        Go to next occurence of this word. 
+        """ 
+        b = event.cli.current_buffer 
+ 
+        search_state = get_search_state(event.cli) 
+        search_state.text = b.document.get_word_under_cursor() 
+        search_state.direction = IncrementalSearchDirection.FORWARD 
+ 
+        b.apply_search(search_state, count=event.arg, 
+                       include_current_position=False) 
+ 
+    @handle('(', filter=navigation_mode) 
+    def _(event): 
+        # TODO: go to begin of sentence. 
         # XXX: should become text_object.
-        pass
-
-    @handle(')', filter=navigation_mode)
-    def _(event):
-        # TODO: go to end of sentence.
+        pass 
+ 
+    @handle(')', filter=navigation_mode) 
+    def _(event): 
+        # TODO: go to end of sentence. 
         # XXX: should become text_object.
-        pass
-
+        pass 
+ 
     operator = create_operator_decorator(registry)
     text_object = create_text_object_decorator(registry)
-
+ 
     @text_object(Keys.Any, filter=operator_given)
     def _(event):
         """
         Unknown key binding while waiting for a text object.
         """
         event.cli.output.bell()
-
+ 
     #
     # *** Operators ***
     #
-
+ 
     def create_delete_and_change_operators(delete_only, with_register=False):
         """
         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.
         """
@@ -935,16 +935,16 @@ def load_vi_bindings(get_search_state=None):
             handler_keys = ('"', Keys.Any, 'cd'[delete_only])
         else:
             handler_keys = 'cd'[delete_only]
-
+ 
         @operator(*handler_keys, filter=~IsReadOnly())
         def delete_or_change_operator(event, text_object):
             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:
@@ -953,11 +953,11 @@ def load_vi_bindings(get_search_state=None):
                         event.cli.vi_state.named_registers[reg_name] = clipboard_data
                 else:
                     event.cli.clipboard.set_data(clipboard_data)
-
+ 
             # Only go back to insert mode in case of 'change'.
             if not delete_only:
                 event.cli.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)
@@ -1034,68 +1034,68 @@ def load_vi_bindings(get_search_state=None):
     #
 
     @text_object('b')
-    def _(event):
-        """ Move one word or token left. """
+    def _(event): 
+        """ 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 _(event):
-        """ Move one non-blank word left """
+    def _(event): 
+        """ 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 key_dollar(event):
-        """ 'c$', 'd$' and '$':  Delete/change/move until end of line. """
+    def key_dollar(event): 
+        """ '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 _(event):
-        """ 'word' forward. 'cw', 'dw', 'w': Delete/change/move one word.  """
+    def _(event): 
+        """ '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())
-
+                            event.current_buffer.document.get_end_of_document_position()) 
+ 
     @text_object('W')
-    def _(event):
-        """ 'WORD' forward. 'cW', 'dW', 'W': Delete/change/move one WORD.  """
+    def _(event): 
+        """ '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())
-
+                            event.current_buffer.document.get_end_of_document_position()) 
+ 
     @text_object('e')
-    def _(event):
-        """ End of 'word': 'ce', 'de', 'e' """
-        end = event.current_buffer.document.find_next_word_ending(count=event.arg)
+    def _(event): 
+        """ 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 _(event):
-        """ End of 'WORD': 'cE', 'dE', 'E' """
-        end = event.current_buffer.document.find_next_word_ending(count=event.arg, WORD=True)
+    def _(event): 
+        """ 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 _(event):
-        """ Inner 'word': ciw and diw """
-        start, end = event.current_buffer.document.find_boundaries_of_current_word()
+    def _(event): 
+        """ 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 _(event):
-        """ A 'word': caw and daw """
-        start, end = event.current_buffer.document.find_boundaries_of_current_word(include_trailing_whitespace=True)
+    def _(event): 
+        """ 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 _(event):
-        """ Inner 'WORD': ciW and diW """
-        start, end = event.current_buffer.document.find_boundaries_of_current_word(WORD=True)
+    def _(event): 
+        """ 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 _(event):
-        """ A 'WORD': caw and daw """
-        start, end = event.current_buffer.document.find_boundaries_of_current_word(WORD=True, include_trailing_whitespace=True)
+    def _(event): 
+        """ 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 _(event):
         """
@@ -1106,24 +1106,24 @@ def load_vi_bindings(get_search_state=None):
         return TextObject(start, end)
 
     @text_object('^')
-    def key_circumflex(event):
-        """ 'c^', 'd^' and '^': Soft start of line, after whitespace. """
+    def key_circumflex(event): 
+        """ '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 key_zero(event):
-        """
-        'c0', 'd0': Hard start of line, before whitespace.
-        (The move '0' key is implemented elsewhere, because a '0' could also change the `arg`.)
-        """
+    def key_zero(event): 
+        """ 
+        '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, ci_end, inner, key=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.
-        """
+                # 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):
             if ci_start == ci_end:
                 # Quotes
@@ -1133,53 +1133,53 @@ def load_vi_bindings(get_search_state=None):
                 # 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
+ 
+            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.
+            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)
-
+    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 _(event):
-        """
-        Move to previous blank-line separated section.
-        Implements '{', 'c{', 'd{', 'y{'
-        """
+    def _(event): 
+        """ 
+        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 _(event):
-        """
-        Move to next blank-line separated section.
-        Implements '}', 'c}', 'd}', 'y}'
-        """
+    def _(event): 
+        """ 
+        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 _(event):
-        """
-        Go to next occurance of character. Typing 'fx' will move the
-        cursor to the next occurance of character. 'x'.
-        """
+    def _(event): 
+        """ 
+        Go to next occurance of character. Typing 'fx' will move the 
+        cursor to the next occurance of character. 'x'. 
+        """ 
         event.cli.vi_state.last_character_find = CharacterFind(event.data, False)
         match = event.current_buffer.document.find(
             event.data, in_current_line=True, count=event.arg)
@@ -1187,22 +1187,22 @@ def load_vi_bindings(get_search_state=None):
             return TextObject(match, type=TextObjectType.INCLUSIVE)
         else:
             return TextObject(0)
-
+ 
     @text_object('F', Keys.Any)
-    def _(event):
-        """
-        Go to previous occurance of character. Typing 'Fx' will move the
-        cursor to the previous occurance of character. 'x'.
-        """
+    def _(event): 
+        """ 
+        Go to previous occurance of character. Typing 'Fx' will move the 
+        cursor to the previous occurance of character. 'x'. 
+        """ 
         event.cli.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 _(event):
-        """
-        Move right to the next occurance of c, then one char backward.
-        """
+    def _(event): 
+        """ 
+        Move right to the next occurance of c, then one char backward. 
+        """ 
         event.cli.vi_state.last_character_find = CharacterFind(event.data, False)
         match = event.current_buffer.document.find(
             event.data, in_current_line=True, count=event.arg)
@@ -1210,138 +1210,138 @@ def load_vi_bindings(get_search_state=None):
             return TextObject(match - 1, type=TextObjectType.INCLUSIVE)
         else:
             return TextObject(0)
-
+ 
     @text_object('T', Keys.Any)
-    def _(event):
-        """
-        Move left to the previous occurance of c, then one char forward.
-        """
+    def _(event): 
+        """ 
+        Move left to the previous occurance of c, then one char forward. 
+        """ 
         event.cli.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):
-        """
-        Create ',' and ';' commands.
-        """
+ 
+    def repeat(reverse): 
+        """ 
+        Create ',' and ';' commands. 
+        """ 
         @text_object(',' if reverse else ';')
-        def _(event):
-            # Repeat the last 'f'/'F'/'t'/'T' command.
-            pos = 0
+        def _(event): 
+            # Repeat the last 'f'/'F'/'t'/'T' command. 
+            pos = 0 
             vi_state = event.cli.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)
+            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)
-
+    repeat(True) 
+    repeat(False) 
+ 
     @text_object('h')
     @text_object(Keys.Left)
-    def _(event):
-        """ Implements 'ch', 'dh', 'h': Cursor left. """
+    def _(event): 
+        """ 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 _(event):
-        """ Implements 'cj', 'dj', 'j', ... Cursor up. """
+    def _(event): 
+        """ 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 _(event):
-        """ Implements 'ck', 'dk', 'k', ... Cursor up. """
+    def _(event): 
+        """ 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(Keys.Right)
-    def _(event):
-        """ Implements 'cl', 'dl', 'l', 'c ', 'd ', ' '. Cursor right. """
+    def _(event): 
+        """ 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 _(event):
-        """
-        Moves to the start of the visible region. (Below the scroll offset.)
-        Implements 'cH', 'dH', 'H'.
-        """
-        w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name)
-        b = event.current_buffer
-
+    def _(event): 
+        """ 
+        Moves to the start of the visible region. (Below the scroll offset.) 
+        Implements 'cH', 'dH', 'H'. 
+        """ 
+        w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name) 
+        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)
+            # 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 _(event):
-        """
-        Moves cursor to the vertical center of the visible region.
-        Implements 'cM', 'dM', 'M'.
-        """
-        w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name)
-        b = event.current_buffer
-
+    def _(event): 
+        """ 
+        Moves cursor to the vertical center of the visible region. 
+        Implements 'cM', 'dM', 'M'. 
+        """ 
+        w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name) 
+        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)
+            # 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 _(event):
-        """
-        Moves to the end of the visible region. (Above the scroll offset.)
-        """
-        w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name)
-        b = event.current_buffer
-
+    def _(event): 
+        """ 
+        Moves to the end of the visible region. (Above the scroll offset.) 
+        """ 
+        w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name) 
+        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)
+            # 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 _(event):
         " Search next. "
@@ -1374,50 +1374,50 @@ def load_vi_bindings(get_search_state=None):
             ~get_search_state(event.cli), include_current_position=False,
             count=event.arg)
 
-    @handle('z', '+', filter=navigation_mode|selection_mode)
-    @handle('z', 't', filter=navigation_mode|selection_mode)
-    @handle('z', Keys.ControlJ, filter=navigation_mode|selection_mode)
-    def _(event):
-        """
-        Scrolls the window to makes the current line the first line in the visible region.
-        """
-        w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name)
-        b = event.cli.current_buffer
+    @handle('z', '+', filter=navigation_mode|selection_mode) 
+    @handle('z', 't', filter=navigation_mode|selection_mode) 
+    @handle('z', Keys.ControlJ, filter=navigation_mode|selection_mode) 
+    def _(event): 
+        """ 
+        Scrolls the window to makes the current line the first line in the visible region. 
+        """ 
+        w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name) 
+        b = event.cli.current_buffer 
         w.vertical_scroll = b.document.cursor_position_row
-
-    @handle('z', '-', filter=navigation_mode|selection_mode)
-    @handle('z', 'b', filter=navigation_mode|selection_mode)
-    def _(event):
-        """
-        Scrolls the window to makes the current line the last line in the visible region.
-        """
-        w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name)
-
+ 
+    @handle('z', '-', filter=navigation_mode|selection_mode) 
+    @handle('z', 'b', filter=navigation_mode|selection_mode) 
+    def _(event): 
+        """ 
+        Scrolls the window to makes the current line the last line in the visible region. 
+        """ 
+        w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name) 
+ 
         # We can safely set the scroll offset to zero; the Window will meke
         # sure that it scrolls at least enough to make the cursor visible
         # again.
         w.vertical_scroll = 0
-
-    @handle('z', 'z', filter=navigation_mode|selection_mode)
-    def _(event):
-        """
-        Center Window vertically around cursor.
-        """
-        w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name)
-        b = event.cli.current_buffer
-
-        if w and w.render_info:
+ 
+    @handle('z', 'z', filter=navigation_mode|selection_mode) 
+    def _(event): 
+        """ 
+        Center Window vertically around cursor. 
+        """ 
+        w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name) 
+        b = event.cli.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.
+            # 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
@@ -1427,81 +1427,81 @@ def load_vi_bindings(get_search_state=None):
             w.vertical_scroll = y
 
     @text_object('%')
-    def _(event):
-        """
-        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(
+    def _(event): 
+        """ 
+        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:
+            else: 
                 return TextObject(0)  # Do nothing.
-
-        else:
-            # Move to the corresponding opening/closing bracket (()'s, []'s and {}'s).
+ 
+        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 _(event):
-        # Move to the n-th column (you may specify the argument n by typing
-        # it on number keys, for example, 20|).
+    def _(event): 
+        # 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 _(event):
-        """
-        Implements 'gg', 'cgg', 'ygg'
-        """
-        d = event.current_buffer.document
-
-        if event._arg:
-            # Move to the given line.
+    def _(event): 
+        """ 
+        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.
+        else: 
+            # Move to the top of the input. 
             return TextObject(d.get_start_of_document_position(), type=TextObjectType.LINEWISE)
-
+ 
     @text_object('g', '_')
-    def _(event):
-        """
-        Go to last non-blank of line.
-        'g_', 'cg_', 'yg_', etc..
-        """
+    def _(event): 
+        """ 
+        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 _(event):
-        """
-        Go to last character of previous word.
-        'ge', 'cge', 'yge', etc..
-        """
+    def _(event): 
+        """ 
+        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 _(event):
-        """
-        Go to last character of previous WORD.
-        'gE', 'cgE', 'ygE', etc..
-        """
+    def _(event): 
+        """ 
+        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 _(event):
-        """
+    def _(event): 
+        """ 
         Like g0, but half a screenwidth to the right. (Or as much as possible.)
         """
         w = find_window_for_buffer_name(event.cli, event.cli.current_buffer_name)
@@ -1518,58 +1518,58 @@ def load_vi_bindings(get_search_state=None):
     @text_object('G')
     def _(event):
         """
-        Go to the end of the document. (If no arg has been given.)
-        """
+        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=HasArg())
-    def _(event):
-        """
-        If an argument is given, move to this line in the  history. (for
-        example, 15G)
-        """
-        event.current_buffer.go_to_history(event.arg - 1)
-
+    @handle('G', filter=HasArg()) 
+    def _(event): 
+        """ 
+        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=navigation_mode|selection_mode|operator_given)
         def _(event):
             """
             Always handle numberics in navigation mode as arg.
             """
-            event.append_to_arg_count(event.data)
-
+            event.append_to_arg_count(event.data) 
+ 
     @handle('0', filter=(navigation_mode|selection_mode|operator_given) & HasArg())
     def _(event):
         " Zero when an argument was already give. "
         event.append_to_arg_count(event.data)
 
-    @handle(Keys.Any, filter=replace_mode)
-    def _(event):
-        """
-        Insert data at cursor position.
-        """
-        event.current_buffer.insert_text(event.data, overwrite=True)
-
+    @handle(Keys.Any, filter=replace_mode) 
+    def _(event): 
+        """ 
+        Insert data at cursor position. 
+        """ 
+        event.current_buffer.insert_text(event.data, overwrite=True) 
+ 
     @handle(Keys.Any, filter=insert_multiple_mode,
             save_before=(lambda e: not e.is_repeat))
     def _(event):
-        """
+        """ 
         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)
@@ -1654,27 +1654,27 @@ def load_vi_bindings(get_search_state=None):
             event.cli.output.bell()
 
 
-    @handle(Keys.ControlX, Keys.ControlL, filter=insert_mode)
-    def _(event):
-        """
-        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(Keys.ControlX, Keys.ControlF, filter=insert_mode)
-    def _(event):
-        """
-        Complete file names.
-        """
-        # TODO
-        pass
-
+    @handle(Keys.ControlX, Keys.ControlL, filter=insert_mode) 
+    def _(event): 
+        """ 
+        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(Keys.ControlX, Keys.ControlF, filter=insert_mode) 
+    def _(event): 
+        """ 
+        Complete file names. 
+        """ 
+        # TODO 
+        pass 
+ 
     @handle(Keys.ControlK, filter=insert_mode|replace_mode)
     def _(event):
         " Go into digraph mode. "
         event.cli.vi_state.waiting_for_digraph = True
-
+ 
     @Condition
     def digraph_symbol_1_given(cli):
         return cli.vi_state.digraph_symbol1 is not None
@@ -1709,128 +1709,128 @@ def load_vi_bindings(get_search_state=None):
 
 
 def load_vi_open_in_editor_bindings():
-    """
-    Pressing 'v' in navigation mode will open the buffer in an external editor.
-    """
+    """ 
+    Pressing 'v' in navigation mode will open the buffer in an external editor. 
+    """ 
     registry = Registry()
     navigation_mode = ViNavigationMode()
-
+ 
     registry.add_binding('v', filter=navigation_mode)(
         get_by_name('edit-and-execute-command'))
     return registry
-
-
+ 
+ 
 def load_vi_system_bindings():
     registry = ConditionalRegistry(Registry(), ViMode())
     handle = registry.add_binding
 
-    has_focus = filters.HasFocus(SYSTEM_BUFFER)
+    has_focus = filters.HasFocus(SYSTEM_BUFFER) 
     navigation_mode = ViNavigationMode()
-
-    @handle('!', filter=~has_focus & navigation_mode)
-    def _(event):
-        """
-        '!' opens the system prompt.
-        """
-        event.cli.push_focus(SYSTEM_BUFFER)
+ 
+    @handle('!', filter=~has_focus & navigation_mode) 
+    def _(event): 
+        """ 
+        '!' opens the system prompt. 
+        """ 
+        event.cli.push_focus(SYSTEM_BUFFER) 
         event.cli.vi_state.input_mode = InputMode.INSERT
-
-    @handle(Keys.Escape, filter=has_focus)
-    @handle(Keys.ControlC, filter=has_focus)
-    def _(event):
-        """
-        Cancel system prompt.
-        """
+ 
+    @handle(Keys.Escape, filter=has_focus) 
+    @handle(Keys.ControlC, filter=has_focus) 
+    def _(event): 
+        """ 
+        Cancel system prompt. 
+        """ 
         event.cli.vi_state.input_mode = InputMode.NAVIGATION
-        event.cli.buffers[SYSTEM_BUFFER].reset()
-        event.cli.pop_focus()
-
-    @handle(Keys.ControlJ, filter=has_focus)
-    def _(event):
-        """
-        Run system command.
-        """
+        event.cli.buffers[SYSTEM_BUFFER].reset() 
+        event.cli.pop_focus() 
+ 
+    @handle(Keys.ControlJ, filter=has_focus) 
+    def _(event): 
+        """ 
+        Run system command. 
+        """ 
         event.cli.vi_state.input_mode = InputMode.NAVIGATION
-
-        system_buffer = event.cli.buffers[SYSTEM_BUFFER]
-        event.cli.run_system_command(system_buffer.text)
-        system_buffer.reset(append_to_history=True)
-
-        # Focus previous buffer again.
-        event.cli.pop_focus()
-
+ 
+        system_buffer = event.cli.buffers[SYSTEM_BUFFER] 
+        event.cli.run_system_command(system_buffer.text) 
+        system_buffer.reset(append_to_history=True) 
+ 
+        # Focus previous buffer again. 
+        event.cli.pop_focus() 
+ 
     return registry
-
+ 
 
 def load_vi_search_bindings(get_search_state=None,
                             search_buffer_name=SEARCH_BUFFER):
-    assert get_search_state is None or callable(get_search_state)
-
-    if not get_search_state:
-        def get_search_state(cli): return cli.search_state
-
+    assert get_search_state is None or callable(get_search_state) 
+ 
+    if not get_search_state: 
+        def get_search_state(cli): return cli.search_state 
+ 
     registry = ConditionalRegistry(Registry(), ViMode())
     handle = registry.add_binding
 
-    has_focus = filters.HasFocus(search_buffer_name)
+    has_focus = filters.HasFocus(search_buffer_name) 
     navigation_mode = ViNavigationMode()
     selection_mode = ViSelectionMode()
-
+ 
     reverse_vi_search_direction = Condition(
         lambda cli: cli.application.reverse_vi_search_direction(cli))
 
     @handle('/', filter=(navigation_mode|selection_mode)&~reverse_vi_search_direction)
     @handle('?', filter=(navigation_mode|selection_mode)&reverse_vi_search_direction)
-    @handle(Keys.ControlS, filter=~has_focus)
-    def _(event):
-        """
-        Vi-style forward search.
-        """
-        # Set the ViState.
-        get_search_state(event.cli).direction = IncrementalSearchDirection.FORWARD
+    @handle(Keys.ControlS, filter=~has_focus) 
+    def _(event): 
+        """ 
+        Vi-style forward search. 
+        """ 
+        # Set the ViState. 
+        get_search_state(event.cli).direction = IncrementalSearchDirection.FORWARD 
         event.cli.vi_state.input_mode = InputMode.INSERT
-
-        # Focus search buffer.
-        event.cli.push_focus(search_buffer_name)
-
+ 
+        # Focus search buffer. 
+        event.cli.push_focus(search_buffer_name) 
+ 
     @handle('?', filter=(navigation_mode|selection_mode)&~reverse_vi_search_direction)
     @handle('/', filter=(navigation_mode|selection_mode)&reverse_vi_search_direction)
-    @handle(Keys.ControlR, filter=~has_focus)
-    def _(event):
-        """
-        Vi-style backward search.
-        """
-        # Set the ViState.
-        get_search_state(event.cli).direction = IncrementalSearchDirection.BACKWARD
-
-        # Focus search buffer.
-        event.cli.push_focus(search_buffer_name)
+    @handle(Keys.ControlR, filter=~has_focus) 
+    def _(event): 
+        """ 
+        Vi-style backward search. 
+        """ 
+        # Set the ViState. 
+        get_search_state(event.cli).direction = IncrementalSearchDirection.BACKWARD 
+ 
+        # Focus search buffer. 
+        event.cli.push_focus(search_buffer_name) 
         event.cli.vi_state.input_mode = InputMode.INSERT
-
-    @handle(Keys.ControlJ, filter=has_focus)
+ 
+    @handle(Keys.ControlJ, filter=has_focus) 
     @handle(Keys.Escape, filter=has_focus)
-    def _(event):
-        """
-        Apply the search. (At the / or ? prompt.)
-        """
-        input_buffer = event.cli.buffers.previous(event.cli)
-        search_buffer = event.cli.buffers[search_buffer_name]
-
-        # Update search state.
-        if search_buffer.text:
-            get_search_state(event.cli).text = search_buffer.text
-
-        # Apply search.
-        input_buffer.apply_search(get_search_state(event.cli))
-
-        # Add query to history of search line.
-        search_buffer.append_to_history()
-        search_buffer.reset()
-
-        # Focus previous document again.
+    def _(event): 
+        """ 
+        Apply the search. (At the / or ? prompt.) 
+        """ 
+        input_buffer = event.cli.buffers.previous(event.cli) 
+        search_buffer = event.cli.buffers[search_buffer_name] 
+ 
+        # Update search state. 
+        if search_buffer.text: 
+            get_search_state(event.cli).text = search_buffer.text 
+ 
+        # Apply search. 
+        input_buffer.apply_search(get_search_state(event.cli)) 
+ 
+        # Add query to history of search line. 
+        search_buffer.append_to_history() 
+        search_buffer.reset() 
+ 
+        # Focus previous document again. 
         event.cli.vi_state.input_mode = InputMode.NAVIGATION
-        event.cli.pop_focus()
-
+        event.cli.pop_focus() 
+ 
     def incremental_search(cli, direction, count=1):
         " Apply search, but keep search buffer focussed. "
         # Update search_state.
@@ -1854,41 +1854,41 @@ def load_vi_search_bindings(get_search_state=None,
     def _(event):
         incremental_search(event.cli, IncrementalSearchDirection.FORWARD, count=event.arg)
 
-    def search_buffer_is_empty(cli):
-        """ Returns True when the search buffer is empty. """
-        return cli.buffers[search_buffer_name].text == ''
-
-    @handle(Keys.ControlC, filter=has_focus)
+    def search_buffer_is_empty(cli): 
+        """ Returns True when the search buffer is empty. """ 
+        return cli.buffers[search_buffer_name].text == '' 
+ 
+    @handle(Keys.ControlC, filter=has_focus) 
     @handle(Keys.ControlH, filter=has_focus & Condition(search_buffer_is_empty))
-    @handle(Keys.Backspace, filter=has_focus & Condition(search_buffer_is_empty))
-    def _(event):
-        """
-        Cancel search.
-        """
+    @handle(Keys.Backspace, filter=has_focus & Condition(search_buffer_is_empty)) 
+    def _(event): 
+        """ 
+        Cancel search. 
+        """ 
         event.cli.vi_state.input_mode = InputMode.NAVIGATION
-
-        event.cli.pop_focus()
-        event.cli.buffers[search_buffer_name].reset()
-
+ 
+        event.cli.pop_focus() 
+        event.cli.buffers[search_buffer_name].reset() 
+ 
     return registry
-
+ 
 
 def load_extra_vi_page_navigation_bindings():
-    """
-    Key bindings, for scrolling up and down through pages.
-    This are separate bindings, because GNU readline doesn't have them.
-    """
+    """ 
+    Key bindings, for scrolling up and down through pages. 
+    This are separate bindings, because GNU readline doesn't have them. 
+    """ 
     registry = ConditionalRegistry(Registry(), ViMode())
     handle = registry.add_binding
-
-    handle(Keys.ControlF)(scroll_forward)
-    handle(Keys.ControlB)(scroll_backward)
-    handle(Keys.ControlD)(scroll_half_page_down)
-    handle(Keys.ControlU)(scroll_half_page_up)
-    handle(Keys.ControlE)(scroll_one_line_down)
-    handle(Keys.ControlY)(scroll_one_line_up)
-    handle(Keys.PageDown)(scroll_page_down)
-    handle(Keys.PageUp)(scroll_page_up)
+ 
+    handle(Keys.ControlF)(scroll_forward) 
+    handle(Keys.ControlB)(scroll_backward) 
+    handle(Keys.ControlD)(scroll_half_page_down) 
+    handle(Keys.ControlU)(scroll_half_page_up) 
+    handle(Keys.ControlE)(scroll_one_line_down) 
+    handle(Keys.ControlY)(scroll_one_line_up) 
+    handle(Keys.PageDown)(scroll_page_down) 
+    handle(Keys.PageUp)(scroll_page_up) 
 
     return registry