Add json output for gclient.

gclient_scm.py

 # 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.
 
 """Gclient-specific SCM-specific operations."""
 
 import collections
 import logging
 import os
 import posixpath
@@ skipping 172 matching lines @@
     match = self.PERCENT_RE.match(line)
     if not match:
       self.last_time = 0
     if (now - self.last_time) >= self.time_throttle:
       self.last_time = now
       print line
 
 
 class GitWrapper(SCMWrapper):
   """Wrapper for Git"""
+  name = 'git'
 
   cache_dir = None
   # If a given cache is used in a solution more than once, prevent multiple
   # threads from updating it simultaneously.
   cache_locks = collections.defaultdict(threading.Lock)
 
   def __init__(self, url=None, root_dir=None, relpath=None):
     """Removes 'git+' fake prefix from git URL."""
     if url.startswith('git+http://') or url.startswith('git+https://'):
       url = url[4:]
@@ skipping 153 matching lines @@
          not os.path.exists(os.path.join(self.checkout_path, '.git')))):
       self._Clone(revision, url, options)
       self.UpdateSubmoduleConfig()
       if file_list is not None:
         files = self._Capture(['ls-files']).splitlines()
         file_list.extend([os.path.join(self.checkout_path, f) for f in files])
       if not verbose:
         # Make the output a little prettier. It's nice to have some whitespace
         # between projects when cloning.
         print('')
-      return
+      return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
     if not managed:
       self._UpdateBranchHeads(options, fetch=False)
       self.UpdateSubmoduleConfig()
       print ('________ unmanaged solution; skipping %s' % self.relpath)
-      return
+      return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
     if not os.path.exists(os.path.join(self.checkout_path, '.git')):
       raise gclient_utils.Error('\n____ %s%s\n'
                                 '\tPath is not a git repo. No .git dir.\n'
                                 '\tTo resolve:\n'
                                 '\t\trm -rf %s\n'
                                 '\tAnd run gclient sync again\n'
                                 % (self.relpath, rev_str, self.relpath))
 
     # See if the url has changed (the unittests use git://foo for the url, let
@@ skipping 16 matching lines @@
       # Switch over to the new upstream
       self._Run(['remote', 'set-url', 'origin', url], options)
       self._FetchAndReset(revision, file_list, options)
       return_early = True
 
     # Need to do this in the normal path as well as in the post-remote-switch
     # path.
     self._PossiblySwitchCache(url, options)
 
     if return_early:
-      return
+      return self._Capture(['rev-parse', '--verify', 'HEAD'])
 
     cur_branch = self._GetCurrentBranch()
 
     # Cases:
     # 0) HEAD is detached. Probably from our initial clone.
     #   - make sure HEAD is contained by a named ref, then update.
     # Cases 1-4. HEAD is a branch.
     # 1) current branch is not tracking a remote branch (could be git-svn)
     #   - try to rebase onto the new hash or branch
     # 2) current branch is tracking a remote branch with local committed
@@ skipping 168 matching lines @@
       # 'git ls-files --directory --others --exclude-standard' here directly.
       paths = scm.GIT.Capture(
           ['ls-files', '--directory', '--others', '--exclude-standard'],
           self.checkout_path)
       for path in (p for p in paths.splitlines() if p.endswith('/')):
         full_path = os.path.join(self.checkout_path, path)
         if not os.path.islink(full_path):
           print('\n_____ removing unversioned directory %s' % path)
           gclient_utils.rmtree(full_path)
 
+    return self._Capture(['rev-parse', '--verify', 'HEAD'])
+
 
   def revert(self, options, _args, file_list):
     """Reverts local modifications.
 
     All reverted files will be appended to file_list.
     """
     if not os.path.isdir(self.checkout_path):
       # revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
       print('\n_____ %s is missing, synching instead' % self.relpath)
@@ skipping 473 matching lines @@
     else:
       kwargs.setdefault('print_stdout', True)
     stdout = kwargs.get('stdout', sys.stdout)
     stdout.write('\n________ running \'git %s\' in \'%s\'\n' % (
                  ' '.join(args), kwargs['cwd']))
     gclient_utils.CheckCallAndFilter(['git'] + args, **kwargs)
 
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
+  name = 'svn'
 
   @staticmethod
   def BinaryExists():
     """Returns true if the command exists."""
     try:
       result, version = scm.SVN.AssertVersion('1.4')
       if not result:
         raise gclient_utils.Error('SVN version is older than 1.4: %s' % version)
       return result
     except OSError:
@@ skipping 94 matching lines @@
           msg = ('Can\'t update/checkout %s if an unversioned directory is '
                  'present. Delete the directory and try again.')
           raise gclient_utils.Error(msg % self.checkout_path)
 
     if not exists:
       gclient_utils.safe_makedirs(os.path.dirname(self.checkout_path))
       # We need to checkout.
       command = ['checkout', url, self.checkout_path]
       command = self._AddAdditionalUpdateFlags(command, options, revision)
       self._RunAndGetFileList(command, options, file_list, self._root_dir)
-      return
+      return self.Svnversion()
 
     if not managed:
       print ('________ unmanaged solution; skipping %s' % self.relpath)
-      return
+      return self.Svnversion()
 
     if 'URL' not in from_info:
       raise gclient_utils.Error(
           ('gclient is confused. Couldn\'t get the url for %s.\n'
            'Try using @unmanaged.\n%s') % (
             self.checkout_path, from_info))
 
     # Look for locked directories.
     dir_info = scm.SVN.CaptureStatus(
         None, os.path.join(self.checkout_path, '.'))
@@ skipping 67 matching lines @@
                   ('Can\'t switch the checkout to %s; UUID don\'t match and '
                    'there is local changes in %s. Delete the directory and '
                    'try again.') % (url, self.checkout_path))
         # Ok delete it.
         print('\n_____ switching %s to a new checkout' % self.relpath)
         gclient_utils.rmtree(self.checkout_path)
         # We need to checkout.
         command = ['checkout', url, self.checkout_path]
         command = self._AddAdditionalUpdateFlags(command, options, revision)
         self._RunAndGetFileList(command, options, file_list, self._root_dir)
-        return
+        return self.Svnversion()
 
     # If the provided url has a revision number that matches the revision
     # number of the existing directory, then we don't need to bother updating.
     if not options.force and str(from_info['Revision']) == revision:
       if options.verbose or not forced_revision:
         print('\n_____ %s%s' % (self.relpath, rev_str))
     else:
       command = ['update', self.checkout_path]
       command = self._AddAdditionalUpdateFlags(command, options, revision)
       self._RunAndGetFileList(command, options, file_list, self._root_dir)
 
     # If --reset and --delete_unversioned_trees are specified, remove any
     # untracked files and directories.
     if options.reset and options.delete_unversioned_trees:
       for status in scm.SVN.CaptureStatus(None, self.checkout_path):
         full_path = os.path.join(self.checkout_path, status[1])
         if (status[0][0] == '?'
             and os.path.isdir(full_path)
             and not os.path.islink(full_path)):
           print('\n_____ removing unversioned directory %s' % status[1])
           gclient_utils.rmtree(full_path)
+    return self.Svnversion()
 
   def updatesingle(self, options, args, file_list):
     filename = args.pop()
     if scm.SVN.AssertVersion("1.5")[0]:
       if not os.path.exists(os.path.join(self.checkout_path, '.svn')):
         # Create an empty checkout and then update the one file we want.  Future
         # operations will only apply to the one file we checked out.
         command = ["checkout", "--depth", "empty", self.url, self.checkout_path]
         self._Run(command, options, cwd=self._root_dir)
         if os.path.exists(os.path.join(self.checkout_path, filename)):
@@ skipping 106 matching lines @@
     return '/'.join(self.url.split('/')[:4]) + url
 
   def _Run(self, args, options, **kwargs):
     """Runs a commands that goes to stdout."""
     kwargs.setdefault('cwd', self.checkout_path)
     kwargs.setdefault('nag_timer', self.nag_timer)
     kwargs.setdefault('nag_max', self.nag_max)
     gclient_utils.CheckCallAndFilterAndHeader(['svn'] + args,
         always=options.verbose, **kwargs)
 
+  def Svnversion(self):
+    """Runs the lowest checked out revision in the current project."""
+    info = scm.SVN.CaptureLocalInfo([], os.path.join(self.checkout_path, '.'))
+    return info['Revision']
+
   def _RunAndGetFileList(self, args, options, file_list, cwd=None):
     """Runs a commands that goes to stdout and grabs the file listed."""
     cwd = cwd or self.checkout_path
     scm.SVN.RunAndGetFileList(
         options.verbose,
         args + ['--ignore-externals'],
         cwd=cwd,
         file_list=file_list)
 
   @staticmethod
@@ skipping 19 matching lines @@
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'theirs-conflict'))
     elif options.manually_grab_svn_rev:
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'postpone'))
     elif command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
       new_command.extend(('--accept', 'postpone'))
     return new_command