[test] Let presubmit only run over affected files.

tools/presubmit.py

 #!/usr/bin/env python
 #
 # Copyright 2012 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 53 matching lines @@
 -build/namespaces
 -readability/check
 -readability/fn_size
 +readability/streams
 -runtime/references
 """.split()
 
 LINT_OUTPUT_PATTERN = re.compile(r'^.+[:(]\d+[:)]|^Done processing')
 FLAGS_LINE = re.compile("//\s*Flags:.*--([A-z0-9-])+_[A-z0-9].*\n")
 
+TOOLS_PATH = dirname(abspath(__file__))
+
 def CppLintWorker(command):
   try:
     process = subprocess.Popen(command, stderr=subprocess.PIPE)
     process.wait()
     out_lines = ""
     error_count = -1
     while True:
       out_line = process.stderr.readline()
       if out_line == '' and process.poll() != None:
         if error_count == -1:
@@ skipping 65 matching lines @@
     if file in self.sums:
       self.sums.pop(file)
 
 
 class SourceFileProcessor(object):
   """
   Utility class that can run through a directory structure, find all relevant
   files and invoke a custom check on the files.
   """
 
-  def Run(self, path):
+  def RunOnPath(self, path):
+    """Runs processor on all files under the given path."""
+
     all_files = []
     for file in self.GetPathsToSearch():
       all_files += self.FindFilesIn(join(path, file))
-    if not self.ProcessFiles(all_files, path):
-      return False
-    return True
+    return self.ProcessFiles(all_files)
+
+  def RunOnFiles(self, files):
+    """Runs processor only on affected files."""
+
+    # Helper for getting directory pieces.
+    dirs = lambda f: dirname(f).split(os.sep)
+
+    # Path offsets where to look (to be in sync with RunOnPath).
+    # Normalize '.' to check for it with str.startswith.
+    search_paths = [('' if p == '.' else p) for p in self.GetPathsToSearch()]
+
+    all_files = [
+      f.AbsoluteLocalPath()
+      for f in files
+      if (not self.IgnoreFile(f.LocalPath()) and
+          self.IsRelevant(f.LocalPath()) and
+          all(not self.IgnoreDir(d) for d in dirs(f.LocalPath())) and
+          any(map(f.LocalPath().startswith, search_paths)))
+    ]
+
+    return self.ProcessFiles(all_files)
 
   def IgnoreDir(self, name):
     return (name.startswith('.') or
             name in ('buildtools', 'data', 'gmock', 'gtest', 'kraken',
                      'octane', 'sunspider'))
 
   def IgnoreFile(self, name):
     return name.startswith('.')
 
   def FindFilesIn(self, path):
@@ skipping 31 matching lines @@
 
   def GetCpplintScript(self, prio_path):
     for path in [prio_path] + os.environ["PATH"].split(os.pathsep):
       path = path.strip('"')
       cpplint = os.path.join(path, "cpplint.py")
       if os.path.isfile(cpplint):
         return cpplint
 
     return None
 
-  def ProcessFiles(self, files, path):
+  def ProcessFiles(self, files):
     good_files_cache = FileContentsCache('.cpplint-cache')
     good_files_cache.Load()
     files = good_files_cache.FilterUnchangedFiles(files)
     if len(files) == 0:
       print 'No changes in files detected. Skipping cpplint check.'
       return True
 
     filters = ",".join([n for n in LINT_RULES])
     command = [sys.executable, 'cpplint.py', '--filter', filters]
-    cpplint = self.GetCpplintScript(join(path, "tools"))
+    cpplint = self.GetCpplintScript(TOOLS_PATH)
     if cpplint is None:
       print('Could not find cpplint.py. Make sure '
             'depot_tools is installed and in the path.')
       sys.exit(1)
 
     command = [sys.executable, cpplint, '--filter', filters]
 
     commands = join([command + [file] for file in files])
     count = multiprocessing.cpu_count()
     pool = multiprocessing.Pool(count)
@@ skipping 136 matching lines @@
       print "%s does not end with a single new line." % name
       result = False
     # Sanitize flags for fuzzer.
     if "mjsunit" in name:
       match = FLAGS_LINE.search(contents)
       if match:
         print "%s Flags should use '-' (not '_')" % name
         result = False
     return result
 
-  def ProcessFiles(self, files, path):
+  def ProcessFiles(self, files):
     success = True
     violations = 0
     for file in files:
       try:
         handle = open(file)
         contents = handle.read()
         if not self.ProcessContents(file, contents):
           success = False
           violations += 1
       finally:
@@ skipping 36 matching lines @@
     keys = {}
     for key, value in pairs:
       if key in keys:
         print("%s: Error: duplicate key %s" % (filepath, key))
         status["success"] = False
       keys[key] = True
 
   json.loads(contents, object_pairs_hook=check_pairs)
   return status["success"]
 
 def CheckStatusFiles(workspace):

[Michael Achenbach, 2016/11/23 20:18:25]

Will also change this one in a follow up CL. Probably just takes a few
miliseconds, but for consistency...

   success = True
   suite_paths = utils.GetSuitePaths(join(workspace, "test"))
   for root in suite_paths:
     suite_path = join(workspace, "test", root)
     status_file_path = join(suite_path, root + ".status")
     suite = testsuite.TestSuite.LoadTestSuite(suite_path)
     if suite and exists(status_file_path):
       success &= statusfile.PresubmitCheck(status_file_path)
       success &= _CheckStatusFileForDuplicateKeys(status_file_path)
   return success
@@ skipping 33 matching lines @@
   return result
 
 
 def Main():
   workspace = abspath(join(dirname(sys.argv[0]), '..'))
   parser = GetOptions()
   (options, args) = parser.parse_args()
   success = True
   print "Running C++ lint check..."
   if not options.no_lint:
-    success &= CppLintProcessor().Run(workspace)
+    success &= CppLintProcessor().RunOnPath(workspace)
   print "Running copyright header, trailing whitespaces and " \
         "two empty lines between declarations check..."
-  success &= SourceProcessor().Run(workspace)
+  success &= SourceProcessor().RunOnPath(workspace)
   success &= CheckStatusFiles(workspace)
   if success:
     return 0
   else:
     return 1
 
 
 if __name__ == '__main__':
   sys.exit(Main())