Fix issue with svn copy/move directories.

scm.py

 # Copyright (c) 2006-2009 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 os
 import re
 import shutil
 import subprocess
 import sys
 import tempfile
 import time
 import xml.dom.minidom
 
@@ skipping 17 matching lines @@
       subpath = '\\'.join(paths[:i+1])
       prev = len('\\'.join(paths[:i]))
       # glob.glob will return the cased path for the last item only. This is why
       # we are calling it in a loop. Extract the data we want and put it back
       # into the list.
       paths[i] = glob.glob(subpath + '*')[0][prev+1:len(subpath)]
     path = '\\'.join(paths)
   return path
 
 
+def GenFakeDiff(filename):
+  """Generates a fake diff from a file."""
+  file_content = gclient_utils.FileRead(filename, 'rb').splitlines(True)
+  nb_lines = len(file_content)
+  # We need to use / since patch on unix will fail otherwise.
+  data = cStringIO.StringIO()
+  data.write("Index: %s\n" % filename)
+  data.write('=' * 67 + '\n')
+  # Note: Should we use /dev/null instead?
+  data.write("--- %s\n" % filename)
+  data.write("+++ %s\n" % filename)
+  data.write("@@ -0,0 +1,%d @@\n" % nb_lines)
+  # Prepend '+' to every lines.
+  for line in file_content:
+    data.write('+')
+    data.write(line)
+  result = data.getvalue()
+  data.close()
+  return result
+
+
 class GIT(object):
   COMMAND = "git"
 
   @staticmethod
   def Capture(args, in_directory=None, print_error=True, error_ok=False):
     """Runs git, capturing output sent to stdout as a string.
 
     Args:
       args: A sequence of command line parameters to be passed to git.
       in_directory: The directory where git is to be run.
@@ skipping 548 matching lines @@
           if wc_status[0].getAttribute('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):
     """Determine if a file has been added through svn mv"""
-    info = SVN.CaptureInfo(filename)
+    return SVN.IsMovedInfo(SVN.CaptureInfo(filename))
+
+  @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(file, property_name):
     """Returns the value of an SVN property for the given file.
 
     Args:
       file: 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.
     """
     output = SVN.Capture(["propget", property_name, file])
     if (output.startswith("svn: ") and
         output.endswith("is not under version control")):
       return ""
     else:
       return output
 
   @staticmethod
   def DiffItem(filename, full_move=False, revision=None):
     """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."""
-    # Use svn info output instead of os.path.isdir because the latter fails
-    # when the file is deleted.
-    if SVN.CaptureInfo(filename).get("Node Kind") == "directory":
-      return None
     # 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:
-      # Grabs the diff data.
-      command = ["diff", "--config-dir", bogus_dir, filename]
-      if revision:
-        command.extend(['--revision', revision])
-      if SVN.IsMoved(filename):
-        if full_move:
-          file_content = gclient_utils.FileRead(filename, 'rb')
-          # Prepend '+' to every lines.
-          file_content = ['+' + i for i in file_content.splitlines(True)]
-          nb_lines = len(file_content)
-          # We need to use / since patch on unix will fail otherwise.
-          data = "Index: %s\n" % filename
-          data += '=' * 67 + '\n'
-          # Note: Should we use /dev/null instead?
-          data += "--- %s\n" % filename
-          data += "+++ %s\n" % filename
-          data += "@@ -0,0 +1,%d @@\n" % nb_lines
-          data += ''.join(file_content)
+      # Use "svn info" output instead of os.path.isdir because the latter fails
+      # when the file is deleted.
+      return SVN._DiffItemInternal(SVN.CaptureInfo(filename),
+                                   full_move=full_move, revision=revision)
+    finally:
+      shutil.rmtree(bogus_dir)
+
+  @staticmethod
+  def _DiffItemInternal(filename, info, bogus_dir, full_move=False,
+                        revision=None):
+    """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.
+          # This will put a lot of pressure on the heap. This is why StringIO
+          # is used and converted back into a string at the end. The reason to
+          # return a string instead of a StringIO is that StringIO.write()
+          # doesn't accept a StringIO object. *sigh*.
+          for (dirpath, dirnames, filenames) in os.walk(filename):
+            # Cleanup all files starting with a '.'.
+            for d in dirnames:
+              if d.startswith('.'):
+                dirnames.remove(d)
+            for f in filenames:
+              if f.startswith('.'):
+                filenames.remove(f)
+            for f in filenames:
+              if data is None:
+                data = cStringIO.StringIO()
+              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, None)
           if not data:
             # We put in an empty Index entry so upload.py knows about them.
             data = "Index: %s\n" % filename
-      else:
+        # Otherwise silently ignore directories.
+    else:
+      if info.get("Node Kind") != "directory":
+        # Normal simple case.
         data = SVN.Capture(command, None)
-    finally:
-      shutil.rmtree(bogus_dir)
+      # Otherwise silently ignore directories.
     return data
 
   @staticmethod
   def GenerateDiff(filenames, root=None, full_move=False, revision=None):
     """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.
     """
     previous_cwd = os.getcwd()
     root = root or SVN.GetCheckoutRoot(previous_cwd)
     root = os.path.normcase(os.path.join(root, ''))
     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)
-      diff = "".join(filter(None,
-                            [SVN.DiffItem(RelativePath(f, root),
-                                          full_move=full_move,
-                                          revision=revision)
-                             for f in filenames]))
+      # 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])
+      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]
+      # Now ready to do the actual diff.
+      diffs = []
+      for filename in sorted(data.iterkeys()):
+        diffs.append(SVN._DiffItemInternal(filename, data[filename], bogus_dir,
+                                           full_move=full_move,
+                                           revision=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)
-    return diff
-
+      shutil.rmtree(bogus_dir)
 
   @staticmethod
   def GetEmail(repo_root):
     """Retrieves the svn account which we assume is an email address."""
     infos = SVN.CaptureInfo(repo_root)
     uuid = infos.get('UUID')
     root = infos.get('Repository Root')
     if not root:
       return None
 
@@ skipping 74 matching lines @@
     if not SVN.current_version:
       SVN.current_version = SVN.Capture(['--version']).split()[2]
     current_version_list = map(only_int, SVN.current_version.split('.'))
     for min_ver in map(int, min_version.split('.')):
       ver = current_version_list.pop(0)
       if ver < min_ver:
         return (False, SVN.current_version)
       elif ver > min_ver:
         return (True, SVN.current_version)
     return (True, SVN.current_version)