569 lines
16 KiB
Python
569 lines
16 KiB
Python
#!/usr/bin/env python
|
|
# encoding: utf-8
|
|
|
|
import re
|
|
|
|
from PySnipEmu.Buffer import TextBuffer
|
|
from PySnipEmu.Geometry import Span, Position
|
|
|
|
__all__ = [ "Mirror", "Transformation", "SnippetInstance", "StartMarker" ]
|
|
|
|
# TODO: remove me
|
|
from PySnipEmu.debug import debug
|
|
|
|
###########################################################################
|
|
# Helper class #
|
|
###########################################################################
|
|
class _CleverReplace(object):
|
|
"""
|
|
This class mimics TextMates replace syntax
|
|
"""
|
|
_DOLLAR = re.compile(r"\$(\d+)", re.DOTALL)
|
|
_SIMPLE_CASEFOLDINGS = re.compile(r"\\([ul].)", re.DOTALL)
|
|
_LONG_CASEFOLDINGS = re.compile(r"\\([UL].*?)\\E", re.DOTALL)
|
|
_CONDITIONAL = re.compile(r"\(\?(\d+):(.*?)(?<!\\)\)", re.DOTALL)
|
|
|
|
_UNESCAPE = re.compile(r'\\[^ntrab]')
|
|
|
|
def __init__(self, s):
|
|
self._s = s
|
|
|
|
def _scase_folding(self, m):
|
|
if m.group(1)[0] == 'u':
|
|
return m.group(1)[-1].upper()
|
|
else:
|
|
return m.group(1)[-1].lower()
|
|
def _lcase_folding(self, m):
|
|
if m.group(1)[0] == 'U':
|
|
return m.group(1)[1:].upper()
|
|
else:
|
|
return m.group(1)[1:].lower()
|
|
|
|
def _unescape(self, v):
|
|
return self._UNESCAPE.subn(lambda m: m.group(0)[-1], v)[0]
|
|
def replace(self, match):
|
|
start, end = match.span()
|
|
|
|
tv = self._s
|
|
|
|
# Replace all $? with capture groups
|
|
tv = self._DOLLAR.subn(lambda m: match.group(int(m.group(1))), tv)[0]
|
|
|
|
def _conditional(m):
|
|
args = m.group(2).split(':')
|
|
# TODO: the returned string should be checked for conditionals
|
|
if match.group(int(m.group(1))):
|
|
return self._unescape(args[0])
|
|
elif len(args) > 1:
|
|
return self._unescape(args[1])
|
|
else:
|
|
return ""
|
|
|
|
# Replace CaseFoldings
|
|
tv = self._SIMPLE_CASEFOLDINGS.subn(self._scase_folding, tv)[0]
|
|
tv = self._LONG_CASEFOLDINGS.subn(self._lcase_folding, tv)[0]
|
|
tv = self._CONDITIONAL.subn(_conditional, tv)[0]
|
|
|
|
rv = tv.decode("string-escape")
|
|
|
|
return rv
|
|
|
|
class _TOParser(object):
|
|
# A simple tabstop with default value
|
|
_TABSTOP = re.compile(r'''\${(\d+)[:}]''')
|
|
# A mirror or a tabstop without default value.
|
|
_MIRROR_OR_TS = re.compile(r'\$(\d+)')
|
|
# A mirror or a tabstop without default value.
|
|
_TRANSFORMATION = re.compile(r'\${(\d+)/(.*?)/(.*?)/([a-zA-z]*)}')
|
|
|
|
def __init__(self, parent, val):
|
|
self._v = val
|
|
self._p = parent
|
|
|
|
self._childs = []
|
|
|
|
def __repr__(self):
|
|
return "TOParser(%s)" % self._p
|
|
|
|
def parse(self):
|
|
self._parse_tabs()
|
|
self._parse_transformations()
|
|
self._parse_mirrors_or_ts()
|
|
self._finish()
|
|
|
|
########
|
|
# TABS #
|
|
########
|
|
def _parse_tabs(self):
|
|
ts = []
|
|
m = self._TABSTOP.search(self._v)
|
|
while m:
|
|
ts.append(self._handle_tabstop(m))
|
|
m = self._TABSTOP.search(self._v)
|
|
|
|
|
|
for t, def_text in ts:
|
|
child_parser = _TOParser(t, def_text)
|
|
child_parser._parse_tabs()
|
|
self._childs.append(child_parser)
|
|
|
|
def _handle_tabstop(self, m):
|
|
def _find_closingbracket(v,start_pos):
|
|
bracks_open = 1
|
|
for idx, c in enumerate(v[start_pos:]):
|
|
if c == '{':
|
|
if v[idx+start_pos-1] != '\\':
|
|
bracks_open += 1
|
|
elif c == '}':
|
|
if v[idx+start_pos-1] != '\\':
|
|
bracks_open -= 1
|
|
if not bracks_open:
|
|
return start_pos+idx+1
|
|
|
|
start_pos = m.start()
|
|
end_pos = _find_closingbracket(self._v, start_pos+2)
|
|
|
|
def_text = self._v[m.end():end_pos-1]
|
|
|
|
start, end = self._get_start_end(self._v,start_pos,end_pos)
|
|
|
|
ts = TabStop(self._p, start, end, def_text)
|
|
|
|
self._p._add_tabstop(int(m.group(1)),ts)
|
|
|
|
self._overwrite_area(start_pos, end_pos)
|
|
|
|
return ts, def_text
|
|
|
|
###################
|
|
# TRANSFORMATIONS #
|
|
###################
|
|
def _parse_transformations(self):
|
|
self._trans = []
|
|
for m in self._TRANSFORMATION.finditer(self._v):
|
|
self._trans.append(self._handle_transformation(m))
|
|
|
|
for t in self._childs:
|
|
t._parse_transformations()
|
|
|
|
def _handle_transformation(self, m):
|
|
no = int(m.group(1))
|
|
search = m.group(2)
|
|
replace = m.group(3)
|
|
options = m.group(4)
|
|
|
|
start_pos, end_pos = m.span()
|
|
start, end = self._get_start_end(self._v,start_pos,end_pos)
|
|
|
|
self._overwrite_area(*m.span())
|
|
|
|
return Transformation(self._p, no, start, end, search, replace, options)
|
|
|
|
#####################
|
|
# MIRRORS OR TS: $1 #
|
|
#####################
|
|
def _parse_mirrors_or_ts(self):
|
|
for m in self._MIRROR_OR_TS.finditer(self._v):
|
|
self._handle_ts_or_mirror(m)
|
|
|
|
for t in self._childs:
|
|
t._parse_mirrors_or_ts()
|
|
|
|
def _handle_ts_or_mirror(self, m):
|
|
no = int(m.group(1))
|
|
|
|
start_pos, end_pos = m.span()
|
|
start, end = self._get_start_end(self._v,start_pos,end_pos)
|
|
|
|
ts = self._p._get_tabstop(self._p, no)
|
|
if ts is not None:
|
|
rv = Mirror(self._p, ts, start, end)
|
|
else:
|
|
rv = TabStop(self._p, start, end)
|
|
self._p._add_tabstop(no,rv)
|
|
|
|
self._overwrite_area(*m.span())
|
|
|
|
return rv
|
|
|
|
###################
|
|
# Resolve symbols #
|
|
###################
|
|
def _finish(self):
|
|
for c in self._childs:
|
|
c._finish()
|
|
|
|
for t in self._trans:
|
|
ts = self._p._get_tabstop(self._p,t._ts)
|
|
if ts is None:
|
|
raise RuntimeError, "Tabstop %i is not known" % t._ts
|
|
t._ts = ts
|
|
|
|
####################
|
|
# Helper functions #
|
|
####################
|
|
def _get_start_end(self, val, start_pos, end_pos):
|
|
def _get_pos(s, pos):
|
|
line_idx = s[:pos].count('\n')
|
|
line_start = s[:pos].rfind('\n') + 1
|
|
start_in_line = pos - line_start
|
|
return Position(line_idx, start_in_line)
|
|
|
|
return _get_pos(val, start_pos), _get_pos(val, end_pos)
|
|
|
|
def _overwrite_area(self, s, e):
|
|
"""Overwrite the given span with spaces"""
|
|
self._v = self._v[:s] + (e-s)*" " + self._v[e:]
|
|
|
|
|
|
|
|
###########################################################################
|
|
# Public classes #
|
|
###########################################################################
|
|
|
|
class TextObject(object):
|
|
"""
|
|
This base class represents any object in the text
|
|
that has a span in any ways
|
|
"""
|
|
def __init__(self, parent, start, end, initial_text):
|
|
self._start = start
|
|
self._end = end
|
|
|
|
self._parent = parent
|
|
|
|
self._children = []
|
|
self._tabstops = {}
|
|
|
|
if parent is not None:
|
|
parent._add_child(self)
|
|
|
|
self._current_text = TextBuffer(initial_text)
|
|
|
|
self._cts = 0
|
|
|
|
def __cmp__(self, other):
|
|
return cmp(self._start, other._start)
|
|
|
|
|
|
##############
|
|
# PROPERTIES #
|
|
##############
|
|
def current_text():
|
|
def fget(self):
|
|
return str(self._current_text)
|
|
def fset(self, text):
|
|
self._current_text = TextBuffer(text)
|
|
|
|
# All our children are set to "" so they
|
|
# do no longer disturb anything that mirrors it
|
|
for c in self._children:
|
|
c.current_text = ""
|
|
self._children = []
|
|
self._tabstops = {}
|
|
return locals()
|
|
|
|
current_text = property(**current_text())
|
|
def abs_start(self):
|
|
if self._parent:
|
|
ps = self._parent.abs_start
|
|
if self._start.line == 0:
|
|
return ps + self._start
|
|
else:
|
|
return Position(ps.line + self._start.line, self._start.col)
|
|
return self._start
|
|
abs_start = property(abs_start)
|
|
|
|
def abs_end(self):
|
|
if self._parent:
|
|
ps = self._parent.abs_start
|
|
if self._end.line == 0:
|
|
return ps + self._end
|
|
else:
|
|
return Position(ps.line + self._end.line, self._end.col)
|
|
|
|
return self._end
|
|
abs_end = property(abs_end)
|
|
|
|
def span(self):
|
|
return Span(self._start, self._end)
|
|
span = property(span)
|
|
|
|
def start(self):
|
|
return self._start
|
|
start = property(start)
|
|
|
|
def end(self):
|
|
return self._end
|
|
end = property(end)
|
|
|
|
def abs_span(self):
|
|
return Span(self.abs_start, self.abs_end)
|
|
abs_span = property(abs_span)
|
|
|
|
####################
|
|
# Public functions #
|
|
####################
|
|
def update(self):
|
|
for idx,c in enumerate(self._children):
|
|
oldend = Position(c.end.line, c.end.col)
|
|
|
|
new_end = c.update()
|
|
|
|
moved_lines = new_end.line - oldend.line
|
|
moved_cols = new_end.col - oldend.col
|
|
|
|
self._current_text.replace_text(c.start, oldend, c._current_text)
|
|
|
|
self._move_textobjects_behind(c.start, oldend, moved_lines,
|
|
moved_cols, idx)
|
|
|
|
self._do_update()
|
|
|
|
new_end = self._current_text.calc_end(self._start)
|
|
|
|
self._end = new_end
|
|
|
|
return new_end
|
|
|
|
def _get_next_tab(self, no):
|
|
if not len(self._tabstops.keys()):
|
|
return
|
|
tno_max = max(self._tabstops.keys())
|
|
|
|
posible_sol = []
|
|
i = no + 1
|
|
while i <= tno_max:
|
|
if i in self._tabstops:
|
|
posible_sol.append( (i, self._tabstops[i]) )
|
|
break
|
|
i += 1
|
|
|
|
c = [ c._get_next_tab(no) for c in self._children ]
|
|
c = filter(lambda i: i, c)
|
|
|
|
posible_sol += c
|
|
|
|
if not len(posible_sol):
|
|
return None
|
|
|
|
return min(posible_sol)
|
|
|
|
|
|
def _get_prev_tab(self, no):
|
|
if not len(self._tabstops.keys()):
|
|
return
|
|
tno_min = min(self._tabstops.keys())
|
|
|
|
posible_sol = []
|
|
i = no - 1
|
|
while i >= tno_min and i > 0:
|
|
if i in self._tabstops:
|
|
posible_sol.append( (i, self._tabstops[i]) )
|
|
break
|
|
i -= 1
|
|
|
|
c = [ c._get_prev_tab(no) for c in self._children ]
|
|
c = filter(lambda i: i, c)
|
|
|
|
posible_sol += c
|
|
|
|
if not len(posible_sol):
|
|
return None
|
|
|
|
return max(posible_sol)
|
|
|
|
|
|
###############################
|
|
# Private/Protected functions #
|
|
###############################
|
|
def _do_update(self):
|
|
pass
|
|
|
|
def _move_textobjects_behind(self, start, end, lines, cols, obj_idx):
|
|
if lines == 0 and cols == 0:
|
|
return
|
|
|
|
for idx,m in enumerate(self._children[obj_idx+1:]):
|
|
delta_lines = 0
|
|
delta_cols_begin = 0
|
|
delta_cols_end = 0
|
|
|
|
if m.start.line > end.line:
|
|
delta_lines = lines
|
|
elif m.start.line == end.line:
|
|
if m.start.col >= end.col:
|
|
if lines:
|
|
delta_lines = lines
|
|
delta_cols_begin = cols
|
|
if m.start.line == m.end.line:
|
|
delta_cols_end = cols
|
|
m.start.line += delta_lines
|
|
m.end.line += delta_lines
|
|
m.start.col += delta_cols_begin
|
|
m.end.col += delta_cols_end
|
|
|
|
def _get_tabstop(self, requester, no):
|
|
if no in self._tabstops:
|
|
return self._tabstops[no]
|
|
for c in self._children:
|
|
if c == requester:
|
|
continue
|
|
|
|
rv = c._get_tabstop(self, no)
|
|
if rv is not None:
|
|
return rv
|
|
|
|
if self._parent and requester != self._parent:
|
|
return self._parent._get_tabstop(self, no)
|
|
|
|
def _add_child(self,c):
|
|
self._children.append(c)
|
|
self._children.sort()
|
|
|
|
def _add_tabstop(self, no, ts):
|
|
self._tabstops[no] = ts
|
|
|
|
|
|
|
|
class StartMarker(TextObject):
|
|
"""
|
|
This class only remembers it's starting position. It is used to
|
|
transform relative values into absolute position values in the vim
|
|
buffer
|
|
"""
|
|
def __init__(self, start):
|
|
end = Position(start.line, start.col)
|
|
TextObject.__init__(self, None, start, end, "")
|
|
|
|
|
|
class Mirror(TextObject):
|
|
"""
|
|
A Mirror object mirrors a TabStop that is, text is repeated here
|
|
"""
|
|
def __init__(self, parent, ts, start, end):
|
|
TextObject.__init__(self, parent, start, end, "")
|
|
|
|
self._ts = ts
|
|
|
|
def _do_update(self):
|
|
self.current_text = self._ts.current_text
|
|
|
|
def __repr__(self):
|
|
return "Mirror(%s -> %s)" % (self._start, self._end)
|
|
|
|
|
|
class Transformation(Mirror):
|
|
def __init__(self, parent, ts, start, end, s, r, options):
|
|
Mirror.__init__(self, parent, ts, start, end)
|
|
|
|
flags = 0
|
|
self._match_this_many = 1
|
|
if options:
|
|
if "g" in options:
|
|
self._match_this_many = 0
|
|
if "i" in options:
|
|
flags |= re.IGNORECASE
|
|
|
|
self._find = re.compile(s, flags)
|
|
self._replace = _CleverReplace(r)
|
|
|
|
def _do_update(self):
|
|
t = self._ts.current_text
|
|
t = self._find.subn(self._replace.replace, t, self._match_this_many)[0]
|
|
self.current_text = t
|
|
|
|
def __repr__(self):
|
|
return "Transformation(%s -> %s)" % (self._start, self._end)
|
|
|
|
|
|
class TabStop(TextObject):
|
|
"""
|
|
This is the most important TextObject. A TabStop is were the cursor
|
|
comes to rest when the user taps through the Snippet.
|
|
"""
|
|
def __init__(self, parent, start, end, default_text = ""):
|
|
TextObject.__init__(self, parent, start, end, default_text)
|
|
|
|
def __repr__(self):
|
|
return "TabStop(%s -> %s, %s)" % (self._start, self._end,
|
|
repr(self._current_text))
|
|
|
|
class SnippetInstance(TextObject):
|
|
"""
|
|
A Snippet instance is an instance of a Snippet Definition. That is,
|
|
when the user expands a snippet, a SnippetInstance is created to
|
|
keep track of the corresponding TextObjects. The Snippet itself is
|
|
also a TextObject because it has a start an end
|
|
"""
|
|
|
|
def __init__(self, parent, initial_text):
|
|
start = Position(0,0)
|
|
end = Position(0,0)
|
|
|
|
TextObject.__init__(self, parent, start, end, initial_text)
|
|
|
|
_TOParser(self, initial_text).parse()
|
|
|
|
TextObject.update(self)
|
|
|
|
# Check if we have a zero Tab, if not, add one at the end
|
|
if 0 not in self._tabstops:
|
|
delta = self._end - self._start
|
|
col = self.end.col
|
|
if delta.line == 0:
|
|
col -= self.start.col
|
|
start = Position(delta.line, col)
|
|
end = Position(delta.line, col)
|
|
ts = TabStop(self, start, end, "")
|
|
self._add_tabstop(0,ts)
|
|
|
|
TextObject.update(self)
|
|
|
|
def __repr__(self):
|
|
return "SnippetInstance(%s -> %s)" % (self._start, self._end)
|
|
|
|
|
|
def _get_tabstop(self, requester, no):
|
|
# SnippetInstances are completly self contained,
|
|
# therefore, we do not need to ask our parent
|
|
# for Tabstops
|
|
# TODO: otherwise, this code is identical to
|
|
# TextObject._get_tabstop
|
|
if no in self._tabstops:
|
|
return self._tabstops[no]
|
|
for c in self._children:
|
|
if c == requester:
|
|
continue
|
|
|
|
rv = c._get_tabstop(self, no)
|
|
if rv is not None:
|
|
return rv
|
|
|
|
def select_next_tab(self, backwards = False):
|
|
if self._cts is None:
|
|
return
|
|
|
|
if backwards:
|
|
cts_bf = self._cts
|
|
|
|
res = self._get_prev_tab(self._cts)
|
|
if res is None:
|
|
self._cts = cts_bf
|
|
return self._tabstops[self._cts]
|
|
self._cts, ts = res
|
|
return ts
|
|
else:
|
|
res = self._get_next_tab(self._cts)
|
|
if res is None:
|
|
self._cts = None
|
|
if 0 in self._tabstops:
|
|
return self._tabstops[0]
|
|
else:
|
|
self._cts, ts = res
|
|
return ts
|
|
|
|
return self._tabstops[self._cts]
|
|
|
|
|