merge codecheck clean

Author: RonnyPfannschmidt

.hgignore

@@ -1,4 +1,5 @@
 dist/
 build/
+.cache/
 \.tox/
 .*\.egg-info

pyrepl/_minimal_curses.py

@@ -9,7 +9,8 @@
 hide this one if compiled in.
 """
 
-import ctypes, ctypes.util
+import ctypes.util
+
 
 class error(Exception):
     pass
@@ -42,8 +43,12 @@ def _find_clib():
 
 # ____________________________________________________________
 
-try: from __pypy__ import builtinify
-except ImportError: builtinify = lambda f: f
+try:
+    from __pypy__ import builtinify
+    builtinify  # silence broken pyflakes
+except ImportError:
+    builtinify = lambda f: f
+
 
 @builtinify
 def setupterm(termstr, fd):
@@ -52,6 +57,7 @@ def setupterm(termstr, fd):
     if result == ERR:
         raise error("setupterm() failed (err=%d)" % err.value)
 
+
 @builtinify
 def tigetstr(cap):
     if not isinstance(cap, bytes):
@@ -61,6 +67,7 @@ def tigetstr(cap):
         return None
     return ctypes.cast(result, ctypes.c_char_p).value
 
+
 @builtinify
 def tparm(str, i1=0, i2=0, i3=0, i4=0, i5=0, i6=0, i7=0, i8=0, i9=0):
     result = clib.tparm(str, i1, i2, i3, i4, i5, i6, i7, i8, i9)

pyrepl/cmdrepl.py

@@ -35,26 +35,28 @@
 
 from __future__ import print_function
 
-from pyrepl import completing_reader as cr, reader, completer
+from pyrepl import completer
 from pyrepl.completing_reader import CompletingReader as CR
 import cmd
 
+
 class CmdReader(CR):
     def collect_keymap(self):
         return super(CmdReader, self).collect_keymap() + (
             ("\\M-\\n", "invalid-key"),
             ("\\n", "accept"))
-    
-    CR_init = CR.__init__
+
     def __init__(self, completions):
-        self.CR_init(self)
+        super(CmdReader, self).__init__()
         self.completions = completions
 
     def get_completions(self, stem):
         if len(stem) != self.pos:
             return []
-        return sorted(set(s for s in self.completions
-                           if s.startswith(stem)))
+        return sorted(set(s
+                          for s in self.completions
+                          if s.startswith(stem)))
+
 
 def replize(klass, history_across_invocations=1):
 
@@ -71,26 +73,25 @@ def replize(klass, history_across_invocations=1):
                    for s in completer.get_class_members(klass)
                    if s.startswith("do_")]
 
-    if not issubclass(klass, cmd.Cmd):
-        raise Exception
+    assert issubclass(klass, cmd.Cmd)
 #    if klass.cmdloop.im_class is not cmd.Cmd:
 #        print "this may not work"
 
-    class CmdRepl(klass):
-        k_init = klass.__init__
-
-        if history_across_invocations:
-            _CmdRepl__history = []
-            def __init__(self, *args, **kw):
-                self.k_init(*args, **kw)
-                self.__reader = CmdReader(completions)
-                self.__reader.history = CmdRepl._CmdRepl__history
-                self.__reader.historyi = len(CmdRepl._CmdRepl__history)
-        else:
-            def __init__(self, *args, **kw):
-                self.k_init(*args, **kw)
-                self.__reader = CmdReader(completions)
-        
+    class MultiHist(object):
+        __history = []
+
+        def __init__(self, *args, **kw):
+            super(MultiHist, self).__init__(*args, **kw)
+            self.__reader = CmdReader(completions)
+            self.__reader.history = self.__history
+            self.__reader.historyi = len(self.__history)
+
+    class SimpleHist(object):
+        def __init__(self, *args, **kw):
+            super(SimpleHist, self).__init__(*args, **kw)
+            self.__reader = CmdReader(completions)
+
+    class CmdLoopMixin(object):
         def cmdloop(self, intro=None):
             self.preloop()
             if intro is not None:
@@ -113,6 +114,8 @@ def cmdloop(self, intro=None):
                 stop = self.postcmd(stop, line)
             self.postloop()
 
-    CmdRepl.__name__ = "replize(%s.%s)"%(klass.__module__, klass.__name__)
-    return CmdRepl
+    hist = MultiHist if history_across_invocations else SimpleHist
 
+    class CmdRepl(hist, CmdLoopMixin, klass):
+        __name__ = "replize(%s.%s)" % (klass.__module__, klass.__name__)
+    return CmdRepl

pyrepl/completer.py

@@ -19,10 +19,12 @@
 
 try:
     import __builtin__ as builtins
+    builtins  # silence broken pyflakes
 except ImportError:
     import builtins
 
-class Completer:
+
+class Completer(object):
     def __init__(self, ns):
         self.ns = ns
 
@@ -79,11 +81,10 @@ def attr_matches(self, text):
                 matches.append("%s.%s" % (expr, word))
         return matches
 
+
 def get_class_members(klass):
     ret = dir(klass)
     if hasattr(klass, '__bases__'):
         for base in klass.__bases__:
             ret = ret + get_class_members(base)
     return ret
-
-

pyrepl/completing_reader.py

@@ -18,11 +18,12 @@
 # CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 # CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
+import re
 from pyrepl import commands, reader
 from pyrepl.reader import Reader
 
 
-def prefix(wordlist, j = 0):
+def prefix(wordlist, j=0):
     d = {}
     i = j
     try:
@@ -36,14 +37,18 @@ def prefix(wordlist, j = 0):
     except IndexError:
         return wordlist[0][j:i]
 
-import re
+
+STRIPCOLOR_REGEX = re.compile(r"\x1B\[([0-9]{1,3}(;[0-9]{1,2})?)?[m|K]")
+
+
 def stripcolor(s):
-    return stripcolor.regexp.sub('', s)
-stripcolor.regexp = re.compile(r"\x1B\[([0-9]{1,3}(;[0-9]{1,2})?)?[m|K]")
+    return STRIPCOLOR_REGEX.regexp.sub('', s)
+
 
 def real_len(s):
     return len(stripcolor(s))
 
+
 def left_align(s, maxlen):
     stripped = stripcolor(s)
     if len(stripped) > maxlen:
@@ -52,6 +57,7 @@ def left_align(s, maxlen):
     padding = maxlen - len(stripped)
     return s + ' '*padding
 
+
 def build_menu(cons, wordlist, start, use_brackets, sort_in_column):
     if use_brackets:
         item = "[ %s ]"
@@ -66,14 +72,14 @@ def build_menu(cons, wordlist, start, use_brackets, sort_in_column):
     if sort_in_column:
         # sort_in_column=False (default)     sort_in_column=True
         #          A B C                       A D G
-        #          D E F                       B E 
+        #          D E F                       B E
         #          G                           C F
         #
         # "fill" the table with empty words, so we always have the same amout
         # of rows for each column
         missing = cols*rows - len(wordlist)
         wordlist = wordlist + ['']*missing
-        indexes = [(i%cols)*rows + i//cols for i in range(len(wordlist))]
+        indexes = [(i % cols) * rows + i // cols for i in range(len(wordlist))]
         wordlist = [wordlist[i] for i in indexes]
     menu = []
     i = start
@@ -84,14 +90,14 @@ def build_menu(cons, wordlist, start, use_brackets, sort_in_column):
             i += 1
             if i >= len(wordlist):
                 break
-        menu.append( ''.join(row) )
+        menu.append(''.join(row))
         if i >= len(wordlist):
             i = 0
             break
         if r + 5 > cons.height:
-            menu.append("   %d more... "%(len(wordlist) - i))
+            menu.append("   %d more... " % (len(wordlist) - i))
             break
-    return menu, i    
+    return menu, i
 
 # this gets somewhat user interface-y, and as a result the logic gets
 # very convoluted.
@@ -118,7 +124,7 @@ def build_menu(cons, wordlist, start, use_brackets, sort_in_column):
 # only if the ``assume_immutable_completions`` is True.
 #
 # now it gets complicated.
-# 
+#
 # for the first press of a completion key:
 #  if there's a common prefix, stick it in.
 
@@ -140,30 +146,30 @@ def build_menu(cons, wordlist, start, use_brackets, sort_in_column):
 # for subsequent bangs, rotate the menu around (if there are sufficient
 # choices).
 
+
 class complete(commands.Command):
     def do(self):
         r = self.reader
+        last_is_completer = r.last_command_is(self.__class__)
+        immutable_completions = r.assume_immutable_completions
+        completions_unchangable = last_is_completer and immutable_completions
         stem = r.get_stem()
-        if r.assume_immutable_completions and \
-                r.last_command_is(self.__class__):
-            completions = r.cmpltn_menu_choices
-        else:
-            r.cmpltn_menu_choices = completions = \
-                                        r.get_completions(stem)
-        if len(completions) == 0:
+        if not completions_unchangable:
+            r.cmpltn_menu_choices = r.get_completions(stem)
+
+        completions = r.cmpltn_menu_choices
+        if not completions:
             r.error("no matches")
         elif len(completions) == 1:
-            if r.assume_immutable_completions and \
-                   len(completions[0]) == len(stem) and \
-                   r.last_command_is(self.__class__):
+            if completions_unchangable and len(completions[0]) == len(stem):
                 r.msg = "[ sole completion ]"
                 r.dirty = 1
             r.insert(completions[0][len(stem):])
         else:
             p = prefix(completions, len(stem))
             if p:
                 r.insert(p)
-            if r.last_command_is(self.__class__):
+            if last_is_completer:
                 if not r.cmpltn_menu_vis:
                     r.cmpltn_menu_vis = 1
                 r.cmpltn_menu, r.cmpltn_menu_end = build_menu(
@@ -177,6 +183,7 @@ def do(self):
                 r.msg = "[ not unique ]"
                 r.dirty = 1
 
+
 class self_insert(commands.self_insert):
     def do(self):
         commands.self_insert.do(self)
@@ -195,6 +202,7 @@ def do(self):
                 else:
                     r.cmpltn_reset()
 
+
 class CompletingReader(Reader):
     """Adds completion support
 
@@ -204,26 +212,25 @@ class CompletingReader(Reader):
     """
     # see the comment for the complete command
     assume_immutable_completions = True
-    use_brackets = True # display completions inside []
+    use_brackets = True  # display completions inside []
     sort_in_column = False
-    
+
     def collect_keymap(self):
         return super(CompletingReader, self).collect_keymap() + (
             (r'\t', 'complete'),)
-    
+
     def __init__(self, console):
         super(CompletingReader, self).__init__(console)
         self.cmpltn_menu = ["[ menu 1 ]", "[ menu 2 ]"]
         self.cmpltn_menu_vis = 0
         self.cmpltn_menu_end = 0
-        for c in [complete, self_insert]:
+        for c in (complete, self_insert):
             self.commands[c.__name__] = c
-            self.commands[c.__name__.replace('_', '-')] = c        
+            self.commands[c.__name__.replace('_', '-')] = c
 
     def after_command(self, cmd):
         super(CompletingReader, self).after_command(cmd)
-        if not isinstance(cmd, self.commands['complete']) \
-           and not isinstance(cmd, self.commands['self_insert']):
+        if not isinstance(cmd, (complete, self_insert)):
             self.cmpltn_reset()
 
     def calc_screen(self):
@@ -243,7 +250,7 @@ def cmpltn_reset(self):
         self.cmpltn_menu = []
         self.cmpltn_menu_vis = 0
         self.cmpltn_menu_end = 0
-        self.cmpltn_menu_choices = []        
+        self.cmpltn_menu_choices = []
 
     def get_stem(self):
         st = self.syntax_table
@@ -257,11 +264,14 @@ def get_stem(self):
     def get_completions(self, stem):
         return []
 
+
 def test():
     class TestReader(CompletingReader):
         def get_completions(self, stem):
-            return [s for l in map(lambda x:x.split(),self.history)
-                    for s in l if s and s.startswith(stem)]
+            return [s for l in self.history
+                    for s in l.split()
+                    if s and s.startswith(stem)]
+
     reader = TestReader()
     reader.ps1 = "c**> "
     reader.ps2 = "c/*> "
@@ -270,5 +280,6 @@ def get_completions(self, stem):
     while reader.readline():
         pass
 
-if __name__=='__main__':
+
+if __name__ == '__main__':
     test()