Python 3 compatibility

pylib/gyp/xcodeproj_file.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Xcode project file generator.
 
 This module is both an Xcode project file generator and a documentation of the
 Xcode project file format.  Knowledge of the project file format was gained
 based on extensive experience with Xcode, and by making changes to projects in
 Xcode.app and observing the resultant changes in the associated project files.
@@ skipping 136 matching lines @@
 # and other secure hashes.  In 2.6, sha is deprecated.  Import hashlib if
 # available, avoiding a deprecation warning under 2.6.  Import sha otherwise,
 # preserving 2.4 compatibility.
 try:
   import hashlib
   _new_sha1 = hashlib.sha1
 except ImportError:
   import sha
   _new_sha1 = sha.new
 
+try:
+  basestring = basestring
+except NameError:
+  basestring = str
 
 # See XCObject._EncodeString.  This pattern is used to determine when a string
 # can be printed unquoted.  Strings that match this pattern may be printed
 # unquoted.  Strings that do not match must be quoted and may be further
 # transformed to be properly encoded.  Note that this expression matches the
 # characters listed with "+", for 1 or more occurrences: if a string is empty,
 # it must not match this pattern, because it needs to be encoded as "".
 _unquoted = re.compile('^[A-Za-z0-9$./_]+$')
 
 # Strings that match this pattern are quoted regardless of what _unquoted says.
@@ skipping 140 matching lines @@
     """Make a copy of this object.
 
     The new object will have its own copy of lists and dicts.  Any XCObject
     objects owned by this object (marked "strong") will be copied in the
     new object, even those found in lists.  If this object has any weak
     references to other XCObjects, the same references are added to the new
     object without making a copy.
     """
 
     that = self.__class__(id=self.id, parent=self.parent)
-    for key, value in self._properties.iteritems():
+    for key, value in self._properties.items():
       is_strong = self._schema[key][2]
 
       if isinstance(value, XCObject):
         if is_strong:
           new_value = value.Copy()
           new_value.parent = that
           that._properties[key] = new_value
         else:
           that._properties[key] = value
-      elif isinstance(value, str) or isinstance(value, unicode) or \
-           isinstance(value, int):
+      elif isinstance(value, basestring) or isinstance(value, int):
         that._properties[key] = value
       elif isinstance(value, list):
         if is_strong:
           # If is_strong is True, each element is an XCObject, so it's safe to
           # call Copy.
           that._properties[key] = []
           for item in value:
             new_item = item.Copy()
             new_item.parent = that
             that._properties[key].append(new_item)
@@ skipping 103 matching lines @@
           _HashUpdate(child_hash, hashable)
 
       for child in self.Children():
         child.ComputeIDs(recursive, overwrite, child_hash)
 
     if overwrite or self.id is None:
       # Xcode IDs are only 96 bits (24 hex characters), but a SHA-1 digest is
       # is 160 bits.  Instead of throwing out 64 bits of the digest, xor them
       # into the portion that gets used.
       assert hash.digest_size % 4 == 0
-      digest_int_count = hash.digest_size / 4
+      digest_int_count = hash.digest_size // 4
       digest_ints = struct.unpack('>' + 'I' * digest_int_count, hash.digest())
       id_ints = [0, 0, 0]
-      for index in xrange(0, digest_int_count):
+      for index in range(0, digest_int_count):
         id_ints[index % 3] ^= digest_ints[index]
       self.id = '%08X%08X%08X' % tuple(id_ints)
 
   def EnsureNoIDCollisions(self):
     """Verifies that no two objects have the same ID.  Checks all descendants.
     """
 
     ids = {}
     descendants = self.Descendants()
     for descendant in descendants:
       if descendant.id in ids:
         other = ids[descendant.id]
         raise KeyError(
               'Duplicate ID %s, objects "%s" and "%s" in "%s"' % \
               (descendant.id, str(descendant._properties),
                str(other._properties), self._properties['rootObject'].Name()))
       ids[descendant.id] = descendant
 
   def Children(self):
     """Returns a list of all of this object's owned (strong) children."""
 
     children = []
-    for property, attributes in self._schema.iteritems():
+    for property, attributes in self._schema.items():
       (is_list, property_type, is_strong) = attributes[0:3]
       if is_strong and property in self._properties:
         if not is_list:
           children.append(self._properties[property])
         else:
           children.extend(self._properties[property])
     return children
 
   def Descendants(self):
     """Returns a list of all of this object's descendants, including this
@@ skipping 107 matching lines @@
     else:
       sep = '\n'
       element_tabs = '\t' * (tabs + 1)
       end_tabs = '\t' * tabs
 
     if isinstance(value, XCObject):
       printable += value.id
       comment = value.Comment()
     elif isinstance(value, str):
       printable += self._EncodeString(value)
-    elif isinstance(value, unicode):
+    # A python3 compatible way of saying isinstance(value, unicode).
+    # basestring is str in python3 so this is equivalent to the above isinstance.
+    # Thus if it failed above it will fail here.
+    # In python2 we test against str and unicode at this point. str has already
+    # failed in the above isinstance so we test against unicode.
+    elif isinstance(value, basestring):
       printable += self._EncodeString(value.encode('utf-8'))
     elif isinstance(value, int):
       printable += str(value)
     elif isinstance(value, list):
       if flatten_list and len(value) <= 1:
         if len(value) == 0:
           printable += self._EncodeString('')
         else:
           printable += self._EncodeString(value[0])
       else:
         printable = '(' + sep
         for item in value:
           printable += element_tabs + \
                        self._XCPrintableValue(tabs + 1, item, flatten_list) + \
                        ',' + sep
         printable += end_tabs + ')'
     elif isinstance(value, dict):
       printable = '{' + sep
-      for item_key, item_value in sorted(value.iteritems()):
+      for item_key, item_value in sorted(value.items()):
         printable += element_tabs + \
             self._XCPrintableValue(tabs + 1, item_key, flatten_list) + ' = ' + \
             self._XCPrintableValue(tabs + 1, item_value, flatten_list) + ';' + \
             sep
       printable += end_tabs + '}'
     else:
       raise TypeError("Can't make " + value.__class__.__name__ + ' printable')
 
     if comment != None:
       printable += ' ' + self._EncodeComment(comment)
@@ skipping 48 matching lines @@
       flatten_list = False
 
     try:
       printable_key = self._XCPrintableValue(tabs, key, flatten_list)
       printable_value = self._XCPrintableValue(tabs, value_to_print,
                                                flatten_list)
       if strip_value_quotes and len(printable_value) > 1 and \
           printable_value[0] == '"' and printable_value[-1] == '"':
         printable_value = printable_value[1:-1]
       printable += printable_key + ' = ' + printable_value + ';' + after_kv
-    except TypeError, e:
+    except TypeError as e:
       gyp.common.ExceptionAppend(e,
                                  'while printing key "%s"' % key)
       raise
 
     self._XCPrint(file, 0, printable)
 
   def Print(self, file=sys.stdout):
     """Prints a reprentation of this object to file, adhering to Xcode output
     formatting.
     """
@@ skipping 18 matching lines @@
 
     # Start the object.  For example, '\t\tPBXProject = {\n'.
     self._XCPrint(file, 2, self._XCPrintableValue(2, self) + ' = {' + sep)
 
     # "isa" isn't in the _properties dictionary, it's an intrinsic property
     # of the class which the object belongs to.  Xcode always outputs "isa"
     # as the first element of an object dictionary.
     self._XCKVPrint(file, 3, 'isa', self.__class__.__name__)
 
     # The remaining elements of an object dictionary are sorted alphabetically.
-    for property, value in sorted(self._properties.iteritems()):
+    for property, value in sorted(self._properties.items()):
       self._XCKVPrint(file, 3, property, value)
 
     # End the object.
     self._XCPrint(file, end_tabs, '};\n')
 
   def UpdateProperties(self, properties, do_copy=False):
     """Merge the supplied properties into the _properties dictionary.
 
     The input properties must adhere to the class schema or a KeyError or
     TypeError exception will be raised.  If adding an object of an XCObject
     subclass and the schema indicates a strong relationship, the object's
     parent will be set to this object.
 
     If do_copy is True, then lists, dicts, strong-owned XCObjects, and
     strong-owned XCObjects in lists will be copied instead of having their
     references added.
     """
 
     if properties is None:
       return
 
-    for property, value in properties.iteritems():
+    for property, value in properties.items():
       # Make sure the property is in the schema.
       if not property in self._schema:
         raise KeyError(property + ' not in ' + self.__class__.__name__)
 
       # Make sure the property conforms to the schema.
       (is_list, property_type, is_strong) = self._schema[property][0:3]
       if is_list:
         if value.__class__ != list:
           raise TypeError(
                 property + ' of ' + self.__class__.__name__ + \
                 ' must be list, not ' + value.__class__.__name__)
         for item in value:
           if not isinstance(item, property_type) and \
-             not (item.__class__ == unicode and property_type == str):
+             not (isinstance(item, basestring) and property_type == str):
             # Accept unicode where str is specified.  str is treated as
             # UTF-8-encoded.
             raise TypeError(
                   'item of ' + property + ' of ' + self.__class__.__name__ + \
                   ' must be ' + property_type.__name__ + ', not ' + \
                   item.__class__.__name__)
       elif not isinstance(value, property_type) and \
-           not (value.__class__ == unicode and property_type == str):
+           not (isinstance(value, basestring) and property_type == str):
         # Accept unicode where str is specified.  str is treated as
         # UTF-8-encoded.
         raise TypeError(
               property + ' of ' + self.__class__.__name__ + ' must be ' + \
               property_type.__name__ + ', not ' + value.__class__.__name__)
 
       # Checks passed, perform the assignment.
       if do_copy:
         if isinstance(value, XCObject):
           if is_strong:
             self._properties[property] = value.Copy()
           else:
             self._properties[property] = value
-        elif isinstance(value, str) or isinstance(value, unicode) or \
-             isinstance(value, int):
+        elif isinstance(value, basestring) or isinstance(value, int):
           self._properties[property] = value
         elif isinstance(value, list):
           if is_strong:
             # If is_strong is True, each element is an XCObject, so it's safe
             # to call Copy.
             self._properties[property] = []
             for item in value:
               self._properties[property].append(item.Copy())
           else:
             self._properties[property] = value[:]
@@ skipping 55 matching lines @@
     # Store the item.
     self._properties[key].append(value)
 
   def VerifyHasRequiredProperties(self):
     """Ensure that all properties identified as required by the schema are
     set.
     """
 
     # TODO(mark): A stronger verification mechanism is needed.  Some
     # subclasses need to perform validation beyond what the schema can enforce.
-    for property, attributes in self._schema.iteritems():
+    for property, attributes in self._schema.items():
       (is_list, property_type, is_strong, is_required) = attributes[0:4]
       if is_required and not property in self._properties:
         raise KeyError(self.__class__.__name__ + ' requires ' + property)
 
   def _SetDefaultsFromSchema(self):
     """Assign object default values according to the schema.  This will not
     overwrite properties that have already been set."""
 
     defaults = {}
-    for property, attributes in self._schema.iteritems():
+    for property, attributes in self._schema.items():
       (is_list, property_type, is_strong, is_required) = attributes[0:4]
       if is_required and len(attributes) >= 5 and \
           not property in self._properties:
         default = attributes[4]
 
         defaults[property] = default
 
     if len(defaults) > 0:
       # Use do_copy=True so that each new object gets its own copy of strong
       # objects, lists, and dicts.
@@ skipping 530 matching lines @@
     # obtain additional hashables specific to this XCFileLikeElement.  Don't
     # just use this object's hashables, they're not specific and unique enough
     # on their own (without access to the parent hashables.)  Instead, provide
     # hashables that identify this object by path by getting its hashables as
     # well as the hashables of ancestor XCHierarchicalElement objects.
 
     hashables = []
     xche = self
     while xche != None and isinstance(xche, XCHierarchicalElement):
       xche_hashables = xche.Hashables()
-      for index in xrange(0, len(xche_hashables)):
-        hashables.insert(index, xche_hashables[index])
+      for index, xche_hashable in enumerate(xche_hashables):
+        hashables.insert(index, xche_hashable)
       xche = xche.parent
     return hashables
 
 
 class XCContainerPortal(XCObject):
   # Abstract base for objects that can be used as the containerPortal property
   # of PBXContainerItemProxy.
   pass
 
 
@@ skipping 953 matching lines @@
     return the_phase
 
   def HeadersPhase(self):
     headers_phase = self.GetBuildPhaseByType(PBXHeadersBuildPhase)
     if headers_phase is None:
       headers_phase = PBXHeadersBuildPhase()
 
       # The headers phase should come before the resources, sources, and
       # frameworks phases, if any.
       insert_at = len(self._properties['buildPhases'])
-      for index in xrange(0, len(self._properties['buildPhases'])):
-        phase = self._properties['buildPhases'][index]
+      for index, phase in enumerate(self._properties['buildPhases']):
         if isinstance(phase, PBXResourcesBuildPhase) or \
            isinstance(phase, PBXSourcesBuildPhase) or \
            isinstance(phase, PBXFrameworksBuildPhase):
           insert_at = index
           break
 
       self._properties['buildPhases'].insert(insert_at, headers_phase)
       headers_phase.parent = self
 
     return headers_phase
 
   def ResourcesPhase(self):
     resources_phase = self.GetBuildPhaseByType(PBXResourcesBuildPhase)
     if resources_phase is None:
       resources_phase = PBXResourcesBuildPhase()
 
       # The resources phase should come before the sources and frameworks
       # phases, if any.
       insert_at = len(self._properties['buildPhases'])
-      for index in xrange(0, len(self._properties['buildPhases'])):
-        phase = self._properties['buildPhases'][index]
+      for index, phase in enumerate(self._properties['buildPhases']):
         if isinstance(phase, PBXSourcesBuildPhase) or \
            isinstance(phase, PBXFrameworksBuildPhase):
           insert_at = index
           break
 
       self._properties['buildPhases'].insert(insert_at, resources_phase)
       resources_phase.parent = self
 
     return resources_phase
 
@@ skipping 400 matching lines @@
       # present in the remote_products list.
       x_remote = x._properties['remoteRef']._properties['remoteGlobalIDString']
       y_remote = y._properties['remoteRef']._properties['remoteGlobalIDString']
       x_index = remote_products.index(x_remote)
       y_index = remote_products.index(y_remote)
 
       # Use the order of each remote PBXFileReference in remote_products to
       # determine the sort order.
       return cmp(x_index, y_index)
 
-    for other_pbxproject, ref_dict in self._other_pbxprojects.iteritems():
+    for other_pbxproject, ref_dict in self._other_pbxprojects.items():
       # Build up a list of products in the remote project file, ordered the
       # same as the targets that produce them.
       remote_products = []
       for target in other_pbxproject._properties['targets']:
         if not isinstance(target, PBXNativeTarget):
           continue
         remote_products.append(target._properties['productReference'])
 
       # Sort the PBXReferenceProxy children according to the list of remote
       # products.
@@ skipping 60 matching lines @@
       self._XCPrint(file, 0, '/* Begin ' + class_name + ' section */\n')
       for object in sorted(objects_by_class[class_name],
                            cmp=lambda x, y: cmp(x.id, y.id)):
         object.Print(file)
       self._XCPrint(file, 0, '/* End ' + class_name + ' section */\n')
 
     if self._should_print_single_line:
       self._XCPrint(file, 0, '}; ')
     else:
       self._XCPrint(file, 1, '};\n')