annotate attributes with parens

thomasballinger · thomasballinger · commit 98e7214115fc · 2015-12-11T08:37:52.000-05:00
fix tests
diff --git a/bpython/autocomplete.py b/bpython/autocomplete.py
@@ -253,9 +253,6 @@ def matches(self, cursor_offset, line, **kwargs):
         matches = set(''.join([r.word[:-i], m])
                       for m in self.attr_matches(methodtext, locals_))
 
-        # TODO add open paren for methods via _callable_prefix
-        matches = set(_callable_postfix(eval(m, locals_), m)
-                      for m in matches)
         # unless the first character is a _ filter out all attributes
         # starting with a _
         if r.word.split('.')[-1].startswith('__'):
@@ -664,6 +661,57 @@ def safe_eval(expr, namespace):
         raise EvaluationError
 
 
+attr_matches_re = LazyReCompile(r"(\w+(\.\w+)*)\.(\w*)")
+
+
+def attr_matches(text, namespace):
+    """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 = attr_matches_re.match(text)
+    if not m:
+        return []
+
+    expr, attr = m.group(1, 3)
+    if expr.isdigit():
+        # Special case: float literal, using attrs here will result in
+        # a SyntaxError
+        return []
+    try:
+        obj = safe_eval(expr, namespace)
+    except EvaluationError:
+        return []
+    with inspection.AttrCleaner(obj):
+        matches = attr_lookup(obj, expr, attr)
+    return matches
+
+
+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."""
+    words = dir(obj)
+    if hasattr(obj, '__class__'):
+        words.append('__class__')
+        words = words + rlcompleter.get_class_members(obj.__class__)
+        if 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) and word != "__builtins__":
+            attr_obj = getattr(obj, word)  # scary!
+            matches.append(_callable_postfix(attr_obj, "%s.%s" % (expr, word)))
+    return matches
+
+
 def _callable_postfix(value, word):
     """rlcompleter's _callable_postfix done right."""
     with inspection.AttrCleaner(value):
diff --git a/bpython/test/test_autocomplete.py b/bpython/test/test_autocomplete.py
@@ -32,6 +32,12 @@ def test_catches_syntax_error(self):
         with self.assertRaises(autocomplete.EvaluationError):
             autocomplete.safe_eval('1re', {})
 
+    def test_doesnt_eval_properties(self):
+        self.assertRaises(autocomplete.EvaluationError,
+                          autocomplete.safe_eval, '1re', {})
+        p = Properties()
+        autocomplete.safe_eval('p.asserts_when_called', {'p': p})
+
 
 class TestFormatters(unittest.TestCase):
 
@@ -235,6 +241,13 @@ def method(self, x):
                                  'In Python 3 there are no old style classes')
 
 
+class Properties(Foo):
+
+    @property
+    def asserts_when_called(self):
+        raise AssertionError("getter method called")
+
+
 class TestAttrCompletion(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
diff --git a/bpython/test/test_repl.py b/bpython/test/test_repl.py
@@ -364,7 +364,7 @@ def test_simple_attribute_complete(self):
 
         self.assertTrue(self.repl.complete())
         self.assertTrue(hasattr(self.repl.matches_iter, 'matches'))
-        self.assertEqual(self.repl.matches_iter.matches, ['Foo.bar'])
+        self.assertEqual(self.repl.matches_iter.matches, ['Foo.bar('])
 
     def test_substring_attribute_complete(self):
         self.repl = FakeRepl({'autocomplete_mode': autocomplete.SUBSTRING})
