Fix handling of file renames.

patch.py

 # coding=utf8
 # 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.
 """Utility functions to handle patches."""
 
 import posixpath
 import os
 import re
 
@@ skipping 14 matching lines @@
 class FilePatchBase(object):
   """Defines a single file being modified.
 
   '/' is always used instead of os.sep for consistency.
   """
   is_delete = False
   is_binary = False
   is_new = False
 
   def __init__(self, filename):
+    assert self.__class__ is not FilePatchBase
     self.filename = self._process_filename(filename)
     # Set when the file is copied or moved.
     self.source_filename = None
 
   @staticmethod
   def _process_filename(filename):
     filename = filename.replace('\\', '/')
     # Blacklist a few characters for simplicity.
     for i in ('%', '$', '..', '\'', '"'):
       if i in filename:
         raise UnsupportedPatchFormat(
             filename, 'Can\'t use \'%s\' in filename.' % i)
     for i in ('/', 'CON', 'COM'):
       if filename.startswith(i):
         raise UnsupportedPatchFormat(
             filename, 'Filename can\'t start with \'%s\'.' % i)
     return filename
 
-  def get(self):  # pragma: no coverage
-    raise NotImplementedError('Nothing to grab')
-
   def set_relpath(self, relpath):
     if not relpath:
       return
     relpath = relpath.replace('\\', '/')
     if relpath[0] == '/':
       self._fail('Relative path starts with %s' % relpath[0])
     self.filename = self._process_filename(
         posixpath.join(relpath, self.filename))
     if self.source_filename:
       self.source_filename = self._process_filename(
           posixpath.join(relpath, self.source_filename))
 
   def _fail(self, msg):
     """Shortcut function to raise UnsupportedPatchFormat."""
     raise UnsupportedPatchFormat(self.filename, msg)
 
+  def __str__(self):
+    # Use a status-like board.
+    out = ''
+    if self.is_binary:
+      out += 'B'
+    else:
+      out += ' '
+    if self.is_delete:
+      out += 'D'
+    else:
+      out += ' '
+    if self.is_new:
+      out += 'N'
+    else:
+      out += ' '
+    if self.source_filename:
+      out += 'R'
+    else:
+      out += ' '
+    return out + '  %s->%s' % (self.source_filename, self.filename)
+
 
 class FilePatchDelete(FilePatchBase):
   """Deletes a file."""
   is_delete = True
 
   def __init__(self, filename, is_binary):
     super(FilePatchDelete, self).__init__(filename)
     self.is_binary = is_binary
 
-  def get(self):
-    raise NotImplementedError('Nothing to grab')
-
 
 class FilePatchBinary(FilePatchBase):
   """Content of a new binary file."""
   is_binary = True
 
   def __init__(self, filename, data, svn_properties, is_new):
     super(FilePatchBinary, self).__init__(filename)
     self.data = data
     self.svn_properties = svn_properties or []
     self.is_new = is_new
@@ skipping 10 matching lines @@
     if not diff:
       self._fail('File doesn\'t have a diff.')
     self.diff_header, self.diff_hunks = self._split_header(diff)
     self.svn_properties = svn_properties or []
     self.is_git_diff = self._is_git_diff_header(self.diff_header)
     self.patchlevel = 0
     if self.is_git_diff:
       self._verify_git_header()
     else:
       self._verify_svn_header()
+    if self.source_filename and not self.is_new:
+      self._fail('If source_filename is set, is_new must be also be set')
 
-  def get(self):
-    return self.diff_header + self.diff_hunks
+  def get(self, for_git):
+    if for_git or not self.source_filename:
+      return self.diff_header + self.diff_hunks
+    else:
+      # patch is stupid. It patches the source_filename instead so get rid of
+      # any source_filename reference if needed.
+      return (
+          self.diff_header.replace(self.source_filename, self.filename) +
+          self.diff_hunks)
 
   def set_relpath(self, relpath):
     old_filename = self.filename
     old_source_filename = self.source_filename or self.filename
     super(FilePatchDiff, self).set_relpath(relpath)
     # Update the header too.
     source_filename = self.source_filename or self.filename
     lines = self.diff_header.splitlines(True)
     for i, line in enumerate(lines):
       if line.startswith('diff --git'):
@@ skipping 130 matching lines @@
     match = re.match(r'^(rename|copy) to (.+)$', line)
     if match:
       if self.filename != match.group(2):
         self._fail('Unexpected git diff output name for line %s.' % line)
       if not last_line.startswith('%s from ' % match.group(1)):
         self._fail(
             'Confused %s from/to git diff for line %s.' %
                 (match.group(1), line))
       return
 
+    # Ignore "deleted file mode 100644" since it's not needed.
     match = re.match(r'^new(| file) mode (\d{6})$', line)
     if match:
       mode = match.group(2)
       # Only look at owner ACL for executable.
       # TODO(maruel): Add support to remove a property.
       if bool(int(mode[4]) & 1):
         self.svn_properties.append(('svn:executable', '*'))
 
     match = re.match(r'^--- (.*)$', line)
     if match:
@@ skipping 72 matching lines @@
       if lines:
         self._fail('Crap after +++')
       # We're done.
       return
 
 
 class PatchSet(object):
   """A list of FilePatch* objects."""
 
   def __init__(self, patches):
-    self.patches = patches
-    for p in self.patches:
+    for p in patches:
       assert isinstance(p, FilePatchBase)
 
+    def key(p):
+      """Sort by ordering of application.
+
+      File move are first.
+      Deletes are last.
+      """
+      if p.source_filename:
+        return (p.is_delete, p.source_filename, p.filename)
+      else:
+        # tuple are always greater than string, abuse that fact.
+        return (p.is_delete, (p.filename,), p.filename)
+
+    self.patches = sorted(patches, key=key)
+
   def set_relpath(self, relpath):
     """Used to offset the patch into a subdirectory."""
     for patch in self.patches:
       patch.set_relpath(relpath)
 
   def __iter__(self):
     for patch in self.patches:
       yield patch
 
+  def __getitem__(self, key):
+    return self.patches[key]
+
   @property
   def filenames(self):
     return [p.filename for p in self.patches]