Add .revisions() implementation to *Checkout classes.

checkout.py

 # coding=utf8
 # 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.
 """Manages a project checkout.
 
 Includes support for svn, git-svn and git.
 """
 
 import ConfigParser
@@ skipping 102 matching lines @@
 
     Args:
       patches: patch.PatchSet object.
     """
     raise NotImplementedError()
 
   def commit(self, commit_message, user):
     """Commits the patch upstream, while impersonating 'user'."""
     raise NotImplementedError()
 
+  def revisions(self, rev1, rev2):
+    """Returns the count of revisions from rev1 to rev2, e.g. len(]rev1, rev2]).
+
+    If rev2 is None, it means 'HEAD'.
+
+    Returns None if there is no link between the two.
+    """
+    raise NotImplementedError()
+
 
 class RawCheckout(CheckoutBase):
   """Used to apply a patch locally without any intent to commit it.
 
   To be used by the try server.
   """
   def prepare(self, revision):
     """Stubbed out."""
     pass
 
@@ skipping 42 matching lines @@
       except OSError, e:
         raise PatchApplicationFailed(p, '%s%s' % (stdout, e))
       except subprocess.CalledProcessError, e:
         raise PatchApplicationFailed(
             p, '%s%s' % (stdout, getattr(e, 'stdout', None)))
 
   def commit(self, commit_message, user):
     """Stubbed out."""
     raise NotImplementedError('RawCheckout can\'t commit')
 
+  def revisions(self, _rev1, _rev2):
+    return None

[cmp, 2012/07/25 20:03:01]

should this raise NotImplementedError, instead?

[M-A Ruel, 2012/07/25 20:25:03]

I prefer to keep None being returned when it's impossible to get the value,
since it's simpler for the caller.

Note that I uploaded another patchset that traps the CalledProcessError, I had
forgot about trapping them properly.

+
 
 class SvnConfig(object):
   """Parses a svn configuration file."""
   def __init__(self, svn_config_dir=None):
     super(SvnConfig, self).__init__()
     self.svn_config_dir = svn_config_dir
     self.default = not bool(self.svn_config_dir)
     if not self.svn_config_dir:
       if sys.platform == 'win32':
         self.svn_config_dir = os.path.join(os.environ['APPDATA'], 'Subversion')
@@ skipping 223 matching lines @@
     return self._get_revision()
 
   def _get_revision(self):
     out = self._check_output_svn(['info', '.'])
     revision = int(self._parse_svn_info(out, 'revision'))
     if revision != self._last_seen_revision:
       logging.info('Updated to revision %d' % revision)
       self._last_seen_revision = revision
     return revision
 
+  def revisions(self, rev1, rev2):
+    """Returns the number of actual commits, not just the difference between
+    numbers.
+    """
+    rev2 = rev2 or 'HEAD'
+    # Revision range is inclusive and ordering doesn't matter, they'll appear in
+    # the order specified.
+    out = self._check_output_svn(
+        ['log', '-q', self.svn_url, '-r', '%s:%s' % (rev1, rev2)])
+    # Ignore the '----' lines.
+    return len([l for l in out.splitlines() if l.startswith('r')]) - 1
+
 
 class GitCheckoutBase(CheckoutBase):
   """Base class for git checkout. Not to be used as-is."""
   def __init__(self, root_dir, project_name, remote_branch,
       post_processors=None):
     super(GitCheckoutBase, self).__init__(
         root_dir, project_name, post_processors)
     # There is no reason to not hardcode it.
     self.remote = 'origin'
     self.remote_branch = remote_branch
@@ skipping 120 matching lines @@
     """Returns the list of branches and the active one."""
     out = self._check_output_git(['branch']).splitlines(False)
     branches = [l[2:] for l in out]
     active = None
     for l in out:
       if l.startswith('*'):
         active = l[2:]
         break
     return branches, active
 
+  def revisions(self, rev1, rev2):
+    """Returns the number of actual commits between both hash."""
+    self._fetch_remote()
+
+    rev2 = rev2 or '%s/%s' % (self.remote, self.remote_branch)
+    # Revision range is ]rev1, rev2] and ordering matters.
+    out = self._check_output_git(
+        ['log', '--format="%H"' , '%s..%s' % (rev1, rev2)])
+    return len(out.splitlines())
+
+  def _fetch_remote(self):
+    """Fetches the remote without rebasing."""
+    raise NotImplementedError()
+
+
+class GitCheckout(GitCheckoutBase):
+  """Git checkout implementation."""
+  def _fetch_remote(self):
+    # git fetch is always verbose even with -q -q so redirect its output.
+    self._check_output_git(['fetch', self.remote, self.remote_branch])
+
 
 class ReadOnlyCheckout(object):
   """Converts a checkout into a read-only one."""
   def __init__(self, checkout, post_processors=None):
     super(ReadOnlyCheckout, self).__init__()
     self.checkout = checkout
     self.post_processors = (post_processors or []) + (
         self.checkout.post_processors or [])
 
   def prepare(self, revision):
     return self.checkout.prepare(revision)
 
   def get_settings(self, key):
     return self.checkout.get_settings(key)
 
   def apply_patch(self, patches, post_processors=None):
     return self.checkout.apply_patch(
         patches, post_processors or self.post_processors)
 
   def commit(self, message, user):  # pylint: disable=R0201
     logging.info('Would have committed for %s with message: %s' % (
         user, message))
     return 'FAKE'
 
+  def revisions(self, rev1, rev2):
+    return self.checkout.revisions(rev1, rev2)
+
   @property
   def project_name(self):
     return self.checkout.project_name
 
   @property
   def project_path(self):
     return self.checkout.project_path