1002 lines
35 KiB
Python
1002 lines
35 KiB
Python
"""
|
|
The `Document` that implements all the text operations/querying.
|
|
"""
|
|
from __future__ import unicode_literals
|
|
|
|
import bisect
|
|
import re
|
|
import six
|
|
import string
|
|
import weakref
|
|
from six.moves import range, map
|
|
|
|
from .selection import SelectionType, SelectionState, PasteMode
|
|
from .clipboard import ClipboardData
|
|
|
|
__all__ = ('Document',)
|
|
|
|
|
|
# Regex for finding "words" in documents. (We consider a group of alnum
|
|
# characters a word, but also a group of special characters a word, as long as
|
|
# it doesn't contain a space.)
|
|
# (This is a 'word' in Vi.)
|
|
_FIND_WORD_RE = re.compile(r'([a-zA-Z0-9_]+|[^a-zA-Z0-9_\s]+)')
|
|
_FIND_CURRENT_WORD_RE = re.compile(r'^([a-zA-Z0-9_]+|[^a-zA-Z0-9_\s]+)')
|
|
_FIND_CURRENT_WORD_INCLUDE_TRAILING_WHITESPACE_RE = re.compile(r'^(([a-zA-Z0-9_]+|[^a-zA-Z0-9_\s]+)\s*)')
|
|
|
|
# Regex for finding "WORDS" in documents.
|
|
# (This is a 'WORD in Vi.)
|
|
_FIND_BIG_WORD_RE = re.compile(r'([^\s]+)')
|
|
_FIND_CURRENT_BIG_WORD_RE = re.compile(r'^([^\s]+)')
|
|
_FIND_CURRENT_BIG_WORD_INCLUDE_TRAILING_WHITESPACE_RE = re.compile(r'^([^\s]+\s*)')
|
|
|
|
# Share the Document._cache between all Document instances.
|
|
# (Document instances are considered immutable. That means that if another
|
|
# `Document` is constructed with the same text, it should have the same
|
|
# `_DocumentCache`.)
|
|
_text_to_document_cache = weakref.WeakValueDictionary() # Maps document.text to DocumentCache instance.
|
|
|
|
|
|
class _ImmutableLineList(list):
|
|
"""
|
|
Some protection for our 'lines' list, which is assumed to be immutable in the cache.
|
|
(Useful for detecting obvious bugs.)
|
|
"""
|
|
def _error(self, *a, **kw):
|
|
raise NotImplementedError('Attempt to modifiy an immutable list.')
|
|
|
|
__setitem__ = _error
|
|
append = _error
|
|
clear = _error
|
|
extend = _error
|
|
insert = _error
|
|
pop = _error
|
|
remove = _error
|
|
reverse = _error
|
|
sort = _error
|
|
|
|
|
|
class _DocumentCache(object):
|
|
def __init__(self):
|
|
#: List of lines for the Document text.
|
|
self.lines = None
|
|
|
|
#: List of index positions, pointing to the start of all the lines.
|
|
self.line_indexes = None
|
|
|
|
|
|
class Document(object):
|
|
"""
|
|
This is a immutable class around the text and cursor position, and contains
|
|
methods for querying this data, e.g. to give the text before the cursor.
|
|
|
|
This class is usually instantiated by a :class:`~libs.prompt_toolkit.buffer.Buffer`
|
|
object, and accessed as the `document` property of that class.
|
|
|
|
:param text: string
|
|
:param cursor_position: int
|
|
:param selection: :class:`.SelectionState`
|
|
"""
|
|
__slots__ = ('_text', '_cursor_position', '_selection', '_cache')
|
|
|
|
def __init__(self, text='', cursor_position=None, selection=None):
|
|
assert isinstance(text, six.text_type), 'Got %r' % text
|
|
assert selection is None or isinstance(selection, SelectionState)
|
|
|
|
# Check cursor position. It can also be right after the end. (Where we
|
|
# insert text.)
|
|
assert cursor_position is None or cursor_position <= len(text), AssertionError(
|
|
'cursor_position=%r, len_text=%r' % (cursor_position, len(text)))
|
|
|
|
# By default, if no cursor position was given, make sure to put the
|
|
# cursor position is at the end of the document. This is what makes
|
|
# sense in most places.
|
|
if cursor_position is None:
|
|
cursor_position = len(text)
|
|
|
|
# Keep these attributes private. A `Document` really has to be
|
|
# considered to be immutable, because otherwise the caching will break
|
|
# things. Because of that, we wrap these into read-only properties.
|
|
self._text = text
|
|
self._cursor_position = cursor_position
|
|
self._selection = selection
|
|
|
|
# Cache for lines/indexes. (Shared with other Document instances that
|
|
# contain the same text.
|
|
try:
|
|
self._cache = _text_to_document_cache[self.text]
|
|
except KeyError:
|
|
self._cache = _DocumentCache()
|
|
_text_to_document_cache[self.text] = self._cache
|
|
|
|
# XX: For some reason, above, we can't use 'WeakValueDictionary.setdefault'.
|
|
# This fails in Pypy3. `self._cache` becomes None, because that's what
|
|
# 'setdefault' returns.
|
|
# self._cache = _text_to_document_cache.setdefault(self.text, _DocumentCache())
|
|
# assert self._cache
|
|
|
|
def __repr__(self):
|
|
return '%s(%r, %r)' % (self.__class__.__name__, self.text, self.cursor_position)
|
|
|
|
@property
|
|
def text(self):
|
|
" The document text. "
|
|
return self._text
|
|
|
|
@property
|
|
def cursor_position(self):
|
|
" The document cursor position. "
|
|
return self._cursor_position
|
|
|
|
@property
|
|
def selection(self):
|
|
" :class:`.SelectionState` object. "
|
|
return self._selection
|
|
|
|
@property
|
|
def current_char(self):
|
|
""" Return character under cursor or an empty string. """
|
|
return self._get_char_relative_to_cursor(0) or ''
|
|
|
|
@property
|
|
def char_before_cursor(self):
|
|
""" Return character before the cursor or an empty string. """
|
|
return self._get_char_relative_to_cursor(-1) or ''
|
|
|
|
@property
|
|
def text_before_cursor(self):
|
|
return self.text[:self.cursor_position:]
|
|
|
|
@property
|
|
def text_after_cursor(self):
|
|
return self.text[self.cursor_position:]
|
|
|
|
@property
|
|
def current_line_before_cursor(self):
|
|
""" Text from the start of the line until the cursor. """
|
|
_, _, text = self.text_before_cursor.rpartition('\n')
|
|
return text
|
|
|
|
@property
|
|
def current_line_after_cursor(self):
|
|
""" Text from the cursor until the end of the line. """
|
|
text, _, _ = self.text_after_cursor.partition('\n')
|
|
return text
|
|
|
|
@property
|
|
def lines(self):
|
|
"""
|
|
Array of all the lines.
|
|
"""
|
|
# Cache, because this one is reused very often.
|
|
if self._cache.lines is None:
|
|
self._cache.lines = _ImmutableLineList(self.text.split('\n'))
|
|
|
|
return self._cache.lines
|
|
|
|
@property
|
|
def _line_start_indexes(self):
|
|
"""
|
|
Array pointing to the start indexes of all the lines.
|
|
"""
|
|
# Cache, because this is often reused. (If it is used, it's often used
|
|
# many times. And this has to be fast for editing big documents!)
|
|
if self._cache.line_indexes is None:
|
|
# Create list of line lengths.
|
|
line_lengths = map(len, self.lines)
|
|
|
|
# Calculate cumulative sums.
|
|
indexes = [0]
|
|
append = indexes.append
|
|
pos = 0
|
|
|
|
for line_length in line_lengths:
|
|
pos += line_length + 1
|
|
append(pos)
|
|
|
|
# Remove the last item. (This is not a new line.)
|
|
if len(indexes) > 1:
|
|
indexes.pop()
|
|
|
|
self._cache.line_indexes = indexes
|
|
|
|
return self._cache.line_indexes
|
|
|
|
@property
|
|
def lines_from_current(self):
|
|
"""
|
|
Array of the lines starting from the current line, until the last line.
|
|
"""
|
|
return self.lines[self.cursor_position_row:]
|
|
|
|
@property
|
|
def line_count(self):
|
|
r""" Return the number of lines in this document. If the document ends
|
|
with a trailing \n, that counts as the beginning of a new line. """
|
|
return len(self.lines)
|
|
|
|
@property
|
|
def current_line(self):
|
|
""" Return the text on the line where the cursor is. (when the input
|
|
consists of just one line, it equals `text`. """
|
|
return self.current_line_before_cursor + self.current_line_after_cursor
|
|
|
|
@property
|
|
def leading_whitespace_in_current_line(self):
|
|
""" The leading whitespace in the left margin of the current line. """
|
|
current_line = self.current_line
|
|
length = len(current_line) - len(current_line.lstrip())
|
|
return current_line[:length]
|
|
|
|
def _get_char_relative_to_cursor(self, offset=0):
|
|
"""
|
|
Return character relative to cursor position, or empty string
|
|
"""
|
|
try:
|
|
return self.text[self.cursor_position + offset]
|
|
except IndexError:
|
|
return ''
|
|
|
|
@property
|
|
def on_first_line(self):
|
|
"""
|
|
True when we are at the first line.
|
|
"""
|
|
return self.cursor_position_row == 0
|
|
|
|
@property
|
|
def on_last_line(self):
|
|
"""
|
|
True when we are at the last line.
|
|
"""
|
|
return self.cursor_position_row == self.line_count - 1
|
|
|
|
@property
|
|
def cursor_position_row(self):
|
|
"""
|
|
Current row. (0-based.)
|
|
"""
|
|
row, _ = self._find_line_start_index(self.cursor_position)
|
|
return row
|
|
|
|
@property
|
|
def cursor_position_col(self):
|
|
"""
|
|
Current column. (0-based.)
|
|
"""
|
|
# (Don't use self.text_before_cursor to calculate this. Creating
|
|
# substrings and doing rsplit is too expensive for getting the cursor
|
|
# position.)
|
|
_, line_start_index = self._find_line_start_index(self.cursor_position)
|
|
return self.cursor_position - line_start_index
|
|
|
|
def _find_line_start_index(self, index):
|
|
"""
|
|
For the index of a character at a certain line, calculate the index of
|
|
the first character on that line.
|
|
|
|
Return (row, index) tuple.
|
|
"""
|
|
indexes = self._line_start_indexes
|
|
|
|
pos = bisect.bisect_right(indexes, index) - 1
|
|
return pos, indexes[pos]
|
|
|
|
def translate_index_to_position(self, index):
|
|
"""
|
|
Given an index for the text, return the corresponding (row, col) tuple.
|
|
(0-based. Returns (0, 0) for index=0.)
|
|
"""
|
|
# Find start of this line.
|
|
row, row_index = self._find_line_start_index(index)
|
|
col = index - row_index
|
|
|
|
return row, col
|
|
|
|
|
|
def translate_row_col_to_index(self, row, col):
|
|
"""
|
|
Given a (row, col) tuple, return the corresponding index.
|
|
(Row and col params are 0-based.)
|
|
|
|
Negative row/col values are turned into zero.
|
|
"""
|
|
try:
|
|
result = self._line_start_indexes[row]
|
|
line = self.lines[row]
|
|
except IndexError:
|
|
if row < 0:
|
|
result = self._line_start_indexes[0]
|
|
line = self.lines[0]
|
|
else:
|
|
result = self._line_start_indexes[-1]
|
|
line = self.lines[-1]
|
|
|
|
result += max(0, min(col, len(line)))
|
|
|
|
# Keep in range. (len(self.text) is included, because the cursor can be
|
|
# right after the end of the text as well.)
|
|
result = max(0, min(result, len(self.text)))
|
|
return result
|
|
|
|
@property
|
|
def is_cursor_at_the_end(self):
|
|
""" True when the cursor is at the end of the text. """
|
|
return self.cursor_position == len(self.text)
|
|
|
|
@property
|
|
def is_cursor_at_the_end_of_line(self):
|
|
""" True when the cursor is at the end of this line. """
|
|
return self.current_char in ('\n', '')
|
|
|
|
def has_match_at_current_position(self, sub):
|
|
"""
|
|
`True` when this substring is found at the cursor position.
|
|
"""
|
|
return self.text.find(sub, self.cursor_position) == self.cursor_position
|
|
|
|
def find(self, sub, in_current_line=False, include_current_position=False,
|
|
ignore_case=False, count=1):
|
|
"""
|
|
Find `text` after the cursor, return position relative to the cursor
|
|
position. Return `None` if nothing was found.
|
|
|
|
:param count: Find the n-th occurance.
|
|
"""
|
|
assert isinstance(ignore_case, bool)
|
|
|
|
if in_current_line:
|
|
text = self.current_line_after_cursor
|
|
else:
|
|
text = self.text_after_cursor
|
|
|
|
if not include_current_position:
|
|
if len(text) == 0:
|
|
return # (Otherwise, we always get a match for the empty string.)
|
|
else:
|
|
text = text[1:]
|
|
|
|
flags = re.IGNORECASE if ignore_case else 0
|
|
iterator = re.finditer(re.escape(sub), text, flags)
|
|
|
|
try:
|
|
for i, match in enumerate(iterator):
|
|
if i + 1 == count:
|
|
if include_current_position:
|
|
return match.start(0)
|
|
else:
|
|
return match.start(0) + 1
|
|
except StopIteration:
|
|
pass
|
|
|
|
def find_all(self, sub, ignore_case=False):
|
|
"""
|
|
Find all occurances of the substring. Return a list of absolute
|
|
positions in the document.
|
|
"""
|
|
flags = re.IGNORECASE if ignore_case else 0
|
|
return [a.start() for a in re.finditer(re.escape(sub), self.text, flags)]
|
|
|
|
def find_backwards(self, sub, in_current_line=False, ignore_case=False, count=1):
|
|
"""
|
|
Find `text` before the cursor, return position relative to the cursor
|
|
position. Return `None` if nothing was found.
|
|
|
|
:param count: Find the n-th occurance.
|
|
"""
|
|
if in_current_line:
|
|
before_cursor = self.current_line_before_cursor[::-1]
|
|
else:
|
|
before_cursor = self.text_before_cursor[::-1]
|
|
|
|
flags = re.IGNORECASE if ignore_case else 0
|
|
iterator = re.finditer(re.escape(sub[::-1]), before_cursor, flags)
|
|
|
|
try:
|
|
for i, match in enumerate(iterator):
|
|
if i + 1 == count:
|
|
return - match.start(0) - len(sub)
|
|
except StopIteration:
|
|
pass
|
|
|
|
def get_word_before_cursor(self, WORD=False):
|
|
"""
|
|
Give the word before the cursor.
|
|
If we have whitespace before the cursor this returns an empty string.
|
|
"""
|
|
if self.text_before_cursor[-1:].isspace():
|
|
return ''
|
|
else:
|
|
return self.text_before_cursor[self.find_start_of_previous_word(WORD=WORD):]
|
|
|
|
def find_start_of_previous_word(self, count=1, WORD=False):
|
|
"""
|
|
Return an index relative to the cursor position pointing to the start
|
|
of the previous word. Return `None` if nothing was found.
|
|
"""
|
|
# Reverse the text before the cursor, in order to do an efficient
|
|
# backwards search.
|
|
text_before_cursor = self.text_before_cursor[::-1]
|
|
|
|
regex = _FIND_BIG_WORD_RE if WORD else _FIND_WORD_RE
|
|
iterator = regex.finditer(text_before_cursor)
|
|
|
|
try:
|
|
for i, match in enumerate(iterator):
|
|
if i + 1 == count:
|
|
return - match.end(1)
|
|
except StopIteration:
|
|
pass
|
|
|
|
def find_boundaries_of_current_word(self, WORD=False, include_leading_whitespace=False,
|
|
include_trailing_whitespace=False):
|
|
"""
|
|
Return the relative boundaries (startpos, endpos) of the current word under the
|
|
cursor. (This is at the current line, because line boundaries obviously
|
|
don't belong to any word.)
|
|
If not on a word, this returns (0,0)
|
|
"""
|
|
text_before_cursor = self.current_line_before_cursor[::-1]
|
|
text_after_cursor = self.current_line_after_cursor
|
|
|
|
def get_regex(include_whitespace):
|
|
return {
|
|
(False, False): _FIND_CURRENT_WORD_RE,
|
|
(False, True): _FIND_CURRENT_WORD_INCLUDE_TRAILING_WHITESPACE_RE,
|
|
(True, False): _FIND_CURRENT_BIG_WORD_RE,
|
|
(True, True): _FIND_CURRENT_BIG_WORD_INCLUDE_TRAILING_WHITESPACE_RE,
|
|
}[(WORD, include_whitespace)]
|
|
|
|
match_before = get_regex(include_leading_whitespace).search(text_before_cursor)
|
|
match_after = get_regex(include_trailing_whitespace).search(text_after_cursor)
|
|
|
|
# When there is a match before and after, and we're not looking for
|
|
# WORDs, make sure that both the part before and after the cursor are
|
|
# either in the [a-zA-Z_] alphabet or not. Otherwise, drop the part
|
|
# before the cursor.
|
|
if not WORD and match_before and match_after:
|
|
c1 = self.text[self.cursor_position - 1]
|
|
c2 = self.text[self.cursor_position]
|
|
alphabet = string.ascii_letters + '0123456789_'
|
|
|
|
if (c1 in alphabet) != (c2 in alphabet):
|
|
match_before = None
|
|
|
|
return (
|
|
- match_before.end(1) if match_before else 0,
|
|
match_after.end(1) if match_after else 0
|
|
)
|
|
|
|
def get_word_under_cursor(self, WORD=False):
|
|
"""
|
|
Return the word, currently below the cursor.
|
|
This returns an empty string when the cursor is on a whitespace region.
|
|
"""
|
|
start, end = self.find_boundaries_of_current_word(WORD=WORD)
|
|
return self.text[self.cursor_position + start: self.cursor_position + end]
|
|
|
|
def find_next_word_beginning(self, count=1, WORD=False):
|
|
"""
|
|
Return an index relative to the cursor position pointing to the start
|
|
of the next word. Return `None` if nothing was found.
|
|
"""
|
|
if count < 0:
|
|
return self.find_previous_word_beginning(count=-count, WORD=WORD)
|
|
|
|
regex = _FIND_BIG_WORD_RE if WORD else _FIND_WORD_RE
|
|
iterator = regex.finditer(self.text_after_cursor)
|
|
|
|
try:
|
|
for i, match in enumerate(iterator):
|
|
# Take first match, unless it's the word on which we're right now.
|
|
if i == 0 and match.start(1) == 0:
|
|
count += 1
|
|
|
|
if i + 1 == count:
|
|
return match.start(1)
|
|
except StopIteration:
|
|
pass
|
|
|
|
def find_next_word_ending(self, include_current_position=False, count=1, WORD=False):
|
|
"""
|
|
Return an index relative to the cursor position pointing to the end
|
|
of the next word. Return `None` if nothing was found.
|
|
"""
|
|
if count < 0:
|
|
return self.find_previous_word_ending(count=-count, WORD=WORD)
|
|
|
|
if include_current_position:
|
|
text = self.text_after_cursor
|
|
else:
|
|
text = self.text_after_cursor[1:]
|
|
|
|
regex = _FIND_BIG_WORD_RE if WORD else _FIND_WORD_RE
|
|
iterable = regex.finditer(text)
|
|
|
|
try:
|
|
for i, match in enumerate(iterable):
|
|
if i + 1 == count:
|
|
value = match.end(1)
|
|
|
|
if include_current_position:
|
|
return value
|
|
else:
|
|
return value + 1
|
|
|
|
except StopIteration:
|
|
pass
|
|
|
|
def find_previous_word_beginning(self, count=1, WORD=False):
|
|
"""
|
|
Return an index relative to the cursor position pointing to the start
|
|
of the previous word. Return `None` if nothing was found.
|
|
"""
|
|
if count < 0:
|
|
return self.find_next_word_beginning(count=-count, WORD=WORD)
|
|
|
|
regex = _FIND_BIG_WORD_RE if WORD else _FIND_WORD_RE
|
|
iterator = regex.finditer(self.text_before_cursor[::-1])
|
|
|
|
try:
|
|
for i, match in enumerate(iterator):
|
|
if i + 1 == count:
|
|
return - match.end(1)
|
|
except StopIteration:
|
|
pass
|
|
|
|
def find_previous_word_ending(self, count=1, WORD=False):
|
|
"""
|
|
Return an index relative to the cursor position pointing to the end
|
|
of the previous word. Return `None` if nothing was found.
|
|
"""
|
|
if count < 0:
|
|
return self.find_next_word_ending(count=-count, WORD=WORD)
|
|
|
|
text_before_cursor = self.text_after_cursor[:1] + self.text_before_cursor[::-1]
|
|
|
|
regex = _FIND_BIG_WORD_RE if WORD else _FIND_WORD_RE
|
|
iterator = regex.finditer(text_before_cursor)
|
|
|
|
try:
|
|
for i, match in enumerate(iterator):
|
|
# Take first match, unless it's the word on which we're right now.
|
|
if i == 0 and match.start(1) == 0:
|
|
count += 1
|
|
|
|
if i + 1 == count:
|
|
return -match.start(1) + 1
|
|
except StopIteration:
|
|
pass
|
|
|
|
def find_next_matching_line(self, match_func, count=1):
|
|
"""
|
|
Look downwards for empty lines.
|
|
Return the line index, relative to the current line.
|
|
"""
|
|
result = None
|
|
|
|
for index, line in enumerate(self.lines[self.cursor_position_row + 1:]):
|
|
if match_func(line):
|
|
result = 1 + index
|
|
count -= 1
|
|
|
|
if count == 0:
|
|
break
|
|
|
|
return result
|
|
|
|
def find_previous_matching_line(self, match_func, count=1):
|
|
"""
|
|
Look upwards for empty lines.
|
|
Return the line index, relative to the current line.
|
|
"""
|
|
result = None
|
|
|
|
for index, line in enumerate(self.lines[:self.cursor_position_row][::-1]):
|
|
if match_func(line):
|
|
result = -1 - index
|
|
count -= 1
|
|
|
|
if count == 0:
|
|
break
|
|
|
|
return result
|
|
|
|
def get_cursor_left_position(self, count=1):
|
|
"""
|
|
Relative position for cursor left.
|
|
"""
|
|
if count < 0:
|
|
return self.get_cursor_right_position(-count)
|
|
|
|
return - min(self.cursor_position_col, count)
|
|
|
|
def get_cursor_right_position(self, count=1):
|
|
"""
|
|
Relative position for cursor_right.
|
|
"""
|
|
if count < 0:
|
|
return self.get_cursor_left_position(-count)
|
|
|
|
return min(count, len(self.current_line_after_cursor))
|
|
|
|
def get_cursor_up_position(self, count=1, preferred_column=None):
|
|
"""
|
|
Return the relative cursor position (character index) where we would be if the
|
|
user pressed the arrow-up button.
|
|
|
|
:param preferred_column: When given, go to this column instead of
|
|
staying at the current column.
|
|
"""
|
|
assert count >= 1
|
|
column = self.cursor_position_col if preferred_column is None else preferred_column
|
|
|
|
return self.translate_row_col_to_index(
|
|
max(0, self.cursor_position_row - count), column) - self.cursor_position
|
|
|
|
def get_cursor_down_position(self, count=1, preferred_column=None):
|
|
"""
|
|
Return the relative cursor position (character index) where we would be if the
|
|
user pressed the arrow-down button.
|
|
|
|
:param preferred_column: When given, go to this column instead of
|
|
staying at the current column.
|
|
"""
|
|
assert count >= 1
|
|
column = self.cursor_position_col if preferred_column is None else preferred_column
|
|
|
|
return self.translate_row_col_to_index(
|
|
self.cursor_position_row + count, column) - self.cursor_position
|
|
|
|
def find_enclosing_bracket_right(self, left_ch, right_ch, end_pos=None):
|
|
"""
|
|
Find the right bracket enclosing current position. Return the relative
|
|
position to the cursor position.
|
|
|
|
When `end_pos` is given, don't look past the position.
|
|
"""
|
|
if self.current_char == right_ch:
|
|
return 0
|
|
|
|
if end_pos is None:
|
|
end_pos = len(self.text)
|
|
else:
|
|
end_pos = min(len(self.text), end_pos)
|
|
|
|
stack = 1
|
|
|
|
# Look forward.
|
|
for i in range(self.cursor_position + 1, end_pos):
|
|
c = self.text[i]
|
|
|
|
if c == left_ch:
|
|
stack += 1
|
|
elif c == right_ch:
|
|
stack -= 1
|
|
|
|
if stack == 0:
|
|
return i - self.cursor_position
|
|
|
|
def find_enclosing_bracket_left(self, left_ch, right_ch, start_pos=None):
|
|
"""
|
|
Find the left bracket enclosing current position. Return the relative
|
|
position to the cursor position.
|
|
|
|
When `start_pos` is given, don't look past the position.
|
|
"""
|
|
if self.current_char == left_ch:
|
|
return 0
|
|
|
|
if start_pos is None:
|
|
start_pos = 0
|
|
else:
|
|
start_pos = max(0, start_pos)
|
|
|
|
stack = 1
|
|
|
|
# Look backward.
|
|
for i in range(self.cursor_position - 1, start_pos - 1, -1):
|
|
c = self.text[i]
|
|
|
|
if c == right_ch:
|
|
stack += 1
|
|
elif c == left_ch:
|
|
stack -= 1
|
|
|
|
if stack == 0:
|
|
return i - self.cursor_position
|
|
|
|
def find_matching_bracket_position(self, start_pos=None, end_pos=None):
|
|
"""
|
|
Return relative cursor position of matching [, (, { or < bracket.
|
|
|
|
When `start_pos` or `end_pos` are given. Don't look past the positions.
|
|
"""
|
|
|
|
# Look for a match.
|
|
for A, B in '()', '[]', '{}', '<>':
|
|
if self.current_char == A:
|
|
return self.find_enclosing_bracket_right(A, B, end_pos=end_pos) or 0
|
|
elif self.current_char == B:
|
|
return self.find_enclosing_bracket_left(A, B, start_pos=start_pos) or 0
|
|
|
|
return 0
|
|
|
|
def get_start_of_document_position(self):
|
|
""" Relative position for the start of the document. """
|
|
return - self.cursor_position
|
|
|
|
def get_end_of_document_position(self):
|
|
""" Relative position for the end of the document. """
|
|
return len(self.text) - self.cursor_position
|
|
|
|
def get_start_of_line_position(self, after_whitespace=False):
|
|
""" Relative position for the start of this line. """
|
|
if after_whitespace:
|
|
current_line = self.current_line
|
|
return len(current_line) - len(current_line.lstrip()) - self.cursor_position_col
|
|
else:
|
|
return - len(self.current_line_before_cursor)
|
|
|
|
def get_end_of_line_position(self):
|
|
""" Relative position for the end of this line. """
|
|
return len(self.current_line_after_cursor)
|
|
|
|
def last_non_blank_of_current_line_position(self):
|
|
"""
|
|
Relative position for the last non blank character of this line.
|
|
"""
|
|
return len(self.current_line.rstrip()) - self.cursor_position_col - 1
|
|
|
|
def get_column_cursor_position(self, column):
|
|
"""
|
|
Return the relative cursor position for this column at the current
|
|
line. (It will stay between the boundaries of the line in case of a
|
|
larger number.)
|
|
"""
|
|
line_length = len(self.current_line)
|
|
current_column = self.cursor_position_col
|
|
column = max(0, min(line_length, column))
|
|
|
|
return column - current_column
|
|
|
|
def selection_range(self): # XXX: shouldn't this return `None` if there is no selection???
|
|
"""
|
|
Return (from, to) tuple of the selection.
|
|
start and end position are included.
|
|
|
|
This doesn't take the selection type into account. Use
|
|
`selection_ranges` instead.
|
|
"""
|
|
if self.selection:
|
|
from_, to = sorted([self.cursor_position, self.selection.original_cursor_position])
|
|
else:
|
|
from_, to = self.cursor_position, self.cursor_position
|
|
|
|
return from_, to
|
|
|
|
def selection_ranges(self):
|
|
"""
|
|
Return a list of (from, to) tuples for the selection or none if nothing
|
|
was selected. start and end position are always included in the
|
|
selection.
|
|
|
|
This will yield several (from, to) tuples in case of a BLOCK selection.
|
|
"""
|
|
if self.selection:
|
|
from_, to = sorted([self.cursor_position, self.selection.original_cursor_position])
|
|
|
|
if self.selection.type == SelectionType.BLOCK:
|
|
from_line, from_column = self.translate_index_to_position(from_)
|
|
to_line, to_column = self.translate_index_to_position(to)
|
|
from_column, to_column = sorted([from_column, to_column])
|
|
lines = self.lines
|
|
|
|
for l in range(from_line, to_line + 1):
|
|
line_length = len(lines[l])
|
|
if from_column < line_length:
|
|
yield (self.translate_row_col_to_index(l, from_column),
|
|
self.translate_row_col_to_index(l, min(line_length - 1, to_column)))
|
|
else:
|
|
# In case of a LINES selection, go to the start/end of the lines.
|
|
if self.selection.type == SelectionType.LINES:
|
|
from_ = max(0, self.text.rfind('\n', 0, from_) + 1)
|
|
|
|
if self.text.find('\n', to) >= 0:
|
|
to = self.text.find('\n', to)
|
|
else:
|
|
to = len(self.text) - 1
|
|
|
|
yield from_, to
|
|
|
|
def selection_range_at_line(self, row):
|
|
"""
|
|
If the selection spans a portion of the given line, return a (from, to) tuple.
|
|
Otherwise, return None.
|
|
"""
|
|
if self.selection:
|
|
row_start = self.translate_row_col_to_index(row, 0)
|
|
row_end = self.translate_row_col_to_index(row, max(0, len(self.lines[row]) - 1))
|
|
|
|
from_, to = sorted([self.cursor_position, self.selection.original_cursor_position])
|
|
|
|
# Take the intersection of the current line and the selection.
|
|
intersection_start = max(row_start, from_)
|
|
intersection_end = min(row_end, to)
|
|
|
|
if intersection_start <= intersection_end:
|
|
if self.selection.type == SelectionType.LINES:
|
|
intersection_start = row_start
|
|
intersection_end = row_end
|
|
elif self.selection.type == SelectionType.BLOCK:
|
|
_, col1 = self.translate_index_to_position(from_)
|
|
_, col2 = self.translate_index_to_position(to)
|
|
col1, col2 = sorted([col1, col2])
|
|
intersection_start = self.translate_row_col_to_index(row, col1)
|
|
intersection_end = self.translate_row_col_to_index(row, col2)
|
|
|
|
_, from_column = self.translate_index_to_position(intersection_start)
|
|
_, to_column = self.translate_index_to_position(intersection_end)
|
|
|
|
return from_column, to_column
|
|
|
|
def cut_selection(self):
|
|
"""
|
|
Return a (:class:`.Document`, :class:`.ClipboardData`) tuple, where the
|
|
document represents the new document when the selection is cut, and the
|
|
clipboard data, represents whatever has to be put on the clipboard.
|
|
"""
|
|
if self.selection:
|
|
cut_parts = []
|
|
remaining_parts = []
|
|
new_cursor_position = self.cursor_position
|
|
|
|
last_to = 0
|
|
for from_, to in self.selection_ranges():
|
|
if last_to == 0:
|
|
new_cursor_position = from_
|
|
|
|
remaining_parts.append(self.text[last_to:from_])
|
|
cut_parts.append(self.text[from_:to + 1])
|
|
last_to = to + 1
|
|
|
|
remaining_parts.append(self.text[last_to:])
|
|
|
|
cut_text = '\n'.join(cut_parts)
|
|
remaining_text = ''.join(remaining_parts)
|
|
|
|
# In case of a LINES selection, don't include the trailing newline.
|
|
if self.selection.type == SelectionType.LINES and cut_text.endswith('\n'):
|
|
cut_text = cut_text[:-1]
|
|
|
|
return (Document(text=remaining_text, cursor_position=new_cursor_position),
|
|
ClipboardData(cut_text, self.selection.type))
|
|
else:
|
|
return self, ClipboardData('')
|
|
|
|
def paste_clipboard_data(self, data, paste_mode=PasteMode.EMACS, count=1):
|
|
"""
|
|
Return a new :class:`.Document` instance which contains the result if
|
|
we would paste this data at the current cursor position.
|
|
|
|
:param paste_mode: Where to paste. (Before/after/emacs.)
|
|
:param count: When >1, Paste multiple times.
|
|
"""
|
|
assert isinstance(data, ClipboardData)
|
|
assert paste_mode in (PasteMode.VI_BEFORE, PasteMode.VI_AFTER, PasteMode.EMACS)
|
|
|
|
before = (paste_mode == PasteMode.VI_BEFORE)
|
|
after = (paste_mode == PasteMode.VI_AFTER)
|
|
|
|
if data.type == SelectionType.CHARACTERS:
|
|
if after:
|
|
new_text = (self.text[:self.cursor_position + 1] + data.text * count +
|
|
self.text[self.cursor_position + 1:])
|
|
else:
|
|
new_text = self.text_before_cursor + data.text * count + self.text_after_cursor
|
|
|
|
new_cursor_position = self.cursor_position + len(data.text) * count
|
|
if before:
|
|
new_cursor_position -= 1
|
|
|
|
elif data.type == SelectionType.LINES:
|
|
l = self.cursor_position_row
|
|
if before:
|
|
lines = self.lines[:l] + [data.text] * count + self.lines[l:]
|
|
new_text = '\n'.join(lines)
|
|
new_cursor_position = len(''.join(self.lines[:l])) + l
|
|
else:
|
|
lines = self.lines[:l + 1] + [data.text] * count + self.lines[l + 1:]
|
|
new_cursor_position = len(''.join(self.lines[:l + 1])) + l + 1
|
|
new_text = '\n'.join(lines)
|
|
|
|
elif data.type == SelectionType.BLOCK:
|
|
lines = self.lines[:]
|
|
start_line = self.cursor_position_row
|
|
start_column = self.cursor_position_col + (0 if before else 1)
|
|
|
|
for i, line in enumerate(data.text.split('\n')):
|
|
index = i + start_line
|
|
if index >= len(lines):
|
|
lines.append('')
|
|
|
|
lines[index] = lines[index].ljust(start_column)
|
|
lines[index] = lines[index][:start_column] + line * count + lines[index][start_column:]
|
|
|
|
new_text = '\n'.join(lines)
|
|
new_cursor_position = self.cursor_position + (0 if before else 1)
|
|
|
|
return Document(text=new_text, cursor_position=new_cursor_position)
|
|
|
|
def empty_line_count_at_the_end(self):
|
|
"""
|
|
Return number of empty lines at the end of the document.
|
|
"""
|
|
count = 0
|
|
for line in self.lines[::-1]:
|
|
if not line or line.isspace():
|
|
count += 1
|
|
else:
|
|
break
|
|
|
|
return count
|
|
|
|
def start_of_paragraph(self, count=1, before=False):
|
|
"""
|
|
Return the start of the current paragraph. (Relative cursor position.)
|
|
"""
|
|
def match_func(text):
|
|
return not text or text.isspace()
|
|
|
|
line_index = self.find_previous_matching_line(match_func=match_func, count=count)
|
|
|
|
if line_index:
|
|
add = 0 if before else 1
|
|
return min(0, self.get_cursor_up_position(count=-line_index) + add)
|
|
else:
|
|
return -self.cursor_position
|
|
|
|
def end_of_paragraph(self, count=1, after=False):
|
|
"""
|
|
Return the end of the current paragraph. (Relative cursor position.)
|
|
"""
|
|
def match_func(text):
|
|
return not text or text.isspace()
|
|
|
|
line_index = self.find_next_matching_line(match_func=match_func, count=count)
|
|
|
|
if line_index:
|
|
add = 0 if after else 1
|
|
return max(0, self.get_cursor_down_position(count=line_index) - add)
|
|
else:
|
|
return len(self.text_after_cursor)
|
|
|
|
# Modifiers.
|
|
|
|
def insert_after(self, text):
|
|
"""
|
|
Create a new document, with this text inserted after the buffer.
|
|
It keeps selection ranges and cursor position in sync.
|
|
"""
|
|
return Document(
|
|
text=self.text + text,
|
|
cursor_position=self.cursor_position,
|
|
selection=self.selection)
|
|
|
|
def insert_before(self, text):
|
|
"""
|
|
Create a new document, with this text inserted before the buffer.
|
|
It keeps selection ranges and cursor position in sync.
|
|
"""
|
|
selection_state = self.selection
|
|
|
|
if selection_state:
|
|
selection_state = SelectionState(
|
|
original_cursor_position=selection_state.original_cursor_position + len(text),
|
|
type=selection_state.type)
|
|
|
|
return Document(
|
|
text=text + self.text,
|
|
cursor_position=self.cursor_position + len(text),
|
|
selection=selection_state)
|