From a66965446602733fc0c0f41192c8d881bd93b017 Mon Sep 17 00:00:00 2001 From: Holger Rapp Date: Sat, 8 Feb 2014 10:51:31 +0100 Subject: [PATCH] More linting done. --- pylintrc | 1 + pythonx/UltiSnips/indent_util.py | 22 +- pythonx/UltiSnips/text_objects/_base.py | 251 ++++++++++-------- pythonx/UltiSnips/text_objects/_mirror.py | 4 +- .../UltiSnips/text_objects/_python_code.py | 6 +- pythonx/UltiSnips/text_objects/_shell_code.py | 3 +- .../text_objects/_snippet_instance.py | 14 +- pythonx/UltiSnips/text_objects/_viml_code.py | 3 +- pythonx/UltiSnips/text_objects/_visual.py | 2 +- 9 files changed, 160 insertions(+), 146 deletions(-) diff --git a/pylintrc b/pylintrc index 156e2b6..47439b3 100644 --- a/pylintrc +++ b/pylintrc @@ -43,6 +43,7 @@ disable= too-many-public-methods, too-few-public-methods, too-many-branches, + too-many-statements, [REPORTS] diff --git a/pythonx/UltiSnips/indent_util.py b/pythonx/UltiSnips/indent_util.py index 78ef1d5..769af7e 100644 --- a/pythonx/UltiSnips/indent_util.py +++ b/pythonx/UltiSnips/indent_util.py @@ -1,39 +1,39 @@ #!/usr/bin/env python # encoding: utf-8 -import os +"""See module doc.""" import UltiSnips._vim as _vim class IndentUtil(object): - """ Utility class for dealing properly with indentation. """ + """Utility class for dealing properly with indentation. """ def __init__(self): self.reset() def reset(self): """ Gets the spacing properties from Vim. """ - self.sw = int(_vim.eval("&sw")) - self.sts = int(_vim.eval("&sts")) - self.et = (_vim.eval("&expandtab") == "1") - self.ts = int(_vim.eval("&ts")) + self.shiftwidth = int(_vim.eval("&shiftwidth")) + self._expandtab = (_vim.eval("&expandtab") == "1") + self._tabstop = int(_vim.eval("&tabstop")) def ntabs_to_proper_indent(self, ntabs): - line_ind = ntabs * self.sw * " " + """Convert 'ntabs' number of tabs to the proper indent prefix.""" + line_ind = ntabs * self.shiftwidth * " " line_ind = self.indent_to_spaces(line_ind) line_ind = self.spaces_to_indent(line_ind) return line_ind def indent_to_spaces(self, indent): """ Converts indentation to spaces respecting Vim settings. """ - indent = indent.expandtabs(self.ts) + indent = indent.expandtabs(self._tabstop) right = (len(indent) - len(indent.rstrip(" "))) * " " indent = indent.replace(" ", "") - indent = indent.replace('\t', " " * self.ts) + indent = indent.replace('\t', " " * self._tabstop) return indent + right def spaces_to_indent(self, indent): """ Converts spaces to proper indentation respecting Vim settings """ - if not self.et: - indent = indent.replace(" " * self.ts, '\t') + if not self._expandtab: + indent = indent.replace(" " * self._tabstop, '\t') return indent diff --git a/pythonx/UltiSnips/text_objects/_base.py b/pythonx/UltiSnips/text_objects/_base.py index 76289a3..2af825b 100755 --- a/pythonx/UltiSnips/text_objects/_base.py +++ b/pythonx/UltiSnips/text_objects/_base.py @@ -1,16 +1,19 @@ #!/usr/bin/env python # encoding: utf-8 +"""Base classes for all text objects.""" + import UltiSnips._vim as _vim from UltiSnips.geometry import Position __all__ = ["TextObject", "EditableTextObject", "NoneditableTextObject"] -def _calc_end(lines, start): - if len(lines) == 1: - new_end = start + Position(0,len(lines[0])) +def _calc_end(text, start): + """Calculate the end position of the 'text' starting at 'start.""" + if len(text) == 1: + new_end = start + Position(0, len(text[0])) else: - new_end = Position(start.line + len(lines)-1, len(lines[-1])) + new_end = Position(start.line + len(text)-1, len(text[-1])) return new_end def _text_to_vim(start, end, text): @@ -38,14 +41,12 @@ def _text_to_vim(start, end, text): class TextObject(object): - """ - This base class represents any object in the text - that has a span in any ways - """ - def __init__(self, parent, token, end = None, initial_text = "", tiebreaker = None): + """Represents any object in the text that has a span in any ways.""" + + def __init__(self, parent, token, end=None, + initial_text="", tiebreaker=None): self._parent = parent - ct = None if end is not None: # Took 4 arguments self._start = token self._end = end @@ -54,41 +55,29 @@ class TextObject(object): self._start = token.start self._end = token.end self._initial_text = token.initial_text - self._tiebreaker = tiebreaker or Position(self._start.line, self._end.line) - + self._tiebreaker = tiebreaker or Position( + self._start.line, self._end.line) if parent is not None: parent._add_child(self) - def overwrite(self, gtext = None): - """ - Overwrite the text of this object in the Vim Buffer and update its - length information - """ - # We explicitly do not want to move our childs around here as we - # either have non or we are replacing text initially which means we do - # not want to mess with their positions - if self.current_text == gtext: return - old_end = self._end - self._end = _text_to_vim( - self._start, self._end, gtext or self._initial_text) - if self._parent: - self._parent._child_has_moved( - self._parent._childs.index(self), min(old_end, self._end), - self._end.diff(old_end) - ) + def _move(self, pivot, diff): + """Move this object by 'diff' while 'pivot' is the point of change.""" + self._start.move(pivot, diff) + self._end.move(pivot, diff) def __lt__(self, other): - me = (self._start.line, self._start.col, + me_tuple = (self.start.line, self.start.col, self._tiebreaker.line, self._tiebreaker.col) - o = (other._start.line, other._start.col, + other_tuple = (other._start.line, other._start.col, other._tiebreaker.line, other._tiebreaker.col) - return me < o + return me_tuple < other_tuple + def __le__(self, other): - me = (self._start.line, self._start.col, + me_tuple = (self._start.line, self._start.col, self._tiebreaker.line, self._tiebreaker.col) - o = (other._start.line, other._start.col, + other_tuple = (other._start.line, other._start.col, other._tiebreaker.line, other._tiebreaker.col) - return me <= o + return me_tuple <= other_tuple def __repr__(self): ct = "" @@ -100,11 +89,9 @@ class TextObject(object): return "%s(%r->%r,%r)" % (self.__class__.__name__, self._start, self._end, ct) - ############## - # PROPERTIES # - ############## @property def current_text(self): + """The current text of this object.""" if self._start.line == self._end.line: return _vim.buf[self._start.line][self._start.col:self._end.col] else: @@ -113,20 +100,35 @@ class TextObject(object): lines.append(_vim.buf[self._end.line][:self._end.col]) return '\n'.join(lines) + @property def start(self): + """The start position.""" return self._start - start = property(start) + @property def end(self): + """The end position.""" return self._end - end = property(end) - #################### - # Public functions # - #################### - def _move(self, pivot, diff): - self._start.move(pivot, diff) - self._end.move(pivot, diff) + def overwrite(self, gtext=None): + """Overwrite the text of this object in the Vim Buffer and update its + length information. If 'gtext' is None use the initial text of this + object. + """ + # We explicitly do not want to move our childs around here as we + # either have non or we are replacing text initially which means we do + # not want to mess with their positions + if self.current_text == gtext: + return + old_end = self._end + self._end = _text_to_vim( + self._start, self._end, gtext or self._initial_text) + if self._parent: + self._parent._child_has_moved( + self._parent._childs.index(self), min(old_end, self._end), + self._end.diff(old_end) + ) + class EditableTextObject(TextObject): """ @@ -144,73 +146,84 @@ class EditableTextObject(TextObject): ############## @property def _editable_childs(self): - return [ c for c in self._childs if isinstance(c, EditableTextObject) ] + """All childs that are EditableTextObject s""" + return [child for child in self._childs if + isinstance(child, EditableTextObject)] #################### # Public Functions # #################### def find_parent_for_new_to(self, pos): - for c in self._editable_childs: - if (c._start <= pos < c._end): - return c.find_parent_for_new_to(pos) + """Figure out the parent object for something at 'pos'.""" + for childs in self._editable_childs: + if childs._start <= pos < childs._end: + return childs.find_parent_for_new_to(pos) return self ############################### # Private/Protected functions # ############################### def _do_edit(self, cmd): + """Apply the edit 'cmd' to this object.""" ctype, line, col, text = cmd - assert( ('\n' not in text) or (text == "\n")) + assert ('\n' not in text) or (text == "\n") pos = Position(line, col) to_kill = set() new_cmds = [] - for c in self._childs: + for child in self._childs: if ctype == "I": # Insertion - if c._start < pos < Position(c._end.line, c._end.col) and isinstance(c, NoneditableTextObject): - to_kill.add(c) + if (child._start < pos < + Position(child._end.line, child._end.col) and + isinstance(child, NoneditableTextObject)): + to_kill.add(child) new_cmds.append(cmd) break - elif (c._start <= pos <= c._end) and isinstance(c, EditableTextObject): - c._do_edit(cmd) + elif ((child._start <= pos <= child._end) and + isinstance(child, EditableTextObject)): + child._do_edit(cmd) return else: # Deletion delend = pos + Position(0, len(text)) if text != "\n" \ else Position(line + 1, 0) - if (c._start <= pos < c._end) and (c._start < delend <= c._end): + if ((child._start <= pos < child._end) and + (child._start < delend <= child._end)): # this edit command is completely for the child - if isinstance(c, NoneditableTextObject): - to_kill.add(c) + if isinstance(child, NoneditableTextObject): + to_kill.add(child) new_cmds.append(cmd) break else: - c._do_edit(cmd) + child._do_edit(cmd) return - elif (pos < c._start and c._end <= delend) or (pos <= c._start and c._end < delend): + elif ((pos < child._start and child._end <= delend) or + (pos <= child._start and child._end < delend)): # Case: this deletion removes the child - to_kill.add(c) + to_kill.add(child) new_cmds.append(cmd) break - elif (pos < c._start and (c._start < delend <= c._end)): + elif (pos < child._start and + (child._start < delend <= child._end)): # Case: partially for us, partially for the child - my_text = text[:(c._start-pos).col] - c_text = text[(c._start-pos).col:] + my_text = text[:(child._start-pos).col] + c_text = text[(child._start-pos).col:] new_cmds.append((ctype, line, col, my_text)) new_cmds.append((ctype, line, col, c_text)) break - elif (delend >= c._end and (c._start <= pos < c._end)): + elif (delend >= child._end and ( + child._start <= pos < child._end)): # Case: partially for us, partially for the child - c_text = text[(c._end-pos).col:] - my_text = text[:(c._end-pos).col] + c_text = text[(child._end-pos).col:] + my_text = text[:(child._end-pos).col] new_cmds.append((ctype, line, col, c_text)) new_cmds.append((ctype, line, col, my_text)) break - for c in to_kill: - self._del_child(c) + for child in to_kill: + self._del_child(child) if len(new_cmds): - for c in new_cmds: - self._do_edit(c) + for child in new_cmds: + self._do_edit(child) return # We have to handle this ourselves @@ -222,45 +235,48 @@ class EditableTextObject(TextObject): delta.col *= -1 pivot = Position(line, col) idx = -1 - for cidx, c in enumerate(self._childs): - if c._start < pivot <= c._end: + for cidx, child in enumerate(self._childs): + if child._start < pivot <= child._end: idx = cidx self._child_has_moved(idx, pivot, delta) def _move(self, pivot, diff): TextObject._move(self, pivot, diff) - for c in self._childs: - c._move(pivot, diff) + for child in self._childs: + child._move(pivot, diff) def _child_has_moved(self, idx, pivot, diff): + """Called when a the child with 'idx' has moved behind 'pivot' by + 'diff'.""" self._end.move(pivot, diff) - for c in self._childs[idx+1:]: - c._move(pivot, diff) + for child in self._childs[idx+1:]: + child._move(pivot, diff) if self._parent: self._parent._child_has_moved( self._parent._childs.index(self), pivot, diff ) - def _get_next_tab(self, no): + def _get_next_tab(self, number): + """Returns the next tabstop after 'number'.""" if not len(self._tabstops.keys()): return tno_max = max(self._tabstops.keys()) possible_sol = [] - i = no + 1 + i = number + 1 while i <= tno_max: if i in self._tabstops: - possible_sol.append( (i, self._tabstops[i]) ) + possible_sol.append((i, self._tabstops[i])) break i += 1 - c = [ c._get_next_tab(no) for c in self._editable_childs ] - c = filter(lambda i: i, c) + child = [c._get_next_tab(number) for c in self._editable_childs] + child = [c for c in child if c] - possible_sol += c + possible_sol += child if not len(possible_sol): return None @@ -268,73 +284,72 @@ class EditableTextObject(TextObject): return min(possible_sol) - def _get_prev_tab(self, no): + def _get_prev_tab(self, number): + """Returns the previous tabstop before 'number'.""" if not len(self._tabstops.keys()): return tno_min = min(self._tabstops.keys()) possible_sol = [] - i = no - 1 + i = number - 1 while i >= tno_min and i > 0: if i in self._tabstops: - possible_sol.append( (i, self._tabstops[i]) ) + possible_sol.append((i, self._tabstops[i])) break i -= 1 - c = [ c._get_prev_tab(no) for c in self._editable_childs ] - c = filter(lambda i: i, c) + child = [c._get_prev_tab(number) for c in self._editable_childs] + child = [c for c in child if c] - possible_sol += c + possible_sol += child if not len(possible_sol): return None return max(possible_sol) - def _get_tabstop(self, requester, no): - if no in self._tabstops: - return self._tabstops[no] - for c in self._editable_childs: - if c is requester: + def _get_tabstop(self, requester, number): + """Returns the tabstop 'number'. 'requester' is the class that is + interested in this.""" + if number in self._tabstops: + return self._tabstops[number] + for child in self._editable_childs: + if child is requester: continue - - rv = c._get_tabstop(self, no) + rv = child._get_tabstop(self, number) if rv is not None: return rv if self._parent and requester is not self._parent: - return self._parent._get_tabstop(self, no) + return self._parent._get_tabstop(self, number) - def _update(self, done, not_done): + def _update(self, done): + """Update this object inside the Vim Buffer. + + Return False if you need to be called again for this edit cycle. + Otherwise return True. """ - Update this object inside the Vim Buffer. - - Return False if you want to be called again - for this edit cycle. Otherwise return True. - """ - if all((c in done) for c in self._childs): - assert(self not in done) - + if all((child in done) for child in self._childs): + assert self not in done done.add(self) return True - def _add_child(self,c): - self._childs.append(c) + def _add_child(self, child): + """Add 'child' as a new child of this text object.""" + self._childs.append(child) self._childs.sort() - def _del_child(self,c): - c._parent = None - self._childs.remove(c) + def _del_child(self, child): + """Delete this 'child'.""" + child._parent = None + self._childs.remove(child) # If this is a tabstop, delete it try: - del self._tabstops[c.number] + del self._tabstops[child.number] except AttributeError: pass class NoneditableTextObject(TextObject): - """ - All passive text objects that the user can't edit by hand - """ - - def _update(self, done, not_done): + """All passive text objects that the user can't edit by hand.""" + def _update(self, done): return True diff --git a/pythonx/UltiSnips/text_objects/_mirror.py b/pythonx/UltiSnips/text_objects/_mirror.py index a78caab..c1c6f04 100755 --- a/pythonx/UltiSnips/text_objects/_mirror.py +++ b/pythonx/UltiSnips/text_objects/_mirror.py @@ -12,7 +12,7 @@ class Mirror(NoneditableTextObject): self._ts = tabstop - def _update(self, done, not_done): + def _update(self, done): if self._ts.is_killed: self.overwrite("") self._parent._del_child(self) @@ -26,5 +26,3 @@ class Mirror(NoneditableTextObject): def _get_text(self): return self._ts.current_text - - diff --git a/pythonx/UltiSnips/text_objects/_python_code.py b/pythonx/UltiSnips/text_objects/_python_code.py index b2c74a2..bc5d6f6 100755 --- a/pythonx/UltiSnips/text_objects/_python_code.py +++ b/pythonx/UltiSnips/text_objects/_python_code.py @@ -54,7 +54,7 @@ class SnippetUtil(object): :amount: the amount by which to shift. """ - self.indent += " " * self._ind.sw * amount + self.indent += " " * self._ind.shiftwidth * amount def unshift(self, amount=1): """ Unshift the indentation level. @@ -63,7 +63,7 @@ class SnippetUtil(object): :amount: the amount by which to unshift. """ - by = -self._ind.sw * amount + by = -self._ind.shiftwidth * amount try: self.indent = self.indent[:by] except IndexError: @@ -194,7 +194,7 @@ class PythonCode(NoneditableTextObject): NoneditableTextObject.__init__(self, parent, token) - def _update(self, done, not_done): + def _update(self, done): path = _vim.eval('expand("%")') if path is None: path = "" diff --git a/pythonx/UltiSnips/text_objects/_shell_code.py b/pythonx/UltiSnips/text_objects/_shell_code.py index d5d886e..ae96634 100755 --- a/pythonx/UltiSnips/text_objects/_shell_code.py +++ b/pythonx/UltiSnips/text_objects/_shell_code.py @@ -55,7 +55,7 @@ class ShellCode(NoneditableTextObject): self._code = token.code.replace("\\`", "`") self._tmpdir = _get_tmp() - def _update(self, done, not_done): + def _update(self, done): if not self._tmpdir: output = "Unable to find executable tmp directory, check noexec on /tmp" else: @@ -65,4 +65,3 @@ class ShellCode(NoneditableTextObject): self._parent._del_child(self) return True - diff --git a/pythonx/UltiSnips/text_objects/_snippet_instance.py b/pythonx/UltiSnips/text_objects/_snippet_instance.py index 0ffa50b..201e63a 100755 --- a/pythonx/UltiSnips/text_objects/_snippet_instance.py +++ b/pythonx/UltiSnips/text_objects/_snippet_instance.py @@ -66,14 +66,17 @@ class SnippetInstance(EditableTextObject): counter = 10 while (done != not_done) and counter: - for obj in sorted(not_done - done): # Order matters for python locals! - if obj._update(done, not_done): + # Order matters for python locals! + for obj in sorted(not_done - done): + if obj._update(done): done.add(obj) counter -= 1 if counter == 0: - raise RuntimeError("The snippets content did not converge: Check for Cyclic dependencies " - "or random strings in your snippet. You can use 'if not snip.c' to make sure " - "to only expand random output once.") + raise RuntimeError( + "The snippets content did not converge: Check for Cyclic " + "dependencies or random strings in your snippet. You can use " + "'if not snip.c' to make sure to only expand random output " + "once.") vc.to_vim() self._del_child(vc) @@ -123,4 +126,3 @@ class _VimCursor(NoneditableTextObject): def to_vim(self): assert(self._start == self._end) _vim.buf.cursor = self._start - diff --git a/pythonx/UltiSnips/text_objects/_viml_code.py b/pythonx/UltiSnips/text_objects/_viml_code.py index 682b0b7..507872a 100755 --- a/pythonx/UltiSnips/text_objects/_viml_code.py +++ b/pythonx/UltiSnips/text_objects/_viml_code.py @@ -11,7 +11,6 @@ class VimLCode(NoneditableTextObject): NoneditableTextObject.__init__(self, parent, token) - def _update(self, done, not_done): + def _update(self, done): self.overwrite(_vim.eval(self._code)) return True - diff --git a/pythonx/UltiSnips/text_objects/_visual.py b/pythonx/UltiSnips/text_objects/_visual.py index f56a563..9a43656 100755 --- a/pythonx/UltiSnips/text_objects/_visual.py +++ b/pythonx/UltiSnips/text_objects/_visual.py @@ -33,7 +33,7 @@ class Visual(NoneditableTextObject,TextObjectTransformation): NoneditableTextObject.__init__(self, parent, token) TextObjectTransformation.__init__(self, token) - def _update(self, done, not_done): + def _update(self, done): if self._mode != "v": # Keep the indent for Line/Block Selection text_before = _vim.buf[self.start.line][:self.start.col]