/mercurial/patch.py
Python | 1929 lines | 1834 code | 48 blank | 47 comment | 109 complexity | 9e5a1f98ae306cb52ea5dce4f36e8bf2 MD5 | raw file
Possible License(s): GPL-2.0
Large files files are truncated, but you can click here to view the full file
- # 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 version 2 or any later version.
- import cStringIO, email, os, errno, re, posixpath
- import tempfile, zlib, shutil
- # On python2.4 you have to import these by name or they fail to
- # load. This was not a problem on Python 2.7.
- import email.Generator
- import email.Parser
- from i18n import _
- from node import hex, short
- import base85, mdiff, scmutil, util, diffhelpers, copies, encoding, error
- gitre = re.compile('diff --git a/(.*) b/(.*)')
- class PatchError(Exception):
- pass
- # public functions
- def split(stream):
- '''return an iterator of individual patches from a stream'''
- def isheader(line, inheader):
- if inheader and line[0] in (' ', '\t'):
- # continuation
- return True
- if line[0] in (' ', '-', '+'):
- # diff line - don't check for header pattern in there
- return False
- l = line.split(': ', 1)
- return len(l) == 2 and ' ' not in l[0]
- def chunk(lines):
- return cStringIO.StringIO(''.join(lines))
- def hgsplit(stream, cur):
- inheader = True
- for line in stream:
- if not line.strip():
- inheader = False
- if not inheader and line.startswith('# HG changeset patch'):
- yield chunk(cur)
- cur = []
- inheader = True
- cur.append(line)
- if cur:
- yield chunk(cur)
- def mboxsplit(stream, cur):
- for line in stream:
- if line.startswith('From '):
- for c in split(chunk(cur[1:])):
- yield c
- cur = []
- cur.append(line)
- if cur:
- for c in split(chunk(cur[1:])):
- yield c
- def mimesplit(stream, cur):
- def msgfp(m):
- fp = cStringIO.StringIO()
- g = email.Generator.Generator(fp, mangle_from_=False)
- g.flatten(m)
- fp.seek(0)
- return fp
- for line in stream:
- cur.append(line)
- c = chunk(cur)
- m = email.Parser.Parser().parse(c)
- if not m.is_multipart():
- yield msgfp(m)
- else:
- ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
- for part in m.walk():
- ct = part.get_content_type()
- if ct not in ok_types:
- continue
- yield msgfp(part)
- def headersplit(stream, cur):
- inheader = False
- for line in stream:
- if not inheader and isheader(line, inheader):
- yield chunk(cur)
- cur = []
- inheader = True
- if inheader and not isheader(line, inheader):
- inheader = False
- cur.append(line)
- if cur:
- yield chunk(cur)
- def remainder(cur):
- yield chunk(cur)
- class fiter(object):
- def __init__(self, fp):
- self.fp = fp
- def __iter__(self):
- return self
- def next(self):
- l = self.fp.readline()
- if not l:
- raise StopIteration
- return l
- inheader = False
- cur = []
- mimeheaders = ['content-type']
- if not util.safehasattr(stream, 'next'):
- # http responses, for example, have readline but not next
- stream = fiter(stream)
- for line in stream:
- cur.append(line)
- if line.startswith('# HG changeset patch'):
- return hgsplit(stream, cur)
- elif line.startswith('From '):
- return mboxsplit(stream, cur)
- elif isheader(line, inheader):
- inheader = True
- if line.split(':', 1)[0].lower() in mimeheaders:
- # let email parser handle this
- return mimesplit(stream, cur)
- elif line.startswith('--- ') and inheader:
- # No evil headers seen by diff start, split by hand
- return headersplit(stream, cur)
- # Not enough info, keep reading
- # if we are here, we have a very plain patch
- return remainder(cur)
- def extract(ui, fileobj):
- '''extract patch from data read from fileobj.
- patch can be a normal patch or contained in an email message.
- return tuple (filename, message, user, date, branch, node, p1, p2).
- Any item in the returned tuple can be None. If filename is None,
- fileobj did not contain a patch. Caller must unlink filename when done.'''
- # attempt to detect the start of a patch
- # (this heuristic is borrowed from quilt)
- diffre = re.compile(r'^(?:Index:[ \t]|diff[ \t]|RCS file: |'
- r'retrieving revision [0-9]+(\.[0-9]+)*$|'
- r'---[ \t].*?^\+\+\+[ \t]|'
- r'\*\*\*[ \t].*?^---[ \t])', re.MULTILINE|re.DOTALL)
- fd, tmpname = tempfile.mkstemp(prefix='hg-patch-')
- tmpfp = os.fdopen(fd, 'w')
- try:
- msg = email.Parser.Parser().parse(fileobj)
- subject = msg['Subject']
- user = msg['From']
- if not subject and not user:
- # Not an email, restore parsed headers if any
- subject = '\n'.join(': '.join(h) for h in msg.items()) + '\n'
- # should try to parse msg['Date']
- date = None
- nodeid = None
- branch = None
- parents = []
- if subject:
- if subject.startswith('[PATCH'):
- pend = subject.find(']')
- if pend >= 0:
- subject = subject[pend + 1:].lstrip()
- subject = re.sub(r'\n[ \t]+', ' ', subject)
- 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
- payload = part.get_payload(decode=True)
- m = diffre.search(payload)
- if m:
- hgpatch = False
- hgpatchheader = False
- ignoretext = False
- ui.debug('found patch at byte %d\n' % m.start(0))
- diffs_seen += 1
- cfp = cStringIO.StringIO()
- for line in payload[:m.start(0)].splitlines():
- if line.startswith('# HG changeset patch') and not hgpatch:
- ui.debug('patch generated by hg export\n')
- hgpatch = True
- hgpatchheader = True
- # drop earlier commit message content
- cfp.seek(0)
- cfp.truncate()
- subject = None
- elif hgpatchheader:
- if line.startswith('# User '):
- user = line[7:]
- ui.debug('From: %s\n' % user)
- elif line.startswith("# Date "):
- date = line[7:]
- elif line.startswith("# Branch "):
- branch = line[9:]
- elif line.startswith("# Node ID "):
- nodeid = line[10:]
- elif line.startswith("# Parent "):
- parents.append(line[9:].lstrip())
- elif not line.startswith("# "):
- hgpatchheader = False
- elif line == '---':
- ignoretext = True
- if not hgpatchheader and not ignoretext:
- cfp.write(line)
- cfp.write('\n')
- message = cfp.getvalue()
- if tmpfp:
- tmpfp.write(payload)
- if not payload.endswith('\n'):
- tmpfp.write('\n')
- elif not diffs_seen and message and content_type == 'text/plain':
- message += '\n' + payload
- except: # re-raises
- 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
- p2 = parents and parents.pop(0) or None
- return tmpname, message, user, date, branch, nodeid, p1, p2
- class patchmeta(object):
- """Patched file metadata
- 'op' is the performed operation within ADD, DELETE, RENAME, MODIFY
- or COPY. 'path' is patched file path. 'oldpath' is set to the
- origin file when 'op' is either COPY or RENAME, None otherwise. If
- file mode is changed, 'mode' is a tuple (islink, isexec) where
- 'islink' is True if the file is a symlink and 'isexec' is True if
- the file is executable. Otherwise, 'mode' is None.
- """
- def __init__(self, path):
- self.path = path
- self.oldpath = None
- self.mode = None
- self.op = 'MODIFY'
- self.binary = False
- def setmode(self, mode):
- islink = mode & 020000
- isexec = mode & 0100
- self.mode = (islink, isexec)
- def copy(self):
- other = patchmeta(self.path)
- other.oldpath = self.oldpath
- other.mode = self.mode
- other.op = self.op
- other.binary = self.binary
- return other
- def _ispatchinga(self, afile):
- if afile == '/dev/null':
- return self.op == 'ADD'
- return afile == 'a/' + (self.oldpath or self.path)
- def _ispatchingb(self, bfile):
- if bfile == '/dev/null':
- return self.op == 'DELETE'
- return bfile == 'b/' + self.path
- def ispatching(self, afile, bfile):
- return self._ispatchinga(afile) and self._ispatchingb(bfile)
- def __repr__(self):
- return "<patchmeta %s %r>" % (self.op, self.path)
- def readgitpatch(lr):
- """extract git-style metadata about patches from <patchname>"""
- # Filter patch for git information
- gp = None
- gitpatches = []
- for line in lr:
- line = line.rstrip(' \r\n')
- if line.startswith('diff --git a/'):
- m = gitre.match(line)
- if m:
- if gp:
- gitpatches.append(gp)
- dst = m.group(2)
- gp = patchmeta(dst)
- elif gp:
- if line.startswith('--- '):
- gitpatches.append(gp)
- gp = None
- continue
- if line.startswith('rename from '):
- gp.op = 'RENAME'
- gp.oldpath = line[12:]
- elif line.startswith('rename to '):
- gp.path = line[10:]
- elif line.startswith('copy from '):
- gp.op = 'COPY'
- gp.oldpath = line[10:]
- elif line.startswith('copy to '):
- gp.path = line[8:]
- elif line.startswith('deleted file'):
- gp.op = 'DELETE'
- elif line.startswith('new file mode '):
- gp.op = 'ADD'
- gp.setmode(int(line[-6:], 8))
- elif line.startswith('new mode '):
- gp.setmode(int(line[-6:], 8))
- elif line.startswith('GIT binary patch'):
- gp.binary = True
- if gp:
- gitpatches.append(gp)
- return gitpatches
- class linereader(object):
- # simple class to allow pushing lines back into the input stream
- def __init__(self, fp):
- self.fp = fp
- self.buf = []
- def push(self, line):
- if line is not None:
- 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 __iter__(self):
- while True:
- l = self.readline()
- if not l:
- break
- yield l
- class abstractbackend(object):
- def __init__(self, ui):
- self.ui = ui
- def getfile(self, fname):
- """Return target file data and flags as a (data, (islink,
- isexec)) tuple.
- """
- raise NotImplementedError
- 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. 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."""
- raise NotImplementedError
- def writerej(self, fname, failed, total, lines):
- """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 exists(self, fname):
- raise NotImplementedError
- class fsbackend(abstractbackend):
- def __init__(self, ui, basedir):
- super(fsbackend, self).__init__(ui)
- self.opener = scmutil.opener(basedir)
- def _join(self, f):
- return os.path.join(self.opener.base, f)
- def getfile(self, fname):
- if self.opener.islink(fname):
- return (self.opener.readlink(fname), (True, False))
- isexec = False
- try:
- isexec = self.opener.lstat(fname).st_mode & 0100 != 0
- except OSError, e:
- if e.errno != errno.ENOENT:
- raise
- return (self.opener.read(fname), (False, isexec))
- def setfile(self, fname, data, mode, copysource):
- islink, isexec = mode
- if data is None:
- self.opener.setflags(fname, islink, isexec)
- return
- if islink:
- self.opener.symlink(data, fname)
- else:
- self.opener.write(fname, data)
- if isexec:
- self.opener.setflags(fname, False, True)
- def unlink(self, fname):
- self.opener.unlinkpath(fname, ignoremissing=True)
- def writerej(self, fname, failed, total, lines):
- fname = fname + ".rej"
- self.ui.warn(
- _("%d out of %d hunks FAILED -- saving rejects to file %s\n") %
- (failed, total, fname))
- fp = self.opener(fname, 'w')
- fp.writelines(lines)
- fp.close()
- def exists(self, fname):
- return self.opener.lexists(fname)
- class workingbackend(fsbackend):
- def __init__(self, ui, repo, similarity):
- super(workingbackend, self).__init__(ui, repo.root)
- self.repo = repo
- self.similarity = similarity
- self.removed = set()
- self.changed = set()
- self.copied = []
- def _checkknown(self, fname):
- if self.repo.dirstate[fname] == '?' and self.exists(fname):
- raise PatchError(_('cannot patch %s: file is not tracked') % fname)
- def setfile(self, fname, data, mode, copysource):
- self._checkknown(fname)
- 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):
- self._checkknown(fname)
- super(workingbackend, self).unlink(fname)
- self.removed.add(fname)
- self.changed.add(fname)
- def close(self):
- wctx = self.repo[None]
- changed = set(self.changed)
- for src, dst in self.copied:
- scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst)
- if self.removed:
- wctx.forget(sorted(self.removed))
- for f in self.removed:
- if f not in self.repo.dirstate:
- # File was deleted and no longer belongs to the
- # dirstate, it was probably marked added then
- # deleted, and should not be considered by
- # marktouched().
- changed.discard(f)
- if changed:
- scmutil.marktouched(self.repo, changed, self.similarity)
- return sorted(self.changed)
- class filestore(object):
- def __init__(self, maxsize=None):
- self.opener = None
- self.files = {}
- self.created = 0
- self.maxsize = maxsize
- if self.maxsize is None:
- self.maxsize = 4*(2**20)
- self.size = 0
- self.data = {}
- def setfile(self, fname, data, mode, copied=None):
- if self.maxsize < 0 or (len(data) + self.size) <= self.maxsize:
- self.data[fname] = (data, mode, copied)
- self.size += len(data)
- else:
- 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, copied)
- def getfile(self, fname):
- if fname in self.data:
- return self.data[fname]
- if not self.opener or fname not in self.files:
- raise IOError
- fn, mode, copied = self.files[fname]
- return self.opener.read(fn), mode, copied
- def close(self):
- if self.opener:
- shutil.rmtree(self.opener.base)
- class repobackend(abstractbackend):
- def __init__(self, ui, repo, ctx, store):
- super(repobackend, self).__init__(ui)
- self.repo = repo
- self.ctx = ctx
- self.store = store
- self.changed = set()
- self.removed = set()
- self.copied = {}
- def _checkknown(self, fname):
- if fname not in self.ctx:
- raise PatchError(_('cannot patch %s: file is not tracked') % fname)
- def getfile(self, fname):
- try:
- fctx = self.ctx[fname]
- except error.LookupError:
- raise IOError
- flags = fctx.flags()
- return fctx.data(), ('l' in flags, 'x' in flags)
- def setfile(self, fname, data, mode, copysource):
- if copysource:
- self._checkknown(copysource)
- if data is None:
- data = self.ctx[fname].data()
- self.store.setfile(fname, data, mode, copysource)
- self.changed.add(fname)
- if copysource:
- self.copied[fname] = copysource
- def unlink(self, fname):
- self._checkknown(fname)
- self.removed.add(fname)
- def exists(self, fname):
- return fname in self.ctx
- def close(self):
- return self.changed | self.removed
- # @@ -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, gp, backend, store, eolmode='strict'):
- self.fname = gp.path
- self.eolmode = eolmode
- self.eol = None
- self.backend = backend
- self.ui = ui
- self.lines = []
- self.exists = False
- self.missing = True
- self.mode = gp.mode
- self.copysource = gp.oldpath
- self.create = gp.op in ('ADD', 'COPY', 'RENAME')
- self.remove = gp.op == 'DELETE'
- try:
- if self.copysource is None:
- data, mode = backend.getfile(self.fname)
- self.exists = True
- else:
- data, mode = store.getfile(self.copysource)[:2]
- self.exists = backend.exists(self.fname)
- self.missing = False
- if data:
- self.lines = mdiff.splitnewlines(data)
- 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 self.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
- self.rej = []
- self.fileprinted = False
- self.printfile(False)
- self.hunks = 0
- def writelines(self, fname, lines, mode):
- if self.eolmode == 'auto':
- eol = self.eol
- elif self.eolmode == 'crlf':
- eol = '\r\n'
- else:
- eol = '\n'
- if self.eolmode != 'strict' and eol and eol != '\n':
- rawlines = []
- for l in lines:
- if l and l[-1] == '\n':
- l = l[:-1] + eol
- rawlines.append(l)
- lines = rawlines
- self.backend.setfile(fname, ''.join(lines), mode, self.copysource)
- 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
- cand = self.hash.get(l, [])
- if len(cand) > 1:
- # resort our list of potentials forward then back.
- cand.sort(key=lambda x: abs(x - linenum))
- return cand
- 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
- base = os.path.basename(self.fname)
- lines = ["--- %s\n+++ %s\n" % (base, base)]
- for x in self.rej:
- for l in x.hunk:
- lines.append(l)
- if l[-1] != '\n':
- lines.append("\n\ No newline at end of file\n")
- self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)
- def apply(self, h):
- 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 self.missing:
- self.rej.append(h)
- return -1
- if self.exists and self.create:
- 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:
- self.backend.unlink(self.fname)
- else:
- l = h.new(self.lines)
- self.lines[:] = l
- self.offset += len(l)
- self.dirty = True
- return 0
- horig = h
- if (self.eolmode in ('crlf', 'lf')
- or self.eolmode == 'auto' and self.eol):
- # If new eols are going to be normalized, then normalize
- # hunk data before patching. Otherwise, preserve input
- # line-endings.
- h = h.getnormalized()
- # fast case first, no offsets, no fuzz
- old, oldstart, new, newstart = h.fuzzit(0, False)
- oldstart += self.offset
- orig_start = oldstart
- # 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, oldstart) == 0):
- if self.remove:
- self.backend.unlink(self.fname)
- else:
- self.lines[oldstart:oldstart + len(old)] = new
- self.offset += len(new) - len(old)
- self.dirty = True
- return 0
- # ok, we couldn't match the hunk. Lets look for offsets and fuzz it
- self.hash = {}
- for x, s in enumerate(self.lines):
- self.hash.setdefault(s, []).append(x)
- for fuzzlen in xrange(3):
- for toponly in [True, False]:
- old, oldstart, new, newstart = h.fuzzit(fuzzlen, toponly)
- oldstart = oldstart + self.offset + self.skew
- oldstart = min(oldstart, len(self.lines))
- if old:
- cand = self.findlines(old[0][1:], oldstart)
- else:
- # Only adding lines with no or fuzzed context, just
- # take the skew in account
- cand = [oldstart]
- for l in cand:
- if not old or diffhelpers.testhunk(old, self.lines, l) == 0:
- self.lines[l : l + len(old)] = new
- self.offset += len(new) - len(old)
- self.skew = l - orig_start
- self.dirty = True
- offset = l - orig_start - fuzzlen
- if fuzzlen:
- msg = _("Hunk #%d succeeded at %d "
- "with fuzz %d "
- "(offset %d lines).\n")
- self.printfile(True)
- self.ui.warn(msg %
- (h.number, l + 1, fuzzlen, offset))
- else:
- msg = _("Hunk #%d succeeded at %d "
- "(offset %d lines).\n")
- self.ui.note(msg % (h.number, l + 1, offset))
- return fuzzlen
- self.printfile(True)
- self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))
- self.rej.append(horig)
- return -1
- def close(self):
- if self.dirty:
- 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):
- self.number = num
- self.desc = desc
- self.hunk = [desc]
- self.a = []
- self.b = []
- self.starta = self.lena = None
- self.startb = self.lenb = None
- if lr is not None:
- if context:
- self.read_context_hunk(lr)
- else:
- self.read_unified_hunk(lr)
- def getnormalized(self):
- """Return a copy with line endings normalized to LF."""
- def normalize(lines):
- nlines = []
- for line in lines:
- if line.endswith('\r\n'):
- line = line[:-2] + '\n'
- nlines.append(line)
- return nlines
- # Dummy object, it is rebuilt manually
- 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
- return nh
- def read_unified_hunk(self, lr):
- m = unidesc.match(self.desc)
- if not m:
- raise PatchError(_("bad hunk #%d") % self.number)
- self.starta, self.lena, self.startb, self.lenb = m.groups()
- if self.lena is None:
- self.lena = 1
- else:
- self.lena = int(self.lena)
- if self.lenb is None:
- self.lenb = 1
- else:
- self.lenb = int(self.lenb)
- self.starta = int(self.starta)
- self.startb = int(self.startb)
- diffhelpers.addlines(lr, 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
- self._fixnewline(lr)
- 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)
- self.starta, aend = m.groups()
- self.starta = int(self.starta)
- if aend is 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('---'):
- # lines addition, old block is empty
- 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)
- self.startb, bend = m.groups()
- self.startb = int(self.startb)
- if bend is 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('\ '):
- # XXX: the only way to hit this is with an invalid line range.
- # The no-eol marker is not counted in the line range, but I
- # guess there are diff(1) out there which behave differently.
- s = self.b[-1][:-1]
- self.b[-1] = s
- self.hunk[hunki - 1] = s
- continue
- if not l:
- # line deletions, new block is empty and we hit EOF
- 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:
- # line deletions, new block is empty
- 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
- self._fixnewline(lr)
- def _fixnewline(self, lr):
- l = lr.readline()
- if l.startswith('\ '):
- diffhelpers.fix_newline(self.hunk, self.a, self.b)
- else:
- lr.push(l)
- def complete(self):
- return len(self.a) == self.lena and len(self.b) == self.lenb
- def _fuzzit(self, old, new, 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(old))
- 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
- bot = min(fuzz, bot)
- top = min(fuzz, top)
- return old[top:len(old) - bot], new[top:len(new) - bot], top
- return old, new, 0
- def fuzzit(self, fuzz, toponly):
- old, new, top = self._fuzzit(self.a, self.b, fuzz, toponly)
- oldstart = self.starta + top
- newstart = self.startb + top
- # zero length hunk ranges already have their start decremented
- if self.lena and oldstart > 0:
- oldstart -= 1
- if self.lenb and newstart > 0:
- newstart -= 1
- return old, oldstart, new, newstart
- class binhunk(object):
- 'A binary patch file.'
- def __init__(self, lr, fname):
- self.text = None
- self.delta = False
- self.hunk = ['GIT binary patch\n']
- self._fname = fname
- self._read(lr)
- def complete(self):
- return self.text is not None
- def new(self, lines):
- if self.delta:
- return [applybindelta(self.text, ''.join(lines))]
- return [self.text]
- def _read(self, lr):
- def getline(lr, hunk):
- l = lr.readline()
- hunk.append(l)
- return l.rstrip('\r\n')
- size = 0
- while True:
- line = getline(lr, self.hunk)
- if not line:
- raise PatchError(_('could not extract "%s" binary data')
- % self._fname)
- if line.startswith('literal '):
- size = int(line[8:].rstrip())
- break
- if line.startswith('delta '):
- size = int(line[6:].rstrip())
- self.delta = True
- break
- dec = []
- line = getline(lr, self.hunk)
- 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
- try:
- dec.append(base85.b85decode(line[1:])[:l])
- except ValueError, e:
- raise PatchError(_('could not decode "%s" binary patch: %s')
- % (self._fname, str(e)))
- line = getline(lr, self.hunk)
- text = zlib.decompress(''.join(dec))
- if len(text) != size:
- raise PatchError(_('"%s" length is %d bytes, should be %d')
- % (self._fname, len(text), size))
- self.text = text
- def parsefilename(str):
- # --- filename \t|space stuff
- s = str[4:].rstrip('\r\n')
- i = s.find('\t')
- if i < 0:
- i = s.find(' ')
- if i < 0:
- return s
- return s[:i]
- def pathstrip(path, strip):
- pathlen = len(path)
- i = 0
- if strip == 0:
- return '', path.rstrip()
- count = strip
- while count > 0:
- i = path.find('/', i)
- if i == -1:
- raise PatchError(_("unable to strip away %d of %d dirs from %s") %
- (count, strip, path))
- i += 1
- # consume '//' in the path
- while i < pathlen - 1 and path[i] == '/':
- i += 1
- count -= 1
- return path[:i].lstrip(), path[i:].rstrip()
- def makepatchmeta(backend, afile_orig, bfile_orig, hunk, strip):
- 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)
- missing = not goodb and not gooda and not create
- # 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)
- and hunk.starta == 0 and hunk.lena == 0):
- create = True
- missing = 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))
- fname = None
- if not missing:
- if gooda and goodb:
- fname = isbackup and afile or bfile
- elif gooda:
- fname = afile
- if not fname:
- if not nullb:
- fname = isbackup and afile or bfile
- elif not nulla:
- fname = afile
- else:
- raise PatchError(_("undefined source and destination files"))
- gp = patchmeta(fname)
- if create:
- gp.op = 'ADD'
- elif remove:
- gp.op = 'DELETE'
- return gp
- def scangitpatch(lr, firstline):
- """
- Git patches can emit:
- - rename a to b
- - change b
- - copy a to c
- - change c
- We cannot apply this sequence as-is, the renamed 'a' could not be
- found for it would have been renamed already. And we cannot copy
- from 'b' instead because 'b' would have been changed already. So
- we scan the git patch for copy and rename commands so we can
- perform the copies ahead of time.
- """
- pos = 0
- try:
- pos = lr.fp.tell()
- fp = lr.fp
- except IOError:
- fp = cStringIO.StringIO(lr.fp.read())
- gitlr = linereader(fp)
- gitlr.push(firstline)
- gitpatches = readgitpatch(gitlr)
- fp.seek(pos)
- return gitpatches
- def iterhunks(fp):
- """Read a patch and yield the following events:
- - ("file", afile, bfile, firsthunk): select a new target file.
- - ("hunk", hunk): a new hunk is ready to be applied, follows a
- "file" event.
- - ("git", gitchanges): current diff is in git format, gitchanges
- maps filenames to gitpatch records. Unique event.
- """
- afile = ""
- bfile = ""
- state = None
- hunknum = 0
- emitfile = newfile = False
- gitpatches = None
- # our states
- BFILE = 1
- context = None
- lr = linereader(fp)
- while True:
- x = lr.readline()
- if not x:
- break
- if state == BFILE and (
- (not context and x[0] == '@')
- or (context is not False and x.startswith('***************'))
- or x.startswith('GIT binary patch')):
- gp = None
- if (gitpatches and
- gitpatches[-1].ispatching(afile, bfile)):
- gp = gitpatches.pop()
- if x.startswith('GIT binary patch'):
- h = binhunk(lr, gp.path)
- else:
- if context is None and x.startswith('***************'):
- context = True
- h = hunk(x, hunknum + 1, lr, context)
- hunknum += 1
- if emitfile:
- emitfile = False
- yield 'file', (afile, bfile, h, gp and gp.copy() or None)
- yield 'hunk', h
- elif x.startswith('diff --git a/'):
- m = gitre.match(x.rstrip(' \r\n'))
- if not m:
- continue
- if gitpatches is None:
- # scan whole input for git metadata
- gitpatches = scangitpatch(lr, x)
- yield 'git', [g.copy() for g in gitpatches
- if g.op in ('COPY', 'RENAME')]
- gitpatches.reverse()
- afile = 'a/' + m.group(1)
- bfile = 'b/' + m.group(2)
- while gitpatches and not gitpatches[-1].ispatching(afile, bfile):
- gp = gitpatches.pop()
- yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())
- if not gitpatches:
- raise PatchError(_('failed to synchronize metadata for "%s"')
- % afile[2:])
- gp = gitpatches[-1]
- newfile = True
- elif x.startswith('---'):
- # check for a unified diff
- l2 = lr.readline()
- if not l2.startswith('+++'):
- lr.push(l2)
- continue
- newfile = True
- context = False
- afile = parsefilename(x)
- bfile = parsefilename(l2)
- elif x.startswith('***'):
- # check for a context diff
- l2 = lr.readline()
- if not l2.startswith('---'):
- lr.push(l2)
- continue
- l3 = lr.readline()
- lr.push(l3)
- if not l3.startswith("***************"):
- lr.push(l2)
- continue
- newfile = True
- context = True
- afile = parsefilename(x)
- bfile = parsefilename(l2)
- if newfile:
- newfile = False
- emitfile = True
- state = BFILE
- hunknum = 0
- while gitpatches:
- gp = gitpatches.pop()
- yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())
- def applybindelta(binchunk, data):
- """Apply a binary delta hunk
- The algorithm used is the algorithm from git's patch-delta.c
- """
- def deltahead(binchunk):
- i = 0
- for c in binchunk:
- i += 1
- if not (ord(c) & 0x80):
- return i
- return i
- out = ""
- s = deltahead(binchunk)
- binchunk = binchunk[s:]
- s = deltahead(binchunk)
- binchunk = binchunk[s:]
- i = 0
- while i < len(binchunk):
- cmd = ord(binchunk[i])
- i += 1
- if (cmd & 0x80):
- offset = 0
- size = 0
- if (cmd & 0x01):
- offset = ord(binchunk[i])
- i += 1
- if (cmd & 0x02):
- offset |= ord(binchunk[i]) << 8
- i += 1
- if (cmd & 0x04):
- offset |= ord(binchunk[i]) << 16
- i += 1
- if (cmd & 0x08):
- offset |= ord(binchunk[i]) << 24
- i += 1
- if (cmd & 0x10):
- size = ord(binchunk[i])
- i += 1
- if (cmd & 0x20):
- size |= ord(binchunk[i]) << 8
- i += 1
- if (cmd & 0x40):
- size |= ord(binchunk[i]) << 16
- i += 1
- if size == 0:
- size = 0x10000
- offset_end = offset + size
- out += data[offset:offset_end]
- elif cmd != 0:
- offset_end = i + cmd
- out += binchunk[i:offset_end]
- i += cmd
- else:
- raise PatchError(_('unexpected delta opcode 0'))
- return out
- def applydiff(ui, fp, backend, store, strip=1, eolmode='strict'):
- """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
- 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, store, strip=strip,
- eolmode=eolmode)
- def _applydiff(ui, fp, patcher, backend, store, strip=1,
- eolmode='strict'):
- def pstrip(p):
- return pathstrip(p, strip - 1)[1]
- rejects = 0
- err = 0
- current_file = None
- for state, values in iterhunks(fp):
- if state == 'hunk':
- if not current_file:
- continue
- ret = current_file.apply(values)
- if ret > 0:
- err = 1
- elif state == 'file':
- if current_file:
- rejects += current_file.close()
- current_file = None
- afile, bfile, first_hunk, gp = values
- if gp:
- gp.path = pstrip(gp.path)
- if gp.oldpath:
- gp.oldpath = pstrip(gp.oldpath)
- else:
- gp = makepatchmeta(backend, afile, bfile, first_hunk, strip)
- if gp.op == 'RENAME':
- backend.unlink(gp.oldpath)
- if not first_hunk:
- if gp.op == 'DELETE':
- backend.unlink(gp.path)
- continue
- data, mode = None, None
- if gp.op in ('RENAME', 'COPY'):
- data, mode = store.getfile(gp.oldpath)[:2]
- if gp.mode:
- mode = 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(gp.path)):
- raise PatchError(_("cannot create %s: destination "
- "already exists") % gp.path)
- backend.setfile(gp.path, data, mode, gp.oldpath)
- continue
- try:
- current_file = patcher(ui, gp, backend, store,
- eolmode=eolmode)
- except PatchError, inst:
- ui.warn(str(inst) + '\n')
- current_file = None
- rejects += 1
- continue
- elif state == 'git':
- for gp in values:
- path = pstrip(gp.oldpath)
- try:
- data, mode = backend.getfile(path)
- except IOError, e:
- if e.errno != errno.ENOENT:
- raise
- # The error ignored here will trigger a getfile()
- # error in a place more appropriate for error
- # handling, and will not interrupt the patching
- # process.
- else:
- store.setfile(path, data, mode)
- else:
- raise util.Abort(_('unsupported parser state: %s') % state)
- if current_file:
- rejects += current_file.close()
- if rejects:
- return -1
- return err
- def _externalpatch(ui, repo, patcher, patchname, strip, files,
- similarity):
- """use <patcher> to apply <patchname> to the working directory.
- returns whether patch was applied with fuzz factor."""
- fuzz = False
- args = []
- cwd = repo.root
- if cwd:
- args.append('-d %s' % util.shellquote(cwd))
- fp = util.popen('%s %s -p%d < %s' % (patcher, ' '.join(args), strip,
- util.shellquote(patchname)))
- try:
- for line in fp:
- line = line.rstrip()
- ui.note(line + '\n')
- if line.startswith('patching file '):
- pf = util.parsepatchoutput(line)
- printed_file = False
- files.add(pf)
- 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')
- finally:
- if files:
- scmutil.marktouched(repo, files, similarity)
- code = fp.close()
- if code:
- raise PatchError(_("patch command failed: %s") %
- util.explainexit(code)[0])
- return fuzz
- def patchbackend(ui, backend, patchobj, strip, files=None, eolmode='strict'):
- if files is None:
- files = set()
- if eolmode is None:
- 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()
- try:
- fp = open(patchobj, 'rb'…
Large files files are truncated, but you can click here to view the full file