completion more uniform

thomasballinger · thomasballinger · commit 3ee86961509c · 2014-07-06T14:17:52.000-04:00
diff --git a/bpython/autocomplete.py b/bpython/autocomplete.py
@@ -48,27 +48,36 @@
 SUBSTRING = 'substring'
 FUZZY = 'fuzzy'
 
-def attr_complete(text, namespace=None, config=None):
+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",
+    "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",
+    "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__ #TODO figure out if this __main__ still makes sense
+        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
 
-    if hasattr(config, 'autocomplete_mode'):
-        autocomplete_mode = config.autocomplete_mode
-    else:
-        autocomplete_mode = SUBSTRING
-
-    if "." in text:
-        # Examples: 'foo.b' or 'foo[bar.'
-        for i in range(1, len(text) + 1):
-            if text[-i] == '[':
-                i -= 1
-                break
-        methodtext = text[-i:]
-        return [''.join([text[:-i], m]) for m in
-                            attr_matches(methodtext, namespace, autocomplete_mode)]
-    else:
-        return global_matches(text, namespace, autocomplete_mode)
 
 class SafeEvalFailed(Exception):
     """If this object is returned, safe_eval failed"""
@@ -155,6 +164,8 @@ def global_matches(text, namespace, autocomplete_mode):
     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
@@ -187,57 +198,45 @@ def last_part_of_filename(filename):
 def after_last_dot(name):
     return name.rstrip('.').rsplit('.')[-1]
 
-def dict_key_format(filename):
-    # dictionary key suggestions
-    #items = [x.rstrip(']') for x in items]
-    #if current_item:
-    #    current_item = current_item.rstrip(']')
-    pass
-
-def get_completer(cursor_offset, current_line, locals_, argspec, config, magic_methods):
+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"""
 
-    #TODO use the smarter current_string() in Repl that knows about the buffer
-    #TODO don't pass in config, pass in the settings themselves
+    kwargs = {'locals_':locals_, 'argspec':argspec, 'full_code':full_code,
+              'mode':mode, 'complete_magic_methods':complete_magic_methods}
 
-    matches = ImportCompletion.matches(cursor_offset, current_line)
-    if matches is not None:
-        return sorted(set(matches)), ImportCompletion
+    # mutually exclusive matchers: if one returns [], don't go on
+    for completer in [ImportCompletion, FilenameCompletion,
+                      MagicMethodCompletion, GlobalCompletion]:
+        matches = completer.matches(cursor_offset, current_line, **kwargs)
+        if matches is not None:
+            return sorted(set(matches)), completer
 
-    matches = FilenameCompletion.matches(cursor_offset, current_line)
-    if matches is not None:
-        return sorted(set(matches)), FilenameCompletion
+    # 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
 
-    matches = DictKeyCompletion.matches(cursor_offset, current_line, locals_=locals_, config=config)
-    if matches:
-        return sorted(set(matches)), DictKeyCompletion
+    matches = AttrCompletion.matches(cursor_offset, current_line, **kwargs)
 
-    matches = AttrCompletion.matches(cursor_offset, current_line, locals_=locals_, config=config)
-    if matches is not None:
-        cw = AttrCompletion.locate(cursor_offset, current_line)[2]
-        matches.extend(magic_methods(cw))
-        if argspec:
-            matches.extend(name + '=' for name in argspec[1][0]
-                           if isinstance(name, basestring) and name.startswith(cw))
-            if py3:
-                matches.extend(name + '=' for name in argspec[1][4]
-                               if name.startswith(cw))
+    # 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)
 
-        # unless the first character is a _ filter out all attributes starting with a _
-        if not cw.split('.')[-1].startswith('_'):
-            matches = [match for match in matches
-                       if not match.split('.')[-1].startswith('_')]
-
-        return sorted(set(matches)), AttrCompletion
-
-    return None, None
+    if len(current_word_matches) == 0:
+        return None, None
+    return sorted(set(current_word_matches)), AttrCompletion
 
 
 class BaseCompletionType(object):
     """Describes different completion types"""
-    def matches(cls, cursor_offset, line):
+    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.
 
@@ -268,14 +267,16 @@ def substitute(cls, cursor_offset, line, match):
         return result
 
 class ImportCompletion(BaseCompletionType):
-    matches = staticmethod(importcompletion.complete)
+    @classmethod
+    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)
 
 class FilenameCompletion(BaseCompletionType):
     shown_before_tab = False
     @classmethod
-    def matches(cls, cursor_offset, current_line):
+    def matches(cls, cursor_offset, current_line, **kwargs):
         cs = lineparts.current_string(cursor_offset, current_line)
         if cs is None:
             return None
@@ -285,19 +286,19 @@ def matches(cls, cursor_offset, current_line):
 
 class AttrCompletion(BaseCompletionType):
     @classmethod
-    def matches(cls, cursor_offset, line, locals_, config):
+    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_, config=config)
-    locate = staticmethod(lineparts.current_word)
+        return attr_complete(cw, namespace=locals_, mode=mode)
+    locate = staticmethod(lineparts.current_dotted_attribute)
     format = staticmethod(after_last_dot)
 
 class DictKeyCompletion(BaseCompletionType):
     locate = staticmethod(lineparts.current_dict_key)
     @classmethod
-    def matches(cls, cursor_offset, line, locals_, config):
+    def matches(cls, cursor_offset, line, locals_, **kwargs):
         r = cls.locate(cursor_offset, line)
         if r is None:
             return None
@@ -313,3 +314,43 @@ def matches(cls, cursor_offset, line, locals_, config):
     @classmethod
     def format(cls, match):
         return match[:-1]
+
+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):
+        r = cls.locate(cursor_offset, line)
+        if r is None:
+            return None
+        start, end, word = r
+        return global_matches(word, locals_, mode)
+    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)
diff --git a/bpython/config.py b/bpython/config.py
@@ -6,15 +6,6 @@
 from bpython.keys import cli_key_dispatch as key_dispatch
 from bpython.autocomplete import SIMPLE as default_completion
 
-MAGIC_METHODS = ", ".join("__%s__" % s for s in [
-    "init", "repr", "str", "lt", "le", "eq", "ne", "gt", "ge", "cmp", "hash",
-    "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",
-    "oct", "hex", "index", "coerce", "enter", "exit"]
-)
-
 class Struct(object):
     """Simple class for instantiating objects we can add arbitrary attributes
     to and use for various arbitrary things."""
@@ -55,7 +46,6 @@ def loadini(struct, configfile):
             'auto_display_list': True,
             'color_scheme': 'default',
             'complete_magic_methods' : True,
-            'magic_methods' : MAGIC_METHODS,
             'autocomplete_mode': default_completion,
             'dedent_after': 1,
             'flush_output': True,
@@ -155,8 +145,6 @@ def loadini(struct, configfile):
 
     struct.complete_magic_methods = config.getboolean('general',
                                                       'complete_magic_methods')
-    methods = config.get('general', 'magic_methods')
-    struct.magic_methods = [meth.strip() for meth in methods.split(",")]
     struct.autocomplete_mode = config.get('general', 'autocomplete_mode')
     struct.save_append_py = config.getboolean('general', 'save_append_py')
 
diff --git a/bpython/line.py b/bpython/line.py
@@ -125,3 +125,28 @@ def current_import(cursor_offset, line):
         end = baseline.end() + m.end(1)
         if start < cursor_offset and end >= cursor_offset:
             return start, end, m.group(1)
+
+def current_method_definition_name(cursor_offset, line):
+    """The name of a method being defined"""
+    matches = re.finditer("def\s+([a-zA-Z_][\w]*)", line)
+    for m in matches:
+        if (m.start(1) <= cursor_offset and m.end(1) >= cursor_offset):
+            return m.start(1), m.end(1), m.group(1)
+    return None
+
+def current_single_word(cursor_offset, line):
+    """the un-dotted word just before or under the cursor"""
+    matches = re.finditer(r"(?<![.])\b([a-zA-Z_][\w]*)", line)
+    for m in matches:
+        if (m.start(1) <= cursor_offset and m.end(1) >= cursor_offset):
+            return m.start(1), m.end(1), m.group(1)
+    return None
+
+def current_dotted_attribute(cursor_offset, line):
+    """The dotted attribute-object pair before the cursor"""
+    match = current_word(cursor_offset, line)
+    if match is None: return None
+    start, end, word = match
+    if '.' in word[1:]:
+        return start, end, word
+    return None
diff --git a/bpython/repl.py b/bpython/repl.py
@@ -601,16 +601,6 @@ def set_docstring(self):
                 if not self.docstring:
                     self.docstring = None
 
-    def magic_method_completions(self, cw):
-        #TODO move this to autocompletion and pass in the buffer
-        if (self.config.complete_magic_methods and self.buffer and
-            self.buffer[0].startswith("class ") and
-            self.current_line.lstrip().startswith("def ")):
-            return [name for name in self.config.magic_methods
-                    if name.startswith(cw)]
-        else:
-            return []
-
     def complete(self, tab=False):
         """Construct a full list of possible completions and construct and
         display them in a window. Also check if there's an available argspec
@@ -631,8 +621,10 @@ def complete(self, tab=False):
                 self.current_line,
                 self.interp.locals,
                 self.argspec,
-                self.config,
-                self.magic_method_completions)
+                '\n'.join(self.buffer + [self.current_line]),
+                self.config.autocomplete_mode if hasattr(self.config, 'autocomplete_mode') else autocomplete.SIMPLE,
+                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
diff --git a/bpython/test/test_line_properties.py b/bpython/test/test_line_properties.py
@@ -2,6 +2,7 @@
 import re
 
 from bpython.line import current_word, current_dict_key, current_dict, current_string, current_object, current_object_attribute, current_from_import_from, current_from_import_import, current_import
+from bpython.line import current_word, current_dict_key, current_dict, current_string, current_object, current_object_attribute, current_from_import_from, current_from_import_import, current_import, current_method_definition_name, current_single_word
 
 
 def cursor(s):
@@ -236,5 +237,21 @@ def test_simple(self):
         self.assertAccess('if True: import <xml.do|m.minidom>')
         self.assertAccess('if True: import <xml.do|m.minidom> as something')
 
+class TestMethodDefinitionName(LineTestCase):
+    def setUp(self):
+        self.func = current_method_definition_name
+    def test_simple(self):
+        self.assertAccess('def <foo|>')
+        self.assertAccess('    def bar(x, y)|:')
+        self.assertAccess('    def <bar|>(x, y)')
+
+class TestMethodDefinitionName(LineTestCase):
+    def setUp(self):
+        self.func = current_single_word
+    def test_simple(self):
+        self.assertAccess('foo.bar|')
+        self.assertAccess('.foo|')
+        self.assertAccess(' <foo|>')
+
 if __name__ == '__main__':
     unittest.main()
