Fix for issues #91 and #96: newobject breaks multiple inheritance in v0.13

Also add related tests (currently failing) for multiple inheritance from other future types

Author: edschofield

future/tests/test_bytes.py

@@ -600,6 +600,31 @@ def test_mod(self):
         with self.assertRaises(TypeError):
             bytes(b'%r' % 'abc')
 
+    def test_multiple_inheritance(self):
+        """
+        Issue #96 (for newbytes instead of newobject)
+        """
+        import collections
+
+        class Base(bytes):
+            pass
+
+        class Foo(Base, collections.Container):
+            def __contains__(self, item):
+                return False
+
+    def test_with_metaclass_and_bytes(self):
+        """
+        Issue #91 (for newdict instead of newobject)
+        """
+        from future.utils import with_metaclass
+
+        class MetaClass(type):
+            pass
+
+        class TestClass(with_metaclass(MetaClass, bytes)):
+            pass
+
 
 if __name__ == '__main__':
     unittest.main()

future/tests/test_dict.py

@@ -106,6 +106,32 @@ def test_braces_create_newdict_object(self):
         d = self.d1
         self.assertTrue(type(d) == dict)
 
+    def test_multiple_inheritance(self):
+        """
+        Issue #96 (for newdict instead of newobject)
+        """
+        import collections
+
+        class Base(dict):
+            pass
+
+        class Foo(Base, collections.Container):
+            def __contains__(self, item):
+                return False
+
+    def test_with_metaclass_and_dict(self):
+        """
+        Issue #91 (for newdict instead of newobject)
+        """
+        from future.utils import with_metaclass
+
+        class MetaClass(type):
+            pass
+
+        class TestClass(with_metaclass(MetaClass, dict)):
+            pass
+
+
 
 if __name__ == '__main__':
     unittest.main()

future/tests/test_int.py

@@ -1038,6 +1038,31 @@ class myint(int):
             self.assertRaises(TypeError, myint.from_bytes, mytype(0), 'big')
             # self.assertRaises(TypeError, int.from_bytes, mytype(0), 'big', True)
 
+    def test_multiple_inheritance(self):
+        """
+        Issue #96 (for newint instead of newobject)
+        """
+        import collections
+
+        class Base(int):
+            pass
+
+        class Foo(Base, collections.Container):
+            def __add__(self, other):
+                return 0
+
+    def test_with_metaclass_and_int(self):
+        """
+        Issue #91 (for newint instead of newobject)
+        """
+        from future.utils import with_metaclass
+
+        class MetaClass(type):
+            pass
+
+        class TestClass(with_metaclass(MetaClass, int)):
+            pass
+
 
 if __name__ == "__main__":
     unittest.main()

future/tests/test_object.py

@@ -7,7 +7,7 @@
 from future import utils
 from future.builtins import object, str, next, int, super
 from future.utils import implements_iterator, python_2_unicode_compatible
-from future.tests.base import unittest
+from future.tests.base import unittest, expectedFailurePY2
 
 
 class TestNewObject(unittest.TestCase):
@@ -162,6 +162,7 @@ class C(A):
         self.assertFalse(isinstance(b, C))
         self.assertTrue(isinstance(c, C))
 
+    @expectedFailurePY2
     def test_types_isinstance_newobject(self):
         a = list()
         b = dict()
@@ -204,6 +205,31 @@ def __int__(self):
         if utils.PY2:
             self.assertEqual(long(a), 0)
 
+    def test_multiple_inheritance(self):
+        """
+        Issue #96
+        """
+        import collections
+
+        class Base(object):
+            pass
+
+        class Foo(Base, collections.Container):
+            def __contains__(self, item):
+                return False
+
+    def test_with_metaclass_and_object(self):
+        """
+        Issue #91
+        """
+        from future.utils import with_metaclass
+
+        class MetaClass(type):
+            pass
+
+        class TestClass(with_metaclass(MetaClass, object)):
+            pass
+
 
 if __name__ == '__main__':
     unittest.main()

future/tests/test_str.py

@@ -524,6 +524,31 @@ def test_maketrans_translate(self):
         self.assertRaises(TypeError, 'hello'.translate)
         self.assertRaises(TypeError, 'abababc'.translate, 'abc', 'xyz')
 
+    def test_multiple_inheritance(self):
+        """
+        Issue #96 (for newstr instead of newobject)
+        """
+        import collections
+
+        class Base(str):
+            pass
+
+        class Foo(Base, collections.Container):
+            def __contains__(self, item):
+                return False
+
+    def test_with_metaclass_and_str(self):
+        """
+        Issue #91 (for newstr instead of newobject)
+        """
+        from future.utils import with_metaclass
+
+        class MetaClass(type):
+            pass
+
+        class TestClass(with_metaclass(MetaClass, str)):
+            pass
+
 
 if __name__ == '__main__':
     unittest.main()

future/types/newobject.py

@@ -53,8 +53,17 @@ def __instancecheck__(cls, instance):
         else:
             return issubclass(instance.__class__, cls)
 
+# We no longer define a metaclass for newobject because this breaks multiple
+# inheritance and custom metaclass use with this exception:
 
-class newobject(with_metaclass(BaseNewObject, _builtin_object)):
+# TypeError: Error when calling the metaclass bases
+#     metaclass conflict: the metaclass of a derived class must be a
+#     (non-strict) subclass of the metaclasses of all its bases
+
+# See issues #91 and #96.
+
+
+class newobject(object):
     """
     A magical object class that provides Python 2 compatibility methods::
         next