First stab at using Rietveld wrapper object in both gcl.py and git-cl.

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'
+__version__ = '1.6.1'
 
 # TODO(joi) Add caching where appropriate/needed. The API is designed to allow
 # caching (between all different invocations of presubmit scripts for a given
 # change). We should add it as our presubmit scripts start feeling slow.
 
 import cPickle  # Exposed through the API.
 import cStringIO  # Exposed through the API.
 import fnmatch
 import glob
 import logging
@@ skipping 188 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[\\\/].*",
   )
 
-  # TODO(dpranke): Update callers to pass in tbr, host_url, remove
-  # default arguments.
-  def __init__(self, change, presubmit_path, is_committing, tbr, host_url,
-      verbose):
+  def __init__(self, change, presubmit_path, is_committing, tbr,
+      rietveld, 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
-      host_url: scheme, host, and path of rietveld instance
+      rietveld: rietveld client object
     """
     # Version number of the presubmit_support script.
     self.version = [int(x) for x in __version__.split('.')]
     self.change = change
-    self.host_url = host_url
     self.is_committing = is_committing
     self.tbr = tbr
-    self.host_url = host_url or 'http://codereview.chromium.org'
+    self.rietveld = rietveld
+    # TBD
+    self.host_url = 'http://codereview.chromium.org'
+    if self.rietveld:
+      self.host_url = 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
     self.cStringIO = cStringIO
     self.json = json
     self.os_listdir = os.listdir
     self.os_walk = os.walk
     self.os_path = os.path
@@ skipping 677 matching lines @@
     results += executer.ExecPresubmitScript(presubmit_script, filename)
 
   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, host_url, verbose):
+  def __init__(self, change, committing, tbr, rietveld, 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
-      host_url: scheme, host, and path of rietveld instance
-          (or None for default)
+      rietveld: rietveld client object.
     """
     self.change = change
     self.committing = committing
     self.tbr = tbr
-    self.host_url = host_url
+    self.rietveld = rietveld
     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.host_url, self.verbose)
+                         self.tbr, 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 14 matching lines @@
             'All presubmit results must be of types derived from '
             'output_api.PresubmitResult')
     else:
       result = ()  # no error since the script doesn't care about current event.
 
     # Return the process to the original working directory.
     os.chdir(main_path)
     return result
 
 
-# TODO(dpranke): make all callers pass in tbr, host_url?
 def DoPresubmitChecks(change,
                       committing,
                       verbose,
                       output_stream,
                       input_stream,
                       default_presubmit,
                       may_prompt,
-                      tbr=False,
-                      host_url=None):
+                      tbr,
+                      rietveld):
   """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?
-    host_url: scheme, host, and port of host to use for rietveld-related
-        checks
+    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.
   """
   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, host_url, verbose)
+  executer = PresubmitExecuter(change, committing, tbr, rietveld, 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 129 matching lines @@
                     options.description,
                     options.root,
                     files,
                     options.issue,
                     options.patchset),
         options.commit,
         options.verbose,
         sys.stdout,
         sys.stdin,
         options.default_presubmit,
-        options.may_prompt)
+        options.may_prompt,
+        False,
+        None)
     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))