more autocomplete reformatting

thomasballinger · thomasballinger · commit 64771cd34108 · 2014-07-06T14:30:40.000-04:00
diff --git a/bpython/autocomplete.py b/bpython/autocomplete.py
@@ -57,147 +57,6 @@
     "oct", "hex", "index", "coerce", "enter", "exit"]]
 
 
-def attr_complete(text, namespace=None, mode=SIMPLE):
-    """Return list of matches """
-    if namespace is None:
-        namespace = __main__.__dict__
-
-    assert '.' in text
-
-    for i in range(1, len(text) + 1):
-        if text[-i] == '[':
-            i -= 1
-            break
-    methodtext = text[-i:]
-    matches = [''.join([text[:-i], m]) for m in
-                        attr_matches(methodtext, namespace, mode)]
-
-    # unless the first character is a _ filter out all attributes starting with a _
-    if not text.split('.')[-1].startswith('_'):
-        matches = [match for match in matches
-                   if not match.split('.')[-1].startswith('_')]
-    return matches
-
-
-class SafeEvalFailed(Exception):
-    """If this object is returned, safe_eval failed"""
-    # Because every normal Python value is a possible return value of safe_eval
-
-def safe_eval(expr, namespace):
-    """Not all that safe, just catches some errors"""
-    if expr.isdigit():
-        # Special case: float literal, using attrs here will result in
-        # a SyntaxError
-        return SafeEvalFailed
-    try:
-        obj = eval(expr, namespace)
-        return obj
-    except (NameError,) as e:
-        # If debugging safe_eval, raise this!
-        # raise e
-        return SafeEvalFailed
-
-def attr_matches(text, namespace, autocomplete_mode):
-    """Taken from rlcompleter.py and bent to my will.
-    """
-
-    # Gna, Py 2.6's rlcompleter searches for __call__ inside the
-    # instance instead of the type, so we monkeypatch to prevent
-    # side-effects (__getattr__/__getattribute__)
-    m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text)
-    if not m:
-        return []
-
-    expr, attr = m.group(1, 3)
-    obj = safe_eval(expr, namespace)
-    if obj is SafeEvalFailed:
-        return []
-    with inspection.AttrCleaner(obj):
-        matches = attr_lookup(obj, expr, attr, autocomplete_mode)
-    return matches
-
-def attr_lookup(obj, expr, attr, autocomplete_mode):
-    """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."""
-    words = dir(obj)
-    if hasattr(obj, '__class__'):
-        words.append('__class__')
-        words = words + rlcompleter.get_class_members(obj.__class__)
-        if has_abc and not isinstance(obj.__class__, abc.ABCMeta):
-            try:
-                words.remove('__abstractmethods__')
-            except ValueError:
-                pass
-
-    matches = []
-    n = len(attr)
-    for word in words:
-        if method_match(word, n, attr, autocomplete_mode) and word != "__builtins__":
-            matches.append("%s.%s" % (expr, word))
-    return matches
-
-def _callable_postfix(value, word):
-    """rlcompleter's _callable_postfix done right."""
-    with inspection.AttrCleaner(value):
-        if inspection.is_callable(value):
-            word += '('
-    return word
-
-def global_matches(text, namespace, autocomplete_mode):
-    """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.
-    """
-
-    hash = {}
-    n = len(text)
-    import keyword
-    for word in keyword.kwlist:
-        if method_match(word, n, text, autocomplete_mode):
-            hash[word] = 1
-    for nspace in [__builtin__.__dict__, namespace]:
-        for word, val in nspace.items():
-            if method_match(word, len(text), text, autocomplete_mode) and word != "__builtins__":
-                hash[_callable_postfix(val, word)] = 1
-    matches = hash.keys()
-    matches.sort()
-    return matches
-
-#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 filename_matches(cs):
-    matches = []
-    username = cs.split(os.path.sep, 1)[0]
-    user_dir = os.path.expanduser(username)
-    for filename in glob(os.path.expanduser(cs + '*')):
-        if os.path.isdir(filename):
-            filename += os.path.sep
-        if cs.startswith('~'):
-            filename = username + filename[len(user_dir):]
-        matches.append(filename)
-    return matches
-
-def last_part_of_filename(filename):
-    filename.rstrip(os.sep).rsplit(os.sep)[-1]
-    if os.sep in filename[:-1]:
-        return filename[filename.rindex(os.sep, 0, -1)+1:]
-    else:
-        return filename
-
-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
 
@@ -233,7 +92,6 @@ def get_completer(cursor_offset, current_line, locals_, argspec, full_code, mode
         return None, None
     return sorted(set(current_word_matches)), AttrCompletion
 
-
 class BaseCompletionType(object):
     """Describes different completion types"""
     def matches(cls, cursor_offset, line, **kwargs):
@@ -271,7 +129,9 @@ class ImportCompletion(BaseCompletionType):
     def matches(cls, cursor_offset, current_line, **kwargs):
         return importcompletion.complete(cursor_offset, current_line)
     locate = staticmethod(lineparts.current_word)
-    format = staticmethod(after_last_dot)
+    @classmethod
+    def format(cls, name):
+        return name.rstrip('.').rsplit('.')[-1]
 
 class FilenameCompletion(BaseCompletionType):
     shown_before_tab = False
@@ -280,20 +140,59 @@ def matches(cls, cursor_offset, current_line, **kwargs):
         cs = lineparts.current_string(cursor_offset, current_line)
         if cs is None:
             return None
-        return filename_matches(cs[2])
+        start, end, text = cs
+        matches = []
+        username = text.split(os.path.sep, 1)[0]
+        user_dir = os.path.expanduser(username)
+        for filename in glob(os.path.expanduser(text + '*')):
+            if os.path.isdir(filename):
+                filename += os.path.sep
+            if text.startswith('~'):
+                filename = username + filename[len(user_dir):]
+            matches.append(filename)
+        return matches
+
     locate = staticmethod(lineparts.current_string)
-    format = staticmethod(last_part_of_filename)
+    @classmethod
+    def format(cls, filename):
+        filename.rstrip(os.sep).rsplit(os.sep)[-1]
+        if os.sep in filename[:-1]:
+            return filename[filename.rindex(os.sep, 0, -1)+1:]
+        else:
+            return filename
 
 class AttrCompletion(BaseCompletionType):
     @classmethod
     def matches(cls, cursor_offset, line, locals_, mode, **kwargs):
         r = cls.locate(cursor_offset, line)
         if r is None:
             return None
-        cw = r[2]
-        return attr_complete(cw, namespace=locals_, mode=mode)
+        text = r[2]
+
+        if locals_ is None:
+            locals_ = __main__.__dict__
+
+        assert '.' in text
+
+        for i in range(1, len(text) + 1):
+            if text[-i] == '[':
+                i -= 1
+                break
+        methodtext = text[-i:]
+        matches = [''.join([text[:-i], m]) for m in
+                            attr_matches(methodtext, locals_, mode)]
+
+        #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 _
+        if not text.split('.')[-1].startswith('_'):
+            matches = [match for match in matches
+                       if not match.split('.')[-1].startswith('_')]
+        return matches
+
     locate = staticmethod(lineparts.current_dotted_attribute)
-    format = staticmethod(after_last_dot)
+    @classmethod
+    def format(cls, name):
+        return name.rstrip('.').rsplit('.')[-1]
 
 class DictKeyCompletion(BaseCompletionType):
     locate = staticmethod(lineparts.current_dict_key)
@@ -354,3 +253,138 @@ def matches(cls, cursor_offset, line, argspec, **kwargs):
                                if name.startswith(word))
         return matches
     locate = staticmethod(lineparts.current_word)
+
+class MagicMethodCompletion(BaseCompletionType):
+    locate = staticmethod(lineparts.current_method_definition_name)
+    @classmethod
+    def matches(cls, cursor_offset, line, full_code, **kwargs):
+        r = cls.locate(cursor_offset, line)
+        if r is None:
+            return None
+        if 'class' not in full_code:
+            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):
+        """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.
+        """
+        r = cls.locate(cursor_offset, line)
+        if r is None:
+            return None
+        start, end, text = r
+
+        hash = {}
+        n = len(text)
+        import keyword
+        for word in keyword.kwlist:
+            if method_match(word, n, text, mode):
+                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__":
+                    hash[_callable_postfix(val, word)] = 1
+        matches = hash.keys()
+        matches.sort()
+        return matches
+
+    locate = staticmethod(lineparts.current_single_word)
+
+class ParameterNameCompletion(BaseCompletionType):
+    @classmethod
+    def matches(cls, cursor_offset, line, argspec, **kwargs):
+        if not argspec:
+            return None
+        r = cls.locate(cursor_offset, line)
+        if r is None:
+            return None
+        start, end, word = r
+        if argspec:
+            matches = [name + '=' for name in argspec[1][0]
+                       if isinstance(name, basestring) and name.startswith(word)]
+            if py3:
+                matches.extend(name + '=' for name in argspec[1][4]
+                               if name.startswith(word))
+        return matches
+    locate = staticmethod(lineparts.current_word)
+
+class SafeEvalFailed(Exception):
+    """If this object is returned, safe_eval failed"""
+    # Because every normal Python value is a possible return value of safe_eval
+
+def safe_eval(expr, namespace):
+    """Not all that safe, just catches some errors"""
+    if expr.isdigit():
+        # Special case: float literal, using attrs here will result in
+        # a SyntaxError
+        return SafeEvalFailed
+    try:
+        obj = eval(expr, namespace)
+        return obj
+    except (NameError,) as e:
+        # If debugging safe_eval, raise this!
+        # raise e
+        return SafeEvalFailed
+
+def attr_matches(text, namespace, autocomplete_mode):
+    """Taken from rlcompleter.py and bent to my will.
+    """
+
+    # Gna, Py 2.6's rlcompleter searches for __call__ inside the
+    # instance instead of the type, so we monkeypatch to prevent
+    # side-effects (__getattr__/__getattribute__)
+    m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text)
+    if not m:
+        return []
+
+    expr, attr = m.group(1, 3)
+    obj = safe_eval(expr, namespace)
+    if obj is SafeEvalFailed:
+        return []
+    with inspection.AttrCleaner(obj):
+        matches = attr_lookup(obj, expr, attr, autocomplete_mode)
+    return matches
+
+def attr_lookup(obj, expr, attr, autocomplete_mode):
+    """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."""
+    words = dir(obj)
+    if hasattr(obj, '__class__'):
+        words.append('__class__')
+        words = words + rlcompleter.get_class_members(obj.__class__)
+        if has_abc and not isinstance(obj.__class__, abc.ABCMeta):
+            try:
+                words.remove('__abstractmethods__')
+            except ValueError:
+                pass
+
+    matches = []
+    n = len(attr)
+    for word in words:
+        if method_match(word, n, attr, autocomplete_mode) and word != "__builtins__":
+            matches.append("%s.%s" % (expr, word))
+    return matches
+
+def _callable_postfix(value, word):
+    """rlcompleter's _callable_postfix done right."""
+    with inspection.AttrCleaner(value):
+        if inspection.is_callable(value):
+            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)
