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

equal deleted inserted replaced

-:c78d41db6f88
+:ee574cfd0c32
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 import cStringIO, email.Parser, os, errno, re
-import tempfile, zlib
+import tempfile, zlib, shutil
 from i18n import _
 from node import hex, nullid, short
 import base85, mdiff, scmutil, util, diffhelpers, copies, encoding
 """Return target file data and flags as a (data, (islink,
 isexec)) tuple.
 """
 raise NotImplementedError
-def setfile(self, fname, data, mode):
+def setfile(self, fname, data, mode, copysource):
 """Write data to target file fname and set its mode. mode is a
 (islink, isexec) tuple. If data is None, the file content should
-be left unchanged.
+be left unchanged. If the file is modified after being copied,
+copysource is set to the original file name.
 """
 raise NotImplementedError
 def unlink(self, fname):
 """Unlink target file."""
 """Write rejected lines for fname. total is the number of hunks
 which failed to apply and total the total number of hunks for this
 files.
 """
 pass
-def copy(self, src, dst):
-"""Copy src file into dst file. Create intermediate directories if
-necessary. Files are specified relatively to the patching base
-directory.
-"""
-raise NotImplementedError
 def exists(self, fname):
 raise NotImplementedError
 class fsbackend(abstractbackend):
 except OSError, e:
 if e.errno != errno.ENOENT:
 raise
 return (self.opener.read(fname), (islink, isexec))
-def setfile(self, fname, data, mode):
+def setfile(self, fname, data, mode, copysource):
 islink, isexec = mode
 if data is None:
 util.setflags(self._join(fname), islink, isexec)
 return
 if islink:
 (failed, total, fname))
 fp = self.opener(fname, 'w')
 fp.writelines(lines)
 fp.close()
-def copy(self, src, dst):
-basedir = self.opener.base
-abssrc, absdst = [scmutil.canonpath(basedir, basedir, x)
-for x in [src, dst]]
-if os.path.lexists(absdst):
-raise util.Abort(_("cannot create %s: destination already exists")
-% dst)
-dstdir = os.path.dirname(absdst)
-if dstdir and not os.path.isdir(dstdir):
-try:
-os.makedirs(dstdir)
-except IOError:
-raise util.Abort(
-_("cannot create %s: unable to create destination directory")
-% dst)
-util.copyfile(abssrc, absdst)
 def exists(self, fname):
 return os.path.lexists(self._join(fname))
 class workingbackend(fsbackend):
 def __init__(self, ui, repo, similarity):
 self.similarity = similarity
 self.removed = set()
 self.changed = set()
 self.copied = []
-def setfile(self, fname, data, mode):
+def setfile(self, fname, data, mode, copysource):
-super(workingbackend, self).setfile(fname, data, mode)
+super(workingbackend, self).setfile(fname, data, mode, copysource)
+if copysource is not None:
+self.copied.append((copysource, fname))
 self.changed.add(fname)
 def unlink(self, fname):
 super(workingbackend, self).unlink(fname)
 self.removed.add(fname)
 self.changed.add(fname)
-def copy(self, src, dst):
-super(workingbackend, self).copy(src, dst)
-self.copied.append((src, dst))
-self.changed.add(dst)
 def close(self):
 wctx = self.repo[None]
 addremoved = set(self.changed)
 for src, dst in self.copied:
 addremoved = [util.pathto(self.repo.root, cwd, f)
 for f in addremoved]
 scmutil.addremove(self.repo, addremoved, similarity=self.similarity)
 return sorted(self.changed)
+class filestore(object):
+def __init__(self):
+self.opener = None
+self.files = {}
+self.created = 0
+def setfile(self, fname, data, mode):
+if self.opener is None:
+root = tempfile.mkdtemp(prefix='hg-patch-')
+self.opener = scmutil.opener(root)
+# Avoid filename issues with these simple names
+fn = str(self.created)
+self.opener.write(fn, data)
+self.created += 1
+self.files[fname] = (fn, mode)
+def getfile(self, fname):
+if fname not in self.files:
+raise IOError()
+fn, mode = self.files[fname]
+return self.opener.read(fn), mode
+def close(self):
+if self.opener:
+shutil.rmtree(self.opener.base)
 # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
 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, create, remove, missing=False,
+def __init__(self, ui, fname, backend, store, mode, create, remove,
-eolmode='strict'):
+eolmode='strict', copysource=None):
 self.fname = fname
 self.eolmode = eolmode
 self.eol = None
 self.backend = backend
 self.ui = ui
 self.lines = []
 self.exists = False
-self.missing = missing
+self.missing = True
 self.mode = mode
+self.copysource = copysource
 self.create = create
 self.remove = remove
-if not missing:
+try:
-try:
+if copysource is None:
-data, mode = self.backend.getfile(fname)
+data, mode = backend.getfile(fname)
-if data:
-self.lines = data.splitlines(True)
-if self.mode is None:
-self.mode = mode
-if self.lines:
-# Normalize line endings
-if self.lines[0].endswith('\r\n'):
-self.eol = '\r\n'
-elif self.lines[0].endswith('\n'):
-self.eol = '\n'
-if eolmode != 'strict':
-nlines = []
-for l in self.lines:
-if l.endswith('\r\n'):
-l = l[:-2] + '\n'
-nlines.append(l)
-self.lines = nlines
 self.exists = True
-except IOError:
+else:
-if self.mode is None:
+data, mode = store.getfile(copysource)
-self.mode = (False, False)
+self.exists = backend.exists(fname)
-else:
+self.missing = False
-self.ui.warn(_("unable to find '%s' for patching\n") % self.fname)
+if data:
+self.lines = data.splitlines(True)
+if self.mode is None:
+self.mode = mode
+if self.lines:
+# Normalize line endings
+if self.lines[0].endswith('\r\n'):
+self.eol = '\r\n'
+elif self.lines[0].endswith('\n'):
+self.eol = '\n'
+if eolmode != 'strict':
+nlines = []
+for l in self.lines:
+if l.endswith('\r\n'):
+l = l[:-2] + '\n'
+nlines.append(l)
+self.lines = nlines
+except IOError:
+if create:
+self.missing = False
+if self.mode is None:
+self.mode = (False, False)
+if self.missing:
+self.ui.warn(_("unable to find '%s' for patching\n") % self.fname)
 self.hash = {}
 self.dirty = 0
 self.offset = 0
 self.skew = 0
 if l and l[-1] == '\n':
 l = l[:-1] + eol
 rawlines.append(l)
 lines = rawlines
-self.backend.setfile(fname, ''.join(lines), mode)
+self.backend.setfile(fname, ''.join(lines), mode, self.copysource)
 def printfile(self, warn):
 if self.fileprinted:
 return
 if warn or self.ui.verbose:
 if self.missing:
 self.rej.append(h)
 return -1
 if self.exists and self.create:
-self.ui.warn(_("file %s already exists\n") % self.fname)
+if self.copysource:
+self.ui.warn(_("cannot create %s: destination already "
+"exists\n" % self.fname))
+else:
+self.ui.warn(_("file %s already exists\n") % self.fname)
 self.rej.append(h)
 return -1
 if isinstance(h, binhunk):
 if self.remove:
 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]
-create = gp.op == 'ADD'
+create = gp.op in ('ADD', 'COPY', 'RENAME')
 remove = gp.op == 'DELETE'
 missing = not create and not backend.exists(fname)
-return fname, missing, create, remove
+return fname, 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)
 elif not nulla:
 fname = afile
 else:
 raise PatchError(_("undefined source and destination files"))
-return fname, missing, create, remove
+return fname, create, remove
 def scangitpatch(lr, firstline):
 """
 Git patches can emit:
 - rename a to b
 while gitpatches:
 gp = gitpatches.pop()[1]
 yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp)
-def applydiff(ui, fp, changed, backend, strip=1, eolmode='strict'):
+def applydiff(ui, fp, changed, backend, store, strip=1, eolmode='strict'):
 """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.
 If 'eolmode' is 'strict', the patch content and patched file are
 read in binary mode. Otherwise, line endings are ignored when
 patching then normalized according to 'eolmode'.
 """
-return _applydiff(ui, fp, patchfile, backend, changed, strip=strip,
+return _applydiff(ui, fp, patchfile, backend, store, changed, strip=strip,
 eolmode=eolmode)
-def _applydiff(ui, fp, patcher, backend, changed, strip=1, eolmode='strict'):
+def _applydiff(ui, fp, patcher, backend, store, changed, strip=1,
+eolmode='strict'):
 def pstrip(p):
 return pathstrip(p, strip - 1)[1]
 rejects = 0
 elif state == 'file':
 if current_file:
 rejects += current_file.close()
 current_file = None
 afile, bfile, first_hunk, gp = values
+copysource = None
 if gp:
 path = pstrip(gp.path)
+if gp.oldpath:
+copysource = pstrip(gp.oldpath)
 changed[path] = gp
 if gp.op == 'DELETE':
 backend.unlink(path)
 continue
 if gp.op == 'RENAME':
-backend.unlink(pstrip(gp.oldpath))
+backend.unlink(copysource)
-if gp.mode and not first_hunk:
+if not first_hunk:
-data = None
+data, mode = None, None
-if gp.op == 'ADD':
+if gp.op in ('RENAME', 'COPY'):
-# Added files without content have no hunk and
+data, mode = store.getfile(copysource)
-# must be created
+if gp.mode:
-data = ''
+mode = gp.mode
-backend.setfile(path, data, gp.mode)
+if gp.op == 'ADD':
+# Added files without content have no hunk and
+# must be created
+data = ''
+if data or mode:
+if (gp.op in ('ADD', 'RENAME', 'COPY')
+and backend.exists(path)):
+raise PatchError(_("cannot create %s: destination "
+"already exists") % path)
+backend.setfile(path, data, mode, copysource)
 if not first_hunk:
 continue
 try:
 mode = gp and gp.mode or None
-current_file, missing, create, remove = selectfile(
+current_file, create, remove = selectfile(
 backend, afile, bfile, first_hunk, strip, gp)
-current_file = patcher(ui, current_file, backend, mode,
+current_file = patcher(ui, current_file, backend, store, mode,
-create, remove, missing=missing,
+create, remove, eolmode=eolmode,
-eolmode=eolmode)
+copysource=copysource)
 except PatchError, inst:
 ui.warn(str(inst) + '\n')
 current_file = None
 rejects += 1
 continue
 elif state == 'git':
 for gp in values:
-backend.copy(pstrip(gp.oldpath), pstrip(gp.path))
+path = pstrip(gp.oldpath)
+data, mode = backend.getfile(path)
+store.setfile(path, data, mode)
 else:
 raise util.Abort(_('unsupported parser state: %s') % state)
 if current_file:
 rejects += current_file.close()
 eolmode = ui.config('patch', 'eol', 'strict')
 if eolmode.lower() not in eolmodes:
 raise util.Abort(_('unsupported line endings type: %s') % eolmode)
 eolmode = eolmode.lower()
+store = filestore()
 backend = workingbackend(ui, repo, similarity)
 try:
 fp = open(patchobj, 'rb')
 except TypeError:
 fp = patchobj
 try:
-ret = applydiff(ui, fp, files, backend, strip=strip, eolmode=eolmode)
+ret = applydiff(ui, fp, files, backend, store, strip=strip,
+eolmode=eolmode)
 finally:
 if fp != patchobj:
 fp.close()
 files.update(dict.fromkeys(backend.close()))
+store.close()
 if ret < 0:
 raise PatchError(_('patch failed to apply'))
 return ret > 0
 def patch(ui, repo, patchname, strip=1, files=None, eolmode='strict',
 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, create, remove = selectfile(
+current_file, create, remove = selectfile(
 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

changeset 14452	ee574cfd0c32
parent 14451	c78d41db6f88
child 14453	ea3d548132cc