Only show landmines output if the environment says so.

build/landmines.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. 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 holds a list of reasons why a particular build needs to be clobbered
 (or a list of 'landmines').
 
 This script runs every build as a hook. If it detects that the build should
 be clobbered, it will touch the file <build_dir>/.landmine_triggered. The
 various build scripts will then check for the presence of this file and clobber
 accordingly. The script will also emit the reasons for the clobber to stdout.
 
 A landmine is tripped when a builder checks out a different revision, and the
 diff between the new landmines and the old ones is non-null. At this point, the
 build is clobbered.
 """
 
 import difflib
 import functools
 import gyp_helper
+import optparse
 import os
 import shlex
 import sys
 import time
 
 SRC_DIR = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+VERBOSE = 'LANDMINES_VERBOSE' in os.environ
 
 def memoize(default=None):
   """This decorator caches the return value of a parameterless pure function"""
   def memoizer(func):
     val = []
     @functools.wraps(func)
     def inner():
       if not val:
         ret = func()
         val.append(ret if ret is not None else default)
-        print '%s -> %r' % (func.__name__, val[0])
+        if VERBOSE:
+          print '%s -> %r' % (func.__name__, val[0])
       return val[0]
     return inner
   return memoizer
 
 
 @memoize()
 def IsWindows():
   return sys.platform.startswith('win') or sys.platform == 'cygwin'
 
 
@@ skipping 110 matching lines @@
     ret = os.path.join(SRC_DIR, 'out', target)
   elif build_tool == 'msvs':
     ret = os.path.join(SRC_DIR, 'build', target)
   elif build_tool == 'scons':
     ret = os.path.join(SRC_DIR, 'sconsbuild', target)
   else:
     raise NotImplementedError()
   return os.path.abspath(ret)
 
 
-def main(argv):
-  if len(argv) > 1:
-    print('Unknown arguments %s' % argv[1:])
-    return 1
+def GetOptions():

[M-A Ruel, 2012/11/14 23:12:01]

I don't think it's useful to have a function just for that for a file this
short. I'd personally merge that code in main().

+  parser = optparse.OptionParser()
+  parser.add_option('-v', '--verbose', action='store_true', default=False,

[M-A Ruel, 2012/11/14 23:12:01]

I prefer default='LANDMINES_VERBOSE' in os.environ, have line 30 with VERBOSE =
False and have 'default: %default' in the help. But I don't mind much.

+      help=('Emit some extra debugging information (default off). This option '
+          'is also enabled by the presence of a LANDMINES_VERBOSE environment '
+          'variable.'))
+  options, args = parser.parse_args()
+
+  if args:
+    parser.error('Unknown arguments %s' % args)
+
+  return options
+
+
+def main():
+  global VERBOSE
+  options = GetOptions()
+
+  VERBOSE = VERBOSE or options.verbose
 

[M-A Ruel, 2012/11/14 23:12:01]

FYI, I usually put a main() where I do all the argument parsing and sanitisation
and then call the "main function", which I usually name after the name of the
script name, to do the actual work. This gives a better separation of "input
sanitization vs work".

In your case, you have the "work" function call the sanitization, I usually do
the reverse.

That's fyi, I don't mind.

   gyp_helper.apply_chromium_gyp_env()
 
   for target in ('Debug', 'Release'):
     out_dir = get_target_build_dir(builder(), target,
                                    platform() == 'ios')
 
     landmines_path = os.path.join(out_dir, '.landmines')
     if not os.path.exists(out_dir):
       os.makedirs(out_dir)
 
@@ skipping 15 matching lines @@
         with open(triggered, 'w') as f:
           f.writelines(diff)
       elif os.path.exists(triggered):
         # Remove false triggered landmines.
         os.remove(triggered)
 
   return 0
 
 
 if __name__ == '__main__':
-  sys.exit(main(sys.argv))
+  sys.exit(main())