Port code and tests to Python 3.

src/AccessControl/ImplPython.py

@@ -673,8 +673,7 @@ def removeContext(self, anExecutableObject):
             del stack[-1]
         else:
             indexes = range(len(stack))
-            indexes.reverse()
-            for i in indexes:
+            for i in reversed(indexes):
                 top = stack[i]
                 if top is anExecutableObject:
                     del stack[i:]

src/AccessControl/SimpleObjectPolicies.py

@@ -91,6 +91,7 @@
     type(()): 1,
     type(''): 1,
     type(u''): 1,
+    range: 1,
 }
 
 Containers = ContainerAssertions.get

src/AccessControl/ZopeGuards.py

@@ -16,6 +16,7 @@
 from functools import reduce
 import math
 import random
+import six
 import string
 import sys
 import warnings
@@ -154,19 +155,28 @@ def guarded_pop(index=-1):
     'copy': 1,
     'fromkeys': 1,
     'get': get_dict_get,
-    'has_key': 1,
     'items': 1,
-    'iteritems': 1,
-    'keys': 1,
-    'iterkeys': get_iter,
-    'itervalues': get_iter,
     'pop': get_dict_pop,
     'popitem': 1,
     'setdefault': 1,
     'update': 1,
-    'values': 1,
 }
 
+if six.PY3:
+    _dict_white_list.update({
+        'keys': get_iter,
+        'values': get_iter,
+    })
+else:
+    _dict_white_list.update({
+        'has_key': 1,
+        'iteritems': 1,
+        'iterkeys': get_iter,
+        'itervalues': get_iter,
+        'keys': 1,
+        'values': 1,
+    })
+
 
 def _check_dict_access(name, value):
     # Check whether value is a dict method
@@ -257,10 +267,12 @@ def __next__(self):
 
 class NullIter(SafeIter):
     def __init__(self, ob):
-        self._next = ob.next
+        self._iter = ob
+
+    def __next__(self):
+        return next(self._iter)
 
-    def next(self):
-        return self._next()
+    next = __next__  # Python 2 compat
 
 
 def _error(index):
@@ -273,7 +285,7 @@ def guarded_iter(*args):
         # Don't double-wrap
         if isinstance(i, SafeIter):
             return i
-        if not isinstance(i, xrange):
+        if not isinstance(i, six.moves.range):
             return SafeIter(i)
     # Other call styles / targets don't need to be guarded
     return NullIter(iter(*args))
@@ -351,7 +363,7 @@ def guarded_map(f, *seqs):
     for seqno in range(len(seqs)):
         seq = guarded_getitem(seqs, seqno)
         safe_seqs.append(guarded_iter(seq))
-    return map(f, *safe_seqs)
+    return list(map(f, *safe_seqs))
 
 
 safe_builtins['map'] = guarded_map
@@ -362,14 +374,20 @@ def guarded_zip(*seqs):
     for seqno in range(len(seqs)):
         seq = guarded_getitem(seqs, seqno)
         safe_seqs.append(guarded_iter(seq))
-    return zip(*safe_seqs)
+    return list(zip(*safe_seqs))
 
 
 safe_builtins['zip'] = guarded_zip
 
 
+if six.PY3:
+    import_default_level = 0
+else:
+    import_default_level = -1
+
+
 def guarded_import(mname, globals=None, locals=None, fromlist=None,
-                   level=-1):
+                   level=import_default_level):
     if fromlist is None:
         fromlist = ()
     if '*' in fromlist:
@@ -379,7 +397,7 @@ def guarded_import(mname, globals=None, locals=None, fromlist=None,
     if locals is None:
         locals = {}
     # Refs https://bugs.launchpad.net/zope2/+bug/659968
-    if level != -1:
+    if level != import_default_level:
         raise Unauthorized("Using import with a level specification isn't "
                            "supported by AccessControl: %s" % mname)
 

src/AccessControl/rolemanager.py

@@ -438,8 +438,7 @@ def possible_permissions(self):
         for p in self.ac_inherited_permissions(1):
             d[p[0]] = 1
 
-        d = d.keys()
-        d.sort()
+        d = sorted(d.keys())
         return d
 
 

src/AccessControl/tests/actual_python.py

@@ -34,21 +34,21 @@ def f1():
 
 
 def f2():
-    assert map(lambda x: x + 1, range(3)) == range(1, 4)
+    assert list(map(lambda x: x + 1, range(3))) == list(range(1, 4))
 
 
 f2()
 
 
 def f3():
-    assert filter(None, range(10)) == range(1, 10)
+    assert list(filter(None, range(10))) == list(range(1, 10))
 
 
 f3()
 
 
 def f4():
-    assert [i + 1 for i in range(3)] == range(*(1, 4))
+    assert [i + 1 for i in range(3)] == list(range(*(1, 4)))
 
 
 f4()
@@ -123,21 +123,25 @@ def display(self):
 
 
 def f7():
+    d = apply(dict, [((1, 2), (3, 4))])  # {1: 2, 3: 4}
+    methods = [('keys', 'k'),
+               ('items', 'i'),
+               ('values', 'v')]
     try:
-        d = apply(dict, [((1, 2), (3, 4))]) # {1: 2, 3: 4}
-    except NameError:
-        # Python 3 has no apply
-        d = dict(*[((1, 2), (3, 4))]) # {1: 2, 3: 4}
+        {}.iterkeys
+    except AttributeError:
+        pass
+    else:
+        # Python 2 only:
+        methods.extend([
+            ('iterkeys', 'k'),
+            ('iteritems', 'i'),
+            ('itervalues', 'v')])
 
     expected = {'k': [1, 3],
                 'v': [2, 4],
                 'i': [(1, 2), (3, 4)]}
-    for meth, kind in [('iterkeys', 'k'),
-                       ('iteritems', 'i'),
-                       ('itervalues', 'v'),
-                       ('keys', 'k'),
-                       ('items', 'i'),
-                       ('values', 'v')]:
+    for meth, kind in methods:
         access = getattr(d, meth)
         result = list(access())
         result.sort()

src/AccessControl/tests/testModuleSecurity.py

@@ -11,6 +11,7 @@
 #
 ##############################################################################
 import unittest
+from ..ZopeGuards import import_default_level
 
 
 class ModuleSecurityTests(unittest.TestCase):
@@ -33,13 +34,13 @@ def tearDown(self):
             if module in sys.modules:
                 del sys.modules[module]
 
-    def assertUnauth(self, module, fromlist, level=-1):
+    def assertUnauth(self, module, fromlist, level=import_default_level):
         from zExceptions import Unauthorized
         from AccessControl.ZopeGuards import guarded_import
         self.assertRaises(Unauthorized, guarded_import, module,
                           fromlist=fromlist, level=level)
 
-    def assertAuth(self, module, fromlist, level=-1):
+    def assertAuth(self, module, fromlist, level=import_default_level):
         from AccessControl.ZopeGuards import guarded_import
         guarded_import(module, fromlist=fromlist, level=level)
 
@@ -83,7 +84,8 @@ def test_failed_import_keeps_MSI(self):
         self.failUnless('AccessControl.tests.nonesuch' in MS)
 
     def test_level_default(self):
-        self.assertAuth('AccessControl.tests.public_module', (), level=-1)
+        self.assertAuth('AccessControl.tests.public_module', (),
+                        level=import_default_level)
 
     def test_level_nondefault(self):
         self.assertUnauth('AccessControl.tests.public_module', (), level=1)