Fixing pylint.

tools/pretty_vcproj.py

 #!/usr/bin/env python
 
-# Copyright (c) 2009 Google Inc. All rights reserved.
+# 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.
 
 """Make the format of a vcproj really pretty.
 
    This script normalize and sort an xml. It also fetches all the properties
    inside linked vsprops and include them explicitly in the vcproj.
 
    It outputs the resulting xml to stdout.
 """
 
 __author__ = 'nsylvain (Nicolas Sylvain)'
 
 import os
 import sys
 
 from xml.dom.minidom import parse
 from xml.dom.minidom import Node
 
 REPLACEMENTS = dict()
 ARGUMENTS = None
 
 
 class CmpTuple(object):
   """Compare function between 2 tuple."""
   def __call__(self, x, y):
-    (key1, value1) = x
-    (key2, value2) = y
-    return cmp(key1, key2)
+    return cmp(x[0], y[0])
 
 
 class CmpNode(object):
   """Compare function between 2 xml nodes."""
 
-  def get_string(self, node):
-    node_string = "node"
-    node_string += node.nodeName
-    if node.nodeValue:
-      node_string += node.nodeValue
+  def __call__(self, x, y):
+    def get_string(node):
+      node_string = "node"
+      node_string += node.nodeName
+      if node.nodeValue:
+        node_string += node.nodeValue
 
-    if node.attributes:
-      # We first sort by name, if present.
-      node_string += node.getAttribute("Name")
+      if node.attributes:
+        # We first sort by name, if present.
+        node_string += node.getAttribute("Name")
 
-      all_nodes = []
-      for (name, value) in node.attributes.items():
-        all_nodes.append((name, value))
+        all_nodes = []
+        for (name, value) in node.attributes.items():
+          all_nodes.append((name, value))
 
-      all_nodes.sort(CmpTuple())
-      for (name, value) in all_nodes:
-        node_string += name
-        node_string += value
+        all_nodes.sort(CmpTuple())
+        for (name, value) in all_nodes:
+          node_string += name
+          node_string += value
 
-    return node_string
+      return node_string
 
-  def __call__(self, x, y):
-    return cmp(self.get_string(x), self.get_string(y))
+    return cmp(get_string(x), get_string(y))
 
 
 def PrettyPrintNode(node, indent=0):
   if node.nodeType == Node.TEXT_NODE:
     if node.data.strip():
       print '%s%s' % (' '*indent, node.data.strip())
     return
 
   if node.childNodes:
     node.normalize()
@@ skipping 74 matching lines @@
 
 def CleanupVcproj(node):
   """For each sub node, we call recursively this function."""
   for sub_node in node.childNodes:
     AbsoluteNode(sub_node)
     CleanupVcproj(sub_node)
 
   # Normalize the node, and remove all extranous whitespaces.
   for sub_node in node.childNodes:
     if sub_node.nodeType == Node.TEXT_NODE:
-        sub_node.data = sub_node.data.replace("\r", "")
-        sub_node.data = sub_node.data.replace("\n", "")
-        sub_node.data = sub_node.data.rstrip()
+      sub_node.data = sub_node.data.replace("\r", "")
+      sub_node.data = sub_node.data.replace("\n", "")
+      sub_node.data = sub_node.data.rstrip()
 
   # Fix all the semicolon separated attributes to be sorted, and we also
   # remove the dups.
   if node.attributes:
     for (name, value) in node.attributes.items():
       sorted_list = sorted(value.split(';'))
       unique_list = []
-      [unique_list.append(i) for i in sorted_list if not unique_list.count(i)]
+      for i in sorted_list:
+        if not unique_list.count(i):
+          unique_list.append(i)
       node.setAttribute(name, ';'.join(unique_list))
       if not value:
         node.removeAttribute(name)
 
   if node.childNodes:
     node.normalize()
 
   # For each node, take a copy, and remove it from the list.
   node_array = []
   while node.childNodes and node.childNodes[0]:
@@ skipping 94 matching lines @@
   MergeAttributes(node1, node2)
   for child2 in node2.childNodes:
     child1 = SeekToNode(node1, child2)
     if child1:
       MergeProperties(child1, child2)
     else:
       node1.appendChild(child2.cloneNode(True))
 
 
 def main(argv):
-  global REPLACEMENTS
+  """Main function of this vcproj prettifier."""
   global ARGUMENTS
   ARGUMENTS = argv
-  """Main function of this vcproj prettifier."""
 
   # check if we have exactly 1 parameter.
   if len(argv) < 2:
     print ('Usage: %s "c:\\path\\to\\vcproj.vcproj" [key1=value1] '
            '[key2=value2]' % argv[0])
     return 1
 
   # Parse the keys
   for i in range(2, len(argv)):
     (key, value) = argv[i].split('=')
     REPLACEMENTS[key] = value
 
   # Open the vcproj and parse the xml.
   dom = parse(argv[1])
 
   # First thing we need to do is find the Configuration Node and merge them
   # with the vsprops they include.
   for configuration_node in GetConfiguationNodes(dom.documentElement):
     # Get the property sheets associated with this configuration.
     vsprops = configuration_node.getAttribute('InheritedPropertySheets')
 
     # Fix the filenames to be absolute.
     vsprops_list = FixFilenames(vsprops.strip().split(';'),
                                 os.path.dirname(argv[1]))
 
     # Extend the list of vsprops with all vsprops contained in the current
     # vsprops.
     for current_vsprops in vsprops_list:
-     vsprops_list.extend(GetChildrenVsprops(current_vsprops))
+      vsprops_list.extend(GetChildrenVsprops(current_vsprops))
 
     # Now that we have all the vsprops, we need to merge them.
     for current_vsprops in vsprops_list:
       MergeProperties(configuration_node,
                       parse(current_vsprops).documentElement)
 
   # Now that everything is merged, we need to cleanup the xml.
   CleanupVcproj(dom.documentElement)
 
   # Finally, we use the prett xml function to print the vcproj back to the
   # user.
   #print dom.toprettyxml(newl="\n")
   PrettyPrintNode(dom.documentElement)
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))