new autocomplete hooked up, working some

thomasballinger · thomasballinger · commit 1a0aa07bdc41 · 2014-07-06T13:28:19.000-04:00
simple completion working in cli
filename completion interestingly broken
diff --git a/bpython/autocomplete.py b/bpython/autocomplete.py
@@ -48,17 +48,10 @@
 SUBSTRING = 'substring'
 FUZZY = 'fuzzy'
 
-class Autocomplete(rlcompleter.Completer):
-    def __init__(self, namespace, config):
-        self.namespace = namespace
-        self.config = config
-    def complete(self, cw, _):
-        self.matches = complete(cw, namespace=self.namespace, config=self.config)
-
 def complete(text, namespace=None, config=None):
     """Return list of matches """
     if namespace is None:
-        namespace = __main__.__dict__
+        namespace = __main__.__dict__ #TODO figure out if this __main__ still makes sense
 
     if hasattr(config, 'autocomplete_mode'):
         autocomplete_mode = config.autocomplete_mode
@@ -182,37 +175,40 @@ def filename_matches(cs):
         if cs.startswith('~'):
             filename = username + filename[len(user_dir):]
         matches.append(filename)
-    return cs
+    return matches
 
-def find_matches(cursor_offset, current_line, locals_, current_string_callback, completer, magic_methods, argspec):
+def find_matches(cursor_offset, current_line, locals_, argspec, config, magic_methods):
     """Returns a list of matches and function to use for replacing words on tab"""
 
+    #TODO use the smarter current_string() in Repl that knows about the buffer
+    #TODO don't pass in config, pass in the settings themselves
+    #TODO if importcompletion returns None, that means short circuit return, not
+    #     try something else
     if line.current_string(cursor_offset, current_line):
-        matches = filename_matches(line.current_string(cursor_offset, current_line))
+        matches = filename_matches(line.current_string(cursor_offset, current_line)[2])
         return matches, line.current_string
 
     if line.current_word(cursor_offset, current_line) is None:
         return [], None
 
     matches = importcompletion.complete(cursor_offset, current_line)
-    return matches, line.current_word
+    if matches:
+        return matches, line.current_word
 
     cw = line.current_word(cursor_offset, current_line)[2]
 
     try:
-        completer.complete(cw, 0)
-    #except Exception:
-    #    # This sucks, but it's either that or list all the exceptions that could
-    #    # possibly be raised here, so if anyone wants to do that, feel free to send me
-    #    # a patch. XXX: Make sure you raise here if you're debugging the completion
-    #    # stuff !
-    #    e = True
-    #else:
+        matches = complete(cw, namespace=locals_, config=config)
+    except Exception:
+        # This sucks, but it's either that or list all the exceptions that could
+        # possibly be raised here, so if anyone wants to do that, feel free to send me
+        # a patch. XXX: Make sure you raise here if you're debugging the completion
+        # stuff !
+        e = True
+        raise
+    else:
         e = False
-        matches = completer.matches
         matches.extend(magic_methods(cw))
-    except KeyboardInterrupt:
-        pass
 
     if not e and argspec:
         matches.extend(name + '=' for name in argspec[1][0]
diff --git a/bpython/cli.py b/bpython/cli.py
@@ -459,7 +459,7 @@ def complete(self, tab=False):
         if self.list_win_visible and not self.config.auto_display_list:
             self.scr.touchwin()
             self.list_win_visible = False
-            self.matches_iter.update()
+            self.matches_iter.clear()
             return
 
         if self.config.auto_display_list or tab:
@@ -1484,43 +1484,42 @@ def tab(self, back=False):
             cseq = os.path.commonprefix(seq)
 
         if cseq and mode != autocomplete.FUZZY:
+            print 'doing cseq'
             expanded_string = cseq[len(cw):]
-            self.s += expanded_string
-            expanded = bool(expanded_string)
+            expanded = bool(expanded_string) #TODO move this logic below to matches_iter
+            _, self.s = self.matches_iter.substitute(self.matches_iter.current_word + expanded_string)
             self.print_line(self.s)
             if len(self.matches) == 1 and self.config.auto_display_list:
                 self.scr.touchwin()
             if expanded:
-                self.matches_iter.update(cseq, self.matches)
+                self.matches_iter.update(len(self.s) - self.cpos,
+                                         self.s,
+                                         self.matches)
         else:
             expanded = False
 
         # 4. swap current word for a match list item
         if not expanded and self.matches:
-            # reset s if this is the nth result
-            if self.matches_iter:
-                self.s = self.s[:-len(self.matches_iter.current())] + cw
+            print 'doing swap'
 
             current_match = back and self.matches_iter.previous() \
                                   or self.matches_iter.next()
 
-            # update s with the new match
-            if current_match:
-                try:
-                    self.show_list(self.matches, self.argspec, current_match)
-                except curses.error:
-                    # XXX: This is a massive hack, it will go away when I get
-                    # cusswords into a good enough state that we can start
-                    # using it.
-                    self.list_win.border()
-                    self.list_win.refresh()
-
-                if self.config.autocomplete_mode == autocomplete.SIMPLE:
-                    self.s += current_match[len(cw):]
-                else:
-                    self.s = self.s[:-len(cw)] + current_match
+            try:
+                self.show_list(self.matches, self.argspec, current_match)
+            except curses.error:
+                # XXX: This is a massive hack, it will go away when I get
+                # cusswords into a good enough state that we can start
+                # using it.
+                self.list_win.border()
+                self.list_win.refresh()
+
+            if self.config.autocomplete_mode == autocomplete.SIMPLE:
+                _, self.s = self.matches_iter.cur_line()
+            else:
+                self.s = self.s[:-len(cw)] + current_match
 
-                self.print_line(self.s, True)
+            self.print_line(self.s, True)
         return True
 
     def undo(self, n=1):
diff --git a/bpython/curtsiesfrontend/repl.py b/bpython/curtsiesfrontend/repl.py
@@ -827,6 +827,7 @@ def paint(self, about_to_exit=False, user_quit=False):
         logging.debug('cursor pos: %r', (cursor_row, cursor_column))
         return arr, (cursor_row, cursor_column)
 
+
     @contextlib.contextmanager
     def in_paste_mode(self):
         orig_value = self.paste_mode
diff --git a/bpython/line.py b/bpython/line.py
@@ -42,10 +42,10 @@ def current_string(cursor_offset, line):
 
     Weaker than bpython.Repl's current_string, because that checks that a string is a string
     based on previous lines in the buffer"""
-    matches = list(re.finditer('''(?P<open>(?:""")|"|(?:''\')|')(.*?)(?P=open)''', line))
-    for m in matches:
-        if m.start(2) <= cursor_offset and m.end(2) >= cursor_offset:
-            return m.start(2), m.end(2), m.group(2)
+    for m in re.finditer('''(?P<open>(?:""")|"|(?:''\')|')(?:((?P<closed>.*?)(?P=open))|(?P<unclosed>.*))''', line):
+        i = 3 if m.group(3) else 4
+        if m.start(i) <= cursor_offset and m.end(i) >= cursor_offset:
+            return m.start(i), m.end(i), m.group(i)
     return None
 
 def current_object(cursor_offset, line):
diff --git a/bpython/repl.py b/bpython/repl.py
@@ -50,7 +50,7 @@
 from bpython._py3compat import PythonLexer, py3
 from bpython.formatter import Parenthesis
 from bpython.translations import _
-from bpython.autocomplete import Autocomplete
+import bpython.autocomplete as autocomplete
 
 
 # Needed for special handling of __abstractmethods__
@@ -280,6 +280,9 @@ def __init__(self, current_word='', matches=[]):
         self.current_word = current_word
         self.matches = list(matches)
         self.index = -1
+        self.orig_cursor_offset = None
+        self.orig_line = None
+        self.replacer = None
 
     def __nonzero__(self):
         return self.index != -1
@@ -303,11 +306,33 @@ def previous(self):
 
         return self.matches[self.index]
 
-    def update(self, current_word='', matches=[]):
-        if current_word != self.current_word:
-            self.current_word = current_word
-            self.matches = list(matches)
+    def cur_line(self):
+        """Returns a cursor offset and line pair with the current substitution made"""
+        return self.substitute(self.current())
+
+    def substitute(self, match):
+        if match.startswith("'"):
+            raise ValueError(match)
+        start, end, word = self.replacer(self.orig_cursor_offset, self.orig_line)
+        result = start + len(match), self.orig_line[:start] + match + self.orig_line[end:]
+        return result
+
+    def update(self, cursor_offset, current_line, matches, replacer=None):
+        if cursor_offset != self.orig_cursor_offset or current_line != self.orig_line:
+            if replacer is not None:
+                self.replacer = replacer
+            if matches and self.replacer is not None:
+                self.start, self.end, self.current_word = self.replacer(cursor_offset, current_line)
+            self.orig_cursor_offset = cursor_offset
+            self.orig_line = current_line
             self.index = -1
+            self.matches = list(matches)
+
+    def clear(self):
+        self.cursor_offset = -1
+        self.current_line = ''
+        self.current_word = ''
+        self.replacer = None
 
 
 class Interaction(object):
@@ -378,7 +403,6 @@ def __init__(self, interp, config):
         self.s_hist = []
         self.history = []
         self.evaluating = False
-        self.completer = Autocomplete(self.interp.locals, config)
         self.matches = []
         self.matches_iter = MatchesIterator()
         self.argspec = None
@@ -580,83 +604,30 @@ def complete(self, tab=False):
         (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."""
 
-        #TODO keep factoring out parts of complete
-        # so we can reuse code when we reimplement complete
-        # in bpython.curtsiesfrontend.repl
-        # Maybe move things to autocomplete instead of here?
-
         self.set_docstring()
 
-        cw = self.cw()
-        cs = self.current_string()
-        if not cw:
-            self.matches = []
-            self.matches_iter.update()
-        if not (cw or cs):
-            return bool(self.argspec)
-
-        if cs and tab:
-            self.matches = filename_matches(cs)
-            self.matches_iter.update(cs, self.matches)
-            return bool(self.matches)
-        elif cs:
-            # Do not provide suggestions inside strings, as one cannot tab
-            # them so they would be really confusing.
-            self.matches_iter.update()
-            return False
+        matches, replacer = autocomplete.find_matches(
+                len(self.current_line()) - self.cpos,
+                self.current_line(),
+                self.interp.locals,
+                self.argspec,
+                self.config,
+                self.magic_method_completions)
 
-        # Check for import completion
-        e = False
-        matches = importcompletion.complete(len(self.current_line()) - self.cpos, self.current_line())
-        if matches is not None and not matches:
-            self.matches = []
-            self.matches_iter.update()
-            return False
+        self.matches = matches
+        self.matches_iter.update(len(self.current_line()) - self.cpos,
+                                 self.current_line(), self.matches, replacer=replacer)
 
-        if matches is None:
-            # Nope, no import, continue with normal completion
-            try:
-                self.completer.complete(cw, 0)
-            except Exception:
-                # This sucks, but it's either that or list all the exceptions that could
-                # possibly be raised here, so if anyone wants to do that, feel free to send me
-                # a patch. XXX: Make sure you raise here if you're debugging the completion
-                # stuff !
-                raise
-                e = True
-            else:
-                matches = self.completer.matches
-                matches.extend(self.magic_method_completions(cw))
-
-        if not e and self.argspec:
-            matches.extend(name + '=' for name in self.argspec[1][0]
-                           if isinstance(name, basestring) and name.startswith(cw))
-            if py3:
-                matches.extend(name + '=' for name in self.argspec[1][4]
-                               if name.startswith(cw))
-
-        # unless the first character is a _ filter out all attributes starting with a _
-        if not e and not cw.split('.')[-1].startswith('_'):
-            matches = [match for match in matches
-                       if not match.split('.')[-1].startswith('_')]
-
-        if e or not matches:
-            self.matches = []
-            self.matches_iter.update()
-            if not self.argspec:
-                return False
+        if matches is None or len(matches) == 0:
+            return bool(self.matches or self.argspec)
         else:
-            # remove duplicates
-            self.matches = sorted(set(matches))
-
-
-        if len(self.matches) == 1 and not self.config.auto_display_list:
-            self.list_win_visible = True
-            self.tab()
-            return False
-
-        self.matches_iter.update(cw, self.matches)
-        return True
+            if len(self.matches) == 1 and not self.config.auto_display_list:
+                self.list_win_visible = True
+                self.tab()
+                return False
+            self.matches_iter.update(len(self.current_line()) - self.cpos,
+                                     self.current_line(), self.matches, replacer)
+            return True
 
     def format_docstring(self, docstring, width, height):
         """Take a string and try to format it into a sane list of strings to be
diff --git a/bpython/test/test_autocomplete.py b/bpython/test/test_autocomplete.py
@@ -0,0 +1,18 @@
+from bpython import autocomplete
+from functools import partial
+
+import unittest
+
+class TestSimpleComplete(unittest.TestCase):
+
+    simple_config = type('', (), {})()
+    simple_config.autocomplete_mode = autocomplete.SIMPLE
+    complete = partial(autocomplete.complete,
+                       namespace={'zabcdef':1, 'zabcqwe':2, 'ze':3},
+                       config=simple_config)
+
+    def test_simple_completion(self):
+        self.assertEqual(self.complete('zab'), ['zabcdef', 'zabcqwe'])
+        self.assertEqual(self.complete('zabc'), ['zabcdef', 'zabcqwe'])
+        self.assertEqual(self.complete('zabcd'), ['zabcdef'])
+
diff --git a/bpython/test/test_line_properties.py b/bpython/test/test_line_properties.py
@@ -146,7 +146,7 @@ def test_simple(self):
 class TestCurrentString(LineTestCase):
     def setUp(self):
         self.func = current_string
-    def test_simple(self):
+    def test_closed(self):
         self.assertAccess('"<as|df>"')
         self.assertAccess('"<asdf|>"')
         self.assertAccess('"<|asdf>"')
@@ -155,6 +155,15 @@ def test_simple(self):
         self.assertAccess("'''<asdf|>'''")
         self.assertAccess('"""<asdf|>"""')
         self.assertAccess('asdf.afd("a") + "<asdf|>"')
+    def test_open(self):
+        self.assertAccess('"<as|df>')
+        self.assertAccess('"<asdf|>')
+        self.assertAccess('"<|asdf>')
+        self.assertAccess("'<asdf|>")
+        self.assertAccess("'<|asdf>")
+        self.assertAccess("'''<asdf|>")
+        self.assertAccess('"""<asdf|>')
+        self.assertAccess('asdf.afd("a") + "<asdf|>')
 
 class TestCurrentObject(LineTestCase):
     def setUp(self):
