Enforces using cwd in all svn calls.

scm.py

 # 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.
 
 """SCM-specific utility classes."""
 
 import cStringIO
 import glob
 import logging
 import os
@@ skipping 380 matching lines @@
         return (False, cls.current_version)
       elif ver > min_ver:
         return (True, cls.current_version)
     return (True, cls.current_version)
 
 
 class SVN(object):
   current_version = None
 
   @staticmethod
-  def Capture(args, **kwargs):
+  def Capture(args, cwd, **kwargs):
     """Always redirect stderr.
 
     Throws an exception if non-0 is returned.
     """
     return subprocess2.check_output(
-        ['svn'] + args, stderr=subprocess2.PIPE, **kwargs)
+        ['svn'] + args, stderr=subprocess2.PIPE, cwd=cwd, **kwargs)
 
   @staticmethod
   def RunAndGetFileList(verbose, args, cwd, file_list, stdout=None):
     """Runs svn checkout, update, or status, output to stdout.
 
     The first item in args must be either "checkout", "update", or "status".
 
     svn's stdout is parsed to collect a list of files checked out or updated.
     These files are appended to file_list.  svn's stdout is also printed to
     sys.stdout as in Run.
@@ skipping 89 matching lines @@
             raise
         if retries == 10:
           raise
         print "Sleeping %.1f seconds and retrying...." % backoff_time
         time.sleep(backoff_time)
         backoff_time *= 1.3
         continue
       break
 
   @staticmethod
-  def CaptureInfo(cwd):
+  def CaptureInfo(url, cwd):
     """Returns a dictionary from the svn info output for the given file.
 
     Throws an exception if svn info fails."""
+    assert isinstance(url, (None.__class__, str))
     result = {}
-    output = SVN.Capture(['info', '--xml', cwd])
+    cmd = ['info', '--xml']
+    if url:
+      cmd += [url]
+    output = SVN.Capture(cmd, cwd)
     info = ElementTree.XML(output)
     if info is None:
       return result
     entry = info.find('entry')
     if entry is None:
       return result
 
     # Use .text when the item is not optional.
     result['Path'] = entry.attrib['path']
     result['Revision'] = int(entry.attrib['revision'])
@@ skipping 17 matching lines @@
     for key in result.keys():
       if isinstance(result[key], unicode):
         # Unicode results interferes with the higher layers matching up things
         # in the deps dictionary.
         result[key] = result[key].encode()
       # Automatic conversion of optional parameters.
       result[key] = getattr(result[key], 'text', result[key])
     return result
 
   @staticmethod
-  def CaptureRevision(cwd):
+  def CaptureRevision(url, cwd):
     """Get the base revision of a SVN repository.
 
     Returns:
       Int base revision
     """
-    return SVN.CaptureInfo(cwd).get('Revision')
+    return SVN.CaptureInfo(url, cwd).get('Revision')
 
   @staticmethod
-  def CaptureStatus(files):
+  def CaptureStatus(files, cwd):
     """Returns the svn 1.5 svn status emulated output.
 
     @files can be a string (one file) or a list of files.
 
     Returns an array of (status, file) tuples."""
     command = ["status", "--xml"]
     if not files:
       pass
     elif isinstance(files, basestring):
       command.append(files)
@@ skipping 11 matching lines @@
       'incomplete': '!',
       'merged': 'G',
       'missing': '!',
       'modified': 'M',
       'none': ' ',
       'normal': ' ',
       'obstructed': '~',
       'replaced': 'R',
       'unversioned': '?',
     }
-    dom = ElementTree.XML(SVN.Capture(command))
+    dom = ElementTree.XML(SVN.Capture(command, cwd))
     results = []
     if dom is None:
       return results
     # /status/target/entry/(wc-status|commit|author|date)
     for target in dom.findall('target'):
       for entry in target.findall('entry'):
         file_path = entry.attrib['path']
         wc_status = entry.find('wc-status')
         # Emulate svn 1.5 status ouput...
         statuses = [' '] * 7
@@ skipping 26 matching lines @@
           statuses[3] = '+'
         # Col 4
         if wc_status.attrib.get('switched') == 'true':
           statuses[4] = 'S'
         # TODO(maruel): Col 5 and 6
         item = (''.join(statuses), file_path)
         results.append(item)
     return results
 
   @staticmethod
-  def IsMoved(filename):
+  def IsMoved(filename, cwd):
     """Determine if a file has been added through svn mv"""
-    return SVN.IsMovedInfo(SVN.CaptureInfo(filename))
+    return SVN.IsMovedInfo(SVN.CaptureInfo(filename, cwd))
 
   @staticmethod
   def IsMovedInfo(info):
     """Determine if a file has been added through svn mv"""
     return (info.get('Copied From URL') and
             info.get('Copied From Rev') and
             info.get('Schedule') == 'add')
 
   @staticmethod
-  def GetFileProperty(filename, property_name):
+  def GetFileProperty(filename, property_name, cwd):
     """Returns the value of an SVN property for the given file.
 
     Args:
       filename: The file to check
       property_name: The name of the SVN property, e.g. "svn:mime-type"
 
     Returns:
       The value of the property, which will be the empty string if the property
       is not set on the file.  If the file is not under version control, the
       empty string is also returned.
     """
     try:
-      return SVN.Capture(['propget', property_name, filename])
+      return SVN.Capture(['propget', property_name, filename], cwd)
     except subprocess2.CalledProcessError:
       return ''
 
   @staticmethod
-  def DiffItem(filename, full_move=False, revision=None):
+  def DiffItem(filename, cwd, full_move, revision):
     """Diffs a single file.
 
     Should be simple, eh? No it isn't.
     Be sure to be in the appropriate directory before calling to have the
     expected relative path.
     full_move means that move or copy operations should completely recreate the
     files, usually in the prospect to apply the patch for a try job."""
     # If the user specified a custom diff command in their svn config file,
     # then it'll be used when we do svn diff, which we don't want to happen
     # since we want the unified diff.  Using --diff-cmd=diff doesn't always
     # work, since they can have another diff executable in their path that
     # gives different line endings.  So we use a bogus temp directory as the
     # config directory, which gets around these problems.
     bogus_dir = tempfile.mkdtemp()
     try:
       # Use "svn info" output instead of os.path.isdir because the latter fails
       # when the file is deleted.
-      return SVN._DiffItemInternal(filename, SVN.CaptureInfo(filename),
-                                   bogus_dir,
-                                   full_move=full_move, revision=revision)
+      return SVN._DiffItemInternal(
+          filename,
+          cwd,
+          SVN.CaptureInfo(filename, cwd),
+          bogus_dir,
+          full_move,
+          revision)
     finally:
       gclient_utils.RemoveDirectory(bogus_dir)
 
   @staticmethod
-  def _DiffItemInternal(filename, info, bogus_dir, full_move=False,
-                        revision=None):
+  def _DiffItemInternal(filename, cwd, info, bogus_dir, full_move, revision):
     """Grabs the diff data."""
     command = ["diff", "--config-dir", bogus_dir, filename]
     if revision:
       command.extend(['--revision', revision])
     data = None
     if SVN.IsMovedInfo(info):
       if full_move:
         if info.get("Node Kind") == "directory":
           # Things become tricky here. It's a directory copy/move. We need to
           # diff all the files inside it.
@@ skipping 15 matching lines @@
               data.write(GenFakeDiff(os.path.join(dirpath, f)))
           if data:
             tmp = data.getvalue()
             data.close()
             data = tmp
         else:
           data = GenFakeDiff(filename)
       else:
         if info.get("Node Kind") != "directory":
           # svn diff on a mv/cp'd file outputs nothing if there was no change.
-          data = SVN.Capture(command)
+          data = SVN.Capture(command, cwd)
           if not data:
             # We put in an empty Index entry so upload.py knows about them.
             data = "Index: %s\n" % filename.replace(os.sep, '/')
         # Otherwise silently ignore directories.
     else:
       if info.get("Node Kind") != "directory":
         # Normal simple case.
         try:
-          data = SVN.Capture(command)
+          data = SVN.Capture(command, cwd)
         except subprocess2.CalledProcessError:
           if revision:
             data = GenFakeDiff(filename)
           else:
             raise
       # Otherwise silently ignore directories.
     return data
 
   @staticmethod
-  def GenerateDiff(filenames, root=None, full_move=False, revision=None):
+  def GenerateDiff(filenames, cwd, full_move, revision):
     """Returns a string containing the diff for the given file list.
 
     The files in the list should either be absolute paths or relative to the
     given root. If no root directory is provided, the repository root will be
     used.
     The diff will always use relative paths.
     """
     assert isinstance(filenames, (list, tuple))
-    previous_cwd = os.getcwd()
-    root = root or SVN.GetCheckoutRoot(previous_cwd)
-    root = os.path.normcase(os.path.join(root, ''))
+    root = os.path.normcase(os.path.join(cwd, ''))
     def RelativePath(path, root):
       """We must use relative paths."""
       if os.path.normcase(path).startswith(root):
         return path[len(root):]
       return path
     # If the user specified a custom diff command in their svn config file,
     # then it'll be used when we do svn diff, which we don't want to happen
     # since we want the unified diff.  Using --diff-cmd=diff doesn't always
     # work, since they can have another diff executable in their path that
     # gives different line endings.  So we use a bogus temp directory as the
     # config directory, which gets around these problems.
     bogus_dir = tempfile.mkdtemp()
     try:
-      os.chdir(root)
       # Cleanup filenames
       filenames = [RelativePath(f, root) for f in filenames]
       # Get information about the modified items (files and directories)
-      data = dict([(f, SVN.CaptureInfo(f)) for f in filenames])
+      data = dict([(f, SVN.CaptureInfo(f, root)) for f in filenames])
       diffs = []
       if full_move:
         # Eliminate modified files inside moved/copied directory.
         for (filename, info) in data.iteritems():
           if SVN.IsMovedInfo(info) and info.get("Node Kind") == "directory":
             # Remove files inside the directory.
             filenames = [f for f in filenames
                          if not f.startswith(filename + os.path.sep)]
         for filename in data.keys():
           if not filename in filenames:
             # Remove filtered out items.
             del data[filename]
       else:
         metaheaders = []
         for (filename, info) in data.iteritems():
           if SVN.IsMovedInfo(info):
             # for now, the most common case is a head copy,
             # so let's just encode that as a straight up cp.
             srcurl = info.get('Copied From URL')
-            root = info.get('Repository Root')
+            file_root = info.get('Repository Root')
             rev = int(info.get('Copied From Rev'))
-            assert srcurl.startswith(root)
-            src = srcurl[len(root)+1:]
+            assert srcurl.startswith(file_root)
+            src = srcurl[len(file_root)+1:]
             try:
-              srcinfo = SVN.CaptureInfo(srcurl)
+              srcinfo = SVN.CaptureInfo(srcurl, None)
             except subprocess2.CalledProcessError, e:
               if not 'Not a valid URL' in e.stderr:
                 raise
               # Assume the file was deleted. No idea how to figure out at which
               # revision the file was deleted.
               srcinfo = {'Revision': rev}
             if (srcinfo.get('Revision') != rev and
-                SVN.Capture(['diff', '-r', '%d:head' % rev, srcurl])):
+                SVN.Capture(['diff', '-r', '%d:head' % rev, srcurl], cwd)):
               metaheaders.append("#$ svn cp -r %d %s %s "
                                  "### WARNING: note non-trunk copy\n" %
                                  (rev, src, filename))
             else:
               metaheaders.append("#$ cp %s %s\n" % (src,
                                                     filename))
 
         if metaheaders:
           diffs.append("### BEGIN SVN COPY METADATA\n")
           diffs.extend(metaheaders)
           diffs.append("### END SVN COPY METADATA\n")
       # Now ready to do the actual diff.
       for filename in sorted(data.iterkeys()):
-        diffs.append(SVN._DiffItemInternal(filename, data[filename], bogus_dir,
-                                           full_move=full_move,
-                                           revision=revision))
+        diffs.append(SVN._DiffItemInternal(
+            filename, cwd, data[filename], bogus_dir, full_move, revision))
       # Use StringIO since it can be messy when diffing a directory move with
       # full_move=True.
       buf = cStringIO.StringIO()
       for d in filter(None, diffs):
         buf.write(d)
       result = buf.getvalue()
       buf.close()
       return result
     finally:
-      os.chdir(previous_cwd)
       gclient_utils.RemoveDirectory(bogus_dir)
 
   @staticmethod
-  def GetEmail(repo_root):
+  def GetEmail(cwd):
     """Retrieves the svn account which we assume is an email address."""
     try:
-      infos = SVN.CaptureInfo(repo_root)
+      infos = SVN.CaptureInfo(None, cwd)
     except subprocess2.CalledProcessError:
       return None
 
     # Should check for uuid but it is incorrectly saved for https creds.
     root = infos['Repository Root']
     realm = root.rsplit('/', 1)[0]
     uuid = infos['UUID']
     if root.startswith('https') or not uuid:
       regexp = re.compile(r'<%s:\d+>.*' % realm)
     else:
@@ skipping 32 matching lines @@
       key = ReadOneItem('K')
       if not key:
         break
       value = ReadOneItem('V')
       if not value:
         break
       values[key] = value
     return values
 
   @staticmethod
-  def GetCheckoutRoot(directory):
+  def GetCheckoutRoot(cwd):
     """Returns the top level directory of the current repository.
 
     The directory is returned as an absolute path.
     """
-    directory = os.path.abspath(directory)
+    cwd = os.path.abspath(cwd)
     try:
-      info = SVN.CaptureInfo(directory)
+      info = SVN.CaptureInfo(None, cwd)
       cur_dir_repo_root = info['Repository Root']
       url = info['URL']
     except subprocess2.CalledProcessError:
       return None
     while True:
-      parent = os.path.dirname(directory)
+      parent = os.path.dirname(cwd)
       try:
-        info = SVN.CaptureInfo(parent)
+        info = SVN.CaptureInfo(None, parent)
         if (info['Repository Root'] != cur_dir_repo_root or
             info['URL'] != os.path.dirname(url)):
           break
         url = info['URL']
       except subprocess2.CalledProcessError:
         break
-      directory = parent
-    return GetCasedPath(directory)
+      cwd = parent
+    return GetCasedPath(cwd)
 
   @classmethod
   def AssertVersion(cls, min_version):
     """Asserts svn's version is at least min_version."""
     if cls.current_version is None:
-      cls.current_version = cls.Capture(['--version']).split()[2]
+      cls.current_version = cls.Capture(['--version'], None).split()[2]
     current_version_list = map(only_int, cls.current_version.split('.'))
     for min_ver in map(int, min_version.split('.')):
       ver = current_version_list.pop(0)
       if ver < min_ver:
         return (False, cls.current_version)
       elif ver > min_ver:
         return (True, cls.current_version)
     return (True, cls.current_version)
 
   @staticmethod
-  def Revert(repo_root, callback=None, ignore_externals=False):
-    """Reverts all svn modifications in repo_root, including properties.
+  def Revert(cwd, callback=None, ignore_externals=False):
+    """Reverts all svn modifications in cwd, including properties.
 
     Deletes any modified files or directory.
 
     A "svn update --revision BASE" call is required after to revive deleted
     files.
     """
-    for file_status in SVN.CaptureStatus(repo_root):
-      file_path = os.path.join(repo_root, file_status[1])
+    for file_status in SVN.CaptureStatus(None, cwd):
+      file_path = os.path.join(cwd, file_status[1])
       if (ignore_externals and
           file_status[0][0] == 'X' and
           file_status[0][1:].isspace()):
         # Ignore externals.
         logging.info('Ignoring external %s' % file_status[1])
         continue
 
       if callback:
         callback(file_status)
 
@@ skipping 11 matching lines @@
           gclient_utils.RemoveDirectory(file_path)
         else:
           logging.critical(
             ('No idea what is %s.\nYou just found a bug in gclient'
               ', please ping maruel@chromium.org ASAP!') % file_path)
 
       if (file_status[0][0] in ('D', 'A', '!') or
           not file_status[0][1:].isspace()):
         # Added, deleted file requires manual intervention and require calling
         # revert, like for properties.
-        if not os.path.isdir(repo_root):
+        if not os.path.isdir(cwd):
           # '.' was deleted. It's not worth continuing.
           return
         try:
-          SVN.Capture(['revert', file_status[1]], cwd=repo_root)
+          SVN.Capture(['revert', file_status[1]], cwd=cwd)
         except subprocess2.CalledProcessError:
           if not os.path.exists(file_path):
             continue
           raise