Cleanup pylint errors

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 155 matching lines @@
 # Strings that match this pattern are quoted regardless of what _unquoted says.
 # Oddly, Xcode will quote any string with a run of three or more underscores.
 _quoted = re.compile('___')
 
 # This pattern should match any character that needs to be escaped by
 # XCObject._EncodeString.  See that function.
 _escaped = re.compile('[\\\\"]|[\x00-\x1f]')
 
 
 # Used by SourceTreeAndPathFromPath
-_path_leading_variable = re.compile('^\$\((.*?)\)(/(.*))?$')
+_path_leading_variable = re.compile(r'^\$\((.*?)\)(/(.*))?$')
 
 def SourceTreeAndPathFromPath(input_path):
   """Given input_path, returns a tuple with sourceTree and path values.
 
   Examples:
     input_path     (source_tree, output_path)
     '$(VAR)/path'  ('VAR', 'path')
     '$(VAR)'       ('VAR', None)
     'path'         (None, 'path')
   """
 
   source_group_match = _path_leading_variable.match(input_path)
   if source_group_match:
     source_tree = source_group_match.group(1)
     output_path = source_group_match.group(3)  # This may be None.
   else:
     source_tree = None
     output_path = input_path
 
   return (source_tree, output_path)
 
 def ConvertVariablesToShellSyntax(input_string):
-  return re.sub('\$\((.*?)\)', '${\\1}', input_string)
+  return re.sub(r'\$\((.*?)\)', '${\\1}', input_string)
 
 class XCObject(object):
   """The abstract base of all class types used in Xcode project files.
 
   Class variables:
     _schema: A dictionary defining the properties of this class.  The keys to
              _schema are string property keys as used in project files.  Values
              are a list of four or five elements:
              [ is_list, property_type, is_strong, is_required, default ]
              is_list: True if the property described is a list, as opposed
@@ skipping 124 matching lines @@
           that._properties[key] = []
           for item in value:
             new_item = item.Copy()
             new_item.parent = that
             that._properties[key].append(new_item)
         else:
           that._properties[key] = value[:]
       elif isinstance(value, dict):
         # dicts are never strong.
         if is_strong:
-          raise TypeError, 'Strong dict for key ' + key + ' in ' + \
-                           self.__class__.__name__
+          raise TypeError('Strong dict for key ' + key + ' in ' + \
+                          self.__class__.__name__)
         else:
           that._properties[key] = value.copy()
       else:
-        raise TypeError, 'Unexpected type ' + value.__class__.__name__ + \
-                         ' for key ' + key + ' in ' + self.__class__.__name__
+        raise TypeError('Unexpected type ' + value.__class__.__name__ + \
+                        ' for key ' + key + ' in ' + self.__class__.__name__)
 
     return that
 
   def Name(self):
     """Return the name corresponding to an object.
 
     Not all objects necessarily need to be nameable, and not all that do have
     a "name" property.  Override as needed.
     """
 
     # If the schema indicates that "name" is required, try to access the
     # property even if it doesn't exist.  This will result in a KeyError
     # being raised for the property that should be present, which seems more
     # appropriate than NotImplementedError in this case.
     if 'name' in self._properties or \
         ('name' in self._schema and self._schema['name'][3]):
       return self._properties['name']
 
-    raise NotImplementedError, \
-          self.__class__.__name__ + ' must implement Name'
+    raise NotImplementedError(self.__class__.__name__ + ' must implement Name')
 
   def Comment(self):
     """Return a comment string for the object.
 
     Most objects just use their name as the comment, but PBXProject uses
     different values.
 
     The returned comment is not escaped and does not have any comment marker
     strings applied to it.
     """
@@ skipping 78 matching lines @@
 
   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, \
+        raise KeyError(
               'Duplicate ID %s, objects "%s" and "%s" in "%s"' % \
               (descendant.id, str(descendant._properties),
-               str(other._properties), self._properties['rootObject'].Name())
+               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():
       (is_list, property_type, is_strong) = attributes[0:3]
       if is_strong and property in self._properties:
         if not is_list:
@@ skipping 140 matching lines @@
         printable += end_tabs + ')'
     elif isinstance(value, dict):
       printable = '{' + sep
       for item_key, item_value in sorted(value.iteritems()):
         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'
+      raise TypeError("Can't make " + value.__class__.__name__ + ' printable')
 
     if comment != None:
       printable += ' ' + self._EncodeComment(comment)
 
     return printable
 
   def _XCKVPrint(self, file, tabs, key, value):
     """Prints a key and value, members of an XCObject's _properties dictionary,
     to file.
 
@@ skipping 105 matching lines @@
     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():
       # Make sure the property is in the schema.
       if not property in self._schema:
-        raise KeyError, property + ' not in ' + self.__class__.__name__
+        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, \
+          raise TypeError(
                 property + ' of ' + self.__class__.__name__ + \
-                ' must be list, not ' + value.__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):
             # Accept unicode where str is specified.  str is treated as
             # UTF-8-encoded.
-            raise TypeError, \
+            raise TypeError(
                   'item of ' + property + ' of ' + self.__class__.__name__ + \
                   ' must be ' + property_type.__name__ + ', not ' + \
-                  item.__class__.__name__
+                  item.__class__.__name__)
       elif not isinstance(value, property_type) and \
            not (value.__class__ == unicode and property_type == str):
         # Accept unicode where str is specified.  str is treated as
         # UTF-8-encoded.
-        raise TypeError, \
+        raise TypeError(
               property + ' of ' + self.__class__.__name__ + ' must be ' + \
-              property_type.__name__ + ', not ' + value.__class__.__name__
+              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):
           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[:]
         elif isinstance(value, dict):
           self._properties[property] = value.copy()
         else:
-          raise TypeError, "Don't know how to copy a " + \
-                           value.__class__.__name__ + ' object for ' + \
-                           property + ' in ' + self.__class__.__name__
+          raise TypeError("Don't know how to copy a " + \
+                          value.__class__.__name__ + ' object for ' + \
+                          property + ' in ' + self.__class__.__name__)
       else:
         self._properties[property] = value
 
       # Set up the child's back-reference to this object.  Don't use |value|
       # any more because it may not be right if do_copy is true.
       if is_strong:
         if not is_list:
           self._properties[property].parent = self
         else:
           for item in self._properties[property]:
@@ skipping 10 matching lines @@
 
   def DelProperty(self, key):
     if key in self._properties:
       del self._properties[key]
 
   def AppendProperty(self, key, value):
     # TODO(mark): Support ExtendProperty too (and make this call that)?
 
     # Schema validation.
     if not key in self._schema:
-      raise KeyError, key + ' not in ' + self.__class__.__name__
+      raise KeyError(key + ' not in ' + self.__class__.__name__)
 
     (is_list, property_type, is_strong) = self._schema[key][0:3]
     if not is_list:
-      raise TypeError, key + ' of ' + self.__class__.__name__ + ' must be list'
+      raise TypeError(key + ' of ' + self.__class__.__name__ + ' must be list')
     if not isinstance(value, property_type):
-      raise TypeError, 'item of ' + key + ' of ' + self.__class__.__name__ + \
-                       ' must be ' + property_type.__name__ + ', not ' + \
-                       value.__class__.__name__
+      raise TypeError('item of ' + key + ' of ' + self.__class__.__name__ + \
+                      ' must be ' + property_type.__name__ + ', not ' + \
+                      value.__class__.__name__)
 
     # If the property doesn't exist yet, create a new empty list to receive the
     # item.
     if not key in self._properties:
       self._properties[key] = []
 
     # Set up the ownership link.
     if is_strong:
       value.parent = self
 
     # 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():
       (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
+        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():
       (is_list, property_type, is_strong, is_required) = attributes[0:4]
       if is_required and len(attributes) >= 5 and \
           not property in self._properties:
@@ skipping 253 matching lines @@
   def HashablesForChild(self):
     # To avoid a circular reference the hashables used to compute a child id do
     # not include the child names.
     return XCHierarchicalElement.Hashables(self)
 
   def _AddChildToDicts(self, child):
     # Sets up this PBXGroup object's dicts to reference the child properly.
     child_path = child.PathFromSourceTreeAndPath()
     if child_path:
       if child_path in self._children_by_path:
-        raise ValueError, 'Found multiple children with path ' + child_path
+        raise ValueError('Found multiple children with path ' + child_path)
       self._children_by_path[child_path] = child
 
     if isinstance(child, PBXVariantGroup):
       child_name = child._properties.get('name', None)
       key = (child_name, child_path)
       if key in self._variant_children_by_name_and_path:
-        raise ValueError, 'Found multiple PBXVariantGroup children with ' + \
-                          'name ' + str(child_name) + ' and path ' + \
-                          str(child_path)
+        raise ValueError('Found multiple PBXVariantGroup children with ' + \
+                         'name ' + str(child_name) + ' and path ' + \
+                         str(child_path))
       self._variant_children_by_name_and_path[key] = child
 
   def AppendChild(self, child):
     # Callers should use this instead of calling
     # AppendProperty('children', child) directly because this function
     # maintains the group's dicts.
     self.AppendProperty('children', child)
     self._AddChildToDicts(child)
 
   def GetChildByName(self, name):
@@ skipping 435 matching lines @@
   def Name(self):
     return 'Build configuration list for ' + \
            self.parent.__class__.__name__ + ' "' + self.parent.Name() + '"'
 
   def ConfigurationNamed(self, name):
     """Convenience accessor to obtain an XCBuildConfiguration by name."""
     for configuration in self._properties['buildConfigurations']:
       if configuration._properties['name'] == name:
         return configuration
 
-    raise KeyError, name
+    raise KeyError(name)
 
   def DefaultConfiguration(self):
     """Convenience accessor to obtain the default XCBuildConfiguration."""
     return self.ConfigurationNamed(self._properties['defaultConfigurationName'])
 
   def HasBuildSetting(self, key):
     """Determines the state of a build setting in all XCBuildConfiguration
     child objects.
 
     If all child objects have key in their build settings, and the value is the
@@ skipping 36 matching lines @@
     # TODO(mark): This is wrong for build settings that are lists.  The list
     # contents should be compared (and a list copy returned?)
 
     value = None
     for configuration in self._properties['buildConfigurations']:
       configuration_value = configuration.GetBuildSetting(key)
       if value is None:
         value = configuration_value
       else:
         if value != configuration_value:
-          raise ValueError, 'Variant values for ' + key
+          raise ValueError('Variant values for ' + key)
 
     return value
 
   def SetBuildSetting(self, key, value):
     """Sets the build setting for key to value in all child
     XCBuildConfiguration objects.
     """
 
     for configuration in self._properties['buildConfigurations']:
       configuration.SetBuildSetting(key, value)
@@ skipping 86 matching lines @@
     self._files_by_xcfilelikeelement = {}
     for pbxbuildfile in self._properties.get('files', []):
       self._AddBuildFileToDicts(pbxbuildfile)
 
   def FileGroup(self, path):
     # Subclasses must override this by returning a two-element tuple.  The
     # first item in the tuple should be the PBXGroup to which "path" should be
     # added, either as a child or deeper descendant.  The second item should
     # be a boolean indicating whether files should be added into hierarchical
     # groups or one single flat group.
-    raise NotImplementedError, \
-          self.__class__.__name__ + ' must implement FileGroup'
+    raise NotImplementedError(
+          self.__class__.__name__ + ' must implement FileGroup')
 
   def _AddPathToDict(self, pbxbuildfile, path):
     """Adds path to the dict tracking paths belonging to this build phase.
 
     If the path is already a member of this build phase, raises an exception.
     """
 
     if path in self._files_by_path:
-      raise ValueError, 'Found multiple build files with path ' + path
+      raise ValueError('Found multiple build files with path ' + path)
     self._files_by_path[path] = pbxbuildfile
 
   def _AddBuildFileToDicts(self, pbxbuildfile, path=None):
     """Maintains the _files_by_path and _files_by_xcfilelikeelement dicts.
 
     If path is specified, then it is the path that is being added to the
     phase, and pbxbuildfile must contain either a PBXFileReference directly
     referencing that path, or it must contain a PBXVariantGroup that itself
     contains a PBXFileReference referencing the path.
 
@@ skipping 34 matching lines @@
     # Add the paths first, because if something's going to raise, the
     # messages provided by _AddPathToDict are more useful owing to its
     # having access to a real pathname and not just an object's Name().
     for a_path in paths:
       self._AddPathToDict(pbxbuildfile, a_path)
 
     # If another PBXBuildFile references this XCFileLikeElement, there's a
     # problem.
     if xcfilelikeelement in self._files_by_xcfilelikeelement and \
        self._files_by_xcfilelikeelement[xcfilelikeelement] != pbxbuildfile:
-      raise ValueError, 'Found multiple build files for ' + \
-                        xcfilelikeelement.Name()
+      raise ValueError('Found multiple build files for ' + \
+                       xcfilelikeelement.Name())
     self._files_by_xcfilelikeelement[xcfilelikeelement] = pbxbuildfile
 
   def AppendBuildFile(self, pbxbuildfile, path=None):
     # Callers should use this instead of calling
     # AppendProperty('files', pbxbuildfile) directly because this function
     # maintains the object's dicts.  Better yet, callers can just call AddFile
     # with a pathname and not worry about building their own PBXBuildFile
     # objects.
     self.AppendProperty('files', pbxbuildfile)
     self._AddBuildFileToDicts(pbxbuildfile, path)
@@ skipping 143 matching lines @@
         # The path starts with an unrecognized Xcode variable
         # name like $(SRCROOT).  Xcode will still handle this
         # as an "absolute path" that starts with the variable.
         subfolder = 0
         relative_path = path
     elif path.startswith('/'):
       # Special case.  Absolute paths are in dstSubfolderSpec 0.
       subfolder = 0
       relative_path = path[1:]
     else:
-      raise ValueError, 'Can\'t use path %s in a %s' % \
-                        (path, self.__class__.__name__)
+      raise ValueError('Can\'t use path %s in a %s' % \
+                       (path, self.__class__.__name__))
 
     self._properties['dstPath'] = relative_path
     self._properties['dstSubfolderSpec'] = subfolder
 
 
 class PBXBuildRule(XCObject):
   _schema = XCObject._schema.copy()
   _schema.update({
     'compilerSpec': [0, str, 0, 1],
     'filePatterns': [0, str, 0, 0],
@@ skipping 783 matching lines @@
       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.
       product_group = ref_dict['ProductGroup']
       product_group._properties['children'] = sorted(
           product_group._properties['children'],
-          cmp=lambda x, y: CompareProducts(x, y, remote_products))
+          cmp=lambda x, y, rp=remote_products: CompareProducts(x, y, rp))
 
 
 class XCProjectFile(XCObject):
   _schema = XCObject._schema.copy()
   _schema.update({
     'archiveVersion': [0, int,        0, 1, 1],
     'classes':        [0, dict,       0, 1, {}],
     'objectVersion':  [0, int,        0, 1, 45],
     'rootObject':     [0, PBXProject, 1, 1],
   })
@@ skipping 63 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')