Replace a few os.path.join() calls to use self.checkout_path instead.

gclient_scm.py

 # 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.
 
 """Gclient-specific SCM-specific operations."""
 
 import logging
 import os
 import posixpath
 import re
@@ skipping 132 matching lines @@
     self._Run(['checkout-index', '-a', '--prefix=%s/' % export_path],
               redirect_stdout=False)
 
   def pack(self, options, args, file_list):
     """Generates a patch file which can be applied to the root of the
     repository.
 
     The patch file is generated from a diff of the merge base of HEAD and
     its upstream branch.
     """
-    path = os.path.join(self._root_dir, self.relpath)
     merge_base = self._Run(['merge-base', 'HEAD', 'origin'])
-    command = ['git', 'diff', merge_base]
-    filterer = DiffFilterer(self.relpath)
     gclient_utils.CheckCallAndFilter(
-        command, cwd=path, filter_fn=filterer.Filter, stdout=options.stdout)
+        ['git', 'diff', merge_base],
+        cwd=self.checkout_path,
+        filter_fn=DiffFilterer(self.relpath, options.stdout).Filter,
+        stdout=options.stdout)
 
   def update(self, options, args, file_list):
     """Runs git to update or transparently checkout the working copy.
 
     All updated files will be appended to file_list.
 
     Raises:
       Error: if can't get URL for relative path.
     """
     if args:
@@ skipping 232 matching lines @@
 
     if verbose:
       options.stdout.write('Checked out revision %s\n' %
           self.revinfo(options, (), None))
 
   def revert(self, options, args, file_list):
     """Reverts local modifications.
 
     All reverted files will be appended to file_list.
     """
-    path = os.path.join(self._root_dir, self.relpath)
-    if not os.path.isdir(path):
+    if not os.path.isdir(self.checkout_path):
       # revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
       options.stdout.write('\n_____ %s is missing, synching instead\n' %
           self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     default_rev = "refs/heads/master"
     _, deps_revision = gclient_utils.SplitUrlRevision(self.url)
     if not deps_revision:
@@ skipping 252 matching lines @@
 
 class SVNWrapper(SCMWrapper):
   """ Wrapper for SVN """
 
   def cleanup(self, options, args, file_list):
     """Cleanup working copy."""
     self._Run(['cleanup'] + args, options)
 
   def diff(self, options, args, file_list):
     # NOTE: This function does not currently modify file_list.
-    path = os.path.join(self._root_dir, self.relpath)
-    if not os.path.isdir(path):
-      raise gclient_utils.Error('Directory %s is not present.' % path)
+    if not os.path.isdir(self.checkout_path):
+      raise gclient_utils.Error('Directory %s is not present.' %
+          self.checkout_path)
     self._Run(['diff'] + args, options)
 
   def export(self, options, args, file_list):
     """Export a clean directory tree into the given path."""
     assert len(args) == 1
     export_path = os.path.abspath(os.path.join(args[0], self.relpath))
     try:
       os.makedirs(export_path)
     except OSError:
       pass
     assert os.path.exists(export_path)
     self._Run(['export', '--force', '.', export_path], options)
 
   def pack(self, options, args, file_list):
     """Generates a patch file which can be applied to the root of the
     repository."""
-    path = os.path.join(self._root_dir, self.relpath)
-    if not os.path.isdir(path):
-      raise gclient_utils.Error('Directory %s is not present.' % path)
-    command = ['svn', 'diff', '-x', '--ignore-eol-style']
-    command.extend(args)
-
-    filterer = DiffFilterer(self.relpath, options.stdout)
-    gclient_utils.CheckCallAndFilter(command, cwd=path, always=False,
-        print_stdout=False, filter_fn=filterer.Filter,
+    if not os.path.isdir(self.checkout_path):
+      raise gclient_utils.Error('Directory %s is not present.' %
+          self.checkout_path)
+    gclient_utils.CheckCallAndFilter(
+        ['svn', 'diff', '-x', '--ignore-eol-style'] + args,
+        cwd=self.checkout_path,
+        print_stdout=False,
+        filter_fn=DiffFilterer(self.relpath, options.stdout).Filter,
         stdout=options.stdout)
 
   def update(self, options, args, file_list):
     """Runs svn to update or transparently checkout the working copy.
 
     All updated files will be appended to file_list.
 
     Raises:
       Error: if can't get URL for relative path.
     """
     # Only update if git is not controlling the directory.
-    checkout_path = os.path.join(self._root_dir, self.relpath)
-    git_path = os.path.join(self._root_dir, self.relpath, '.git')
+    git_path = os.path.join(self.checkout_path, '.git')
     if os.path.exists(git_path):
       options.stdout.write('________ found .git directory; skipping %s\n' %
           self.relpath)
       return
 
     if args:
       raise gclient_utils.Error("Unsupported argument(s): %s" % ",".join(args))
 
     # revision is the revision to match. It is None if no revision is specified,
     # i.e. the 'deps ain't pinned'.
     url, revision = gclient_utils.SplitUrlRevision(self.url)
     # Keep the original unpinned url for reference in case the repo is switched.
     base_url = url
     if options.revision:
       # Override the revision number.
       revision = str(options.revision)
     if revision:
       forced_revision = True
       # Reconstruct the url.
       url = '%s@%s' % (url, revision)
       rev_str = ' at %s' % revision
     else:
       forced_revision = False
       rev_str = ''
 
-    if not os.path.exists(checkout_path):
+    if not os.path.exists(self.checkout_path):
       # We need to checkout.
-      command = ['checkout', url, checkout_path]
+      command = ['checkout', url, self.checkout_path]
       command = self._AddAdditionalUpdateFlags(command, options, revision)
       self._RunAndGetFileList(command, options, file_list, self._root_dir)
       return
 
     # Get the existing scm url and the revision number of the current checkout.
-    from_info = scm.SVN.CaptureInfo(os.path.join(checkout_path, '.'), '.')
+    from_info = scm.SVN.CaptureInfo(os.path.join(self.checkout_path, '.'), '.')
     if not from_info:
       raise gclient_utils.Error(('Can\'t update/checkout %r if an unversioned '
                                  'directory is present. Delete the directory '
                                  'and try again.') %
-                                checkout_path)
+                                self.checkout_path)
 
     # Look for locked directories.
-    dir_info = scm.SVN.CaptureStatus(os.path.join(checkout_path, '.'))
-    if [True for d in dir_info if d[0][2] == 'L' and d[1] == checkout_path]:
+    dir_info = scm.SVN.CaptureStatus(os.path.join(self.checkout_path, '.'))
+    if [True for d in dir_info
+        if d[0][2] == 'L' and d[1] == self.checkout_path]:
       # The current directory is locked, clean it up.
       self._Run(['cleanup'], options)
 
     # Retrieve the current HEAD version because svn is slow at null updates.
     if options.manually_grab_svn_rev and not revision:
       from_info_live = scm.SVN.CaptureInfo(from_info['URL'], '.')
       revision = str(from_info_live['Revision'])
       rev_str = ' at %s' % revision
 
     if from_info['URL'] != base_url:
@@ skipping 21 matching lines @@
                    from_info['Repository Root'],
                    to_info['Repository Root'],
                    self.relpath]
         self._Run(command, options, cwd=self._root_dir)
         from_info['URL'] = from_info['URL'].replace(
             from_info['Repository Root'],
             to_info['Repository Root'])
       else:
         if not options.force and not options.reset:
           # Look for local modifications but ignore unversioned files.
-          for status in scm.SVN.CaptureStatus(checkout_path):
+          for status in scm.SVN.CaptureStatus(self.checkout_path):
             if status[0] != '?':
               raise gclient_utils.Error(
                   ('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, checkout_path))
+                   'try again.') % (url, self.checkout_path))
         # Ok delete it.
         options.stdout.write('\n_____ switching %s to a new checkout\n' %
             self.relpath)
-        gclient_utils.RemoveDirectory(checkout_path)
+        gclient_utils.RemoveDirectory(self.checkout_path)
         # We need to checkout.
-        command = ['checkout', url, checkout_path]
+        command = ['checkout', url, self.checkout_path]
         command = self._AddAdditionalUpdateFlags(command, options, revision)
         self._RunAndGetFileList(command, options, file_list, self._root_dir)
         return
 
     # 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:
         options.stdout.write('\n_____ %s%s\n' % (self.relpath, rev_str))
       return
 
-    command = ['update', checkout_path]
+    command = ['update', self.checkout_path]
     command = self._AddAdditionalUpdateFlags(command, options, revision)
     self._RunAndGetFileList(command, options, file_list, self._root_dir)
 
   def updatesingle(self, options, args, file_list):
-    checkout_path = os.path.join(self._root_dir, self.relpath)
     filename = args.pop()
     if scm.SVN.AssertVersion("1.5")[0]:
-      if not os.path.exists(os.path.join(checkout_path, '.svn')):
+      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, checkout_path]
+        command = ["checkout", "--depth", "empty", self.url, self.checkout_path]
         self._Run(command, options, cwd=self._root_dir)
-        if os.path.exists(os.path.join(checkout_path, filename)):
-          os.remove(os.path.join(checkout_path, filename))
+        if os.path.exists(os.path.join(self.checkout_path, filename)):
+          os.remove(os.path.join(self.checkout_path, filename))
         command = ["update", filename]
         self._RunAndGetFileList(command, options, file_list)
       # After the initial checkout, we can use update as if it were any other
       # dep.
       self.update(options, args, file_list)
     else:
       # If the installed version of SVN doesn't support --depth, fallback to
       # just exporting the file.  This has the downside that revision
       # information is not stored next to the file, so we will have to
       # re-export the file every time we sync.
-      if not os.path.exists(checkout_path):
-        os.makedirs(checkout_path)
+      if not os.path.exists(self.checkout_path):
+        os.makedirs(self.checkout_path)
       command = ["export", os.path.join(self.url, filename),
-                 os.path.join(checkout_path, filename)]
+                 os.path.join(self.checkout_path, filename)]
       command = self._AddAdditionalUpdateFlags(command, options,
           options.revision)
       self._Run(command, options, cwd=self._root_dir)
 
   def revert(self, options, args, file_list):
     """Reverts local modifications. Subversion specific.
 
     All reverted files will be appended to file_list, even if Subversion
     doesn't know about them.
     """
-    path = os.path.join(self._root_dir, self.relpath)
-    if not os.path.isdir(path):
+    if not os.path.isdir(self.checkout_path):
       # svn revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
       options.stdout.write('\n_____ %s is missing, synching instead\n' %
           self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
     # Do a flush of sys.stdout every 10 secs or so otherwise it may never be
     # flushed fast enough for buildbot.
     last_flushed_at = time.time()
     sys.stdout.flush()
 
-    for file_status in scm.SVN.CaptureStatus(path):
-      file_path = os.path.join(path, file_status[1])
+    for file_status in scm.SVN.CaptureStatus(self.checkout_path):
+      file_path = os.path.join(self.checkout_path, file_status[1])
       if file_status[0][0] == 'X':
         # Ignore externals.
         logging.info('Ignoring external %s' % file_path)
         continue
 
       if logging.getLogger().isEnabledFor(logging.INFO):
         logging.info('%s%s' % (file[0], file[1]))
       else:
         options.stdout.write(file_path + '\n')
         # Flush at least 10 seconds between line writes.  We wait at least 10
@@ skipping 36 matching lines @@
 
   def revinfo(self, options, args, file_list):
     """Display revision"""
     return scm.SVN.CaptureBaseRevision(self.checkout_path)
 
   def runhooks(self, options, args, file_list):
     self.status(options, args, file_list)
 
   def status(self, options, args, file_list):
     """Display status information."""
-    path = os.path.join(self._root_dir, self.relpath)
     command = ['status'] + args
-    if not os.path.isdir(path):
+    if not os.path.isdir(self.checkout_path):
       # svn status won't work if the directory doesn't exist.
       options.stdout.write(
           ('\n________ couldn\'t run \'%s\' in \'%s\':\nThe directory '
-           'does not exist.') % (' '.join(command), path))
+           'does not exist.') % (' '.join(command), self.checkout_path))
       # There's no file list to retrieve.
     else:
       self._RunAndGetFileList(command, options, file_list)
 
   def FullUrlForRelativeUrl(self, url):
     # Find the forth '/' and strip from there. A bit hackish.
     return '/'.join(self.url.split('/')[:4]) + url
 
   def _Run(self, args, options, **kwargs):
     """Runs a commands that goes to stdout."""
-    kwargs.setdefault('cwd', os.path.join(self._root_dir, self.relpath))
+    kwargs.setdefault('cwd', self.checkout_path)
     gclient_utils.CheckCallAndFilterAndHeader(['svn'] + args,
         always=options.verbose, stdout=options.stdout, **kwargs)
 
   def _RunAndGetFileList(self, args, options, file_list, cwd=None):
     """Runs a commands that goes to stdout and grabs the file listed."""
-    cwd = cwd or os.path.join(self._root_dir, self.relpath)
+    cwd = cwd or self.checkout_path
     scm.SVN.RunAndGetFileList(options.verbose, args, cwd=cwd,
         file_list=file_list, stdout=options.stdout)
 
   @staticmethod
   def _AddAdditionalUpdateFlags(command, options, revision):
     """Add additional flags to command depending on what options are set.
     command should be a list of strings that represents an svn command.
 
     This method returns a new list to be used as a command."""
     new_command = command[:]
     if revision:
       new_command.extend(['--revision', str(revision).strip()])
     # --force was added to 'svn update' in svn 1.5.
     if ((options.force or options.manually_grab_svn_rev) and
         scm.SVN.AssertVersion("1.5")[0]):
       new_command.append('--force')
     return new_command