refactor identifying new-style classes

thomasballinger · thomasballinger · commit a5982a7f2a8e · 2015-12-11T08:37:52.000-05:00
diff --git a/bpython/inspection.py b/bpython/inspection.py
@@ -69,7 +69,7 @@ def __enter__(self):
         # original methods. :-(
         # The upshot being that introspecting on an object to display its
         # attributes will avoid unwanted side-effects.
-        if py3 or type_ != types.InstanceType:
+        if is_new_style(self.obj):
             __getattr__ = getattr(type_, '__getattr__', None)
             if __getattr__ is not None:
                 try:
@@ -98,6 +98,14 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         # /Dark magic
 
 
+if py3:
+    is_new_style = lambda obj: True
+else:
+    def is_new_style(obj):
+        """Returns True if obj is a new-style class or object"""
+        return type(obj) != types.InstanceType and hasattr(obj, '__class__')
+
+
 class _Repr(object):
     """
     Helper for `fixlongargs()`: Returns the given value in `__repr__()`.
diff --git a/bpython/test/test_autocomplete.py b/bpython/test/test_autocomplete.py
@@ -32,12 +32,6 @@ 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):
 
diff --git a/bpython/test/test_inspection.py b/bpython/test/test_inspection.py
@@ -20,29 +20,35 @@
 '''
 
 
-class TestInspection(unittest.TestCase):
-    def test_is_callable(self):
-        class OldCallable:
-            def __call__(self):
-                pass
+class OldCallable:
+    def __call__(self):
+        pass
 
-        class Callable(object):
-            def __call__(self):
-                pass
 
-        class OldNoncallable:
-            pass
+class Callable(object):
+    def __call__(self):
+        pass
 
-        class Noncallable(object):
-            pass
 
-        def spam():
-            pass
+class OldNoncallable:
+    pass
+
+
+class Noncallable(object):
+    pass
 
-        class CallableMethod(object):
-            def method(self):
-                pass
 
+def spam():
+    pass
+
+
+class CallableMethod(object):
+    def method(self):
+        pass
+
+
+class TestInspection(unittest.TestCase):
+    def test_is_callable(self):
         self.assertTrue(inspection.is_callable(spam))
         self.assertTrue(inspection.is_callable(Callable))
         self.assertTrue(inspection.is_callable(Callable()))
@@ -53,6 +59,14 @@ def method(self):
         self.assertFalse(inspection.is_callable(None))
         self.assertTrue(inspection.is_callable(CallableMethod().method))
 
+    def test_is_new_style(self):
+        self.assertTrue(inspection.is_new_style(spam))
+        self.assertTrue(inspection.is_new_style(Noncallable))
+        self.assertFalse(inspection.is_new_style(OldNoncallable))
+        self.assertTrue(inspection.is_new_style(Noncallable()))
+        self.assertFalse(inspection.is_new_style(OldNoncallable()))
+        self.assertTrue(inspection.is_new_style(None))
+
     def test_parsekeywordpairs(self):
         # See issue #109
         def fails(spam=['-a', '-b']):
