Viewing File: /home/ubuntu/combine_ai/combine/lib/python3.10/site-packages/pyreadline3/modes/vi.py
# -*- coding: utf-8 -*-
# *****************************************************************************
# Copyright (C) 2003-2006 Gary Bishop.
# Copyright (C) 2006-2020 Michael Graz. <mgraz@plan10.com>
# Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
# Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
#
# Distributed under the terms of the BSD License. The full license is in
# the file COPYING, distributed as part of this software.
# *****************************************************************************
from __future__ import absolute_import, print_function, unicode_literals
import os
import pyreadline3.lineeditor.history as history
import pyreadline3.lineeditor.lineobj as lineobj
import pyreadline3.logger as logger
from pyreadline3.logger import log
from . import basemode
class ViMode(basemode.BaseMode):
mode = "vi"
def __init__(self, rlobj):
super(ViMode, self).__init__(rlobj)
self.__vi_insert_mode = None
def __repr__(self):
return "<ViMode>"
def process_keyevent(self, keyinfo):
def nop(e):
pass
keytuple = keyinfo.tuple()
# Process exit keys. Only exit on empty line
if keytuple in self.exit_dispatch:
if lineobj.EndOfLine(self.l_buffer) == 0:
raise EOFError
dispatch_func = self.key_dispatch.get(keytuple, self.vi_key)
log("readline from keyboard:%s->%s" % (keytuple, dispatch_func))
r = None
if dispatch_func:
r = dispatch_func(keyinfo)
self.l_buffer.push_undo()
self.previous_func = dispatch_func
if r:
self._update_line()
return True
return False
# Methods below here are bindable emacs functions
def init_editing_mode(self, e): # (M-C-j)
'''Initialize vi editingmode'''
self.show_all_if_ambiguous = 'on'
self.key_dispatch = {}
self.__vi_insert_mode = None
self._vi_command = None
self._vi_command_edit = None
self._vi_key_find_char = None
self._vi_key_find_direction = True
self._vi_yank_buffer = None
self._vi_multiplier1 = ''
self._vi_multiplier2 = ''
self._vi_undo_stack = []
self._vi_undo_cursor = -1
self._vi_current = None
self._vi_search_text = ''
self._vi_search_position = 0
self.vi_save_line()
self.vi_set_insert_mode(True)
# make ' ' to ~ self insert
for c in range(ord(' '), 127):
self._bind_key('%s' % chr(c), self.vi_key)
self._bind_key('BackSpace', self.vi_backspace)
self._bind_key('Escape', self.vi_escape)
self._bind_key('Return', self.vi_accept_line)
self._bind_key('Left', self.backward_char)
self._bind_key('Right', self.forward_char)
self._bind_key('Home', self.beginning_of_line)
self._bind_key('End', self.end_of_line)
self._bind_key('Delete', self.delete_char)
self._bind_key('Control-d', self.vi_eof)
self._bind_key('Control-z', self.vi_eof)
self._bind_key('Control-r', self.vi_redo)
self._bind_key('Up', self.vi_arrow_up)
self._bind_key('Control-p', self.vi_up)
self._bind_key('Down', self.vi_arrow_down)
self._bind_key('Control-n', self.vi_down)
self._bind_key('Tab', self.vi_complete)
# self._bind_key('Control-e', self.emacs)
def vi_key(self, e):
if not self._vi_command:
self._vi_command = ViCommand(self)
elif self._vi_command.is_end:
if self._vi_command.is_edit:
self._vi_command_edit = self._vi_command
self._vi_command = ViCommand(self)
self._vi_command.add_char(e.char)
def vi_error(self):
self._bell()
def vi_get_is_insert_mode(self):
return self.__vi_insert_mode
vi_is_insert_mode = property(vi_get_is_insert_mode)
def vi_escape(self, e):
if self.vi_is_insert_mode:
if self._vi_command:
self._vi_command.add_char(e.char)
else:
self._vi_command = ViCommand(self)
self.vi_set_insert_mode(False)
self.l_buffer.point = lineobj.PrevChar
elif self._vi_command and self._vi_command.is_replace_one:
self._vi_command.add_char(e.char)
else:
self.vi_error()
def vi_backspace(self, e):
if self._vi_command:
self._vi_command.add_char(e.char)
else:
self._vi_do_backspace(self._vi_command)
def _vi_do_backspace(self, vi_cmd):
if self.vi_is_insert_mode or (
self._vi_command and self._vi_command.is_search):
if self.l_buffer.point > 0:
self.l_buffer.point -= 1
if self.l_buffer.overwrite:
try:
prev = self._vi_undo_stack[self._vi_undo_cursor][1][self.l_buffer.point]
self.l_buffer.line_buffer[self.l_buffer.point] = prev
except IndexError:
del self.l_buffer.line_buffer[self.l_buffer.point]
else:
self.vi_save_line()
del self.l_buffer.line_buffer[self.l_buffer.point]
def vi_accept_line(self, e):
if self._vi_command and self._vi_command.is_search:
self._vi_command.do_search()
return False
self._vi_command = None
self.vi_set_insert_mode(True)
self._vi_undo_stack = []
self._vi_undo_cursor = -1
self._vi_current = None
if self.l_buffer.line_buffer:
self.add_history(self.l_buffer.copy())
return self.accept_line(e)
def vi_eof(self, e):
raise EOFError
def vi_set_insert_mode(self, value):
if self.__vi_insert_mode == value:
return
self.__vi_insert_mode = value
if value:
self.vi_save_line()
self.cursor_size = 25
else:
self.cursor_size = 100
def vi_undo_restart(self):
tpl_undo = (self.l_buffer.point, self.l_buffer.line_buffer[:], )
self._vi_undo_stack = [tpl_undo]
self._vi_undo_cursor = 0
def vi_save_line(self):
if self._vi_undo_stack and self._vi_undo_cursor >= 0:
del self._vi_undo_stack[self._vi_undo_cursor + 1:]
# tpl_undo = (self.l_buffer.point, self.l_buffer[:], )
tpl_undo = (self.l_buffer.point, self.l_buffer.line_buffer[:], )
if not self._vi_undo_stack or self._vi_undo_stack[self._vi_undo_cursor][1] != tpl_undo[1]:
self._vi_undo_stack.append(tpl_undo)
self._vi_undo_cursor += 1
def vi_undo_prepare(self):
if self._vi_undo_cursor == len(self._vi_undo_stack) - 1:
self.vi_save_line()
def vi_undo(self, do_pop=True):
self.vi_undo_prepare()
if not self._vi_undo_stack or self._vi_undo_cursor <= 0:
self.vi_error()
return
self._vi_undo_cursor -= 1
self.vi_undo_assign()
def vi_undo_all(self):
self.vi_undo_prepare()
if self._vi_undo_cursor > 0:
self._vi_undo_cursor = 0
self.vi_undo_assign()
else:
self.vi_error()
def vi_undo_assign(self):
tpl_undo = self._vi_undo_stack[self._vi_undo_cursor]
self.l_buffer.line_buffer = tpl_undo[1][:]
self.l_buffer.point = tpl_undo[0]
def vi_redo(self, e):
if self._vi_undo_cursor >= len(self._vi_undo_stack) - 1:
self.vi_error()
return
self._vi_undo_cursor += 1
self.vi_undo_assign()
def vi_search(self, rng):
for i in rng:
line_history = self._history.history[i]
pos = line_history.get_line_text().find(self._vi_search_text)
if pos >= 0:
self._vi_search_position = i
self._history.history_cursor = i
self.l_buffer.line_buffer = list(line_history.line_buffer)
self.l_buffer.point = pos
self.vi_undo_restart()
return True
self._bell()
return False
def vi_search_first(self):
text = ''.join(self.l_buffer.line_buffer[1:])
if text:
self._vi_search_text = text
self._vi_search_position = len(self._history.history) - 1
elif self._vi_search_text:
self._vi_search_position -= 1
else:
self.vi_error()
self.vi_undo()
return
if not self.vi_search(list(range(self._vi_search_position, -1, -1))):
# Here: search text not found
self.vi_undo()
def vi_search_again_backward(self):
self.vi_search(list(range(self._vi_search_position - 1, -1, -1)))
def vi_search_again_forward(self):
self.vi_search(
list(range(self._vi_search_position + 1, len(self._history.history))))
def vi_up(self, e):
if self._history.history_cursor == len(self._history.history):
self._vi_current = self.l_buffer.line_buffer[:]
# self._history.previous_history (e)
self._history.previous_history(self.l_buffer)
if self.vi_is_insert_mode:
self.end_of_line(e)
else:
self.beginning_of_line(e)
self.vi_undo_restart()
def vi_down(self, e):
if self._history.history_cursor >= len(self._history.history):
self.vi_error()
return
if self._history.history_cursor < len(self._history.history) - 1:
# self._history.next_history (e)
self._history.next_history(self.l_buffer)
if self.vi_is_insert_mode:
self.end_of_line(e)
else:
self.beginning_of_line(e)
self.vi_undo_restart()
elif self._vi_current is not None:
self._history.history_cursor = len(self._history.history)
self.l_buffer.line_buffer = self._vi_current
self.end_of_line(e)
if not self.vi_is_insert_mode and self.l_buffer.point > 0:
self.l_buffer.point -= 1
self._vi_current = None
else:
self.vi_error()
return
def vi_arrow_up(self, e):
self.vi_set_insert_mode(True)
self.vi_up(e)
self.vi_save_line()
def vi_arrow_down(self, e):
self.vi_set_insert_mode(True)
self.vi_down(e)
self.vi_save_line()
def vi_complete(self, e):
text = self.l_buffer.get_line_text()
if text and not text.isspace():
return self.complete(e)
else:
return self.vi_key(e)
# vi input states
# sequence of possible states are in the order below
_VI_BEGIN = 'vi_begin'
_VI_MULTI1 = 'vi_multi1'
_VI_ACTION = 'vi_action'
_VI_MULTI2 = 'vi_multi2'
_VI_MOTION = 'vi_motion'
_VI_MOTION_ARGUMENT = 'vi_motion_argument'
_VI_REPLACE_ONE = 'vi_replace_one'
_VI_TEXT = 'vi_text'
_VI_SEARCH = 'vi_search'
_VI_END = 'vi_end'
# vi helper class
class ViCommand:
def __init__(self, readline):
self.readline = readline
self.lst_char = []
self.state = _VI_BEGIN
self.action = self.movement
self.motion = None
self.motion_argument = None
self.text = None
self.pos_motion = None
self.is_edit = False
self.is_overwrite = False
self.is_error = False
self.is_star = False
self.delete_left = 0
self.delete_right = 0
self.readline._vi_multiplier1 = ''
self.readline._vi_multiplier2 = ''
self.set_override_multiplier(0)
self.skip_multipler = False
self.tabstop = 4
self.dct_fcn = {
ord('$'): self.key_dollar,
ord('^'): self.key_hat,
ord(';'): self.key_semicolon,
ord(','): self.key_comma,
ord('%'): self.key_percent,
ord('.'): self.key_dot,
ord('/'): self.key_slash,
ord('*'): self.key_star,
ord('|'): self.key_bar,
ord('~'): self.key_tilde,
8: self.key_backspace,
}
def add_char(self, char):
self.lst_char.append(char)
if self.state == _VI_BEGIN and self.readline.vi_is_insert_mode:
self.readline.vi_save_line()
self.state = _VI_TEXT
if self.state == _VI_SEARCH:
if char == '\x08': # backspace
self.key_backspace(char)
else:
self.set_text(char)
return
if self.state == _VI_TEXT:
if char == '\x1b': # escape
self.escape(char)
elif char == '\x09': # tab
ts = self.tabstop
ws = ' ' * (ts - (self.readline.l_buffer.point % ts))
self.set_text(ws)
elif char == '\x08': # backspace
self.key_backspace(char)
else:
self.set_text(char)
return
if self.state == _VI_MOTION_ARGUMENT:
self.set_motion_argument(char)
return
if self.state == _VI_REPLACE_ONE:
self.replace_one(char)
return
try:
fcn_instance = self.dct_fcn[ord(char)]
except BaseException:
fcn_instance = getattr(self, 'key_%s' % char, None)
if fcn_instance:
fcn_instance(char)
return
if char.isdigit():
self.key_digit(char)
return
# Here: could not process key
self.error()
def set_text(self, text):
if self.text is None:
self.text = text
else:
self.text += text
self.set_buffer(text)
def set_buffer(self, text):
for char in text:
if not self.char_isprint(char):
continue
# self.readline.l_buffer.insert_text(char)
# continue
# #overwrite in l_buffer obj
if self.is_overwrite:
if self.readline.l_buffer.point < len(
self.readline.l_buffer.line_buffer):
# self.readline.l_buffer[self.l_buffer.point]=char
self.readline.l_buffer.line_buffer[self.readline.l_buffer.point] = char
else:
# self.readline.l_buffer.insert_text(char)
self.readline.l_buffer.line_buffer.append(char)
else:
# self.readline.l_buffer.insert_text(char)
self.readline.l_buffer.line_buffer.insert(
self.readline.l_buffer.point, char)
self.readline.l_buffer.point += 1
def replace_one(self, char):
if char == '\x1b': # escape
self.end()
return
self.is_edit = True
self.readline.vi_save_line()
times = self.get_multiplier()
cursor = self.readline.l_buffer.point
self.readline.l_buffer.line_buffer[cursor: cursor +
times] = char * times
if times > 1:
self.readline.l_buffer.point += (times - 1)
self.end()
def char_isprint(self, char):
return ord(char) >= ord(' ') and ord(char) <= ord('~')
def key_dollar(self, char):
self.motion = self.motion_end_in_line
self.delete_right = 1
self.state = _VI_MOTION
self.apply()
def key_hat(self, char):
self.motion = self.motion_beginning_of_line
self.state = _VI_MOTION
self.apply()
def key_0(self, char):
if self.state in [_VI_BEGIN, _VI_ACTION]:
self.key_hat(char)
else:
self.key_digit(char)
def key_digit(self, char):
if self.state in [_VI_BEGIN, _VI_MULTI1]:
self.readline._vi_multiplier1 += char
self.readline._vi_multiplier2 = ''
self.state = _VI_MULTI1
elif self.state in [_VI_ACTION, _VI_MULTI2]:
self.readline._vi_multiplier2 += char
self.state = _VI_MULTI2
def key_w(self, char):
if self.action == self.change:
self.key_e(char)
return
self.motion = self.motion_word_short
self.state = _VI_MOTION
self.apply()
def key_W(self, char):
if self.action == self.change:
self.key_E(char)
return
self.motion = self.motion_word_long
self.state = _VI_MOTION
self.apply()
def key_e(self, char):
self.motion = self.motion_end_short
self.state = _VI_MOTION
self.delete_right = 1
self.apply()
def key_E(self, char):
self.motion = self.motion_end_long
self.state = _VI_MOTION
self.delete_right = 1
self.apply()
def key_b(self, char):
self.motion = self.motion_back_short
self.state = _VI_MOTION
self.apply()
def key_B(self, char):
self.motion = self.motion_back_long
self.state = _VI_MOTION
self.apply()
def key_f(self, char):
self.readline._vi_key_find_direction = True
self.motion = self.motion_find_char_forward
self.delete_right = 1
self.state = _VI_MOTION_ARGUMENT
def key_F(self, char):
self.readline._vi_key_find_direction = False
self.motion = self.motion_find_char_backward
self.delete_left = 1
self.state = _VI_MOTION_ARGUMENT
def key_t(self, char):
self.motion = self.motion_to_char_forward
self.delete_right = 1
self.state = _VI_MOTION_ARGUMENT
def key_T(self, char):
self.motion = self.motion_to_char_backward
self.state = _VI_MOTION_ARGUMENT
def key_j(self, char):
self.readline.vi_down(ViEvent(char))
self.state = _VI_END
def key_k(self, char):
self.readline.vi_up(ViEvent(char))
self.state = _VI_END
def key_semicolon(self, char):
if self.readline._vi_key_find_char is None:
self.error()
return
if self.readline._vi_key_find_direction:
self.motion = self.motion_find_char_forward
else:
self.motion = self.motion_find_char_backward
self.set_motion_argument(self.readline._vi_key_find_char)
def key_comma(self, char):
if self.readline._vi_key_find_char is None:
self.error()
return
if self.readline._vi_key_find_direction:
self.motion = self.motion_find_char_backward
else:
self.motion = self.motion_find_char_forward
self.set_motion_argument(self.readline._vi_key_find_char)
def key_percent(self, char):
'''find matching <([{}])>'''
self.motion = self.motion_matching
self.delete_right = 1
self.state = _VI_MOTION
self.apply()
def key_dot(self, char):
vi_cmd_edit = self.readline._vi_command_edit
if not vi_cmd_edit:
return
if vi_cmd_edit.is_star:
self.key_star(char)
return
if self.has_multiplier():
count = self.get_multiplier()
else:
count = 0
# Create the ViCommand object after getting multipler from self
# Side effect of the ViCommand creation is resetting of global
# multipliers
vi_cmd = ViCommand(self.readline)
if count >= 1:
vi_cmd.set_override_multiplier(count)
vi_cmd_edit.set_override_multiplier(count)
elif vi_cmd_edit.override_multiplier:
vi_cmd.set_override_multiplier(vi_cmd_edit.override_multiplier)
for char in vi_cmd_edit.lst_char:
vi_cmd.add_char(char)
if vi_cmd_edit.is_overwrite and self.readline.l_buffer.point > 0:
self.readline.l_buffer.point -= 1
self.readline.vi_set_insert_mode(False)
self.end()
def key_slash(self, char):
self.readline.vi_save_line()
self.readline.l_buffer.line_buffer = ['/']
self.readline.l_buffer.point = 1
self.state = _VI_SEARCH
def key_star(self, char):
self.is_star = True
self.is_edit = True
self.readline.vi_save_line()
completions = self.readline._get_completions()
if completions:
text = ' '.join(completions) + ' '
self.readline.l_buffer.line_buffer[self.readline.begidx: self.readline.endidx + 1] = list(
text)
prefix_len = self.readline.endidx - self.readline.begidx
self.readline.l_buffer.point += len(text) - prefix_len
self.readline.vi_set_insert_mode(True)
else:
self.error()
self.state = _VI_TEXT
def key_bar(self, char):
self.motion = self.motion_column
self.state = _VI_MOTION
self.apply()
def key_tilde(self, char):
self.is_edit = True
self.readline.vi_save_line()
for i in range(self.get_multiplier()):
try:
c = self.readline.l_buffer.line_buffer[self.readline.l_buffer.point]
if c.isupper():
self.readline.l_buffer.line_buffer[self.readline.l_buffer.point] = c.lower(
)
elif c.islower():
self.readline.l_buffer.line_buffer[self.readline.l_buffer.point] = c.upper(
)
self.readline.l_buffer.point += 1
except IndexError:
break
self.end()
def key_h(self, char):
self.motion = self.motion_left
self.state = _VI_MOTION
self.apply()
def key_backspace(self, char):
if self.state in [_VI_TEXT, _VI_SEARCH]:
if self.text and len(self.text):
self.text = self.text[:-1]
try:
# Remove backspaces for potential dot command
self.lst_char.pop()
self.lst_char.pop()
except IndexError:
pass
else:
self.key_h(char)
self.readline._vi_do_backspace(self)
if self.state == _VI_SEARCH and not (
self.readline.l_buffer.line_buffer):
self.state = _VI_BEGIN
def key_l(self, char):
self.motion = self.motion_right
self.state = _VI_MOTION
self.apply()
def key_i(self, char):
self.is_edit = True
self.state = _VI_TEXT
self.readline.vi_set_insert_mode(True)
def key_I(self, char):
self.is_edit = True
self.state = _VI_TEXT
self.readline.vi_set_insert_mode(True)
self.readline.l_buffer.point = 0
def key_a(self, char):
self.is_edit = True
self.state = _VI_TEXT
self.readline.vi_set_insert_mode(True)
if len(self.readline.l_buffer.line_buffer):
self.readline.l_buffer.point += 1
def key_A(self, char):
self.is_edit = True
self.state = _VI_TEXT
self.readline.vi_set_insert_mode(True)
self.readline.l_buffer.point = len(self.readline.l_buffer.line_buffer)
def key_d(self, char):
self.is_edit = True
self.state = _VI_ACTION
self.action = self.delete
def key_D(self, char):
self.is_edit = True
self.state = _VI_ACTION
self.action = self.delete_end_of_line
self.apply()
def key_x(self, char):
self.is_edit = True
self.state = _VI_ACTION
self.action = self.delete_char
self.apply()
def key_X(self, char):
self.is_edit = True
self.state = _VI_ACTION
self.action = self.delete_prev_char
self.apply()
def key_s(self, char):
self.is_edit = True
i1 = self.readline.l_buffer.point
i2 = self.readline.l_buffer.point + self.get_multiplier()
self.skip_multipler = True
self.readline.vi_set_insert_mode(True)
del self.readline.l_buffer.line_buffer[i1: i2]
self.state = _VI_TEXT
def key_S(self, char):
self.is_edit = True
self.readline.vi_set_insert_mode(True)
self.readline.l_buffer.line_buffer = []
self.readline.l_buffer.point = 0
self.state = _VI_TEXT
def key_c(self, char):
self.is_edit = True
self.state = _VI_ACTION
self.action = self.change
def key_C(self, char):
self.is_edit = True
self.readline.vi_set_insert_mode(True)
del self.readline.l_buffer.line_buffer[self.readline.l_buffer.point:]
self.state = _VI_TEXT
def key_r(self, char):
self.state = _VI_REPLACE_ONE
def key_R(self, char):
self.is_edit = True
self.is_overwrite = True
self.readline.l_buffer.overwrite = True
self.readline.vi_set_insert_mode(True)
self.state = _VI_TEXT
def key_y(self, char):
self._state = _VI_ACTION
self.action = self.yank
def key_Y(self, char):
self.readline._vi_yank_buffer = self.readline.l_buffer.get_line_text()
self.end()
def key_p(self, char):
if not self.readline._vi_yank_buffer:
return
self.is_edit = True
self.readline.vi_save_line()
self.readline.l_buffer.point += 1
self.readline.l_buffer.insert_text(
self.readline._vi_yank_buffer *
self.get_multiplier())
self.readline.l_buffer.point -= 1
self.state = _VI_END
def key_P(self, char):
if not self.readline._vi_yank_buffer:
return
self.is_edit = True
self.readline.vi_save_line()
self.readline.l_buffer.insert_text(
self.readline._vi_yank_buffer *
self.get_multiplier())
self.readline.l_buffer.point -= 1
self.state = _VI_END
def key_u(self, char):
self.readline.vi_undo()
self.state = _VI_END
def key_U(self, char):
self.readline.vi_undo_all()
self.state = _VI_END
def key_v(self, char):
editor = ViExternalEditor(self.readline.l_buffer.line_buffer)
self.readline.l_buffer.line_buffer = list(editor.result)
self.readline.l_buffer.point = 0
self.is_edit = True
self.state = _VI_END
def error(self):
self.readline._bell()
self.is_error = True
def state_is_end(self):
return self.state == _VI_END
is_end = property(state_is_end)
def state_is_search(self):
return self.state == _VI_SEARCH
is_search = property(state_is_search)
def state_is_replace_one(self):
return self.state == _VI_REPLACE_ONE
is_replace_one = property(state_is_replace_one)
def do_search(self):
self.readline.vi_search_first()
self.state = _VI_END
def key_n(self, char):
self.readline.vi_search_again_backward()
self.state = _VI_END
def key_N(self, char):
self.readline.vi_search_again_forward()
self.state = _VI_END
def motion_beginning_of_line(self, line, index=0, count=1, **kw):
return 0
def motion_end_in_line(self, line, index=0, count=1, **kw):
return max(0, len(self.readline.l_buffer.line_buffer) - 1)
def motion_word_short(self, line, index=0, count=1, **kw):
return vi_pos_word_short(line, index, count)
def motion_word_long(self, line, index=0, count=1, **kw):
return vi_pos_word_long(line, index, count)
def motion_end_short(self, line, index=0, count=1, **kw):
return vi_pos_end_short(line, index, count)
def motion_end_long(self, line, index=0, count=1, **kw):
return vi_pos_end_long(line, index, count)
def motion_back_short(self, line, index=0, count=1, **kw):
return vi_pos_back_short(line, index, count)
def motion_back_long(self, line, index=0, count=1, **kw):
return vi_pos_back_long(line, index, count)
def motion_find_char_forward(self, line, index=0, count=1, char=None):
self.readline._vi_key_find_char = char
return vi_pos_find_char_forward(line, char, index, count)
def motion_find_char_backward(self, line, index=0, count=1, char=None):
self.readline._vi_key_find_char = char
return vi_pos_find_char_backward(line, char, index, count)
def motion_to_char_forward(self, line, index=0, count=1, char=None):
return vi_pos_to_char_forward(line, char, index, count)
def motion_to_char_backward(self, line, index=0, count=1, char=None):
return vi_pos_to_char_backward(line, char, index, count)
def motion_left(self, line, index=0, count=1, char=None):
return max(0, index - count)
def motion_right(self, line, index=0, count=1, char=None):
return min(len(line), index + count)
def motion_matching(self, line, index=0, count=1, char=None):
return vi_pos_matching(line, index)
def motion_column(self, line, index=0, count=1, char=None):
return max(0, count - 1)
def has_multiplier(self):
return self.override_multiplier or self.readline._vi_multiplier1 or self.readline._vi_multiplier2
def get_multiplier(self):
if self.override_multiplier:
return int(self.override_multiplier)
if self.readline._vi_multiplier1 == '':
m1 = 1
else:
m1 = int(self.readline._vi_multiplier1)
if self.readline._vi_multiplier2 == '':
m2 = 1
else:
m2 = int(self.readline._vi_multiplier2)
return m1 * m2
def set_override_multiplier(self, count):
self.override_multiplier = count
def apply(self):
if self.motion:
self.pos_motion = self.motion(
self.readline.l_buffer.line_buffer,
self.readline.l_buffer.point,
self.get_multiplier(),
char=self.motion_argument)
if self.pos_motion < 0:
self.error()
return
self.action()
if self.state != _VI_TEXT:
self.end()
def movement(self):
if self.pos_motion <= len(self.readline.l_buffer.line_buffer):
self.readline.l_buffer.point = self.pos_motion
else:
self.readline.l_buffer.point = len(
self.readline.l_buffer.line_buffer) - 1
def yank(self):
if self.pos_motion > self.readline.l_buffer.point:
s = self.readline.l_buffer.line_buffer[self.readline.l_buffer.point: self.pos_motion + self.delete_right]
else:
index = max(0, self.pos_motion - self.delete_left)
s = self.readline.l_buffer.line_buffer[index:
self.readline.l_buffer.point + self.delete_right]
self.readline._vi_yank_buffer = s
def delete(self):
self.readline.vi_save_line()
self.yank()
# point=lineobj.Point(self.readline.l_buffer)
# pm=self.pos_motion
# del self.readline.l_buffer[point:pm]
# return
if self.pos_motion > self.readline.l_buffer.point:
del self.readline.l_buffer.line_buffer[self.readline.l_buffer.point: self.pos_motion + self.delete_right]
if self.readline.l_buffer.point > len(
self.readline.l_buffer.line_buffer):
self.readline.l_buffer.point = len(
self.readline.l_buffer.line_buffer)
else:
index = max(0, self.pos_motion - self.delete_left)
del self.readline.l_buffer.line_buffer[index:
self.readline.l_buffer.point + self.delete_right]
self.readline.l_buffer.point = index
def delete_end_of_line(self):
self.readline.vi_save_line()
# del self.readline.l_buffer [self.readline.l_buffer.point : ]
line_text = self.readline.l_buffer.get_line_text()
line_text = line_text[: self.readline.l_buffer.point]
self.readline.l_buffer.set_line(line_text)
if self.readline.l_buffer.point > 0:
self.readline.l_buffer.point -= 1
def delete_char(self):
# point=lineobj.Point(self.readline.l_buffer)
# del self.readline.l_buffer[point:point+self.get_multiplier ()]
# return
self.pos_motion = self.readline.l_buffer.point + self.get_multiplier()
self.delete()
end = max(0, len(self.readline.l_buffer) - 1)
if self.readline.l_buffer.point > end:
self.readline.l_buffer.point = end
def delete_prev_char(self):
self.pos_motion = self.readline.l_buffer.point - self.get_multiplier()
self.delete()
def change(self):
self.readline.vi_set_insert_mode(True)
self.delete()
self.skip_multipler = True
self.state = _VI_TEXT
def escape(self, char):
if self.state == _VI_TEXT:
if not self.skip_multipler:
times = self.get_multiplier()
if times > 1 and self.text:
extra = self.text * (times - 1)
self.set_buffer(extra)
self.state = _VI_END
def set_motion_argument(self, char):
self.motion_argument = char
self.apply()
def end(self):
self.state = _VI_END
if self.readline.l_buffer.point >= len(
self.readline.l_buffer.line_buffer):
self.readline.l_buffer.point = max(
0, len(self.readline.l_buffer.line_buffer) - 1)
class ViExternalEditor:
def __init__(self, line):
if isinstance(line, type([])):
line = ''.join(line)
file_tmp = self.get_tempfile()
fp_tmp = self.file_open(file_tmp, 'w')
fp_tmp.write(line)
fp_tmp.close()
self.run_editor(file_tmp)
fp_tmp = self.file_open(file_tmp, 'r')
self.result = fp_tmp.read()
fp_tmp.close()
self.file_remove(file_tmp)
def get_tempfile(self):
import tempfile
return tempfile.mktemp(prefix='readline-', suffix='.py')
def file_open(self, filename, mode):
return file(filename, mode)
def file_remove(self, filename):
os.remove(filename)
def get_editor(self):
try:
return os.environ['EDITOR']
except KeyError:
return 'notepad' # ouch
def run_editor(self, filename):
cmd = '%s %s' % (self.get_editor(), filename, )
self.run_command(cmd)
def run_command(self, command):
os.system(command)
class ViEvent:
def __init__(self, char):
self.char = char
# vi standalone functions
def vi_is_word(char):
log('xx vi_is_word: type(%s), %s' % (type(char), char, ))
return char.isalpha() or char.isdigit() or char == '_'
def vi_is_space(char):
return char.isspace()
def vi_is_word_or_space(char):
return vi_is_word(char) or vi_is_space(char)
def vi_pos_word_short(line, index=0, count=1):
try:
for i in range(count):
in_word = vi_is_word(line[index])
if not in_word:
while not vi_is_word(line[index]):
index += 1
else:
while vi_is_word(line[index]):
index += 1
while vi_is_space(line[index]):
index += 1
return index
except IndexError:
return len(line)
def vi_pos_word_long(line, index=0, count=1):
try:
for i in range(count):
in_space = vi_is_space(line[index])
if not in_space:
while not vi_is_space(line[index]):
index += 1
while vi_is_space(line[index]):
index += 1
return index
except IndexError:
return len(line)
def vi_pos_end_short(line, index=0, count=1):
try:
for i in range(count):
index += 1
while vi_is_space(line[index]):
index += 1
in_word = vi_is_word(line[index])
if not in_word:
while not vi_is_word_or_space(line[index]):
index += 1
else:
while vi_is_word(line[index]):
index += 1
return index - 1
except IndexError:
return max(0, len(line) - 1)
def vi_pos_end_long(line, index=0, count=1):
try:
for i in range(count):
index += 1
while vi_is_space(line[index]):
index += 1
while not vi_is_space(line[index]):
index += 1
return index - 1
except IndexError:
return max(0, len(line) - 1)
class vi_list (list):
'''This is a list that cannot have a negative index'''
def __getitem__(self, key):
try:
if int(key) < 0:
raise IndexError
except ValueError:
pass
return list.__getitem__(self, key)
def vi_pos_back_short(line, index=0, count=1):
line = vi_list(line)
try:
for i in range(count):
index -= 1
while vi_is_space(line[index]):
index -= 1
in_word = vi_is_word(line[index])
if in_word:
while vi_is_word(line[index]):
index -= 1
else:
while not vi_is_word_or_space(line[index]):
index -= 1
return index + 1
except IndexError:
return 0
def vi_pos_back_long(line, index=0, count=1):
line = vi_list(line)
try:
for i in range(count):
index -= 1
while vi_is_space(line[index]):
index -= 1
while not vi_is_space(line[index]):
index -= 1
return index + 1
except IndexError:
return 0
def vi_pos_find_char_forward(line, char, index=0, count=1):
try:
for i in range(count):
index += 1
while line[index] != char:
index += 1
return index
except IndexError:
return -1
def vi_pos_find_char_backward(line, char, index=0, count=1):
try:
for i in range(count):
index -= 1
while True:
if index < 0:
return -1
if line[index] == char:
break
index -= 1
return index
except IndexError:
return -1
def vi_pos_to_char_forward(line, char, index=0, count=1):
index = vi_pos_find_char_forward(line, char, index, count)
if index > 0:
return index - 1
return index
def vi_pos_to_char_backward(line, char, index=0, count=1):
index = vi_pos_find_char_backward(line, char, index, count)
if index >= 0:
return index + 1
return index
_vi_dct_matching = {
'<': ('>', +1), '>': ('<', -1),
'(': (')', +1), ')': ('(', -1),
'[': (']', +1), ']': ('[', -1),
'{': ('}', +1), '}': ('{', -1),
}
def vi_pos_matching(line, index=0):
'''find matching <([{}])>'''
anchor = None
target = None
delta = 1
count = 0
try:
while True:
if anchor is None:
# first find anchor
try:
target, delta = _vi_dct_matching[line[index]]
anchor = line[index]
count = 1
except KeyError:
index += 1
continue
else:
# Here the anchor has been found
# Need to get corresponding target
if index < 0:
return -1
if line[index] == anchor:
count += 1
elif line[index] == target:
count -= 1
if count == 0:
return index
index += delta
except IndexError:
return -1
Back to Directory
File Manager