Jedi completion only for multiline blocks

thomasballinger · thomasballinger · commit 57b94b08f659 · 2015-01-24T23:37:26.000-05:00
diff --git a/bpython/autocomplete.py b/bpython/autocomplete.py
@@ -31,6 +31,8 @@
 
 from glob import glob
 
+import jedi
+
 from bpython import inspection
 from bpython import importcompletion
 from bpython import line as lineparts
@@ -114,7 +116,7 @@ def locate(self, current_offset, line):
     def format(self, word):
         return self._completers[0].format(word)
 
-    def matches(self, cursor_offset, line, locals_, argspec, current_block, complete_magic_methods):
+    def matches(self, cursor_offset, line, locals_, argspec, current_block, complete_magic_methods, history):
         all_matches = set()
         for completer in self._completers:
             # these have to be explicitely listed to deal with the different
@@ -124,7 +126,8 @@ def matches(self, cursor_offset, line, locals_, argspec, current_block, complete
                                         locals_=locals_,
                                         argspec=argspec,
                                         current_block=current_block,
-                                        complete_magic_methods=complete_magic_methods)
+                                        complete_magic_methods=complete_magic_methods,
+                                        history=history)
             if matches is not None:
                 all_matches.update(matches)
 
@@ -308,6 +311,43 @@ def matches(self, cursor_offset, line, **kwargs):
     def locate(self, current_offset, line):
         return lineparts.current_string_literal_attr(current_offset, line)
 
+class JediCompletion(BaseCompletionType):
+    @classmethod
+    def matches(self, cursor_offset, line, history, **kwargs):
+        if not lineparts.current_word(cursor_offset, line):
+            return None
+        history = '\n'.join(history) + '\n' + line
+        script = jedi.Script(history, len(history.splitlines()), cursor_offset, 'fake.py')
+        completions = script.completions()
+        if completions:
+            self._original = completions[0]
+        else:
+            self._original = None
+
+        matches = [c.name for c in completions]
+        if all(m.startswith('_') for m in matches):
+            return matches
+        elif any(not m.startswith(matches[0][0]) for m in matches):
+            return matches
+        else:
+            return [m for m in matches if not m.startswith('_')]
+
+    def locate(self, cursor_offset, line):
+        start = cursor_offset - (len(self._original.name) - len(self._original.complete))
+        end = cursor_offset
+        return start, end, line[start:end]
+
+
+class MultilineJediCompletion(JediCompletion):
+    @classmethod
+    def matches(cls, cursor_offset, line, current_block, history, **kwargs):
+        if '\n' in current_block:
+            assert cursor_offset <= len(line), "%r %r" % (cursor_offset, line)
+            results = JediCompletion.matches(cursor_offset, line, history)
+            return results
+        else:
+            return None
+
 
 def get_completer(completers, cursor_offset, line, **kwargs):
     """Returns a list of matches and an applicable completer
@@ -338,6 +378,7 @@ def get_completer(completers, cursor_offset, line, **kwargs):
     ImportCompletion(),
     FilenameCompletion(),
     MagicMethodCompletion(),
+    MultilineJediCompletion(),
     GlobalCompletion(),
     CumulativeCompleter((AttrCompletion(), ParameterNameCompletion()))
 )
diff --git a/bpython/curtsiesfrontend/repl.py b/bpython/curtsiesfrontend/repl.py
@@ -607,9 +607,7 @@ def readline_kill(self, e):
             self.cut_buffer = cut
 
     def on_enter(self, insert_into_history=True):
-        self.cursor_offset = -1 # so the cursor isn't touching a paren
-        self.unhighlight_paren()        # in unhighlight_paren
-        self.highlighted_paren = None
+        self._set_cursor_offset(-1, update_completion=False) # so the cursor isn't touching a paren
 
         self.history.append(self.current_line)
         self.push(self.current_line, insert_into_history=insert_into_history)
@@ -866,7 +864,7 @@ def run_code_and_maybe_finish(self, for_code=None):
                 self.display_lines.extend(paint.display_linize(self.current_stdouterr_line, self.width))
                 self.current_stdouterr_line = ''
 
-            self.current_line = ' '*indent
+            self._set_current_line(' '*indent, update_completion=True)
             self.cursor_offset = len(self.current_line)
 
     def keyboard_interrupt(self):
diff --git a/bpython/repl.py b/bpython/repl.py
@@ -534,7 +534,8 @@ def complete(self, tab=False):
             locals_=self.interp.locals,
             argspec=self.argspec,
             current_block='\n'.join(self.buffer + [self.current_line]),
-            complete_magic_methods=self.config.complete_magic_methods)
+            complete_magic_methods=self.config.complete_magic_methods,
+            history=self.history)
         #TODO implement completer.shown_before_tab == False (filenames shouldn't fill screen)
 
         if len(matches) == 0:
diff --git a/bpython/test/test_autocomplete.py b/bpython/test/test_autocomplete.py
@@ -83,18 +83,18 @@ def test_no_completers_fails(self):
     def test_one_empty_completer_returns_empty(self):
         a = self.completer([])
         cumulative = autocomplete.CumulativeCompleter([a])
-        self.assertEqual(cumulative.matches(3, 'abc', 1, 1, 1, 1), [])
+        self.assertEqual(cumulative.matches(3, 'abc', 1, 1, 1, 1, 1), [])
 
     def test_one_none_completer_returns_empty(self):
         a = self.completer(None)
         cumulative = autocomplete.CumulativeCompleter([a])
-        self.assertEqual(cumulative.matches(3, 'abc', 1, 1, 1, 1), [])
+        self.assertEqual(cumulative.matches(3, 'abc', 1, 1, 1, 1, 1), [])
 
     def test_two_completers_get_both(self):
         a = self.completer(['a'])
         b = self.completer(['b'])
         cumulative = autocomplete.CumulativeCompleter([a, b])
-        self.assertEqual(cumulative.matches(3, 'abc', 1, 1, 1, 1), (['a', 'b']))
+        self.assertEqual(cumulative.matches(3, 'abc', 1, 1, 1, 1, 1), (['a', 'b']))
 
 
 class TestFilenameCompletion(unittest.TestCase):
diff --git a/bpython/test/test_line_properties.py b/bpython/test/test_line_properties.py
@@ -124,6 +124,10 @@ def test_dots(self):
         self.assertAccess('stuff[<asd|fg>]')
         self.assertAccess('stuff[asdf[<asd|fg>]')
 
+    def test_open_paren(self):
+        self.assertAccess('<foo(|>')
+        # documenting current behavior - TODO is this intended?
+
 class TestCurrentDictKey(LineTestCase):
     def setUp(self):
         self.func = current_dict_key
