Fix unicode upgrade of patch.

patch.py

 # coding=utf8
 # Copyright (c) 2012 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 19 matching lines @@
   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
 
+  @property
+  def filename_utf8(self):
+    return self.filename.encode('utf-8')
+
+  @property
+  def source_filename_utf8(self):
+    if self.source_filename is not None:
+      return self.source_filename.encode('utf-8')
+
   @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):
@@ skipping 31 matching lines @@
     if self.is_new:
       out += 'N'
     else:
       out += ' '
     if self.source_filename:
       out += 'R'
     else:
       out += ' '
     out += '  '
     if self.source_filename:
-      out += '%s->' % self.source_filename
-    return out + str(self.filename)
+      out += '%s->' % self.source_filename_utf8
+    return out + self.filename_utf8
 
 
 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
 
@@ skipping 43 matching lines @@
     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, 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_header.replace(
+              self.source_filename_utf8, self.filename_utf8) +
           self.diff_hunks)
 
   def set_relpath(self, relpath):
-    old_filename = self.filename
-    old_source_filename = self.source_filename or self.filename
+    old_filename = self.filename_utf8
+    old_source_filename = self.source_filename_utf8 or self.filename_utf8
     super(FilePatchDiff, self).set_relpath(relpath)
     # Update the header too.
-    source_filename = self.source_filename or self.filename
+    filename = self.filename_utf8
+    source_filename = self.source_filename_utf8 or self.filename_utf8
     lines = self.diff_header.splitlines(True)
     for i, line in enumerate(lines):
       if line.startswith('diff --git'):
         lines[i] = line.replace(
             'a/' + old_source_filename, source_filename).replace(
-                'b/' + old_filename, self.filename)
+                'b/' + old_filename, filename)
       elif re.match(r'^\w+ from .+$', line) or line.startswith('---'):
         lines[i] = line.replace(old_source_filename, source_filename)
       elif re.match(r'^\w+ to .+$', line) or line.startswith('+++'):
-        lines[i] = line.replace(old_filename, self.filename)
+        lines[i] = line.replace(old_filename, filename)
     self.diff_header = ''.join(lines)
 
   def _split_header(self, diff):
     """Splits a diff in two: the header and the hunks."""
     header = []
     hunks = diff.splitlines(True)
     while hunks:
       header.append(hunks.pop(0))
       if header[-1].startswith('--- '):
         break
     else:
       # Some diff may not have a ---/+++ set like a git rename with no change or
       # a svn diff with only property change.
       pass
 
     if hunks:
       if not hunks[0].startswith('+++ '):
         self._fail('Inconsistent header')
       header.append(hunks.pop(0))
       if hunks:
         if not hunks[0].startswith('@@ '):
           self._fail('Inconsistent hunk header')
 
     # Mangle any \\ in the header to /.
     header_lines = ('Index:', 'diff', 'copy', 'rename', '+++', '---')
-    basename = os.path.basename(self.filename)
+    basename = os.path.basename(self.filename_utf8)
     for i in xrange(len(header)):
       if (header[i].split(' ', 1)[0] in header_lines or
           header[i].endswith(basename)):
         header[i] = header[i].replace('\\', '/')
     return ''.join(header), ''.join(hunks)
 
   @staticmethod
   def _is_git_diff_header(diff_header):
     """Returns True if the diff for a single files was generated with git."""
     # Delete: http://codereview.chromium.org/download/issue6368055_22_29.diff
@@ skipping 96 matching lines @@
     while lines:
       match = re.match(r'^diff \-\-git (.*?) (.*)$', lines.pop(0))
       if not match:
         continue
       if match.group(1).startswith('a/') and match.group(2).startswith('b/'):
         self.patchlevel = 1
       old = self.mangle(match.group(1))
       new = self.mangle(match.group(2))
 
       # The rename is about the new file so the old file can be anything.
-      if new not in (self.filename, 'dev/null'):
+      if new not in (self.filename_utf8, 'dev/null'):
         self._fail('Unexpected git diff output name %s.' % new)
       if old == 'dev/null' and new == 'dev/null':
         self._fail('Unexpected /dev/null git diff.')
       break
 
     if not old or not new:
       self._fail('Unexpected git diff; couldn\'t find git header.')
 
-    if old not in (self.filename, 'dev/null'):
+    if old not in (self.filename_utf8, 'dev/null'):
       # Copy or rename.
-      self.source_filename = old
+      self.source_filename = old.decode('utf-8')
       self.is_new = True
 
     last_line = ''
 
     while lines:
       line = lines.pop(0)
       self._verify_git_header_process_line(lines, line, last_line)
       last_line = line
 
     # Cheap check to make sure the file name is at least mentioned in the
     # 'diff' header. That the only remaining invariant.
-    if not self.filename in self.diff_header:
+    if not self.filename_utf8 in self.diff_header:
       self._fail('Diff seems corrupted.')
 
   def _verify_git_header_process_line(self, lines, line, last_line):
     """Processes a single line of the header.
 
     Returns True if it should continue looping.
 
     Format is described to
     http://www.kernel.org/pub/software/scm/git/docs/git-diff.html
     """
     match = re.match(r'^(rename|copy) from (.+)$', line)
-    old = self.source_filename or self.filename
+    old = self.source_filename_utf8 or self.filename_utf8
     if match:
       if old != match.group(2):
         self._fail('Unexpected git diff input name for line %s.' % line)
       if not lines or not lines[0].startswith('%s to ' % match.group(1)):
         self._fail(
             'Confused %s from/to git diff for line %s.' %
                 (match.group(1), line))
       return
 
     match = re.match(r'^(rename|copy) to (.+)$', line)
     if match:
-      if self.filename != match.group(2):
+      if self.filename_utf8 != 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
 
     match = re.match(r'^deleted file mode (\d{6})$', line)
     if match:
       # It is necessary to parse it because there may be no hunk, like when the
@@ skipping 22 matching lines @@
       if not lines or not lines[0].startswith('+++'):
         self._fail('Missing git diff output name.')
       return
 
     match = re.match(r'^\+\+\+ (.*)$', line)
     if match:
       if not last_line.startswith('---'):
         self._fail('Unexpected git diff: --- not following +++.')
       if '/dev/null' == match.group(1):
         self.is_delete = True
-      elif self.filename != self.mangle(match.group(1)):
+      elif self.filename_utf8 != self.mangle(match.group(1)):
         self._fail(
             'Unexpected git diff: %s != %s.' % (self.filename, match.group(1)))
       if lines:
         self._fail('Crap after +++')
       # We're done.
       return
 
   def _verify_svn_header(self):
     """Sanity checks the header.
 
     A svn diff can contain only property changes, in that case there will be no
     proper header. To make things worse, this property change header is
     localized.
     """
     lines = self.diff_header.splitlines()
     last_line = ''
 
     while lines:
       line = lines.pop(0)
       self._verify_svn_header_process_line(lines, line, last_line)
       last_line = line
 
     # Cheap check to make sure the file name is at least mentioned in the
     # 'diff' header. That the only remaining invariant.
-    if not self.filename in self.diff_header:
+    if not self.filename_utf8 in self.diff_header:
       self._fail('Diff seems corrupted.')
 
   def _verify_svn_header_process_line(self, lines, line, last_line):
     """Processes a single line of the header.
 
     Returns True if it should continue looping.
     """
     match = re.match(r'^--- ([^\t]+).*$', line)
     if match:
       if last_line[:3] in ('---', '+++'):
         self._fail('--- and +++ are reversed')
       if match.group(1) == '/dev/null':
         self.is_new = True
-      elif self.mangle(match.group(1)) != self.filename:
+      elif self.mangle(match.group(1)) != self.filename_utf8:
         # guess the source filename.
-        self.source_filename = match.group(1)
+        self.source_filename = match.group(1).decode('utf-8')
         self.is_new = True
       if not lines or not lines[0].startswith('+++'):
         self._fail('Nothing after header.')
       return
 
     match = re.match(r'^\+\+\+ ([^\t]+).*$', line)
     if match:
       if not last_line.startswith('---'):
         self._fail('Unexpected diff: --- not following +++.')
       if match.group(1) == '/dev/null':
         self.is_delete = True
-      elif self.mangle(match.group(1)) != self.filename:
+      elif self.mangle(match.group(1)) != self.filename_utf8:
         self._fail('Unexpected diff: %s.' % match.group(1))
       if lines:
         self._fail('Crap after +++')
       # We're done.
       return
 
 
 class PatchSet(object):
   """A list of FilePatch* objects."""
 
   def __init__(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)
+        return (p.is_delete, p.source_filename_utf8, p.filename_utf8)
       else:
         # tuple are always greater than string, abuse that fact.
-        return (p.is_delete, (p.filename,), p.filename)
+        return (p.is_delete, (p.filename_utf8,), p.filename_utf8)
 
     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]