Merge branch 'clean-up-completion'

thomasballinger · thomasballinger · commit 78f53049f83f · 2015-01-14T06:42:59.000+01:00
Conflicts:
	bpython/autocomplete.py
	bpython/repl.py
diff --git a/bpython/autocomplete.py b/bpython/autocomplete.py
@@ -30,6 +30,7 @@
 import re
 import os
 from glob import glob
+from functools import partial
 from bpython import inspection
 from bpython import importcompletion
 from bpython._py3compat import py3
@@ -43,7 +44,7 @@
 
 MAGIC_METHODS = ["__%s__" % s for s in [
     "init", "repr", "str", "lt", "le", "eq", "ne", "gt", "ge", "cmp", "hash",
-    "nonzero", "unicode", "getattr", "setattr", "get", "set","call", "len",
+    "nonzero", "unicode", "getattr", "setattr", "get", "set", "call", "len",
     "getitem", "setitem", "iter", "reversed", "contains", "add", "sub", "mul",
     "floordiv", "mod", "divmod", "pow", "lshift", "rshift", "and", "xor", "or",
     "div", "truediv", "neg", "pos", "abs", "invert", "complex", "int", "float",
@@ -53,61 +54,60 @@
 def after_last_dot(name):
     return name.rstrip('.').rsplit('.')[-1]
 
-def get_completer(cursor_offset, current_line, locals_, argspec, full_code, mode, complete_magic_methods):
-    """Returns a list of matches and a class for what kind of completion is happening
-
-    If no completion type is relevant, returns None, None
-
-    argspec is an output of inspect.getargspec
+def get_completer(completers, cursor_offset, line, **kwargs):
+    """Returns a list of matches and an applicable completer
+
+    If no matches available, returns a tuple of an empty list and None
+
+    kwargs (all required):
+        cursor_offset is the current cursor column
+        line is a string of the current line
+        locals_ is a dictionary of the environment
+        argspec is an inspect.ArgSpec instance for the current function where
+            the cursor is
+        current_block is the possibly multiline not-yet-evaluated block of
+            code which the current line is part of
+        mode is one of SIMPLE, SUBSTRING or FUZZY - ways to find matches
+        complete_magic_methods is a bool of whether we ought to complete
+            double underscore methods like __len__ in method signatures
     """
 
-    kwargs = {'locals_':locals_, 'argspec':argspec, 'full_code':full_code,
-              'mode':mode, 'complete_magic_methods':complete_magic_methods}
-
-    # mutually exclusive if matches: If one of these returns [], try the next one
-    for completer in [DictKeyCompletion]:
-        matches = completer.matches(cursor_offset, current_line, **kwargs)
-        if matches:
-            return sorted(set(matches)), completer
-
-    # mutually exclusive matchers: if one returns [], don't go on
-    for completer in [StringLiteralAttrCompletion, ImportCompletion,
-            FilenameCompletion, MagicMethodCompletion, GlobalCompletion]:
-        matches = completer.matches(cursor_offset, current_line, **kwargs)
+    for completer in completers:
+        matches = completer.matches(cursor_offset, line, **kwargs)
         if matches is not None:
-            return sorted(set(matches)), completer
-
-    matches = AttrCompletion.matches(cursor_offset, current_line, **kwargs)
-
-    # cumulative completions - try them all
-    # They all use current_word replacement and formatting
-    current_word_matches = []
-    for completer in [AttrCompletion, ParameterNameCompletion]:
-        matches = completer.matches(cursor_offset, current_line, **kwargs)
-        if matches is not None:
-            current_word_matches.extend(matches)
-
-    if len(current_word_matches) == 0:
-        return None, None
-    return sorted(set(current_word_matches)), AttrCompletion
+            return matches, (completer if matches else None)
+    return [], None
+
+def get_completer_bpython(**kwargs):
+    """"""
+    return get_completer([DictKeyCompletion,
+                          StringLiteralAttrCompletion,
+                          ImportCompletion,
+                          FilenameCompletion,
+                          MagicMethodCompletion,
+                          GlobalCompletion,
+                          CumulativeCompleter([AttrCompletion, ParameterNameCompletion])],
+                         **kwargs)
 
 class BaseCompletionType(object):
     """Describes different completion types"""
+    @classmethod
     def matches(cls, cursor_offset, line, **kwargs):
         """Returns a list of possible matches given a line and cursor, or None
         if this completion type isn't applicable.
 
         ie, import completion doesn't make sense if there cursor isn't after
-        an import or from statement
+        an import or from statement, so it ought to return None.
 
         Completion types are used to:
-            * `locate(cur, line)` their target word to replace given a line and cursor
+            * `locate(cur, line)` their initial target word to replace given a line and cursor
             * find `matches(cur, line)` that might replace that word
             * `format(match)` matches to be displayed to the user
             * determine whether suggestions should be `shown_before_tab`
             * `substitute(cur, line, match)` in a match for what's found with `target`
             """
         raise NotImplementedError
+    @classmethod
     def locate(cls, cursor_offset, line):
         """Returns a start, stop, and word given a line and cursor, or None
         if no target for this type of completion is found under the cursor"""
@@ -116,25 +116,58 @@ def locate(cls, cursor_offset, line):
     def format(cls, word):
         return word
     shown_before_tab = True # whether suggestions should be shown before the
-                           # user hits tab, or only once that has happened
+                            # user hits tab, or only once that has happened
     def substitute(cls, cursor_offset, line, match):
         """Returns a cursor offset and line with match swapped in"""
         start, end, word = cls.locate(cursor_offset, line)
         result = start + len(match), line[:start] + match + line[end:]
         return result
 
+class CumulativeCompleter(object):
+    """Returns combined matches from several completers"""
+    def __init__(self, completers):
+        if not completers:
+            raise ValueError("CumulativeCompleter requires at least one completer")
+        self._completers = completers
+        self.shown_before_tab = True
+
+    @property
+    def locate(self):
+        return self._completers[0].locate if self._completers else lambda *args: None
+
+    @property
+    def format(self):
+        return self._completers[0].format if self._completers else lambda s: s
+
+    def matches(self, cursor_offset, line, locals_, argspec, current_block, complete_magic_methods):
+        all_matches = []
+        for completer in self._completers:
+            # these have to be explicitely listed to deal with the different
+            # signatures of various matches() methods of completers
+            matches = completer.matches(cursor_offset=cursor_offset,
+                                        line=line,
+                                        locals_=locals_,
+                                        argspec=argspec,
+                                        current_block=current_block,
+                                        complete_magic_methods=complete_magic_methods)
+            if matches is not None:
+                all_matches.extend(matches)
+
+        return sorted(set(all_matches))
+
+
 class ImportCompletion(BaseCompletionType):
     @classmethod
-    def matches(cls, cursor_offset, current_line, **kwargs):
-        return importcompletion.complete(cursor_offset, current_line)
+    def matches(cls, cursor_offset, line, **kwargs):
+        return importcompletion.complete(cursor_offset, line)
     locate = staticmethod(lineparts.current_word)
     format = staticmethod(after_last_dot)
 
 class FilenameCompletion(BaseCompletionType):
     shown_before_tab = False
     @classmethod
-    def matches(cls, cursor_offset, current_line, **kwargs):
-        cs = lineparts.current_string(cursor_offset, current_line)
+    def matches(cls, cursor_offset, line, **kwargs):
+        cs = lineparts.current_string(cursor_offset, line)
         if cs is None:
             return None
         start, end, text = cs
@@ -160,7 +193,7 @@ def format(cls, filename):
 
 class AttrCompletion(BaseCompletionType):
     @classmethod
-    def matches(cls, cursor_offset, line, locals_, mode, **kwargs):
+    def matches(cls, cursor_offset, line, locals_, **kwargs):
         r = cls.locate(cursor_offset, line)
         if r is None:
             return None
@@ -177,7 +210,7 @@ def matches(cls, cursor_offset, line, locals_, mode, **kwargs):
                 break
         methodtext = text[-i:]
         matches = [''.join([text[:-i], m]) for m in
-                            attr_matches(methodtext, locals_, mode)]
+                            attr_matches(methodtext, locals_)]
 
         #TODO add open paren for methods via _callable_prefix (or decide not to)
         # unless the first character is a _ filter out all attributes starting with a _
@@ -213,18 +246,18 @@ def format(cls, match):
 class MagicMethodCompletion(BaseCompletionType):
     locate = staticmethod(lineparts.current_method_definition_name)
     @classmethod
-    def matches(cls, cursor_offset, line, full_code, **kwargs):
+    def matches(cls, cursor_offset, line, current_block, **kwargs):
         r = cls.locate(cursor_offset, line)
         if r is None:
             return None
-        if 'class' not in full_code:
+        if 'class' not in current_block:
             return None
         start, end, word = r
         return [name for name in MAGIC_METHODS if name.startswith(word)]
 
 class GlobalCompletion(BaseCompletionType):
     @classmethod
-    def matches(cls, cursor_offset, line, locals_, mode, **kwargs):
+    def matches(cls, cursor_offset, line, locals_, **kwargs):
         """Compute matches when text is a simple name.
         Return a list of all keywords, built-in functions and names currently
         defined in self.namespace that match.
@@ -238,11 +271,11 @@ def matches(cls, cursor_offset, line, locals_, mode, **kwargs):
         n = len(text)
         import keyword
         for word in keyword.kwlist:
-            if method_match(word, n, text, mode):
+            if method_match(word, n, text):
                 hash[word] = 1
         for nspace in [__builtin__.__dict__, locals_]:
             for word, val in nspace.items():
-                if method_match(word, len(text), text, mode) and word != "__builtins__":
+                if method_match(word, len(text), text) and word != "__builtins__":
                     hash[_callable_postfix(val, word)] = 1
         matches = hash.keys()
         matches.sort()
@@ -299,7 +332,7 @@ def safe_eval(expr, namespace):
 
 attr_matches_re = re.compile(r"(\w+(\.\w+)*)\.(\w*)")
 
-def attr_matches(text, namespace, autocomplete_mode):
+def attr_matches(text, namespace):
     """Taken from rlcompleter.py and bent to my will.
     """
 
@@ -320,10 +353,10 @@ def attr_matches(text, namespace, autocomplete_mode):
     except EvaluationError:
         return []
     with inspection.AttrCleaner(obj):
-        matches = attr_lookup(obj, expr, attr, autocomplete_mode)
+        matches = attr_lookup(obj, expr, attr)
     return matches
 
-def attr_lookup(obj, expr, attr, autocomplete_mode):
+def attr_lookup(obj, expr, attr):
     """Second half of original attr_matches method factored out so it can
     be wrapped in a safe try/finally block in case anything bad happens to
     restore the original __getattribute__ method."""
@@ -340,7 +373,7 @@ def attr_lookup(obj, expr, attr, autocomplete_mode):
     matches = []
     n = len(attr)
     for word in words:
-        if method_match(word, n, attr, autocomplete_mode) and word != "__builtins__":
+        if method_match(word, n, attr) and word != "__builtins__":
             matches.append("%s.%s" % (expr, word))
     return matches
 
@@ -351,14 +384,5 @@ def _callable_postfix(value, word):
             word += '('
     return word
 
-#TODO use method_match everywhere instead of startswith to implement other completion modes
-#     will also need to rewrite checking mode so cseq replace doesn't happen in frontends
-def method_match(word, size, text, autocomplete_mode):
-    if autocomplete_mode == SIMPLE:
-        return word[:size] == text
-    elif autocomplete_mode == SUBSTRING:
-        s = r'.*%s.*' % text
-        return re.search(s, word)
-    else:
-        s = r'.*%s.*' % '.*'.join(list(text))
-        return re.search(s, word)
+def method_match(word, size, text):
+    return word[:size] == text
diff --git a/bpython/curtsiesfrontend/repl.py b/bpython/curtsiesfrontend/repl.py
@@ -755,9 +755,12 @@ def add_normal_character(self, char):
         if self.incremental_search_mode:
             self.add_to_incremental_search(char)
         else:
-            self.current_line = (self.current_line[:self.cursor_offset] +
-                                 char +
-                                 self.current_line[self.cursor_offset:])
+            self._set_current_line((self.current_line[:self.cursor_offset] +
+                                    char +
+                                    self.current_line[self.cursor_offset:]),
+                                    update_completion=False,
+                                    reset_rl_history=False,
+                                    clear_special_mode=False)
             self.cursor_offset += 1
         if self.config.cli_trim_prompts and self.current_line.startswith(self.ps1):
             self.current_line = self.current_line[4:]
@@ -1237,14 +1240,13 @@ def _get_cursor_offset(self):
     def _set_cursor_offset(self, offset, update_completion=True, reset_rl_history=False, clear_special_mode=True):
         if self._cursor_offset == offset:
             return
-        if update_completion:
-            self.update_completion()
         if reset_rl_history:
             self.rl_history.reset()
         if clear_special_mode:
             self.incremental_search_mode = None
         self._cursor_offset = offset
-        self.update_completion()
+        if update_completion:
+            self.update_completion()
         self.unhighlight_paren()
 
     cursor_offset = property(_get_cursor_offset, _set_cursor_offset, None,
diff --git a/bpython/repl.py b/bpython/repl.py
@@ -498,8 +498,17 @@ def set_docstring(self):
                 if not self.docstring:
                     self.docstring = None
 
+    # What complete() does:
+    # Should we show the completion box? (are there matches, or is there a docstring to show?)
+    #   Some completions should always be shown, other only if tab=True
+    # set the current docstring to the "current function's" docstring
+    # Populate the matches_iter object with new matches from the current state
+    #    if none, clear the matches iterator
+    # If exactly one match that is equal to current line, clear matches
+    # If example one match and tab=True, then choose that and clear matches
+
     def complete(self, tab=False):
-        """Construct a full list of possible completions and construct and
+        """Construct a full list of possible completions and
         display them in a window. Also check if there's an available argspec
         (via the inspect module) and bang that on top of the completions too.
         The return value is whether the list_win is visible or not.
@@ -513,35 +522,30 @@ def complete(self, tab=False):
 
         self.set_docstring()
 
-        matches, completer = autocomplete.get_completer(
-                self.cursor_offset,
-                self.current_line,
-                self.interp.locals,
-                self.argspec,
-                '\n'.join(self.buffer + [self.current_line]),
-                self.config.autocomplete_mode,
-                self.config.complete_magic_methods)
+        matches, completer = autocomplete.get_completer_bpython(
+            cursor_offset=self.cursor_offset,
+            line=self.current_line,
+            locals_=self.interp.locals,
+            argspec=self.argspec,
+            current_block='\n'.join(self.buffer + [self.current_line]),
+            complete_magic_methods=self.config.complete_magic_methods)
         #TODO implement completer.shown_before_tab == False (filenames shouldn't fill screen)
 
-        if (matches is None            # no completion is relevant
-                or len(matches) == 0): # a target for completion was found
-                                       #   but no matches were found
+        if len(matches) == 0:
             self.matches_iter.clear()
             return bool(self.argspec)
 
         self.matches_iter.update(self.cursor_offset,
                                  self.current_line, matches, completer)
 
         if len(matches) == 1:
-                self.matches_iter.next()
-                if tab: # if this complete is being run for a tab key press, tab() to do the swap
-
-                    self.cursor_offset, self.current_line = self.matches_iter.substitute_cseq()
-                    return Repl.complete(self)
-                elif self.matches_iter.current_word == matches[0]:
-                    self.matches_iter.clear()
-                    return False
-                return completer.shown_before_tab
+            if tab: # if this complete is being run for a tab key press, substitute common sequence
+                self._cursor_offset, self._current_line = self.matches_iter.substitute_cseq()
+                return Repl.complete(self)
+            elif self.matches_iter.current_word == matches[0]:
+                self.matches_iter.clear()
+                return False
+            return completer.shown_before_tab
 
         else:
             assert len(matches) > 1
diff --git a/bpython/test/test_autocomplete.py b/bpython/test/test_autocomplete.py
