This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11824

errors: return more detailed errors when failing to parse or apply patch
ClosedPublic

Authored by martinvonz on Nov 29 2021, 4:57 PM.

Details

Reviewers
durin42
Alphare
Group Reviewers
hg-reviewers
Commits
rHG6a454e7053a1: errors: return more detailed errors when failing to parse or apply patch
Summary

This patch adds subclasses of PatchError so we can distinguish
between failure to parse a patch from failure to apply it. It updates
the callers to raise either InputError or StateError depending on
which type of error occurred.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Revision Contents
Changeset List

Diff 31196

mercurial/cmdutil.py

diffopts.showfunc = True diffopts.showfunc = True
originaldiff = patch.diff(repo, changes=status, opts=diffopts) originaldiff = patch.diff(repo, changes=status, opts=diffopts)
original_headers = patch.parsepatch(originaldiff) original_headers = patch.parsepatch(originaldiff)
match = scmutil.match(repo[None], pats) match = scmutil.match(repo[None], pats)
# 1. filter patch, since we are intending to apply subset of it # 1. filter patch, since we are intending to apply subset of it
try: try:
chunks, newopts = filterfn(ui, original_headers, match) chunks, newopts = filterfn(ui, original_headers, match)
except error.PatchError as err: except error.PatchParseError as err:
raise error.InputError(_(b'error parsing patch: %s') % err) raise error.InputError(_(b'error parsing patch: %s') % err)
except error.PatchApplicationError as err:
raise error.StateError(_(b'error applying patch: %s') % err)
opts.update(newopts) opts.update(newopts)
# We need to keep a backup of files that have been newly added and # We need to keep a backup of files that have been newly added and
# modified during the recording process because there is a previous # modified during the recording process because there is a previous
# version without the edit in the workdir. We also will need to restore # version without the edit in the workdir. We also will need to restore
# files that were the sources of renames so that the patch application # files that were the sources of renames so that the patch application
# works. # works.
newlyaddedandmodifiedfiles, alsorestore = newandmodified(chunks) newlyaddedandmodifiedfiles, alsorestore = newandmodified(chunks)
mergemod.revert_to(repo[b'.'], matcher=m) mergemod.revert_to(repo[b'.'], matcher=m)
# 3b. (apply) # 3b. (apply)
if dopatch: if dopatch:
try: try:
ui.debug(b'applying patch\n') ui.debug(b'applying patch\n')
ui.debug(fp.getvalue()) ui.debug(fp.getvalue())
patch.internalpatch(ui, repo, fp, 1, eolmode=None) patch.internalpatch(ui, repo, fp, 1, eolmode=None)
except error.PatchError as err: except error.PatchParseError as err:
raise error.InputError(pycompat.bytestr(err)) raise error.InputError(pycompat.bytestr(err))
except error.PatchApplicationError as err:
raise error.StateError(pycompat.bytestr(err))
del fp del fp
# 4. We prepared working directory according to filtered # 4. We prepared working directory according to filtered
# patch. Now is the time to delegate the job to # patch. Now is the time to delegate the job to
# commit/qrefresh or the like! # commit/qrefresh or the like!
# Make all of the pathnames absolute. # Make all of the pathnames absolute.
newfiles = [repo.wjoin(nf) for nf in newfiles] newfiles = [repo.wjoin(nf) for nf in newfiles]
repo, repo,
tmpname, tmpname,
strip=strip, strip=strip,
prefix=prefix, prefix=prefix,
files=files, files=files,
eolmode=None, eolmode=None,
similarity=sim / 100.0, similarity=sim / 100.0,
) )
except error.PatchError as e: except error.PatchParseError as e:
raise error.InputError(pycompat.bytestr(e))
except error.PatchApplicationError as e:
if not partial: if not partial:
raise error.Abort(pycompat.bytestr(e)) raise error.StateError(pycompat.bytestr(e))
if partial: if partial:
rejects = True rejects = True
files = list(files) files = list(files)
if nocommit: if nocommit:
if message: if message:
msgs.append(message) msgs.append(message)
else: else:
p1, p1,
store, store,
tmpname, tmpname,
strip, strip,
prefix, prefix,
files, files,
eolmode=None, eolmode=None,
) )
except error.PatchError as e: except error.PatchParseError as e:
raise error.Abort(stringutil.forcebytestr(e)) raise error.InputError(stringutil.forcebytestr(e))
except error.PatchApplicationError as e:
raise error.StateError(stringutil.forcebytestr(e))
if opts.get(b'exact'): if opts.get(b'exact'):
editor = None editor = None
else: else:
editor = getcommiteditor(editform=b'import.bypass') editor = getcommiteditor(editform=b'import.bypass')
memctx = context.memctx( memctx = context.memctx(
repo, repo,
(p1.node(), p2.node()), (p1.node(), p2.node()),
message, message,
try: try:
chunks, opts = recordfilter( chunks, opts = recordfilter(
repo.ui, original_headers, match, operation=operation repo.ui, original_headers, match, operation=operation
) )
if operation == b'discard': if operation == b'discard':
chunks = patch.reversehunks(chunks) chunks = patch.reversehunks(chunks)
except error.PatchError as err: except error.PatchParseError as err:
raise error.Abort(_(b'error parsing patch: %s') % err) raise error.InputError(_(b'error parsing patch: %s') % err)
except error.PatchApplicationError as err:
raise error.StateError(_(b'error applying patch: %s') % err)
# FIXME: when doing an interactive revert of a copy, there's no way of # FIXME: when doing an interactive revert of a copy, there's no way of
# performing a partial revert of the added file, the only option is # performing a partial revert of the added file, the only option is
# "remove added file <name> (Yn)?", so we don't need to worry about the # "remove added file <name> (Yn)?", so we don't need to worry about the
# alsorestore value. Ideally we'd be able to partially revert # alsorestore value. Ideally we'd be able to partially revert
# copied/renamed files. # copied/renamed files.
newlyaddedandmodifiedfiles, unusedalsorestore = newandmodified(chunks) newlyaddedandmodifiedfiles, unusedalsorestore = newandmodified(chunks)
if tobackup is None: if tobackup is None:
if operation == b'keep': if operation == b'keep':
checkout(abs) checkout(abs)
c.write(fp) c.write(fp)
dopatch = fp.tell() dopatch = fp.tell()
fp.seek(0) fp.seek(0)
if dopatch: if dopatch:
try: try:
patch.internalpatch(repo.ui, repo, fp, 1, eolmode=None) patch.internalpatch(repo.ui, repo, fp, 1, eolmode=None)
except error.PatchError as err: except error.PatchParseError as err:
raise error.Abort(pycompat.bytestr(err)) raise error.InputError(pycompat.bytestr(err))
except error.PatchApplicationError as err:
raise error.StateError(pycompat.bytestr(err))
del fp del fp
else: else:
for f in actions[b'revert'][0]: for f in actions[b'revert'][0]:
prntstatusmsg(b'revert', f) prntstatusmsg(b'revert', f)
checkout(f) checkout(f)
if normal: if normal:
normal(f) normal(f)

mercurial/error.py

message += _(b"(%s)\n") % self.hint message += _(b"(%s)\n") % self.hint
return message return message
class PatchError(Exception): class PatchError(Exception):
__bytes__ = _tobytes __bytes__ = _tobytes
class PatchParseError(PatchError):
__bytes__ = _tobytes
class PatchApplicationError(PatchError):
__bytes__ = _tobytes
def getsimilar(symbols, value): def getsimilar(symbols, value):
# type: (Iterable[bytes], bytes) -> List[bytes] # type: (Iterable[bytes], bytes) -> List[bytes]
sim = lambda x: difflib.SequenceMatcher(None, value, x).ratio() sim = lambda x: difflib.SequenceMatcher(None, value, x).ratio()
# The cutoff for similarity here is pretty arbitrary. It should # The cutoff for similarity here is pretty arbitrary. It should
# probably be investigated and tweaked. # probably be investigated and tweaked.
return [s for s in symbols if sim(s) > 0.6] return [s for s in symbols if sim(s) > 0.6]

mercurial/patch.py

gitre = re.compile(br'diff --git a/(.*) b/(.*)') gitre = re.compile(br'diff --git a/(.*) b/(.*)')
tabsplitter = re.compile(br'(\t+|[^\t]+)') tabsplitter = re.compile(br'(\t+|[^\t]+)')
wordsplitter = re.compile( wordsplitter = re.compile(
br'(\t+| +|[a-zA-Z0-9_\x80-\xff]+|[^ \ta-zA-Z0-9_\x80-\xff])' br'(\t+| +|[a-zA-Z0-9_\x80-\xff]+|[^ \ta-zA-Z0-9_\x80-\xff])'
) )
PatchError = error.PatchError PatchError = error.PatchError
PatchParseError = error.PatchParseError
PatchApplicationError = error.PatchApplicationError
# public functions # public functions
def split(stream): def split(stream):
'''return an iterator of individual patches from a stream''' '''return an iterator of individual patches from a stream'''
def isheader(line, inheader): def isheader(line, inheader):
self.removed = set() self.removed = set()
self.changed = set() self.changed = set()
self.copied = [] self.copied = []
def _checkknown(self, fname): def _checkknown(self, fname):
if not self.repo.dirstate.get_entry(fname).any_tracked and self.exists( if not self.repo.dirstate.get_entry(fname).any_tracked and self.exists(
fname fname
): ):
raise PatchError(_(b'cannot patch %s: file is not tracked') % fname) raise PatchApplicationError(
_(b'cannot patch %s: file is not tracked') % fname
)
def setfile(self, fname, data, mode, copysource): def setfile(self, fname, data, mode, copysource):
self._checkknown(fname) self._checkknown(fname)
super(workingbackend, self).setfile(fname, data, mode, copysource) super(workingbackend, self).setfile(fname, data, mode, copysource)
if copysource is not None: if copysource is not None:
self.copied.append((copysource, fname)) self.copied.append((copysource, fname))
self.changed.add(fname) self.changed.add(fname)
self.ctx = ctx self.ctx = ctx
self.store = store self.store = store
self.changed = set() self.changed = set()
self.removed = set() self.removed = set()
self.copied = {} self.copied = {}
def _checkknown(self, fname): def _checkknown(self, fname):
if fname not in self.ctx: if fname not in self.ctx:
raise PatchError(_(b'cannot patch %s: file is not tracked') % fname) raise PatchApplicationError(
_(b'cannot patch %s: file is not tracked') % fname
)
def getfile(self, fname): def getfile(self, fname):
try: try:
fctx = self.ctx[fname] fctx = self.ctx[fname]
except error.LookupError: except error.LookupError:
return None, None return None, None
flags = fctx.flags() flags = fctx.flags()
return fctx.data(), (b'l' in flags, b'x' in flags) return fctx.data(), (b'l' in flags, b'x' in flags)
for l in x.hunk: for l in x.hunk:
lines.append(l) lines.append(l)
if l[-1:] != b'\n': if l[-1:] != b'\n':
lines.append(b'\n' + diffhelper.MISSING_NEWLINE_MARKER) lines.append(b'\n' + diffhelper.MISSING_NEWLINE_MARKER)
self.backend.writerej(self.fname, len(self.rej), self.hunks, lines) self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)
def apply(self, h): def apply(self, h):
if not h.complete(): if not h.complete():
raise PatchError( raise PatchParseError(
_(b"bad hunk #%d %s (%d %d %d %d)") _(b"bad hunk #%d %s (%d %d %d %d)")
% (h.number, h.desc, len(h.a), h.lena, len(h.b), h.lenb) % (h.number, h.desc, len(h.a), h.lena, len(h.b), h.lenb)
) )
self.hunks += 1 self.hunks += 1
if self.missing: if self.missing:
self.rej.append(h) self.rej.append(h)
nh.startb = self.startb nh.startb = self.startb
nh.lena = self.lena nh.lena = self.lena
nh.lenb = self.lenb nh.lenb = self.lenb
return nh return nh
def read_unified_hunk(self, lr): def read_unified_hunk(self, lr):
m = unidesc.match(self.desc) m = unidesc.match(self.desc)
if not m: if not m:
raise PatchError(_(b"bad hunk #%d") % self.number) raise PatchParseError(_(b"bad hunk #%d") % self.number)
self.starta, self.lena, self.startb, self.lenb = m.groups() self.starta, self.lena, self.startb, self.lenb = m.groups()
if self.lena is None: if self.lena is None:
self.lena = 1 self.lena = 1
else: else:
self.lena = int(self.lena) self.lena = int(self.lena)
if self.lenb is None: if self.lenb is None:
self.lenb = 1 self.lenb = 1
else: else:
self.lenb = int(self.lenb) self.lenb = int(self.lenb)
self.starta = int(self.starta) self.starta = int(self.starta)
self.startb = int(self.startb) self.startb = int(self.startb)
try: try:
diffhelper.addlines( diffhelper.addlines(
lr, self.hunk, self.lena, self.lenb, self.a, self.b lr, self.hunk, self.lena, self.lenb, self.a, self.b
) )
except error.ParseError as e: except error.ParseError as e:
raise PatchError(_(b"bad hunk #%d: %s") % (self.number, e)) raise PatchParseError(_(b"bad hunk #%d: %s") % (self.number, e))
# if we hit eof before finishing out the hunk, the last line will # if we hit eof before finishing out the hunk, the last line will
# be zero length. Lets try to fix it up. # be zero length. Lets try to fix it up.
while len(self.hunk[-1]) == 0: while len(self.hunk[-1]) == 0:
del self.hunk[-1] del self.hunk[-1]
del self.a[-1] del self.a[-1]
del self.b[-1] del self.b[-1]
self.lena -= 1 self.lena -= 1
self.lenb -= 1 self.lenb -= 1
self._fixnewline(lr) self._fixnewline(lr)
def read_context_hunk(self, lr): def read_context_hunk(self, lr):
self.desc = lr.readline() self.desc = lr.readline()
m = contextdesc.match(self.desc) m = contextdesc.match(self.desc)
if not m: if not m:
raise PatchError(_(b"bad hunk #%d") % self.number) raise PatchParseError(_(b"bad hunk #%d") % self.number)
self.starta, aend = m.groups() self.starta, aend = m.groups()
self.starta = int(self.starta) self.starta = int(self.starta)
if aend is None: if aend is None:
aend = self.starta aend = self.starta
self.lena = int(aend) - self.starta self.lena = int(aend) - self.starta
if self.starta: if self.starta:
self.lena += 1 self.lena += 1
for x in pycompat.xrange(self.lena): for x in pycompat.xrange(self.lena):
l = lr.readline() l = lr.readline()
if l.startswith(b'---'): if l.startswith(b'---'):
# lines addition, old block is empty # lines addition, old block is empty
lr.push(l) lr.push(l)
break break
s = l[2:] s = l[2:]
if l.startswith(b'- ') or l.startswith(b'! '): if l.startswith(b'- ') or l.startswith(b'! '):
u = b'-' + s u = b'-' + s
elif l.startswith(b' '): elif l.startswith(b' '):
u = b' ' + s u = b' ' + s
else: else:
raise PatchError( raise PatchParseError(
_(b"bad hunk #%d old text line %d") % (self.number, x) _(b"bad hunk #%d old text line %d") % (self.number, x)
) )
self.a.append(u) self.a.append(u)
self.hunk.append(u) self.hunk.append(u)
l = lr.readline() l = lr.readline()
if l.startswith(br'\ '): if l.startswith(br'\ '):
s = self.a[-1][:-1] s = self.a[-1][:-1]
self.a[-1] = s self.a[-1] = s
self.hunk[-1] = s self.hunk[-1] = s
l = lr.readline() l = lr.readline()
m = contextdesc.match(l) m = contextdesc.match(l)
if not m: if not m:
raise PatchError(_(b"bad hunk #%d") % self.number) raise PatchParseError(_(b"bad hunk #%d") % self.number)
self.startb, bend = m.groups() self.startb, bend = m.groups()
self.startb = int(self.startb) self.startb = int(self.startb)
if bend is None: if bend is None:
bend = self.startb bend = self.startb
self.lenb = int(bend) - self.startb self.lenb = int(bend) - self.startb
if self.startb: if self.startb:
self.lenb += 1 self.lenb += 1
hunki = 1 hunki = 1
u = b'+' + s u = b'+' + s
elif l.startswith(b' '): elif l.startswith(b' '):
u = b' ' + s u = b' ' + s
elif len(self.b) == 0: elif len(self.b) == 0:
# line deletions, new block is empty # line deletions, new block is empty
lr.push(l) lr.push(l)
break break
else: else:
raise PatchError( raise PatchParseError(
_(b"bad hunk #%d old text line %d") % (self.number, x) _(b"bad hunk #%d old text line %d") % (self.number, x)
) )
self.b.append(s) self.b.append(s)
while True: while True:
if hunki >= len(self.hunk): if hunki >= len(self.hunk):
h = b"" h = b""
else: else:
h = self.hunk[hunki] h = self.hunk[hunki]
def getline(lr, hunk): def getline(lr, hunk):
l = lr.readline() l = lr.readline()
hunk.append(l) hunk.append(l)
return l.rstrip(b'\r\n') return l.rstrip(b'\r\n')
while True: while True:
line = getline(lr, self.hunk) line = getline(lr, self.hunk)
if not line: if not line:
raise PatchError( raise PatchParseError(
_(b'could not extract "%s" binary data') % self._fname _(b'could not extract "%s" binary data') % self._fname
) )
if line.startswith(b'literal '): if line.startswith(b'literal '):
size = int(line[8:].rstrip()) size = int(line[8:].rstrip())
break break
if line.startswith(b'delta '): if line.startswith(b'delta '):
size = int(line[6:].rstrip()) size = int(line[6:].rstrip())
self.delta = True self.delta = True
break break
dec = [] dec = []
line = getline(lr, self.hunk) line = getline(lr, self.hunk)
while len(line) > 1: while len(line) > 1:
l = line[0:1] l = line[0:1]
if l <= b'Z' and l >= b'A': if l <= b'Z' and l >= b'A':
l = ord(l) - ord(b'A') + 1 l = ord(l) - ord(b'A') + 1
else: else:
l = ord(l) - ord(b'a') + 27 l = ord(l) - ord(b'a') + 27
try: try:
dec.append(util.b85decode(line[1:])[:l]) dec.append(util.b85decode(line[1:])[:l])
except ValueError as e: except ValueError as e:
raise PatchError( raise PatchParseError(
_(b'could not decode "%s" binary patch: %s') _(b'could not decode "%s" binary patch: %s')
% (self._fname, stringutil.forcebytestr(e)) % (self._fname, stringutil.forcebytestr(e))
) )
line = getline(lr, self.hunk) line = getline(lr, self.hunk)
text = zlib.decompress(b''.join(dec)) text = zlib.decompress(b''.join(dec))
if len(text) != size: if len(text) != size:
raise PatchError( raise PatchParseError(
_(b'"%s" length is %d bytes, should be %d') _(b'"%s" length is %d bytes, should be %d')
% (self._fname, len(text), size) % (self._fname, len(text), size)
) )
self.text = text self.text = text
def parsefilename(str): def parsefilename(str):
# --- filename \t|space stuff # --- filename \t|space stuff
fp.write(b''.join(originalchunks)) fp.write(b''.join(originalchunks))
fp.seek(0) fp.seek(0)
state = b'context' state = b'context'
for newstate, data in scanpatch(fp): for newstate, data in scanpatch(fp):
try: try:
p.transitions[state][newstate](p, data) p.transitions[state][newstate](p, data)
except KeyError: except KeyError:
raise PatchError( raise PatchParseError(
b'unhandled transition: %s -> %s' % (state, newstate) b'unhandled transition: %s -> %s' % (state, newstate)
) )
state = newstate state = newstate
del fp del fp
return p.finished() return p.finished()
def pathtransform(path, strip, prefix): def pathtransform(path, strip, prefix):
>>> pathtransform(b' a/b/c ', 2, b'') >>> pathtransform(b' a/b/c ', 2, b'')
('a/b/', 'c') ('a/b/', 'c')
>>> pathtransform(b'a/b/c', 0, b'd/e/') >>> pathtransform(b'a/b/c', 0, b'd/e/')
('', 'd/e/a/b/c') ('', 'd/e/a/b/c')
>>> pathtransform(b' a//b/c ', 2, b'd/e/') >>> pathtransform(b' a//b/c ', 2, b'd/e/')
('a//b/', 'd/e/c') ('a//b/', 'd/e/c')
>>> pathtransform(b'a/b/c', 3, b'') >>> pathtransform(b'a/b/c', 3, b'')
Traceback (most recent call last): Traceback (most recent call last):
PatchError: unable to strip away 1 of 3 dirs from a/b/c PatchApplicationError: unable to strip away 1 of 3 dirs from a/b/c
""" """
pathlen = len(path) pathlen = len(path)
i = 0 i = 0
if strip == 0: if strip == 0:
return b'', prefix + path.rstrip() return b'', prefix + path.rstrip()
count = strip count = strip
while count > 0: while count > 0:
i = path.find(b'/', i) i = path.find(b'/', i)
if i == -1: if i == -1:
raise PatchError( raise PatchApplicationError(
_(b"unable to strip away %d of %d dirs from %s") _(b"unable to strip away %d of %d dirs from %s")
% (count, strip, path) % (count, strip, path)
) )
i += 1 i += 1
# consume '//' in the path # consume '//' in the path
while i < pathlen - 1 and path[i : i + 1] == b'/': while i < pathlen - 1 and path[i : i + 1] == b'/':
i += 1 i += 1
count -= 1 count -= 1
if not nullb: if not nullb:
if isbackup: if isbackup:
fname = afile fname = afile
else: else:
fname = bfile fname = bfile
elif not nulla: elif not nulla:
fname = afile fname = afile
else: else:
raise PatchError(_(b"undefined source and destination files")) raise PatchParseError(_(b"undefined source and destination files"))
gp = patchmeta(fname) gp = patchmeta(fname)
if create: if create:
gp.op = b'ADD' gp.op = b'ADD'
elif remove: elif remove:
gp.op = b'DELETE' gp.op = b'DELETE'
return gp return gp
gp = gitpatches.pop() gp = gitpatches.pop()
yield b'file', ( yield b'file', (
b'a/' + gp.path, b'a/' + gp.path,
b'b/' + gp.path, b'b/' + gp.path,
None, None,
gp.copy(), gp.copy(),
) )
if not gitpatches: if not gitpatches:
raise PatchError( raise PatchParseError(
_(b'failed to synchronize metadata for "%s"') % afile[2:] _(b'failed to synchronize metadata for "%s"') % afile[2:]
) )
newfile = True newfile = True
elif x.startswith(b'---'): elif x.startswith(b'---'):
# check for a unified diff # check for a unified diff
l2 = lr.readline() l2 = lr.readline()
if not l2.startswith(b'+++'): if not l2.startswith(b'+++'):
lr.push(l2) lr.push(l2)
size = 0x10000 size = 0x10000
offset_end = offset + size offset_end = offset + size
out += data[offset:offset_end] out += data[offset:offset_end]
elif cmd != 0: elif cmd != 0:
offset_end = i + cmd offset_end = i + cmd
out += binchunk[i:offset_end] out += binchunk[i:offset_end]
i += cmd i += cmd
else: else:
raise PatchError(_(b'unexpected delta opcode 0')) raise PatchApplicationError(_(b'unexpected delta opcode 0'))
return out return out
def applydiff(ui, fp, backend, store, strip=1, prefix=b'', eolmode=b'strict'): def applydiff(ui, fp, backend, store, strip=1, prefix=b'', eolmode=b'strict'):
"""Reads a patch from fp and tries to apply it. """Reads a patch from fp and tries to apply it.
Returns 0 for a clean patch, -1 if any rejects were found and 1 if Returns 0 for a clean patch, -1 if any rejects were found and 1 if
there was any fuzz. there was any fuzz.
if gp.op == b'DELETE': if gp.op == b'DELETE':
backend.unlink(gp.path) backend.unlink(gp.path)
continue continue
data, mode = None, None data, mode = None, None
if gp.op in (b'RENAME', b'COPY'): if gp.op in (b'RENAME', b'COPY'):
data, mode = store.getfile(gp.oldpath)[:2] data, mode = store.getfile(gp.oldpath)[:2]
if data is None: if data is None:
# This means that the old path does not exist # This means that the old path does not exist
raise PatchError( raise PatchApplicationError(
_(b"source file '%s' does not exist") % gp.oldpath _(b"source file '%s' does not exist") % gp.oldpath
) )
if gp.mode: if gp.mode:
mode = gp.mode mode = gp.mode
if gp.op == b'ADD': if gp.op == b'ADD':
# Added files without content have no hunk and # Added files without content have no hunk and
# must be created # must be created
data = b'' data = b''
if data or mode: if data or mode:
if gp.op in (b'ADD', b'RENAME', b'COPY') and backend.exists( if gp.op in (b'ADD', b'RENAME', b'COPY') and backend.exists(
gp.path gp.path
): ):
raise PatchError( raise PatchApplicationError(
_( _(
b"cannot create %s: destination " b"cannot create %s: destination "
b"already exists" b"already exists"
) )
% gp.path % gp.path
) )
backend.setfile(gp.path, data, mode, gp.oldpath) backend.setfile(gp.path, data, mode, gp.oldpath)
continue continue
ui.warn(pf + b'\n') ui.warn(pf + b'\n')
printed_file = True printed_file = True
ui.warn(line + b'\n') ui.warn(line + b'\n')
finally: finally:
if files: if files:
scmutil.marktouched(repo, files, similarity) scmutil.marktouched(repo, files, similarity)
code = fp.close() code = fp.close()
if code: if code:
raise PatchError( raise PatchApplicationError(
_(b"patch command failed: %s") % procutil.explainexit(code) _(b"patch command failed: %s") % procutil.explainexit(code)
) )
return fuzz return fuzz
def patchbackend( def patchbackend(
ui, backend, patchobj, strip, prefix, files=None, eolmode=b'strict' ui, backend, patchobj, strip, prefix, files=None, eolmode=b'strict'
): ):
ui, fp, backend, store, strip=strip, prefix=prefix, eolmode=eolmode ui, fp, backend, store, strip=strip, prefix=prefix, eolmode=eolmode
) )
finally: finally:
if fp != patchobj: if fp != patchobj:
fp.close() fp.close()
files.update(backend.close()) files.update(backend.close())
store.close() store.close()
if ret < 0: if ret < 0:
raise PatchError(_(b'patch failed to apply')) raise PatchApplicationError(_(b'patch failed to apply'))
return ret > 0 return ret > 0
def internalpatch( def internalpatch(
ui, ui,
repo, repo,
patchobj, patchobj,
strip, strip,

tests/test-commit-interactive.t

+This line has been added +This line has been added
record this change to 'editedfile'? record this change to 'editedfile'?
(enter ? for help) [Ynesfdaq?] e (enter ? for help) [Ynesfdaq?] e
patching file editedfile patching file editedfile
Hunk #1 FAILED at 0 Hunk #1 FAILED at 0
1 out of 1 hunks FAILED -- saving rejects to file editedfile.rej 1 out of 1 hunks FAILED -- saving rejects to file editedfile.rej
abort: patch failed to apply abort: patch failed to apply
[10] [20]
$ cat editedfile $ cat editedfile
This change will not be committed This change will not be committed
This is the second line This is the second line
This line has been added This line has been added
$ hg cat -r tip editedfile $ hg cat -r tip editedfile
This is the first line This is the first line
This change will be committed This change will be committed
This is the third line This is the third line

tests/test-import-bypass.t

Test failure without --exact Test failure without --exact
$ hg import --bypass ../test.diff $ hg import --bypass ../test.diff
applying ../test.diff applying ../test.diff
unable to find 'a' for patching unable to find 'a' for patching
(use '--prefix' to apply patch relative to the current directory) (use '--prefix' to apply patch relative to the current directory)
abort: patch failed to apply abort: patch failed to apply
[255] [20]
$ hg st $ hg st
$ shortlog $ shortlog
o 1:4e322f7ce8e3 test 0 0 - foo - changea o 1:4e322f7ce8e3 test 0 0 - foo - changea
| |
o 0:07f494440405 test 0 0 - default - adda o 0:07f494440405 test 0 0 - default - adda
Test --user, --date and --message Test --user, --date and --message
$ "$PYTHON" -c 'open("a", "wb").write(b"a\r\n")' $ "$PYTHON" -c 'open("a", "wb").write(b"a\r\n")'
$ hg ci -m makeacrlf $ hg ci -m makeacrlf
$ HGEDITOR=cat hg import -m 'should fail because of eol' --edit --bypass ../test.diff $ HGEDITOR=cat hg import -m 'should fail because of eol' --edit --bypass ../test.diff
applying ../test.diff applying ../test.diff
patching file a patching file a
Hunk #1 FAILED at 0 Hunk #1 FAILED at 0
abort: patch failed to apply abort: patch failed to apply
[255] [20]
$ hg --config patch.eol=auto import -d '0 0' -m 'test patch.eol' --bypass ../test.diff $ hg --config patch.eol=auto import -d '0 0' -m 'test patch.eol' --bypass ../test.diff
applying ../test.diff applying ../test.diff
$ shortlog $ shortlog
o 3:c606edafba99 test 0 0 - default - test patch.eol o 3:c606edafba99 test 0 0 - default - test patch.eol
| |
@ 2:872023de769d test 0 0 - default - makeacrlf @ 2:872023de769d test 0 0 - default - makeacrlf
| |
| o 1:4e322f7ce8e3 test 0 0 - foo - changea | o 1:4e322f7ce8e3 test 0 0 - foo - changea

tests/test-import-git.t

> index 78981922613b2afb6025042ff6bd878ac1994e85..10efcb362e9f3b3420fcfbfc0e37f3dc16e29757 > index 78981922613b2afb6025042ff6bd878ac1994e85..10efcb362e9f3b3420fcfbfc0e37f3dc16e29757
> GIT binary patch > GIT binary patch
> literal 5 > literal 5
> Mc$`b*O.$Pw00T?_*Z=?k > Mc$`b*O.$Pw00T?_*Z=?k
> >
> EOF > EOF
applying patch from stdin applying patch from stdin
abort: could not decode "binary2" binary patch: bad base85 character at position 6 abort: could not decode "binary2" binary patch: bad base85 character at position 6
[255] [10]
$ hg revert -aq $ hg revert -aq
$ hg import -d "1000000 0" -m rename-as-binary - <<"EOF" $ hg import -d "1000000 0" -m rename-as-binary - <<"EOF"
> diff --git a/text2 b/binary2 > diff --git a/text2 b/binary2
> rename from text2 > rename from text2
> rename to binary2 > rename to binary2
> index 78981922613b2afb6025042ff6bd878ac1994e85..10efcb362e9f3b3420fcfbfc0e37f3dc16e29757 > index 78981922613b2afb6025042ff6bd878ac1994e85..10efcb362e9f3b3420fcfbfc0e37f3dc16e29757
> GIT binary patch > GIT binary patch
> literal 6 > literal 6
> Mc$`b*O5$Pw00T?_*Z=?k > Mc$`b*O5$Pw00T?_*Z=?k
> >
> EOF > EOF
applying patch from stdin applying patch from stdin
abort: "binary2" length is 5 bytes, should be 6 abort: "binary2" length is 5 bytes, should be 6
[255] [10]
$ hg revert -aq $ hg revert -aq
$ hg import -d "1000000 0" -m rename-as-binary - <<"EOF" $ hg import -d "1000000 0" -m rename-as-binary - <<"EOF"
> diff --git a/text2 b/binary2 > diff --git a/text2 b/binary2
> rename from text2 > rename from text2
> rename to binary2 > rename to binary2
> index 78981922613b2afb6025042ff6bd878ac1994e85..10efcb362e9f3b3420fcfbfc0e37f3dc16e29757 > index 78981922613b2afb6025042ff6bd878ac1994e85..10efcb362e9f3b3420fcfbfc0e37f3dc16e29757
> GIT binary patch > GIT binary patch
> Mc$`b*O5$Pw00T?_*Z=?k > Mc$`b*O5$Pw00T?_*Z=?k
> >
> EOF > EOF
applying patch from stdin applying patch from stdin
abort: could not extract "binary2" binary data abort: could not extract "binary2" binary data
[255] [10]
Simulate a copy/paste turning LF into CRLF (issue2870) Simulate a copy/paste turning LF into CRLF (issue2870)
$ hg revert -aq $ hg revert -aq
$ cat > binary.diff <<"EOF" $ cat > binary.diff <<"EOF"
> diff --git a/text2 b/binary2 > diff --git a/text2 b/binary2
> rename from text2 > rename from text2
> rename to binary2 > rename to binary2
adding b adding b
$ hg import --no-commit - <<EOF $ hg import --no-commit - <<EOF
> diff --git a/a b/b > diff --git a/a b/b
> copy from a > copy from a
> copy to b > copy to b
> EOF > EOF
applying patch from stdin applying patch from stdin
abort: cannot create b: destination already exists abort: cannot create b: destination already exists
[255] [20]
$ cat b $ cat b
b b
Copy and changes with existing destination Copy and changes with existing destination
$ hg import --no-commit - <<EOF $ hg import --no-commit - <<EOF
> diff --git a/a b/b > diff --git a/a b/b
> copy from a > copy from a
> copy to b > copy to b
> --- a/a > --- a/a
> +++ b/b > +++ b/b
> @@ -1,1 +1,2 @@ > @@ -1,1 +1,2 @@
> a > a
> +b > +b
> EOF > EOF
applying patch from stdin applying patch from stdin
cannot create b: destination already exists cannot create b: destination already exists
1 out of 1 hunks FAILED -- saving rejects to file b.rej 1 out of 1 hunks FAILED -- saving rejects to file b.rej
abort: patch failed to apply abort: patch failed to apply
[255] [20]
$ cat b $ cat b
b b
#if symlink #if symlink
$ ln -s b linkb $ ln -s b linkb
$ hg add linkb $ hg add linkb
$ hg ci -m addlinkb $ hg ci -m addlinkb
$ hg import --no-commit - <<EOF $ hg import --no-commit - <<EOF
> diff --git a/linkb b/linkb > diff --git a/linkb b/linkb
> deleted file mode 120000 > deleted file mode 120000
> --- a/linkb > --- a/linkb
> +++ /dev/null > +++ /dev/null
> @@ -1,1 +0,0 @@ > @@ -1,1 +0,0 @@
> -badhunk > -badhunk
> \ No newline at end of file > \ No newline at end of file
> EOF > EOF
applying patch from stdin applying patch from stdin
patching file linkb patching file linkb
Hunk #1 FAILED at 0 Hunk #1 FAILED at 0
1 out of 1 hunks FAILED -- saving rejects to file linkb.rej 1 out of 1 hunks FAILED -- saving rejects to file linkb.rej
abort: patch failed to apply abort: patch failed to apply
[255] [20]
$ hg st $ hg st
? b.rej ? b.rej
? linkb.rej ? linkb.rej
#endif #endif
Test corner case involving copies and multiple hunks (issue3384) Test corner case involving copies and multiple hunks (issue3384)

tests/test-import-unknown.t

$ hg up -qC 0 $ hg up -qC 0
$ hg purge $ hg purge
$ echo a > added $ echo a > added
$ hg import --no-commit ../unknown.diff $ hg import --no-commit ../unknown.diff
applying ../unknown.diff applying ../unknown.diff
file added already exists file added already exists
1 out of 1 hunks FAILED -- saving rejects to file added.rej 1 out of 1 hunks FAILED -- saving rejects to file added.rej
abort: patch failed to apply abort: patch failed to apply
[255] [20]
Test modifying an unknown file Test modifying an unknown file
$ hg revert -aq $ hg revert -aq
$ hg purge $ hg purge
$ hg rm changed $ hg rm changed
$ hg ci -m removechanged $ hg ci -m removechanged
$ echo a > changed $ echo a > changed
$ hg import --no-commit ../unknown.diff $ hg import --no-commit ../unknown.diff
applying ../unknown.diff applying ../unknown.diff
abort: cannot patch changed: file is not tracked abort: cannot patch changed: file is not tracked
[255] [20]
Test removing an unknown file Test removing an unknown file
$ hg up -qC 0 $ hg up -qC 0
$ hg purge $ hg purge
$ hg rm removed $ hg rm removed
$ hg ci -m removeremoved $ hg ci -m removeremoved
created new head created new head
$ echo a > removed $ echo a > removed
$ hg import --no-commit ../unknown.diff $ hg import --no-commit ../unknown.diff
applying ../unknown.diff applying ../unknown.diff
abort: cannot patch removed: file is not tracked abort: cannot patch removed: file is not tracked
[255] [20]
Test copying onto an unknown file Test copying onto an unknown file
$ hg up -qC 0 $ hg up -qC 0
$ hg purge $ hg purge
$ echo a > copied $ echo a > copied
$ hg import --no-commit ../unknown.diff $ hg import --no-commit ../unknown.diff
applying ../unknown.diff applying ../unknown.diff
abort: cannot create copied: destination already exists abort: cannot create copied: destination already exists
[255] [20]
$ cd .. $ cd ..

tests/test-import.t

added 1 changesets with 2 changes to 2 files added 1 changesets with 2 changes to 2 files
new changesets 80971e65b431 new changesets 80971e65b431
updating to branch default updating to branch default
2 files updated, 0 files merged, 0 files removed, 0 files unresolved 2 files updated, 0 files merged, 0 files removed, 0 files unresolved
$ sed 's/1,1/foo/' < diffed-tip.patch > broken.patch $ sed 's/1,1/foo/' < diffed-tip.patch > broken.patch
$ hg --cwd b import -mpatch ../broken.patch $ hg --cwd b import -mpatch ../broken.patch
applying ../broken.patch applying ../broken.patch
abort: bad hunk #1 abort: bad hunk #1
[255] [10]
$ rm -r b $ rm -r b
hg -R repo import hg -R repo import
put the clone in a subdir - having a directory named "a" put the clone in a subdir - having a directory named "a"
used to hide a bug. used to hide a bug.
$ mkdir dir $ mkdir dir
$ hg clone -r0 a dir/b $ hg clone -r0 a dir/b
$ hg ci -m brancha $ hg ci -m brancha
created new head created new head
$ hg import --config patch.fuzz=0 -v fuzzy-tip.patch $ hg import --config patch.fuzz=0 -v fuzzy-tip.patch
applying fuzzy-tip.patch applying fuzzy-tip.patch
patching file a patching file a
Hunk #1 FAILED at 0 Hunk #1 FAILED at 0
1 out of 1 hunks FAILED -- saving rejects to file a.rej 1 out of 1 hunks FAILED -- saving rejects to file a.rej
abort: patch failed to apply abort: patch failed to apply
[255] [20]
$ hg import --no-commit -v fuzzy-tip.patch $ hg import --no-commit -v fuzzy-tip.patch
applying fuzzy-tip.patch applying fuzzy-tip.patch
patching file a patching file a
Hunk #1 succeeded at 2 with fuzz 1 (offset 0 lines). Hunk #1 succeeded at 2 with fuzz 1 (offset 0 lines).
applied to working directory applied to working directory
$ hg revert -a $ hg revert -a
reverting a reverting a
Test --exact failure Test --exact failure
$ sed 's/^# Parent .*/# Parent '"`hg log -r. -T '{node}'`"'/' \ $ sed 's/^# Parent .*/# Parent '"`hg log -r. -T '{node}'`"'/' \
> < fuzzy-tip.patch > fuzzy-reparent.patch > < fuzzy-tip.patch > fuzzy-reparent.patch
$ hg import --config patch.fuzz=0 --exact fuzzy-reparent.patch $ hg import --config patch.fuzz=0 --exact fuzzy-reparent.patch
applying fuzzy-reparent.patch applying fuzzy-reparent.patch
patching file a patching file a
Hunk #1 FAILED at 0 Hunk #1 FAILED at 0
1 out of 1 hunks FAILED -- saving rejects to file a.rej 1 out of 1 hunks FAILED -- saving rejects to file a.rej
abort: patch failed to apply abort: patch failed to apply
[255] [20]
$ hg up -qC $ hg up -qC
$ hg import --config patch.fuzz=2 --exact fuzzy-reparent.patch $ hg import --config patch.fuzz=2 --exact fuzzy-reparent.patch
applying fuzzy-reparent.patch applying fuzzy-reparent.patch
patching file a patching file a
Hunk #1 succeeded at 2 with fuzz 1 (offset 0 lines). Hunk #1 succeeded at 2 with fuzz 1 (offset 0 lines).
transaction abort! transaction abort!
rollback completed rollback completed
abort: patch is damaged or loses information abort: patch is damaged or loses information
> file1 > file1
> +file2 > +file2
> EOF > EOF
applying patch from stdin applying patch from stdin
unable to find 'file1' for patching unable to find 'file1' for patching
(use '--prefix' to apply patch relative to the current directory) (use '--prefix' to apply patch relative to the current directory)
1 out of 1 hunks FAILED -- saving rejects to file file1.rej 1 out of 1 hunks FAILED -- saving rejects to file file1.rej
abort: patch failed to apply abort: patch failed to apply
[255] [20]
test import crash (issue5375) test import crash (issue5375)
$ cd .. $ cd ..
$ hg init repo $ hg init repo
$ cd repo $ cd repo
$ printf "diff --git a/a b/b\nrename from a\nrename to b" | hg import - $ printf "diff --git a/a b/b\nrename from a\nrename to b" | hg import -
applying patch from stdin applying patch from stdin
a not tracked! a not tracked!
abort: source file 'a' does not exist abort: source file 'a' does not exist
[255] [20]
test immature end of hunk test immature end of hunk
$ hg import - <<'EOF' $ hg import - <<'EOF'
> diff --git a/foo b/foo > diff --git a/foo b/foo
> --- a/foo > --- a/foo
> --- b/foo > --- b/foo
> @@ -0,0 +1,1 @@ > @@ -0,0 +1,1 @@
> EOF > EOF
applying patch from stdin applying patch from stdin
abort: bad hunk #1: incomplete hunk abort: bad hunk #1: incomplete hunk
[255] [10]
$ hg import - <<'EOF' $ hg import - <<'EOF'
> diff --git a/foo b/foo > diff --git a/foo b/foo
> --- a/foo > --- a/foo
> --- b/foo > --- b/foo
> @@ -0,0 +1,1 @@ > @@ -0,0 +1,1 @@
> \ No newline at end of file > \ No newline at end of file
> EOF > EOF
applying patch from stdin applying patch from stdin
abort: bad hunk #1: incomplete hunk abort: bad hunk #1: incomplete hunk
[255] [10]

tests/test-narrow-expanddirstate.t

> +this text is irrelevant > +this text is irrelevant
> EOF > EOF
$ PATCHINCLUDES=path:patchdir hg import -p0 -e "$TESTTMP/foo.patch" -m ignored $ PATCHINCLUDES=path:patchdir hg import -p0 -e "$TESTTMP/foo.patch" -m ignored
applying $TESTTMP/foo.patch applying $TESTTMP/foo.patch
patching file patchdir/f3 patching file patchdir/f3
Hunk #1 FAILED at 0 Hunk #1 FAILED at 0
1 out of 1 hunks FAILED -- saving rejects to file patchdir/f3.rej 1 out of 1 hunks FAILED -- saving rejects to file patchdir/f3.rej
abort: patch failed to apply abort: patch failed to apply
[255] [20]
$ hg tracked | grep patchdir $ hg tracked | grep patchdir
[1] [1]
$ hg files | grep patchdir > /dev/null $ hg files | grep patchdir > /dev/null
[1] [1]
Let's make it apply cleanly and see that it *did* expand properly Let's make it apply cleanly and see that it *did* expand properly
$ cat > "$TESTTMP/foo.patch" <<EOF $ cat > "$TESTTMP/foo.patch" <<EOF
> --- patchdir/f3 > --- patchdir/f3