add PRESUBMIT for native_client_sdk.

native_client_sdk/src/tools/oshelpers.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import fnmatch
 import glob
 import optparse
 import os
 import posixpath
 import shutil
 import sys
 import time
 import zipfile
 
 
 def IncludeFiles(filters, files):
   """Filter files based on inclusion lists
   
   Return a list of files which match and of the Unix shell-style wildcards
   provided, or return all the files if no filter is provided."""
   if not filters: 
     return files
   match = set()
-  for filter in filters:
-    match |= set(fnmatch.filter(files, filter))
+  for file_filter in filters:
+    match |= set(fnmatch.filter(files, file_filter))
   return [name for name in files if name in match]
 
 
 def ExcludeFiles(filters, files):
   """Filter files based on exclusions lists
   
   Return a list of files which do not match any of the Unix shell-style
   wildcards provided, or return all the files if no filter is provided."""
   if not filters: 
     return files
   match = set()
-  for filter in filters:
-    excludes = set(fnmatch.filter(files, filter))
+  for file_filter in filters:
+    excludes = set(fnmatch.filter(files, file_filter))
     match |= excludes
   return [name for name in files if name not in match]
 
 
 def CopyPath(options, src, dst):
   """CopyPath from src to dst
   
   Copy a fully specified src to a fully specified dst.  If src and dst are
   both files, the dst file is removed first to prevent error.  If and include
   or exclude list are provided, the destination is first matched against that
@@ skipping 106 matching lines @@
 
   options, dsts = parser.parse_args(args)
   if len(dsts) < 1:
     parser.error('ERROR: expecting DIRECTORY...')
 
   for dst in dsts:
     if options.verbose:
       print 'mkdir ' + dst
     try:
       os.makedirs(dst)
-    except OSError as error:
+    except OSError:
       if os.path.isdir(dst):
         if options.parents:
           continue
         raise OSError('mkdir: Already exsists: ' + dst)
       else:
         raise OSError('mkdir: Failed to create: ' + dst)
   return 0
 
 
 def MovePath(options, src, dst):
   """MovePath from src to dst
   
   Moves the src to the dst much like the Unix style mv command, except it
   only handles one source at a time.  Because of possible temporary failures
   do to locks (such as anti-virus software on Windows), the function will retry
   up to five times.""" 
   # if the destination is not an existing directory, then overwrite it
   if os.path.isdir(dst):
     dst = os.path.join(dst, os.path.basename(src))
 
   # If the destination exists, the remove it
   if os.path.exists(dst):
     if options.force:
       Remove(['-vfr', dst])
       if os.path.exists(dst):
         raise OSError('mv: FAILED TO REMOVE ' + dst)
     else:
       raise OSError('mv: already exists ' + dst)
-  for i in range(5):
+  for _ in range(5):
     try:
       os.rename(src, dst)
       return
     except OSError as error:
       print 'Failed on %s with %s, retrying' % (src, error)
       time.sleep(5)
   print 'Gave up.'
   raise OSError('mv: ' + error)
 
 
 def Move(args):
   parser = optparse.OptionParser(usage='usage: mv [Options] souces... dest')
   parser.add_option(
       '-v', '--verbose', dest='verbose', action='store_true',
       default=False,
       help='verbose output.')
   parser.add_option(
       '-f', '--force', dest='force', action='store_true',
       default=False,
       help='force, do not error it files already exist.')
   options, files = parser.parse_args(args)
   if len(files) < 2:
     parser.error('ERROR: expecting SOURCE... and DEST.')
-  if options.verbose:
-    print 'mv %s %s' % (src, dst)
 
   srcs = files[:-1]
   dst = files[-1]
 
+  if options.verbose:
+    print 'mv %s %s' % (' '.join(srcs), dst)
+
   for src in srcs:
     MovePath(options, src, dst)
   return 0
 
 
 def Remove(args):
   """A Unix style rm.
   
   Removes the list of paths.  Because of possible temporary failures do to locks
   (such as anti-virus software on Windows), the function will retry up to five
@@ skipping 124 matching lines @@
     globbed_src_args = glob.glob(src_arg)
     if len(globbed_src_args) == 0:
       if not options.quiet:
         print 'zip warning: name not matched: %s' % (src_arg,)
 
     for src_file in globbed_src_args:
       src_file = os.path.normpath(src_file)
       src_files.append(src_file)
       if options.recursive and os.path.isdir(src_file):
         for root, dirs, files in os.walk(src_file):
-          for dir in dirs:
-            src_files.append(os.path.join(root, dir))
-          for file in files:
-            src_files.append(os.path.join(root, file))
+          for dirname in dirs:
+            src_files.append(os.path.join(root, dirname))
+          for filename in files:
+            src_files.append(os.path.join(root, filename))
 
   zip_stream = None
   # zip_data represents a list of the data to be written or appended to the
   # zip_stream. It is a list of tuples:
   #   (OS file path, zip path/zip file info, and file data)
   # In all cases one of the |os path| or the |file data| will be None.
   # |os path| is None when there is no OS file to write to the archive (i.e.
   # the file data already existed in the archive). |file data| is None when the
   # file is new (never existed in the archive) or being updated.
   zip_data = []
@@ skipping 71 matching lines @@
   'zip': Zip,
 }
 
 
 if __name__ == '__main__':
   func = FuncMap.get(sys.argv[1])
   if not func:
     print 'Do not recognize: ' + sys.argv[1]
     sys.exit(1)
   sys.exit(func(sys.argv[2:]))