Build Tools Cleanup

tools/utils.py

-# Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+# Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 # This file contains a set of utilities functions used by other Python-based
 # scripts.
 
 import commands
 import os
 import platform
 import re
 import shutil
 import subprocess
+import tempfile
 import sys
-import tempfile
 
 class Version(object):
   def __init__(self, channel, major, minor, patch, prerelease,
                prerelease_patch):
     self.channel = channel
     self.major = major
     self.minor = minor
     self.patch = patch
     self.prerelease = prerelease
     self.prerelease_patch = prerelease_patch
 
 # Try to guess the host operating system.
 def GuessOS():
-  id = platform.system()
-  if id == "Linux":
+  os_id = platform.system()
+  if os_id == "Linux":
     return "linux"
-  elif id == "Darwin":
+  elif os_id == "Darwin":
     return "macos"
-  elif id == "Windows" or id == "Microsoft":
+  elif os_id == "Windows" or os_id == "Microsoft":
     # On Windows Vista platform.system() can return "Microsoft" with some
     # versions of Python, see http://bugs.python.org/issue1082 for details.
     return "win32"
-  elif id == 'FreeBSD':
+  elif os_id == 'FreeBSD':
     return 'freebsd'
-  elif id == 'OpenBSD':
+  elif os_id == 'OpenBSD':
     return 'openbsd'
-  elif id == 'SunOS':
+  elif os_id == 'SunOS':
     return 'solaris'
   else:
     return None
 
 
 # Try to guess the host architecture.
 def GuessArchitecture():
-  id = platform.machine()
-  if id.startswith('arm'):
+  os_id = platform.machine()
+  if os_id.startswith('arm'):
     return 'arm'
-  elif id.startswith('aarch64'):
+  elif os_id.startswith('aarch64'):
     return 'arm64'
-  elif id.startswith('mips'):
+  elif os_id.startswith('mips'):
     return 'mips'
-  elif (not id) or (not re.match('(x|i[3-6])86', id) is None):
+  elif (not os_id) or (not re.match('(x|i[3-6])86', os_id) is None):
     return 'ia32'
-  elif id == 'i86pc':
+  elif os_id == 'i86pc':
     return 'ia32'
-  elif '64' in id:
+  elif '64' in os_id:
     return 'x64'
   else:
     guess_os = GuessOS()
-    print "Warning: Guessing architecture %s based on os %s\n" % (id, guess_os)
+    print "Warning: Guessing architecture %s based on os %s\n"\
+          % (os_id, guess_os)
     if guess_os == 'win32':
       return 'ia32'
     return None
 
 
 # Try to guess the number of cpus on this machine.
 def GuessCpus():
   if os.path.exists("/proc/cpuinfo"):
     return int(commands.getoutput("grep -E '^processor' /proc/cpuinfo | wc -l"))
   if os.path.exists("/usr/bin/hostinfo"):
@@ skipping 14 matching lines @@
     wow6432Node = ''
   return r'SOFTWARE\%s%s' % (wow6432Node, name)
 
 # Try to guess Visual Studio location when buiding on Windows.
 def GuessVisualStudioPath():
   defaultPath = r"C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7" \
                 r"\IDE"
   defaultExecutable = "devenv.com"
 
   if not IsWindows():
-    return (defaultPath, defaultExecutable)
+    return defaultPath, defaultExecutable
 
   keyNamesAndExecutables = [
     # Pair for non-Express editions.
     (GetWindowsRegistryKeyName(r'Microsoft\VisualStudio'), 'devenv.com'),
     # Pair for 2012 Express edition.
     (GetWindowsRegistryKeyName(r'Microsoft\VSWinExpress'), 'VSWinExpress.exe'),
     # Pair for pre-2012 Express editions.
     (GetWindowsRegistryKeyName(r'Microsoft\VCExpress'), 'VCExpress.exe')]
 
   bestGuess = (0.0, (defaultPath, defaultExecutable))
 
   import _winreg
   for (keyName, executable) in keyNamesAndExecutables:
     try:
       key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, keyName)
     except WindowsError:
       # Can't find this key - moving on the next one.
       continue
 
     try:
       subkeyCounter = 0
       while True:
         try:
           subkeyName = _winreg.EnumKey(key, subkeyCounter)
-          subkeyCounter = subkeyCounter + 1
+          subkeyCounter += 1
         except WindowsError:
           # Reached end of enumeration. Moving on the next key.
           break
 
         match = re.match(r'^\d+\.\d+$', subkeyName)
         if match:
           with _winreg.OpenKey(key, subkeyName) as subkey:
             try:
               (installDir, registrytype) = _winreg.QueryValueEx(subkey,
                                                                 'InstallDir')
             except WindowsError:
               # Can't find value under the key - continue to the next key.
               continue
             isExpress = executable != 'devenv.com'
             if not isExpress and subkeyName == '10.0':
               # Stop search since if we found non-Express VS2010 version
               # installed, which is preferred version.
-              return (installDir, executable)
+              return installDir, executable
             else:
               version = float(subkeyName)
               # We prefer higher version of Visual Studio and given equal
               # version numbers we prefer non-Express edition.
               if version > bestGuess[0]:
                 bestGuess = (version, (installDir, executable))
     finally:
       _winreg.CloseKey(key)
   return bestGuess[1]
 
@@ skipping 11 matching lines @@
     if '#' in line:
       line = line[:line.find('#')]
     line = line.strip()
     if len(line) == 0:
       continue
     result.append(line)
   return result
 
 # Filters out all arguments until the next '--' argument
 # occurs.
-def ListArgCallback(option, opt_str, value, parser):
+def ListArgCallback(option, value, parser):
    if value is None:
      value = []
 
    for arg in parser.rargs:
      if arg[:2].startswith('--'):
        break
      value.append(arg)
 
    del parser.rargs[:len(value)]
    setattr(parser.values, option.dest, value)
 
 
 # Filters out all argument until the first non '-' or the
 # '--' argument occurs.
-def ListDartArgCallback(option, opt_str, value, parser):
+def ListDartArgCallback(option, value, parser):
    if value is None:
      value = []
 
    for arg in parser.rargs:
      if arg[:2].startswith('--') or arg[0] != '-':
        break
      value.append(arg)
 
    del parser.rargs[:len(value)]
    setattr(parser.values, option.dest, value)
@@ skipping 46 matching lines @@
     return '%s%s%s' % (GetBuildMode(mode), conf_os.title(), arch.upper())
   else:
     # Ask for a cross build if the host and target architectures don't match.
     host_arch = ARCH_GUESS
     cross_build = ''
     if GetArchFamily(host_arch) != GetArchFamily(arch):
       print "GetBuildConf: Cross-build of %s on %s\n" % (arch, host_arch)
       cross_build = 'X'
     return '%s%s%s' % (GetBuildMode(mode), cross_build, arch.upper())
 
-def GetBuildDir(host_os, target_os):
+def GetBuildDir(host_os):
   return BUILD_ROOT[host_os]
 
-def GetBuildRoot(host_os, mode=None, arch=None, target_os=None):
-  build_root = GetBuildDir(host_os, target_os)
+def GetBuildRoot(host_os, mode=None, arch=None):
+  build_root = GetBuildDir(host_os)
   if mode:
     build_root = os.path.join(build_root, GetBuildConf(mode, arch))
   return build_root
 
 def GetBaseDir():
   return BASE_DIR
 
 def GetShortVersion():
   version = ReadVersionFile()
   return ('%s.%s.%s.%s.%s' % (
@@ skipping 36 matching lines @@
   version = ReadVersionFile()
   return version.channel
 
 def GetUserName():
   key = 'USER'
   if sys.platform == 'win32':
     key = 'USERNAME'
   return os.environ.get(key, '')
 
 def ReadVersionFile():
-  def match_against(pattern, content):
-    match = re.search(pattern, content, flags=re.MULTILINE)
+  def match_against(pattern, file_content):
+    match = re.search(pattern, file_content, flags=re.MULTILINE)
     if match:
       return match.group(1)
     return None
 
   version_file = os.path.join(DART_DIR, 'tools', 'VERSION')
   try:
     fd = open(version_file)
     content = fd.read()
     fd.close()
   except:
@@ skipping 73 matching lines @@
 def ParseSvnInfoOutput(output):
   revision_match = re.search('Last Changed Rev: (\d+)', output)
   if revision_match:
     return revision_match.group(1)
   return None
 
 def RewritePathSeparator(path, workspace):
   # Paths in test files are always specified using '/'
   # as the path separator. Replace with the actual
   # path separator before use.
-  if ('/' in path):
+  if '/' in path:
     split_path = path.split('/')
     path = os.sep.join(split_path)
     path = os.path.join(workspace, path)
     if not os.path.exists(path):
       raise Exception(path)
   return path
 
 
 def ParseTestOptions(pattern, source, workspace):
   match = pattern.search(source)
   if match:
     return [RewritePathSeparator(o, workspace) for o in match.group(1).split(' ')]
   else:
     return None
 
 
 def ParseTestOptionsMultiple(pattern, source, workspace):
   matches = pattern.findall(source)
   if matches:
     result = []
     for match in matches:
       if len(match) > 0:
         result.append(
-            [RewritePathSeparator(o, workspace) for o in match.split(' ')]);
+            [RewritePathSeparator(o, workspace) for o in match.split(' ')])
       else:
         result.append([])
     return result
   else:
     return None
 
 
 def ConfigureJava():
   java_home = '/usr/libexec/java_home'
   if os.path.exists(java_home):
     proc = subprocess.Popen([java_home, '-v', '1.6+'],
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
     (stdout, stderr) = proc.communicate()
     if proc.wait() != 0:
       return None
     new = stdout.strip()
-    current = os.getenv('JAVA_HOME', default=new)
+    current = os.getenv('JAVA_HOME', new)
     if current != new:
       sys.stderr.write('Please set JAVA_HOME to %s\n' % new)
       os.putenv('JAVA_HOME', new)
 
 
 def Daemonize():
   """
   Create a detached background process (daemon). Returns True for
   the daemon, False for the parent process.
   See: http://www.faqs.org/faqs/unix-faq/programmer/faq/
   "1.7 How do I get my program to act like a daemon?"
   """
   if os.fork() > 0:
     return False
   os.setsid()
   if os.fork() > 0:
-    os._exit(0)
+    exit(0)
     raise
   return True
 
 
-def PrintError(str):
+def PrintError(string):
   """Writes and flushes a string to stderr."""
-  sys.stderr.write(str)
+  sys.stderr.write(string)
   sys.stderr.write('\n')
 
 
 def CheckedUnlink(name):
   """Unlink a file without throwing an exception."""
   try:
     os.unlink(name)
   except OSError, e:
     PrintError("os.unlink() " + str(e))
 
 
-def Main(argv):
+def Main():
   print "GuessOS() -> ", GuessOS()
   print "GuessArchitecture() -> ", GuessArchitecture()
   print "GuessCpus() -> ", GuessCpus()
   print "IsWindows() -> ", IsWindows()
   print "GuessVisualStudioPath() -> ", GuessVisualStudioPath()
 
 
 class Error(Exception):
   pass
 
@@ skipping 27 matching lines @@
 
 
 def ExecuteCommand(cmd):
   """Execute a command in a subprocess."""
   print 'Executing: ' + ' '.join(cmd)
   pipe = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
       shell=IsWindows())
   output = pipe.communicate()
   if pipe.returncode != 0:
     raise Exception('Execution failed: ' + str(output))
-  return (pipe.returncode, output)
+  return pipe.returncode, output
 
 
 def DartBinary():
   tools_dir = os.path.dirname(os.path.realpath(__file__))
   dart_binary_prefix = os.path.join(tools_dir, 'testing', 'bin')
   if IsWindows():
     return os.path.join(dart_binary_prefix, 'windows', 'dart.exe')
   else:
     arch = GuessArchitecture()
     system = GuessOS()
@@ skipping 33 matching lines @@
     print "Enter directory = ", self._working_directory
     os.chdir(self._working_directory)
 
   def __exit__(self, *_):
     print "Enter directory = ", self._old_cwd
     os.chdir(self._old_cwd)
 
 
 if __name__ == "__main__":
   import sys
-  Main(sys.argv)
+  Main()