Rename utility member functions to be clearer about what they do.

checkout.py

 # coding=utf8
 # Copyright (c) 2010 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 logging
@@ skipping 110 matching lines @@
   def __init__(self, root_dir, project_name, remote_branch):
     super(GitCheckoutBase, self).__init__(root_dir, project_name)
     # There is no reason to not hardcode it.
     self.remote = 'origin'
     self.remote_branch = remote_branch
     self.working_branch = 'working_branch'
 
   def prepare(self):
     """Resets the git repository in a clean state."""
     assert os.path.isdir(self.project_path)
-    self.check_call(['checkout', 'master', '--force'])
-    self.check_call(['pull', self.remote, self.remote_branch])
-    self.call(['branch', '-D', self.working_branch])
+    self._check_call_git(['checkout', 'master', '--force'])
+    self._check_call_git(['pull', self.remote, self.remote_branch])
+    self._call_git(['branch', '-D', self.working_branch])
 
   def apply_patch(self, patch_data):
     """Applies a patch on 'working_branch'."""
-    self.check_call(
+    self._check_call_git(
         ['checkout', '-b', self.working_branch,
          '%s/%s' % (self.remote, self.remote_branch)])
-    self.check_call(['apply', '--index', '-p0'], stdin=patch_data)
-    self.check_call(['commit', '-m', 'Committed patch'])
+    self._check_call_git(['apply', '--index', '-p0'], stdin=patch_data)
+    self._check_call_git(['commit', '-m', 'Committed patch'])
 
   def commit(self, commit_message, user):
-    self.check_call(['commit', '--amend', '-m', commit_message])
+    self._check_call_git(['commit', '--amend', '-m', commit_message])
 
-  def check_call(self, args, **kwargs):
+  def _check_call_git(self, args, **kwargs):
     kwargs.setdefault('cwd', self.project_path)
     return subprocess2.check_call(['git'] + args, **kwargs)
 
-  def call(self, args, **kwargs):
+  def _call_git(self, args, **kwargs):
+    """Like check_call but doesn't throw on failure."""
     kwargs.setdefault('cwd', self.project_path)
     return subprocess2.call(['git'] + args, **kwargs)
 
-  def capture(self, args, **kwargs):
+  def _check_capture_git(self, args, **kwargs):
     kwargs.setdefault('cwd', self.project_path)
-    return subprocess2.capture(['git'] + args, **kwargs)
+    return subprocess2.check_capture(['git'] + args, **kwargs)
 
 
 class GitSvnCheckoutBase(GitCheckoutBase):
   """Base class for git-svn checkout. Not to be used as-is."""
   def __init__(self,
       root_dir, project_name, remote_branch,
       commit_user, commit_pwd,
       svn_repo, trunk):
     """trunk is optional."""
     super(GitSvnCheckoutBase, self).__init__(
         root_dir, project_name + '.git', remote_branch)
     self.commit_user = commit_user
     self.commit_pwd = commit_pwd
     self.svn_repo = svn_repo
     self.trunk = trunk
 
   def prepare(self):
     """Resets the git repository in a clean state."""
-    self.check_call(['checkout', 'master', '--force'])
-    self.check_call(['svn', 'rebase'])
-    self.call(['branch', '-D', self.working_branch])
-    return int(self.svn_info('revision'))
+    self._check_call_git(['checkout', 'master', '--force'])
+    self._check_call_git(['svn', 'rebase'])
+    self._call_git(['branch', '-D', self.working_branch])
+    return int(self._git_svn_info('revision'))
 
-  def svn_info(self, key):
-    return svn_utils.parse_svn_info(self.capture(['svn', 'info']), key)
+  def _git_svn_info(self, key):
+    return svn_utils.parse_svn_info(
+        self._check_capture_git(['svn', 'info']), key)
 
   def commit(self, commit_message, user):
     """Commits a patch."""
     logging.info('Committing patch for %s' % user)
     # Fix the commit message.
     super(GitSvnCheckoutBase, self).commit(commit_message, user)
     # Commit with git svn dcommit, then use svn directly to update the
     # committer on the revision.
-    self._call_git_svn(['dcommit', '--rmdir', '--find-copies-harder'])
-    revision = int(self.svn_info('revision'))
+    self._check_call_git_svn(['dcommit', '--rmdir', '--find-copies-harder'])
+    revision = int(self._git_svn_info('revision'))
     # Fix the committer.
     svn_utils.update_committer(
         self.svn_repo, revision, self.commit_user, self.commit_pwd, user,
         self.project_path)
     return revision
 
   def _cache_svn_auth(self):
     """Caches the svn credentials. It is necessary since git-svn doesn't prompt
     for it."""
     if not self.commit_user:
       return
     logging.info('Caching svn credentials for %s' % self.commit_user)
     subprocess2.check_call(
         ['svn', 'ls', self.svn_repo,
           '--username', self.commit_user,
           '--password', self.commit_pwd,
           '--non-interactive'])
 
-  def _call_git_svn(self, args, **kwargs):
+  def _check_call_git_svn(self, args, **kwargs):
     """Handles svn authentication while calling git svn."""
     args = ['svn'] + args
     if self.commit_user:
       args = args + ['--username', self.commit_user, '--no-auth-cache']
-    return self.check_call(args, stdin=self.commit_pwd, **kwargs)
+    return self._check_call_git(args, stdin=self.commit_pwd, **kwargs)
 
 
 class GitSvnPremadeCheckout(GitSvnCheckoutBase):
   """Manages a git-svn clone made out from an initial git-svn seed.
 
   This class is very similar to GitSvnCheckout but is faster to bootstrap
   because it starts right off with an existing git-svn clone.
   """
   def __init__(self,
       root_dir, project_name, remote_branch,
       commit_user, commit_pwd,
       svn_repo, trunk, git_url):
     super(GitSvnPremadeCheckout, self).__init__(
         root_dir, project_name, remote_branch,
         commit_user, commit_pwd,
         svn_repo, trunk)
     self.git_url = git_url
 
   def prepare(self):
     """Creates the initial checkout for the repo."""
     if not os.path.isdir(self.project_path):
       logging.info('Checking out %s in %s' %
           (self.project_name, self.project_path))
       assert self.remote == 'origin'
-      self.check_call(
+      self._check_call_git(
           ['clone', self.git_url, self.project_name],
           cwd=self.root_dir)
-      self.check_call(
+      self._check_call_git(
           ['svn', 'init',
            '--prefix', self.remote + '/',
            '-T', self.trunk,
            self.svn_repo])
-      self._call_git_svn(['fetch'])
+      self._check_call_git_svn(['fetch'])
     super(GitSvnPremadeCheckout, self).prepare()
-    return int(self.svn_info('revision'))
+    return int(self._git_svn_info('revision'))
 
 
 class GitSvnCheckout(GitSvnCheckoutBase):
   """Manages a git-svn clone.
 
   Using git-svn hides some of the complexity of using a svn checkout.
   """
   def __init__(self,
       root_dir, project_name,
       commit_user, commit_pwd,
       svn_repo, trunk):
     super(GitSvnCheckout, self).__init__(
         root_dir, project_name, 'trunk',
         commit_user, commit_pwd,
         svn_repo, trunk)
 
   def prepare(self):
     """Creates the initial checkout for the repo."""
     if not os.path.isdir(self.project_path):
       logging.info('Checking out %s in %s' %
           (self.project_name, self.project_path))
       # TODO: Create a shallow clone.
-      self._call_git_svn(
+      self._check_call_git_svn(
           ['clone',
            '--prefix', self.remote + '/',
            '-T', self.trunk,
            self.svn_repo, self.project_path],
           cwd=self.root_dir)
     super(GitSvnCheckout, self).prepare()
-    return int(self.svn_info('revision'))
+    return int(self._git_svn_info('revision'))
 
 
 class ReadOnlyCheckout(object):
   """Converts a checkout into a read-only one."""
   def __init__(self, checkout):
     self.checkout = checkout
 
   def prepare(self):
     return self.checkout.prepare()
 
   def get_settings(self, key):
     return self.checkout.get_settings(key)
 
   def apply_patch(self, patch_data):
     return self.checkout.apply_patch(patch_data)
 
   def commit(self, message, user):
     logging.info('Would have committed for %s with message: %s' % (
         user, message))
     return 'FAKE'
 
   @property
   def project_name(self):
     return self.checkout.project_name
 
   @property
   def project_path(self):
     return self.checkout.project_path