mercurial-crew-with-dirclash: comparison mercurial/patch.py

equal deleted inserted replaced

-:f94dbc6c7eaf
+:06154aff2b1a
 # patch.py - patch file parsing routines
 #
 # Copyright 2006 Brendan Cully <brendan@kublai.com>
+# Copyright 2007 Chris Mason <chris.mason@oracle.com>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 from i18n import _
 from node import *
-import base85, cmdutil, mdiff, util, context, revlog
+import base85, cmdutil, mdiff, util, context, revlog, diffhelpers
 import cStringIO, email.Parser, os, popen2, re, sha
 import sys, tempfile, zlib
+class PatchError(Exception):
+pass
+class NoHunks(PatchError):
+pass
 # helper functions
 def copyfile(src, dst, basedir=None):
 if not basedir:
 fd, tmpname = tempfile.mkstemp(prefix='hg-patch-')
 tmpfp = os.fdopen(fd, 'w')
 try:
 msg = email.Parser.Parser().parse(fileobj)
-message = msg['Subject']
+subject = msg['Subject']
 user = msg['From']
 # should try to parse msg['Date']
 date = None
 nodeid = None
 branch = None
 parents = []
-if message:
+if subject:
-if message.startswith('[PATCH'):
+if subject.startswith('[PATCH'):
-pend = message.find(']')
+pend = subject.find(']')
 if pend >= 0:
-message = message[pend+1:].lstrip()
+subject = subject[pend+1:].lstrip()
-message = message.replace('\n\t', ' ')
+subject = subject.replace('\n\t', ' ')
-ui.debug('Subject: %s\n' % message)
+ui.debug('Subject: %s\n' % subject)
 if user:
 ui.debug('From: %s\n' % user)
 diffs_seen = 0
 ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
+message = ''
 for part in msg.walk():
 content_type = part.get_content_type()
 ui.debug('Content-Type: %s\n' % content_type)
 if content_type not in ok_types:
 continue
 ignoretext = False
 ui.debug(_('found patch at byte %d\n') % m.start(0))
 diffs_seen += 1
 cfp = cStringIO.StringIO()
-if message:
-cfp.write(message)
-cfp.write('\n')
 for line in payload[:m.start(0)].splitlines():
 if line.startswith('# HG changeset patch'):
 ui.debug(_('patch generated by hg export\n'))
 hgpatch = True
 # drop earlier commit message content
 cfp.seek(0)
 cfp.truncate()
+subject = None
 elif hgpatch:
 if line.startswith('# User '):
 user = line[7:]
 ui.debug('From: %s\n' % user)
 elif line.startswith("# Date "):
 except:
 tmpfp.close()
 os.unlink(tmpname)
 raise
+if subject and not message.startswith(subject):
+message = '%s\n%s' % (subject, message)
 tmpfp.close()
 if not diffs_seen:
 os.unlink(tmpname)
 return None, message, user, date, branch, None, None, None
 p1 = parents and parents.pop(0) or None
 GP_PATCH  = 1 << 0  # we have to run patch
 GP_FILTER = 1 << 1  # there's some copy/rename operation
 GP_BINARY = 1 << 2  # there's a binary patch
-def readgitpatch(patchname):
+def readgitpatch(fp, firstline=None):
 """extract git-style metadata about patches from <patchname>"""
 class gitpatch:
 "op is one of ADD, DELETE, RENAME, MODIFY or COPY"
 def __init__(self, path):
 self.path = path
 self.op = 'MODIFY'
 self.copymod = False
 self.lineno = 0
 self.binary = False
+def reader(fp, firstline):
+if firstline is not None:
+yield firstline
+for line in fp:
+yield line
 # Filter patch for git information
 gitre = re.compile('diff --git a/(.*) b/(.*)')
-pf = file(patchname)
 gp = None
 gitpatches = []
 # Can have a git patch with only metadata, causing patch to complain
 dopatch = 0
 lineno = 0
-for line in pf:
+for line in reader(fp, firstline):
 lineno += 1
 if line.startswith('diff --git'):
 m = gitre.match(line)
 if m:
 if gp:
 gp.path = line[8:].rstrip()
 elif line.startswith('deleted file'):
 gp.op = 'DELETE'
 elif line.startswith('new file mode '):
 gp.op = 'ADD'
-gp.mode = int(line.rstrip()[-3:], 8)
+gp.mode = int(line.rstrip()[-6:], 8)
 elif line.startswith('new mode '):
-gp.mode = int(line.rstrip()[-3:], 8)
+gp.mode = int(line.rstrip()[-6:], 8)
 elif line.startswith('GIT binary patch'):
 dopatch |= GP_BINARY
 gp.binary = True
 if gp:
 gitpatches.append(gp)
 if not gitpatches:
 dopatch = GP_PATCH
 return (dopatch, gitpatches)
-def dogitpatch(patchname, gitpatches, cwd=None):
+def patch(patchname, ui, strip=1, cwd=None, files={}):
-"""Preprocess git patch so that vanilla patch can handle it"""
+"""apply <patchname> to the working directory.
-def extractbin(fp):
+returns whether patch was applied with fuzz factor."""
-i = [0] # yuck
+patcher = ui.config('ui', 'patch')
-def readline():
+args = []
-i[0] += 1
+try:
-return fp.readline().rstrip()
+if patcher:
-line = readline()
+return externalpatch(patcher, args, patchname, ui, strip, cwd,
+files)
+else:
+try:
+return internalpatch(patchname, ui, strip, cwd, files)
+except NoHunks:
+patcher = util.find_exe('gpatch') or util.find_exe('patch')
+ui.debug('no valid hunks found; trying with %r instead\n' %
+patcher)
+if util.needbinarypatch():
+args.append('--binary')
+return externalpatch(patcher, args, patchname, ui, strip, cwd,
+files)
+except PatchError, err:
+s = str(err)
+if s:
+raise util.Abort(s)
+else:
+raise util.Abort(_('patch failed to apply'))
+def externalpatch(patcher, args, patchname, ui, strip, cwd, files):
+"""use <patcher> to apply <patchname> to the working directory.
+returns whether patch was applied with fuzz factor."""
+fuzz = False
+if cwd:
+args.append('-d %s' % util.shellquote(cwd))
+fp = os.popen('%s %s -p%d < %s' % (patcher, ' '.join(args), strip,
+util.shellquote(patchname)))
+for line in fp:
+line = line.rstrip()
+ui.note(line + '\n')
+if line.startswith('patching file '):
+pf = util.parse_patch_output(line)
+printed_file = False
+files.setdefault(pf, (None, None))
+elif line.find('with fuzz') >= 0:
+fuzz = True
+if not printed_file:
+ui.warn(pf + '\n')
+printed_file = True
+ui.warn(line + '\n')
+elif line.find('saving rejects to file') >= 0:
+ui.warn(line + '\n')
+elif line.find('FAILED') >= 0:
+if not printed_file:
+ui.warn(pf + '\n')
+printed_file = True
+ui.warn(line + '\n')
+code = fp.close()
+if code:
+raise PatchError(_("patch command failed: %s") %
+util.explain_exit(code)[0])
+return fuzz
+def internalpatch(patchobj, ui, strip, cwd, files={}):
+"""use builtin patch to apply <patchobj> to the working directory.
+returns whether patch was applied with fuzz factor."""
+try:
+fp = file(patchobj, 'rb')
+except TypeError:
+fp = patchobj
+if cwd:
+curdir = os.getcwd()
+os.chdir(cwd)
+try:
+ret = applydiff(ui, fp, files, strip=strip)
+finally:
+if cwd:
+os.chdir(curdir)
+if ret < 0:
+raise PatchError
+return ret > 0
+# @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
+unidesc = re.compile('@@ -(\d+)(,(\d+))? \+(\d+)(,(\d+))? @@')
+contextdesc = re.compile('(---|\*\*\*) (\d+)(,(\d+))? (---|\*\*\*)')
+class patchfile:
+def __init__(self, ui, fname):
+self.fname = fname
+self.ui = ui
+try:
+fp = file(fname, 'rb')
+self.lines = fp.readlines()
+self.exists = True
+except IOError:
+dirname = os.path.dirname(fname)
+if dirname and not os.path.isdir(dirname):
+dirs = dirname.split(os.path.sep)
+d = ""
+for x in dirs:
+d = os.path.join(d, x)
+if not os.path.isdir(d):
+os.mkdir(d)
+self.lines = []
+self.exists = False
+self.hash = {}
+self.dirty = 0
+self.offset = 0
+self.rej = []
+self.fileprinted = False
+self.printfile(False)
+self.hunks = 0
+def printfile(self, warn):
+if self.fileprinted:
+return
+if warn or self.ui.verbose:
+self.fileprinted = True
+s = _("patching file %s\n") % self.fname
+if warn:
+self.ui.warn(s)
+else:
+self.ui.note(s)
+def findlines(self, l, linenum):
+# looks through the hash and finds candidate lines.  The
+# result is a list of line numbers sorted based on distance
+# from linenum
+def sorter(a, b):
+vala = abs(a - linenum)
+valb = abs(b - linenum)
+return cmp(vala, valb)
+try:
+cand = self.hash[l]
+except:
+return []
+if len(cand) > 1:
+# resort our list of potentials forward then back.
+cand.sort(cmp=sorter)
+return cand
+def hashlines(self):
+self.hash = {}
+for x in xrange(len(self.lines)):
+s = self.lines[x]
+self.hash.setdefault(s, []).append(x)
+def write_rej(self):
+# our rejects are a little different from patch(1).  This always
+# creates rejects in the same form as the original patch.  A file
+# header is inserted so that you can run the reject through patch again
+# without having to type the filename.
+if not self.rej:
+return
+if self.hunks != 1:
+hunkstr = "s"
+else:
+hunkstr = ""
+fname = self.fname + ".rej"
+self.ui.warn(
+_("%d out of %d hunk%s FAILED -- saving rejects to file %s\n") %
+(len(self.rej), self.hunks, hunkstr, fname))
+try: os.unlink(fname)
+except:
+pass
+fp = file(fname, 'wb')
+base = os.path.basename(self.fname)
+fp.write("--- %s\n+++ %s\n" % (base, base))
+for x in self.rej:
+for l in x.hunk:
+fp.write(l)
+if l[-1] != '\n':
+fp.write("\n\ No newline at end of file\n")
+def write(self, dest=None):
+if self.dirty:
+if not dest:
+dest = self.fname
+st = None
+try:
+st = os.lstat(dest)
+if st.st_nlink > 1:
+os.unlink(dest)
+except: pass
+fp = file(dest, 'wb')
+if st:
+os.chmod(dest, st.st_mode)
+fp.writelines(self.lines)
+fp.close()
+def close(self):
+self.write()
+self.write_rej()
+def apply(self, h, reverse):
+if not h.complete():
+raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %
+(h.number, h.desc, len(h.a), h.lena, len(h.b),
+h.lenb))
+self.hunks += 1
+if reverse:
+h.reverse()
+if self.exists and h.createfile():
+self.ui.warn(_("file %s already exists\n") % self.fname)
+self.rej.append(h)
+return -1
+if isinstance(h, binhunk):
+if h.rmfile():
+os.unlink(self.fname)
+else:
+self.lines[:] = h.new()
+self.offset += len(h.new())
+self.dirty = 1
+return 0
+# fast case first, no offsets, no fuzz
+old = h.old()
+# patch starts counting at 1 unless we are adding the file
+if h.starta == 0:
+start = 0
+else:
+start = h.starta + self.offset - 1
+orig_start = start
+if diffhelpers.testhunk(old, self.lines, start) == 0:
+if h.rmfile():
+os.unlink(self.fname)
+else:
+self.lines[start : start + h.lena] = h.new()
+self.offset += h.lenb - h.lena
+self.dirty = 1
+return 0
+# ok, we couldn't match the hunk.  Lets look for offsets and fuzz it
+self.hashlines()
+if h.hunk[-1][0] != ' ':
+# if the hunk tried to put something at the bottom of the file
+# override the start line and use eof here
+search_start = len(self.lines)
+else:
+search_start = orig_start
+for fuzzlen in xrange(3):
+for toponly in [ True, False ]:
+old = h.old(fuzzlen, toponly)
+cand = self.findlines(old[0][1:], search_start)
+for l in cand:
+if diffhelpers.testhunk(old, self.lines, l) == 0:
+newlines = h.new(fuzzlen, toponly)
+self.lines[l : l + len(old)] = newlines
+self.offset += len(newlines) - len(old)
+self.dirty = 1
+if fuzzlen:
+fuzzstr = "with fuzz %d " % fuzzlen
+f = self.ui.warn
+self.printfile(True)
+else:
+fuzzstr = ""
+f = self.ui.note
+offset = l - orig_start - fuzzlen
+if offset == 1:
+linestr = "line"
+else:
+linestr = "lines"
+f(_("Hunk #%d succeeded at %d %s(offset %d %s).\n") %
+(h.number, l+1, fuzzstr, offset, linestr))
+return fuzzlen
+self.printfile(True)
+self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))
+self.rej.append(h)
+return -1
+class hunk:
+def __init__(self, desc, num, lr, context):
+self.number = num
+self.desc = desc
+self.hunk = [ desc ]
+self.a = []
+self.b = []
+if context:
+self.read_context_hunk(lr)
+else:
+self.read_unified_hunk(lr)
+def read_unified_hunk(self, lr):
+m = unidesc.match(self.desc)
+if not m:
+raise PatchError(_("bad hunk #%d") % self.number)
+self.starta, foo, self.lena, self.startb, foo2, self.lenb = m.groups()
+if self.lena == None:
+self.lena = 1
+else:
+self.lena = int(self.lena)
+if self.lenb == None:
+self.lenb = 1
+else:
+self.lenb = int(self.lenb)
+self.starta = int(self.starta)
+self.startb = int(self.startb)
+diffhelpers.addlines(lr.fp, self.hunk, self.lena, self.lenb, self.a, self.b)
+# if we hit eof before finishing out the hunk, the last line will
+# be zero length.  Lets try to fix it up.
+while len(self.hunk[-1]) == 0:
+del self.hunk[-1]
+del self.a[-1]
+del self.b[-1]
+self.lena -= 1
+self.lenb -= 1
+def read_context_hunk(self, lr):
+self.desc = lr.readline()
+m = contextdesc.match(self.desc)
+if not m:
+raise PatchError(_("bad hunk #%d") % self.number)
+foo, self.starta, foo2, aend, foo3 = m.groups()
+self.starta = int(self.starta)
+if aend == None:
+aend = self.starta
+self.lena = int(aend) - self.starta
+if self.starta:
+self.lena += 1
+for x in xrange(self.lena):
+l = lr.readline()
+if l.startswith('---'):
+lr.push(l)
+break
+s = l[2:]
+if l.startswith('- ') or l.startswith('! '):
+u = '-' + s
+elif l.startswith('  '):
+u = ' ' + s
+else:
+raise PatchError(_("bad hunk #%d old text line %d") %
+(self.number, x))
+self.a.append(u)
+self.hunk.append(u)
+l = lr.readline()
+if l.startswith('\ '):
+s = self.a[-1][:-1]
+self.a[-1] = s
+self.hunk[-1] = s
+l = lr.readline()
+m = contextdesc.match(l)
+if not m:
+raise PatchError(_("bad hunk #%d") % self.number)
+foo, self.startb, foo2, bend, foo3 = m.groups()
+self.startb = int(self.startb)
+if bend == None:
+bend = self.startb
+self.lenb = int(bend) - self.startb
+if self.startb:
+self.lenb += 1
+hunki = 1
+for x in xrange(self.lenb):
+l = lr.readline()
+if l.startswith('\ '):
+s = self.b[-1][:-1]
+self.b[-1] = s
+self.hunk[hunki-1] = s
+continue
+if not l:
+lr.push(l)
+break
+s = l[2:]
+if l.startswith('+ ') or l.startswith('! '):
+u = '+' + s
+elif l.startswith('  '):
+u = ' ' + s
+elif len(self.b) == 0:
+# this can happen when the hunk does not add any lines
+lr.push(l)
+break
+else:
+raise PatchError(_("bad hunk #%d old text line %d") %
+(self.number, x))
+self.b.append(s)
+while True:
+if hunki >= len(self.hunk):
+h = ""
+else:
+h = self.hunk[hunki]
+hunki += 1
+if h == u:
+break
+elif h.startswith('-'):
+continue
+else:
+self.hunk.insert(hunki-1, u)
+break
+if not self.a:
+# this happens when lines were only added to the hunk
+for x in self.hunk:
+if x.startswith('-') or x.startswith(' '):
+self.a.append(x)
+if not self.b:
+# this happens when lines were only deleted from the hunk
+for x in self.hunk:
+if x.startswith('+') or x.startswith(' '):
+self.b.append(x[1:])
+# @@ -start,len +start,len @@
+self.desc = "@@ -%d,%d +%d,%d @@\n" % (self.starta, self.lena,
+self.startb, self.lenb)
+self.hunk[0] = self.desc
+def reverse(self):
+origlena = self.lena
+origstarta = self.starta
+self.lena = self.lenb
+self.starta = self.startb
+self.lenb = origlena
+self.startb = origstarta
+self.a = []
+self.b = []
+# self.hunk[0] is the @@ description
+for x in xrange(1, len(self.hunk)):
+o = self.hunk[x]
+if o.startswith('-'):
+n = '+' + o[1:]
+self.b.append(o[1:])
+elif o.startswith('+'):
+n = '-' + o[1:]
+self.a.append(n)
+else:
+n = o
+self.b.append(o[1:])
+self.a.append(o)
+self.hunk[x] = o
+def fix_newline(self):
+diffhelpers.fix_newline(self.hunk, self.a, self.b)
+def complete(self):
+return len(self.a) == self.lena and len(self.b) == self.lenb
+def createfile(self):
+return self.starta == 0 and self.lena == 0
+def rmfile(self):
+return self.startb == 0 and self.lenb == 0
+def fuzzit(self, l, fuzz, toponly):
+# this removes context lines from the top and bottom of list 'l'.  It
+# checks the hunk to make sure only context lines are removed, and then
+# returns a new shortened list of lines.
+fuzz = min(fuzz, len(l)-1)
+if fuzz:
+top = 0
+bot = 0
+hlen = len(self.hunk)
+for x in xrange(hlen-1):
+# the hunk starts with the @@ line, so use x+1
+if self.hunk[x+1][0] == ' ':
+top += 1
+else:
+break
+if not toponly:
+for x in xrange(hlen-1):
+if self.hunk[hlen-bot-1][0] == ' ':
+bot += 1
+else:
+break
+# top and bot now count context in the hunk
+# adjust them if either one is short
+context = max(top, bot, 3)
+if bot < context:
+bot = max(0, fuzz - (context - bot))
+else:
+bot = min(fuzz, bot)
+if top < context:
+top = max(0, fuzz - (context - top))
+else:
+top = min(fuzz, top)
+return l[top:len(l)-bot]
+return l
+def old(self, fuzz=0, toponly=False):
+return self.fuzzit(self.a, fuzz, toponly)
+def newctrl(self):
+res = []
+for x in self.hunk:
+c = x[0]
+if c == ' ' or c == '+':
+res.append(x)
+return res
+def new(self, fuzz=0, toponly=False):
+return self.fuzzit(self.b, fuzz, toponly)
+class binhunk:
+'A binary patch file. Only understands literals so far.'
+def __init__(self, gitpatch):
+self.gitpatch = gitpatch
+self.text = None
+self.hunk = ['GIT binary patch\n']
+def createfile(self):
+return self.gitpatch.op in ('ADD', 'RENAME', 'COPY')
+def rmfile(self):
+return self.gitpatch.op == 'DELETE'
+def complete(self):
+return self.text is not None
+def new(self):
+return [self.text]
+def extract(self, fp):
+line = fp.readline()
+self.hunk.append(line)
 while line and not line.startswith('literal '):
-line = readline()
+line = fp.readline()
+self.hunk.append(line)
 if not line:
-return None, i[0]
+raise PatchError(_('could not extract binary patch'))
-size = int(line[8:])
+size = int(line[8:].rstrip())
 dec = []
-line = readline()
+line = fp.readline()
-while line:
+self.hunk.append(line)
+while len(line) > 1:
 l = line[0]
 if l <= 'Z' and l >= 'A':
 l = ord(l) - ord('A') + 1
 else:
 l = ord(l) - ord('a') + 27
-dec.append(base85.b85decode(line[1:])[:l])
+dec.append(base85.b85decode(line[1:-1])[:l])
-line = readline()
+line = fp.readline()
+self.hunk.append(line)
 text = zlib.decompress(''.join(dec))
 if len(text) != size:
-raise util.Abort(_('binary patch is %d bytes, not %d') %
+raise PatchError(_('binary patch is %d bytes, not %d') %
-(len(text), size))
+len(text), size)
-return text, i[0]
+self.text = text
-pf = file(patchname)
+def parsefilename(str):
-pfline = 1
+# --- filename \t|space stuff
+s = str[4:]
-fd, patchname = tempfile.mkstemp(prefix='hg-patch-')
+i = s.find('\t')
-tmpfp = os.fdopen(fd, 'w')
+if i < 0:
+i = s.find(' ')
-try:
+if i < 0:
-for i in xrange(len(gitpatches)):
+return s
-p = gitpatches[i]
+return s[:i]
-if not p.copymod and not p.binary:
+def selectfile(afile_orig, bfile_orig, hunk, strip, reverse):
+def pathstrip(path, count=1):
+pathlen = len(path)
+i = 0
+if count == 0:
+return path.rstrip()
+while count > 0:
+i = path.find('/', i)
+if i == -1:
+raise PatchError(_("unable to strip away %d dirs from %s") %
+(count, path))
+i += 1
+# consume '//' in the path
+while i < pathlen - 1 and path[i] == '/':
+i += 1
+count -= 1
+return path[i:].rstrip()
+nulla = afile_orig == "/dev/null"
+nullb = bfile_orig == "/dev/null"
+afile = pathstrip(afile_orig, strip)
+gooda = os.path.exists(afile) and not nulla
+bfile = pathstrip(bfile_orig, strip)
+if afile == bfile:
+goodb = gooda
+else:
+goodb = os.path.exists(bfile) and not nullb
+createfunc = hunk.createfile
+if reverse:
+createfunc = hunk.rmfile
+if not goodb and not gooda and not createfunc():
+raise PatchError(_("unable to find %s or %s for patching") %
+(afile, bfile))
+if gooda and goodb:
+fname = bfile
+if afile in bfile:
+fname = afile
+elif gooda:
+fname = afile
+elif not nullb:
+fname = bfile
+if afile in bfile:
+fname = afile
+elif not nulla:
+fname = afile
+return fname
+class linereader:
+# simple class to allow pushing lines back into the input stream
+def __init__(self, fp):
+self.fp = fp
+self.buf = []
+def push(self, line):
+self.buf.append(line)
+def readline(self):
+if self.buf:
+l = self.buf[0]
+del self.buf[0]
+return l
+return self.fp.readline()
+def applydiff(ui, fp, changed, strip=1, sourcefile=None, reverse=False,
+rejmerge=None, updatedir=None):
+"""reads a patch from fp and tries to apply it.  The dict 'changed' is
+filled in with all of the filenames changed by the patch.  Returns 0
+for a clean patch, -1 if any rejects were found and 1 if there was
+any fuzz."""
+def scangitpatch(fp, firstline, cwd=None):
+'''git patches can modify a file, then copy that file to
+a new file, but expect the source to be the unmodified form.
+So we scan the patch looking for that case so we can do
+the copies ahead of time.'''
+pos = 0
+try:
+pos = fp.tell()
+except IOError:
+fp = cStringIO.StringIO(fp.read())
+(dopatch, gitpatches) = readgitpatch(fp, firstline)
+for gp in gitpatches:
+if gp.copymod:
+copyfile(gp.oldpath, gp.path, basedir=cwd)
+fp.seek(pos)
+return fp, dopatch, gitpatches
+current_hunk = None
+current_file = None
+afile = ""
+bfile = ""
+state = None
+hunknum = 0
+rejects = 0
+git = False
+gitre = re.compile('diff --git (a/.*) (b/.*)')
+# our states
+BFILE = 1
+err = 0
+context = None
+lr = linereader(fp)
+dopatch = True
+gitworkdone = False
+while True:
+newfile = False
+x = lr.readline()
+if not x:
+break
+if current_hunk:
+if x.startswith('\ '):
+current_hunk.fix_newline()
+ret = current_file.apply(current_hunk, reverse)
+if ret >= 0:
+changed.setdefault(current_file.fname, (None, None))
+if ret > 0:
+err = 1
+current_hunk = None
+gitworkdone = False
+if ((sourcefile or state == BFILE) and ((not context and x[0] == '@') or
+((context or context == None) and x.startswith('***************')))):
+try:
+if context == None and x.startswith('***************'):
+context = True
+current_hunk = hunk(x, hunknum + 1, lr, context)
+except PatchError, err:
+ui.debug(err)
+current_hunk = None
 continue
+hunknum += 1
-# rewrite patch hunk
+if not current_file:
-while pfline < p.lineno:
+if sourcefile:
-tmpfp.write(pf.readline())
+current_file = patchfile(ui, sourcefile)
-pfline += 1
+else:
+current_file = selectfile(afile, bfile, current_hunk,
-if p.binary:
+strip, reverse)
-text, delta = extractbin(pf)
+current_file = patchfile(ui, current_file)
-if not text:
+elif state == BFILE and x.startswith('GIT binary patch'):
-raise util.Abort(_('binary patch extraction failed'))
+current_hunk = binhunk(changed[bfile[2:]][1])
-pfline += delta
+if not current_file:
-if not cwd:
+if sourcefile:
-cwd = os.getcwd()
+current_file = patchfile(ui, sourcefile)
-absdst = os.path.join(cwd, p.path)
+else:
-basedir = os.path.dirname(absdst)
+current_file = selectfile(afile, bfile, current_hunk,
-if not os.path.isdir(basedir):
+strip, reverse)
-os.makedirs(basedir)
+current_file = patchfile(ui, current_file)
-out = file(absdst, 'wb')
+hunknum += 1
-out.write(text)
+current_hunk.extract(fp)
-out.close()
+elif x.startswith('diff --git'):
-elif p.copymod:
+# check for git diff, scanning the whole patch file if needed
-copyfile(p.oldpath, p.path, basedir=cwd)
+m = gitre.match(x)
-tmpfp.write('diff --git a/%s b/%s\n' % (p.path, p.path))
+if m:
-line = pf.readline()
+afile, bfile = m.group(1, 2)
-pfline += 1
+if not git:
-while not line.startswith('--- a/'):
+git = True
-tmpfp.write(line)
+fp, dopatch, gitpatches = scangitpatch(fp, x)
-line = pf.readline()
+for gp in gitpatches:
-pfline += 1
+changed[gp.path] = (gp.op, gp)
-tmpfp.write('--- a/%s\n' % p.path)
+# else error?
+# copy/rename + modify should modify target, not source
-line = pf.readline()
+if changed.get(bfile[2:], (None, None))[0] in ('COPY',
-while line:
+'RENAME'):
-tmpfp.write(line)
+afile = bfile
-line = pf.readline()
+gitworkdone = True
-except:
+newfile = True
-tmpfp.close()
+elif x.startswith('---'):
-os.unlink(patchname)
+# check for a unified diff
-raise
+l2 = lr.readline()
+if not l2.startswith('+++'):
-tmpfp.close()
+lr.push(l2)
-return patchname
+continue
+newfile = True
-def patch(patchname, ui, strip=1, cwd=None, files={}):
+context = False
-"""apply the patch <patchname> to the working directory.
+afile = parsefilename(x)
-a list of patched files is returned"""
+bfile = parsefilename(l2)
+elif x.startswith('***'):
-# helper function
+# check for a context diff
-def __patch(patchname):
+l2 = lr.readline()
-"""patch and updates the files and fuzz variables"""
+if not l2.startswith('---'):
-fuzz = False
+lr.push(l2)
+continue
-args = []
+l3 = lr.readline()
-patcher = ui.config('ui', 'patch')
+lr.push(l3)
-if not patcher:
+if not l3.startswith("***************"):
-patcher = util.find_exe('gpatch') or util.find_exe('patch')
+lr.push(l2)
-# Try to be smart only if patch call was not supplied
+continue
-if util.needbinarypatch():
+newfile = True
-args.append('--binary')
+context = True
+afile = parsefilename(x)
-if not patcher:
+bfile = parsefilename(l2)
-raise util.Abort(_('no patch command found in hgrc or PATH'))
+if newfile:
-if cwd:
+if current_file:
-args.append('-d %s' % util.shellquote(cwd))
+current_file.close()
-fp = os.popen('%s %s -p%d < %s' % (patcher, ' '.join(args), strip,
+if rejmerge:
-util.shellquote(patchname)))
+rejmerge(current_file)
+rejects += len(current_file.rej)
-for line in fp:
+state = BFILE
-line = line.rstrip()
+current_file = None
-ui.note(line + '\n')
+hunknum = 0
-if line.startswith('patching file '):
+if current_hunk:
-pf = util.parse_patch_output(line)
+if current_hunk.complete():
-printed_file = False
+ret = current_file.apply(current_hunk, reverse)
-files.setdefault(pf, (None, None))
+if ret >= 0:
-elif line.find('with fuzz') >= 0:
+changed.setdefault(current_file.fname, (None, None))
-fuzz = True
+if ret > 0:
-if not printed_file:
+err = 1
-ui.warn(pf + '\n')
+else:
-printed_file = True
+fname = current_file and current_file.fname or None
-ui.warn(line + '\n')
+raise PatchError(_("malformed patch %s %s") % (fname,
-elif line.find('saving rejects to file') >= 0:
+current_hunk.desc))
-ui.warn(line + '\n')
+if current_file:
-elif line.find('FAILED') >= 0:
+current_file.close()
-if not printed_file:
+if rejmerge:
-ui.warn(pf + '\n')
+rejmerge(current_file)
-printed_file = True
+rejects += len(current_file.rej)
-ui.warn(line + '\n')
+if updatedir and git:
-code = fp.close()
+updatedir(gitpatches)
-if code:
+if rejects:
-raise util.Abort(_("patch command failed: %s") %
+return -1
-util.explain_exit(code)[0])
+if hunknum == 0 and dopatch and not gitworkdone:
-return fuzz
+raise NoHunks
+return err
-(dopatch, gitpatches) = readgitpatch(patchname)
-for gp in gitpatches:
-files[gp.path] = (gp.op, gp)
-fuzz = False
-if dopatch:
-filterpatch = dopatch & (GP_FILTER | GP_BINARY)
-if filterpatch:
-patchname = dogitpatch(patchname, gitpatches, cwd=cwd)
-try:
-if dopatch & GP_PATCH:
-fuzz = __patch(patchname)
-finally:
-if filterpatch:
-os.unlink(patchname)
-return fuzz
 def diffopts(ui, opts={}, untrusted=False):
 def get(key, name=None):
 return (opts.get(key) or
 ui.configbool('diff', name or key, None, untrusted=untrusted))
 showfunc=get('show_function', 'showfunc'),
 ignorews=get('ignore_all_space', 'ignorews'),
 ignorewsamount=get('ignore_space_change', 'ignorewsamount'),
 ignoreblanklines=get('ignore_blank_lines', 'ignoreblanklines'))
-def updatedir(ui, repo, patches, wlock=None):
+def updatedir(ui, repo, patches):
 '''Update dirstate after patch application according to metadata'''
 if not patches:
 return
 copies = []
 removes = {}
 elif ctype == 'DELETE':
 removes[gp.path] = 1
 for src, dst, after in copies:
 if not after:
 copyfile(src, dst, repo.root)
-repo.copy(src, dst, wlock=wlock)
+repo.copy(src, dst)
 removes = removes.keys()
 if removes:
 removes.sort()
-repo.remove(removes, True, wlock=wlock)
+repo.remove(removes, True)
 for f in patches:
 ctype, gp = patches[f]
 if gp and gp.mode:
 x = gp.mode & 0100 != 0
+l = gp.mode & 020000 != 0
 dst = os.path.join(repo.root, gp.path)
 # patch won't create empty files
 if ctype == 'ADD' and not os.path.exists(dst):
 repo.wwrite(gp.path, '', x and 'x' or '')
 else:
-util.set_exec(dst, x)
+util.set_link(dst, l)
-cmdutil.addremove(repo, cfiles, wlock=wlock)
+if not l:
+util.set_exec(dst, x)
+cmdutil.addremove(repo, cfiles)
 files = patches.keys()
 files.extend([r for r in removes if r not in files])
 files.sort()
 return files
-def b85diff(fp, to, tn):
+def b85diff(to, tn):
 '''print base85-encoded binary diff'''
 def gitindex(text):
 if not text:
 return '0' * 40
 l = len(text)
 return
 if node2:
 ctx2 = context.changectx(repo, node2)
 execf2 = ctx2.manifest().execf
+linkf2 = ctx2.manifest().linkf
 else:
 ctx2 = context.workingctx(repo)
 execf2 = util.execfunc(repo.root, None)
+linkf2 = util.linkfunc(repo.root, None)
 if execf2 is None:
-execf2 = ctx2.parents()[0].manifest().copy().execf
+mc = ctx2.parents()[0].manifest().copy()
+execf2 = mc.execf
+linkf2 = mc.linkf
 # returns False if there was no rename between ctx1 and ctx2
 # returns None if the file was created between ctx1 and ctx2
 # returns the (file, node) present in ctx1 that was renamed to f in ctx2
 def renamed(f):
 if f in man1:
 to = getfilectx(f, ctx1).data()
 if f not in removed:
 tn = getfilectx(f, ctx2).data()
 if opts.git:
-def gitmode(x):
+def gitmode(x, l):
-return x and '100755' or '100644'
+return l and '120000' or (x and '100755' or '100644')
 def addmodehdr(header, omode, nmode):
 if omode != nmode:
 header.append('old mode %s\n' % omode)
 header.append('new mode %s\n' % nmode)
 a, b = f, f
 if f in added:
-mode = gitmode(execf2(f))
+mode = gitmode(execf2(f), linkf2(f))
 if f in copied:
 a = copied[f]
-omode = gitmode(man1.execf(a))
+omode = gitmode(man1.execf(a), man1.linkf(a))
 addmodehdr(header, omode, mode)
 if a in removed and a not in gone:
 op = 'rename'
 gone[a] = 1
 else:
 dodiff = 'binary'
 elif f in removed:
 if f in srcs:
 dodiff = False
 else:
-mode = gitmode(man1.execf(f))
+mode = gitmode(man1.execf(f), man1.linkf(f))
 header.append('deleted file mode %s\n' % mode)
 else:
-omode = gitmode(man1.execf(f))
+omode = gitmode(man1.execf(f), man1.linkf(f))
-nmode = gitmode(execf2(f))
+nmode = gitmode(execf2(f), linkf2(f))
 addmodehdr(header, omode, nmode)
 if util.binary(to) or util.binary(tn):
 dodiff = 'binary'
 r = None
 header.insert(0, 'diff --git a/%s b/%s\n' % (a, b))
 if dodiff:
 if dodiff == 'binary':
-text = b85diff(fp, to, tn)
+text = b85diff(to, tn)
 else:
 text = mdiff.unidiff(to, date1,
 # ctx2 date may be dynamic
 tn, util.datestr(ctx2.date()),
 f, r, opts=opts)

changeset 5124	06154aff2b1a
parent 5117	d4fa6bafc43a
child 5260	0fc16031bb45