mercurial-scm/hg: comparison mercurial/patch.py

equal deleted inserted replaced

-:d1a1578c5f78
+:c78d41db6f88
 unidesc = re.compile('@@ -(\d+)(,(\d+))? \+(\d+)(,(\d+))? @@')
 contextdesc = re.compile('(---|\*\*\*) (\d+)(,(\d+))? (---|\*\*\*)')
 eolmodes = ['strict', 'crlf', 'lf', 'auto']
 class patchfile(object):
-def __init__(self, ui, fname, backend, mode, missing=False,
+def __init__(self, ui, fname, backend, mode, create, remove, missing=False,
 eolmode='strict'):
 self.fname = fname
 self.eolmode = eolmode
 self.eol = None
 self.backend = backend
 self.ui = ui
 self.lines = []
 self.exists = False
 self.missing = missing
 self.mode = mode
+self.create = create
+self.remove = remove
 if not missing:
 try:
 data, mode = self.backend.getfile(fname)
 if data:
 self.lines = data.splitlines(True)
 if self.missing:
 self.rej.append(h)
 return -1
-if self.exists and h.createfile():
+if self.exists and self.create:
 self.ui.warn(_("file %s already exists\n") % self.fname)
 self.rej.append(h)
 return -1
 if isinstance(h, binhunk):
-if h.rmfile():
+if self.remove:
 self.backend.unlink(self.fname)
 else:
 self.lines[:] = h.new()
 self.offset += len(h.new())
 self.dirty = True
 orig_start = start
 # if there's skew we want to emit the "(offset %d lines)" even
 # when the hunk cleanly applies at start + skew, so skip the
 # fast case code
 if self.skew == 0 and diffhelpers.testhunk(old, self.lines, start) == 0:
-if h.rmfile():
+if self.remove:
 self.backend.unlink(self.fname)
 else:
 self.lines[start : start + h.lena] = h.new()
 self.offset += h.lenb - h.lena
 self.dirty = True
 self.writelines(self.fname, self.lines, self.mode)
 self.write_rej()
 return len(self.rej)
 class hunk(object):
-def __init__(self, desc, num, lr, context, create=False, remove=False):
+def __init__(self, desc, num, lr, context):
 self.number = num
 self.desc = desc
 self.hunk = [desc]
 self.a = []
 self.b = []
 if lr is not None:
 if context:
 self.read_context_hunk(lr)
 else:
 self.read_unified_hunk(lr)
-self.create = create
-self.remove = remove and not create
 def getnormalized(self):
 """Return a copy with line endings normalized to LF."""
 def normalize(lines):
 line = line[:-2] + '\n'
 nlines.append(line)
 return nlines
 # Dummy object, it is rebuilt manually
-nh = hunk(self.desc, self.number, None, None, False, False)
+nh = hunk(self.desc, self.number, None, None)
 nh.number = self.number
 nh.desc = self.desc
 nh.hunk = self.hunk
 nh.a = normalize(self.a)
 nh.b = normalize(self.b)
 nh.starta = self.starta
 nh.startb = self.startb
 nh.lena = self.lena
 nh.lenb = self.lenb
-nh.create = self.create
-nh.remove = self.remove
 return nh
 def read_unified_hunk(self, lr):
 m = unidesc.match(self.desc)
 if not m:
 lr.push(l)
 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 and self.create
-def rmfile(self):
-return self.startb == 0 and self.lenb == 0 and self.remove
 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)
 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, lr):
+def __init__(self, lr):
-self.gitpatch = gitpatch
 self.text = None
 self.hunk = ['GIT binary patch\n']
 self._read(lr)
-def createfile(self):
-return self.gitpatch.op == 'ADD'
-def rmfile(self):
-return self.gitpatch.op == 'DELETE'
 def complete(self):
 return self.text is not None
 def new(self):
 def selectfile(backend, afile_orig, bfile_orig, hunk, strip, gp):
 if gp:
 # Git patches do not play games. Excluding copies from the
 # following heuristic avoids a lot of confusion
 fname = pathstrip(gp.path, strip - 1)[1]
-missing = not hunk.createfile() and not backend.exists(fname)
+create = gp.op == 'ADD'
-return fname, missing
+remove = gp.op == 'DELETE'
+missing = not create and not backend.exists(fname)
+return fname, missing, create, remove
 nulla = afile_orig == "/dev/null"
 nullb = bfile_orig == "/dev/null"
+create = nulla and hunk.starta == 0 and hunk.lena == 0
+remove = nullb and hunk.startb == 0 and hunk.lenb == 0
 abase, afile = pathstrip(afile_orig, strip)
 gooda = not nulla and backend.exists(afile)
 bbase, bfile = pathstrip(bfile_orig, strip)
 if afile == bfile:
 goodb = gooda
 else:
 goodb = not nullb and backend.exists(bfile)
-createfunc = hunk.createfile
+missing = not goodb and not gooda and not create
-missing = not goodb and not gooda and not createfunc()
 # some diff programs apparently produce patches where the afile is
 # not /dev/null, but afile starts with bfile
 abasedir = afile[:afile.rfind('/') + 1]
 bbasedir = bfile[:bfile.rfind('/') + 1]
-if missing and abasedir == bbasedir and afile.startswith(bfile):
+if (missing and abasedir == bbasedir and afile.startswith(bfile)
-# this isn't very pretty
+and hunk.starta == 0 and hunk.lena == 0):
-hunk.create = True
+create = True
-if createfunc():
+missing = False
-missing = False
-else:
-hunk.create = False
 # If afile is "a/b/foo" and bfile is "a/b/foo.orig" we assume the
 # diff is between a file and its backup. In this case, the original
 # file should be patched (see original mpatch code).
 isbackup = (abase == bbase and bfile.startswith(afile))
 elif not nulla:
 fname = afile
 else:
 raise PatchError(_("undefined source and destination files"))
-return fname, missing
+return fname, missing, create, remove
 def scangitpatch(lr, firstline):
 """
 Git patches can emit:
 - rename a to b
 or x.startswith('GIT binary patch')):
 gp = None
 if gitpatches and gitpatches[-1][0] == bfile:
 gp = gitpatches.pop()[1]
 if x.startswith('GIT binary patch'):
-h = binhunk(gp, lr)
+h = binhunk(lr)
 else:
 if context is None and x.startswith('***************'):
 context = True
-create = afile == '/dev/null' or gp and gp.op == 'ADD'
+h = hunk(x, hunknum + 1, lr, context)
-remove = bfile == '/dev/null' or gp and gp.op == 'DELETE'
-h = hunk(x, hunknum + 1, lr, context, create, remove)
 hunknum += 1
 if emitfile:
 emitfile = False
 yield 'file', (afile, bfile, h, gp)
 yield 'hunk', h
 backend.setfile(path, data, gp.mode)
 if not first_hunk:
 continue
 try:
 mode = gp and gp.mode or None
-current_file, missing = selectfile(backend, afile, bfile,
+current_file, missing, create, remove = selectfile(
-first_hunk, strip, gp)
+backend, afile, bfile, first_hunk, strip, gp)
 current_file = patcher(ui, current_file, backend, mode,
-missing=missing, eolmode=eolmode)
+create, remove, missing=missing,
+eolmode=eolmode)
 except PatchError, inst:
 ui.warn(str(inst) + '\n')
 current_file = None
 rejects += 1
 continue
 changed.add(pathstrip(gp.path, strip - 1)[1])
 if gp.op == 'RENAME':
 changed.add(pathstrip(gp.oldpath, strip - 1)[1])
 if not first_hunk:
 continue
-current_file, missing = selectfile(backend, afile, bfile,
+current_file, missing, create, remove = selectfile(
-first_hunk, strip, gp)
+backend, afile, bfile, first_hunk, strip, gp)
 changed.add(current_file)
 elif state not in ('hunk', 'git'):
 raise util.Abort(_('unsupported parser state: %s') % state)
 return changed
 finally:

changeset 14451	c78d41db6f88
parent 14437	cbe13e6bdc34
child 14452	ee574cfd0c32