Add --clean support to gypbuild....

gypbuild.py

 #! /usr/bin/env python
 # Copyright 2009 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
@@ skipping 19 matching lines @@
 import subprocess
 import platform
 sys.path.append('build')
 import is_admin
 from optparse import OptionParser
 
 
 class GypBuilder(object):
   """A class to help build gyp projects in a cross platform way"""
 
+  class Builder(object):
+    """Base Class for building."""
+
+    def __init__(self, builder):
+      self.builder = builder
+
+    def Log(self, *args):
+      """Prints something if verbose is true."""
+      self.builder.Log(args)
+
+    def Execute(self, args):
+      """Executes an external program if execute is true."""
+      self.builder.Execute(args)
+
+    def Dopresubmit(self, targets, options):
+      """Builds and runs both the unit tests and selenium."""
+      self.Dounit_tests(targets, options)
+      self.Doselenium(targets, options)
+
+    def Doselenium(self, targets, options):
+      """Builds and runs the selenium tests."""
+      print "selenium not yet implemented."
+
+    def Dounit_tests(self, targets, options):
+      """Builds and runs the unit tests."""
+      print "unit_tests not yet implemented."
+
+    def CleanTargets(self, targets, options):
+      """Cleans the targets."""
+      print "clean not implemented for this platform."
+
+
+  class OSXBuilder(Builder):
+    """Class for building on OSX."""
+
+    def __init__(self, builder):
+      GypBuilder.Builder.__init__(self, builder)
+
+    def GetSolutionPath(self):
+      """Gets the solution path."""
+      return '%s.xcodeproj' % GypBuilder.base_name
+
+    def CleanTargets(self, targets, options):
+      """Cleans the specifed targets."""
+      solution = self.GetSolutionPath()
+      self.Execute(['xcodebuild',
+                    '-project', solution,
+                    'clean'])
+
+    def Dobuild(self, targets, options):
+      """Builds the specifed targets."""
+      solution = self.GetSolutionPath()
+      self.Execute(['xcodebuild',
+                    '-project', solution])
+
+  class WinBuilder(Builder):
+    """Class for building on Windows."""
+
+    def __init__(self, builder):
+      GypBuilder.Builder.__init__(self, builder)
+
+    def GetSolutionPath(self):
+      """Gets the solution path."""
+      return os.path.abspath('%s.sln' % GypBuilder.base_name)
+
+    def CheckVisualStudioVersionVsSolution(self, solution):
+      """Checks the solution matches the cl version."""
+      f = open(solution, "r")
+      line = f.readline()
+      f.close()
+      m = re.search(r'Format Version (\d+)\.', line)
+      if m:
+        solution_version = int(m.group(1))
+      else:
+        print "FAILURE: Unknown solution version in %s" % solution
+        sys.exit(1)
+
+      output = subprocess.Popen(['cl.exe'],
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE).communicate()[1]
+      m = re.search(r'Compiler Version (\d+)\.', output)
+      if m:
+        compiler_version = int(m.group(1))
+      else:
+        print "FAILURE: Unknown cl.exe version."
+        sys.exit(1)
+
+      #                        Compiler    Solution
+      # Visual Studio .NET 2005   14          9
+      # Visual Studio .NET 2008   15         10
+      # Visual Studio .NET 2010   ??         ??
+      if (compiler_version - 14) > (solution_version - 9):
+        vs_map = {
+          14: '2005',
+          15: '2008',
+          16: '2010',
+        }
+        sln_map = {
+          9: '2005',
+          10: '2008',
+          11: '2010',
+        }
+        vs_version = vs_map[compiler_version]
+        print ("ERROR: solution (%s) version does not match "
+               "Visual Studio version (%s)" %
+               (sln_map[solution_version], vs_version))
+        print "You should 'set GYP_MSVS_VERSION=auto'"
+        print "and run 'gclient runhooks --force'"
+        sys.exit(1)
+
+    def CleanTargets(self, targets, options):
+      """Cleans the targets."""
+      solution = self.GetSolutionPath()
+      self.Execute(['devenv.exe',
+                    solution,
+                    '/clean',
+                    options.version])
+
+    def Dobuild(self, targets, options):
+      """Builds the specifed targets."""
+      solution = self.GetSolutionPath()
+      if not is_admin.IsAdmin():
+        print ("WARNING: selenium_ie will not run unless you run as admin "
+               "or turn off UAC.\nAfter switching to admin run "
+               "'gclient runhooks --force'")
+      self.CheckVisualStudioVersionVsSolution(solution)
+      self.Execute(['msbuild',
+                    solution,
+                    '/p:Configuration=%s' % options.version])
+
+  class LinuxBuilder(Builder):
+    """Class for building on Linux."""
+
+    def __init__(self, builder):
+      GypBuilder.Builder.__init__(self, builder)
+
+    def GetSolutionPath(self):
+      """Gets the solution path."""
+      return '%s_main.scons' % GypBuilder.base_name
+
+    def CleanTargets(self, targets, options):
+      """Cleans the targets."""
+      solution = self.GetSolutionPath()
+      self.Execute(['hammer',
+                    '-f', solution,
+                    '--clean'])
+
+    def Dobuild(self, targets, options):
+      """Builds the specifed targets."""
+      solution = self.GetSolutionPath()
+      self.Execute(['hammer',
+                    '-f', solution])
+
+  # Use "o3d" for chrome only build?
+  base_name = "o3d_all"
+
   def __init__(self, args):
     self.execute = True
     self.verbose = False
 
     modes = ["build", "presubmit", "selenium", "unit_tests"]
     versions = ["Debug", "Release"]
 
     parser = OptionParser()
     parser.add_option(
         "--list-targets", action="store_true",
-        help="lists all available targets")
+        help="lists all available targets.")
     parser.add_option(
         "--no-execute", action="store_true", default=False,
-        help="just print commands that would get executed")
+        help="just prints commands that would get executed.")
     parser.add_option(
         "--verbose", action="store_true",
-        help="prints more output")
+        help="prints more output.")
     parser.add_option(
         "--targets", action="append",
         help="targets to build separated by commas.")
     parser.add_option(
         "--clean", action="store_true",
-        help="clean the targets")
+        help="cleans the targets.")
+    parser.add_option(
+        "--rebuild", action="store_true",
+        help="cleans, then builds targets")
     parser.add_option(
         "--version", choices=versions, default="Debug",
         help="version to build. Versions are '%s'. Default='Debug' " %
              "', '".join(versions))
     parser.add_option(
         "--mode", choices=modes, default="build",
         help="mode to use. Valid modes are '%s'. Default='build' " %
              "', '".join(modes))
 
     (options, args) = parser.parse_args(args=args)
 
     self.verbose = options.verbose
     self.execute = not options.no_execute
 
     if options.list_targets:
       print "Not yet implemented"
       sys.exit(0)
 
     self.Log("mode:", options.mode)
 
     targets = options.targets
     if targets:
       # flatten the targets.
       targets = sum([t.split(",") for t in targets], [])
 
+    os.chdir("build")
+
+    # Create a platform specific builder.
+    if os.name == 'nt':
+      builder = self.WinBuilder(self)
+    elif platform.system() == 'Darwin':
+      builder = self.OSXBuilder(self)
+    elif platform.system() == 'Linux':
+      builder = self.LinuxBuilder(self)
+    else:
+      print "ERROR: Unknown platform."
+      sys.exit(1)
+
+    # clean if asked.
+    if options.clean or options.rebuild:
+      builder.CleanTargets(targets, options)
+      if not options.rebuild:
+        return
+
     # call a Do method based on the mode.
-    os.chdir("build")
-    func = getattr(self, "Do%s" % options.mode)
+    func = getattr(builder, "Do%s" % options.mode)
     func(targets, options)
 
   def Log(self, *args):
+    """Prints something if verbose is true."""
     if self.verbose:
       print args
 
   def Execute(self, args):
-    """Executes an external program."""
+    """Executes an external program if execute is true."""
     if self.execute:
       self.Log(" ".join(args))
       if subprocess.call(args) > 0:
         raise RuntimeError("FAILED: " + " ".join(args))
     else:
       print " ".join(args)
 
-  def CheckVisualStudioVersionVsSolution(self, solution):
-    """Checks the solution matches the cl version."""
-    f = open(solution, "r")
-    line = f.readline()
-    f.close()
-    m = re.search(r'Format Version (\d+)\.', line)
-    if m:
-      solution_version = int(m.group(1))
-    else:
-      print "FAILURE: Unknown solution version in %s" % solution
-      sys.exit(1)
-
-    output = subprocess.Popen(['cl.exe'],
-                              stdout=subprocess.PIPE,
-                              stderr=subprocess.PIPE).communicate()[1]
-    m = re.search(r'Compiler Version (\d+)\.', output)
-    if m:
-      compiler_version = int(m.group(1))
-    else:
-      print "FAILURE: Unknown cl.exe version."
-      sys.exit(1)
-
-    #                        Compiler    Solution
-    # Visual Studio .NET 2005   14          9
-    # Visual Studio .NET 2008   15         10
-    # Visual Studio .NET 2010   ??         ??
-    if (compiler_version - 14) > (solution_version - 9):
-      vs_map = {
-        14: '2005',
-        15: '2008',
-        16: '2010',
-      }
-      sln_map = {
-        9: '2005',
-        10: '2008',
-        11: '2010',
-      }
-      vs_version = vs_map[compiler_version]
-      print ("ERROR: solution (%s) version does not match "
-             "Visual Studio version (%s)" %
-             (sln_map[solution_version], vs_version))
-      print "You should 'set GYP_MSVS_VERSION=auto'"
-      print "and run 'gclient runhooks --force'"
-      sys.exit(1)
-
-  def Dobuild(self, targets, options):
-    """Builds the specifed targets."""
-
-    # Use "o3d" for chrome only build.
-    name = "o3d_all"
-
-    if os.name == 'nt':
-      solution = os.path.abspath('%s.sln' % name)
-      if not is_admin.IsAdmin():
-        print ("WARNING: selenium_ie will not run unless you run as admin "
-               "or turn off UAC.\nAfter switching to admin run "
-               "'gclient runhooks --force'")
-      self.CheckVisualStudioVersionVsSolution(solution)
-      self.Execute(['msbuild',
-                    solution,
-                    '/p:Configuration=%s' % options.version])
-    elif platform.system() == 'Darwin':
-      self.Execute(['xcodebuild',
-                    '-project', '%s.xcodeproj' % name])
-    elif platform.system() == 'Linux':
-      self.Execute(['hammer',
-                    '-f', '%s_main.scons' % name])
-    else:
-      print "Error: Unknown platform", os.name
-
-  def Dopresubmit(self, targets, options):
-    """Builds and runs both the unit tests and selenium."""
-    self.Dounit_tests(targets, options)
-    self.Doselenium(targets, options)
-
-  def Doselenium(self, targets, options):
-    """Builds and runs the selenium tests."""
-    print "selenium not yet implemented."
-
-  def Dounit_tests(self, targets, options):
-    """Builds and runs the unit tests."""
-    print "unit_tests not yet implemented."
-
 
 def main(args):
   GypBuilder(args[1:])
 
 if __name__ == "__main__":
   main(sys.argv)