Remove manual --tbr support and convert it into automatic TBR= detection.

presubmit_support.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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.
 
 """Enables directory-specific presubmit checks to run at upload and/or commit.
 """
 
 __version__ = '1.6.1'
 
@@ skipping 199 matching lines @@
       r".*\bRelease[\\\/].*",
       r".*\bxcodebuild[\\\/].*",
       r".*\bsconsbuild[\\\/].*",
       # All caps files like README and LICENCE.
       r".*\b[A-Z0-9_]{2,}$",
       # SCM (can happen in dual SCM configuration). (Slightly over aggressive)
       r"(|.*[\\\/])\.git[\\\/].*",
       r"(|.*[\\\/])\.svn[\\\/].*",
   )
 
-  def __init__(self, change, presubmit_path, is_committing, tbr,
+  def __init__(self, change, presubmit_path, is_committing,
       rietveld_obj, verbose):
     """Builds an InputApi object.
 
     Args:
       change: A presubmit.Change object.
       presubmit_path: The path to the presubmit script being processed.
       is_committing: True if the change is about to be committed.
-      tbr: True if '--tbr' was passed to skip any reviewer/owner checks
       rietveld_obj: rietveld.Rietveld client object
     """
     # Version number of the presubmit_support script.
     self.version = [int(x) for x in __version__.split('.')]
     self.change = change
     self.is_committing = is_committing
-    self.tbr = tbr
     self.rietveld = rietveld_obj
     # TBD
     self.host_url = 'http://codereview.chromium.org'
     if self.rietveld:
       self.host_url = self.rietveld.url
 
     # We expose various modules and functions as attributes of the input_api
     # so that presubmit scripts don't have to import them.
     self.basename = os.path.basename
     self.cPickle = cPickle
@@ skipping 164 matching lines @@
     """Reads an arbitrary file.
 
     Deny reading anything outside the repository.
     """
     if isinstance(file_item, AffectedFile):
       file_item = file_item.AbsoluteLocalPath()
     if not file_item.startswith(self.change.RepositoryRoot()):
       raise IOError('Access outside the repository root is denied.')
     return gclient_utils.FileRead(file_item, mode)
 
+  @property
+  def tbr(self):
+    """Returns if a change is TBR'ed."""
+    return 'TBR' in self.change.tags
+
 
 class AffectedFile(object):
   """Representation of a file in a change."""
   # Method could be a function
   # pylint: disable=R0201
   def __init__(self, path, action, repository_root=''):
     self._path = path
     self._action = action
     self._local_root = repository_root
     self._is_directory = None
@@ skipping 520 matching lines @@
         presubmit_script, filename, project)
 
   slaves = list(set(results))
   if slaves and verbose:
     output_stream.write(', '.join(slaves))
     output_stream.write('\n')
   return slaves
 
 
 class PresubmitExecuter(object):
-  def __init__(self, change, committing, tbr, rietveld_obj, verbose):
+  def __init__(self, change, committing, rietveld_obj, verbose):
     """
     Args:
       change: The Change object.
       committing: True if 'gcl commit' is running, False if 'gcl upload' is.
-      tbr: True if '--tbr' was passed to skip any reviewer/owner checks
       rietveld_obj: rietveld.Rietveld client object.
     """
     self.change = change
     self.committing = committing
-    self.tbr = tbr
     self.rietveld = rietveld_obj
     self.verbose = verbose
 
   def ExecPresubmitScript(self, script_text, presubmit_path):
     """Executes a single presubmit script.
 
     Args:
       script_text: The text of the presubmit script.
       presubmit_path: The path to the presubmit file (this will be reported via
         input_api.PresubmitLocalPath()).
 
     Return:
       A list of result objects, empty if no problems.
     """
 
     # Change to the presubmit file's directory to support local imports.
     main_path = os.getcwd()
     os.chdir(os.path.dirname(presubmit_path))
 
     # Load the presubmit script into context.
     input_api = InputApi(self.change, presubmit_path, self.committing,
-                         self.tbr, self.rietveld, self.verbose)
+                         self.rietveld, self.verbose)
     context = {}
     try:
       exec script_text in context
     except Exception, e:
       raise PresubmitFailure('"%s" had an exception.\n%s' % (presubmit_path, e))
 
     # These function names must change if we make substantial changes to
     # the presubmit API that are not backwards compatible.
     if self.committing:
       function_name = 'CheckChangeOnCommit'
@@ skipping 21 matching lines @@
     return result
 
 
 def DoPresubmitChecks(change,
                       committing,
                       verbose,
                       output_stream,
                       input_stream,
                       default_presubmit,
                       may_prompt,
-                      tbr,
                       rietveld_obj):
   """Runs all presubmit checks that apply to the files in the change.
 
   This finds all PRESUBMIT.py files in directories enclosing the files in the
   change (up to the repository root) and calls the relevant entrypoint function
   depending on whether the change is being committed or uploaded.
 
   Prints errors, warnings and notifications.  Prompts the user for warnings
   when needed.
 
   Args:
     change: The Change object.
     committing: True if 'gcl commit' is running, False if 'gcl upload' is.
     verbose: Prints debug info.
     output_stream: A stream to write output from presubmit tests to.
     input_stream: A stream to read input from the user.
     default_presubmit: A default presubmit script to execute in any case.
     may_prompt: Enable (y/n) questions on warning or error.
-    tbr: was --tbr specified to skip any reviewer/owner checks?
     rietveld_obj: rietveld.Rietveld object.
 
   Warning:
     If may_prompt is true, output_stream SHOULD be sys.stdout and input_stream
     SHOULD be sys.stdin.
 
   Return:
     A PresubmitOutput object. Use output.should_continue() to figure out
     if there were errors or warnings and the caller should abort.
   """
   old_environ = os.environ
   try:
     # Make sure python subprocesses won't generate .pyc files.
     os.environ = os.environ.copy()
     os.environ['PYTHONDONTWRITEBYTECODE'] = '1'
 
     output = PresubmitOutput(input_stream, output_stream)
     if committing:
       output.write("Running presubmit commit checks ...\n")
     else:
       output.write("Running presubmit upload checks ...\n")
     start_time = time.time()
     presubmit_files = ListRelevantPresubmitFiles(
         change.AbsoluteLocalPaths(True), change.RepositoryRoot())
     if not presubmit_files and verbose:
       output.write("Warning, no presubmit.py found.\n")
     results = []
-    executer = PresubmitExecuter(change, committing, tbr, rietveld_obj, verbose)
+    executer = PresubmitExecuter(change, committing, rietveld_obj, verbose)
     if default_presubmit:
       if verbose:
         output.write("Running default presubmit script.\n")
       fake_path = os.path.join(change.RepositoryRoot(), 'PRESUBMIT.py')
       results += executer.ExecPresubmitScript(default_presubmit, fake_path)
     for filename in presubmit_files:
       filename = os.path.abspath(filename)
       if verbose:
         output.write("Running %s\n" % filename)
       # Accept CRLF presubmit script.
@@ skipping 143 matching lines @@
                     files,
                     options.issue,
                     options.patchset,
                     options.author),
         options.commit,
         options.verbose,
         sys.stdout,
         sys.stdin,
         options.default_presubmit,
         options.may_prompt,
-        False,
         rietveld_obj)
     return not results.should_continue()
   except PresubmitFailure, e:
     print >> sys.stderr, e
     print >> sys.stderr, 'Maybe your depot_tools is out of date?'
     print >> sys.stderr, 'If all fails, contact maruel@'
     return 2
 
 
 if __name__ == '__main__':
   fix_encoding.fix_encoding()
   sys.exit(Main(None))