Don't generate git patches that rename a file to multiple destinations

With this patch, instead of generating N renames, we'll generate
1 rename and N-1 copies.

Ideally the rename should come after the copies instead of before
them, but that'd be harder to do.

mercurial/patch.py

@@ -1,667 +1,672 b''
 # patch.py - patch file parsing routines
 #
 # Copyright 2006 Brendan Cully <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from demandload import demandload
 from i18n import gettext as _
 from node import *
 demandload(globals(), "base85 cmdutil mdiff util")
 demandload(globals(), "cStringIO email.Parser errno os popen2 re shutil sha")
 demandload(globals(), "sys tempfile zlib")
 
 # helper functions
 
 def copyfile(src, dst, basedir=None):
     if not basedir:
         basedir = os.getcwd()
 
     abssrc, absdst = [os.path.join(basedir, n) for n in (src, dst)]
     if os.path.exists(absdst):
         raise util.Abort(_("cannot create %s: destination already exists") %
                          dst)
 
     targetdir = os.path.dirname(absdst)
     if not os.path.isdir(targetdir):
         os.makedirs(targetdir)
 
     util.copyfile(abssrc, absdst)
 
 # public functions
 
 def extract(ui, fileobj):
     '''extract patch from data read from fileobj.
 
     patch can be normal patch or contained in email message.
 
     return tuple (filename, message, user, date). any item in returned
     tuple can be None.  if filename is None, fileobj did not contain
     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: |' +
                         'retrieving revision [0-9]+(\.[0-9]+)*$|' +
                         '(---|\*\*\*)[ \t])', re.MULTILINE)
 
     fd, tmpname = tempfile.mkstemp(prefix='hg-patch-')
     tmpfp = os.fdopen(fd, 'w')
     try:
         hgpatch = False
 
         msg = email.Parser.Parser().parse(fileobj)
 
         message = msg['Subject']
         user = msg['From']
         # should try to parse msg['Date']
         date = None
 
         if message:
             message = message.replace('\n\t', ' ')
             ui.debug('Subject: %s\n' % message)
         if user:
             ui.debug('From: %s\n' % user)
         diffs_seen = 0
         ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
 
         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:
                 ui.debug(_('found patch at byte %d\n') % m.start(0))
                 diffs_seen += 1
                 cfp = cStringIO.StringIO()
                 if message:
                     cfp.write(message)
                     cfp.write('\n')
                 for line in payload[:m.start(0)].splitlines():
                     if line.startswith('# HG changeset patch'):
                         ui.debug(_('patch generated by hg export\n'))
                         hgpatch = True
                         # drop earlier commit message content
                         cfp.seek(0)
                         cfp.truncate()
                     elif hgpatch:
                         if line.startswith('# User '):
                             user = line[7:]
                             ui.debug('From: %s\n' % user)
                         elif line.startswith("# Date "):
                             date = line[7:]
                     if not line.startswith('# '):
                         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:
         tmpfp.close()
         os.unlink(tmpname)
         raise
 
     tmpfp.close()
     if not diffs_seen:
         os.unlink(tmpname)
         return None, message, user, date
     return tmpname, message, user, date
 
 def readgitpatch(patchname):
     """extract git-style metadata about patches from <patchname>"""
     class gitpatch:
         "op is one of ADD, DELETE, RENAME, MODIFY or COPY"
         def __init__(self, path):
             self.path = path
             self.oldpath = None
             self.mode = None
             self.op = 'MODIFY'
             self.copymod = False
             self.lineno = 0
             self.binary = False
 
     # Filter patch for git information
     gitre = re.compile('diff --git a/(.*) b/(.*)')
     pf = file(patchname)
     gp = None
     gitpatches = []
     # Can have a git patch with only metadata, causing patch to complain
     dopatch = False
 
     lineno = 0
     for line in pf:
         lineno += 1
         if line.startswith('diff --git'):
             m = gitre.match(line)
             if m:
                 if gp:
                     gitpatches.append(gp)
                 src, dst = m.group(1, 2)
                 gp = gitpatch(dst)
                 gp.lineno = lineno
         elif gp:
             if line.startswith('--- '):
                 if gp.op in ('COPY', 'RENAME'):
                     gp.copymod = True
                     dopatch = 'filter'
                 gitpatches.append(gp)
                 gp = None
                 if not dopatch:
                     dopatch = True
                 continue
             if line.startswith('rename from '):
                 gp.op = 'RENAME'
                 gp.oldpath = line[12:].rstrip()
             elif line.startswith('rename to '):
                 gp.path = line[10:].rstrip()
             elif line.startswith('copy from '):
                 gp.op = 'COPY'
                 gp.oldpath = line[10:].rstrip()
             elif line.startswith('copy to '):
                 gp.path = line[8:].rstrip()
             elif line.startswith('deleted file'):
                 gp.op = 'DELETE'
             elif line.startswith('new file mode '):
                 gp.op = 'ADD'
                 gp.mode = int(line.rstrip()[-3:], 8)
             elif line.startswith('new mode '):
                 gp.mode = int(line.rstrip()[-3:], 8)
             elif line.startswith('GIT binary patch'):
                 if not dopatch:
                     dopatch = 'binary'
                 gp.binary = True
     if gp:
         gitpatches.append(gp)
 
     if not gitpatches:
         dopatch = True
 
     return (dopatch, gitpatches)
 
 def dogitpatch(patchname, gitpatches, cwd=None):
     """Preprocess git patch so that vanilla patch can handle it"""
     def extractbin(fp):
         line = fp.readline().rstrip()
         while line and not line.startswith('literal '):
             line = fp.readline().rstrip()
         if not line:
             return
         size = int(line[8:])
         dec = []
         line = fp.readline().rstrip()
         while line:
             l = line[0]
             if l <= 'Z' and l >= 'A':
                 l = ord(l) - ord('A') + 1
             else:
                 l = ord(l) - ord('a') + 27
             dec.append(base85.b85decode(line[1:])[:l])
             line = fp.readline().rstrip()
         text = zlib.decompress(''.join(dec))
         if len(text) != size:
             raise util.Abort(_('binary patch is %d bytes, not %d') %
                              (len(text), size))
         return text
 
     pf = file(patchname)
     pfline = 1
 
     fd, patchname = tempfile.mkstemp(prefix='hg-patch-')
     tmpfp = os.fdopen(fd, 'w')
 
     try:
         for i in xrange(len(gitpatches)):
             p = gitpatches[i]
             if not p.copymod and not p.binary:
                 continue
 
             # rewrite patch hunk
             while pfline < p.lineno:
                 tmpfp.write(pf.readline())
                 pfline += 1
 
             if p.binary:
                 text = extractbin(pf)
                 if not text:
                     raise util.Abort(_('binary patch extraction failed'))
                 if not cwd:
                     cwd = os.getcwd()
                 absdst = os.path.join(cwd, p.path)
                 basedir = os.path.dirname(absdst)
                 if not os.path.isdir(basedir):
                     os.makedirs(basedir)
                 out = file(absdst, 'wb')
                 out.write(text)
                 out.close()
             elif p.copymod:
                 copyfile(p.oldpath, p.path, basedir=cwd)
                 tmpfp.write('diff --git a/%s b/%s\n' % (p.path, p.path))
                 line = pf.readline()
                 pfline += 1
                 while not line.startswith('--- a/'):
                     tmpfp.write(line)
                     line = pf.readline()
                     pfline += 1
                 tmpfp.write('--- a/%s\n' % p.path)
 
         line = pf.readline()
         while line:
             tmpfp.write(line)
             line = pf.readline()
     except:
         tmpfp.close()
         os.unlink(patchname)
         raise
 
     tmpfp.close()
     return patchname
 
 def patch(patchname, ui, strip=1, cwd=None, files={}):
     """apply the patch <patchname> to the working directory.
     a list of patched files is returned"""
 
     # helper function
     def __patch(patchname):
         """patch and updates the files and fuzz variables"""
         fuzz = False
 
         patcher = util.find_in_path('gpatch', os.environ.get('PATH', ''),
                                     'patch')
         args = []
         if cwd:
             args.append('-d %s' % util.shellquote(cwd))
         fp = os.popen('%s %s -p%d < %s' % (patcher, ' '.join(args), strip,
                                            util.shellquote(patchname)))
 
         for line in fp:
             line = line.rstrip()
             ui.note(line + '\n')
             if line.startswith('patching file '):
                 pf = util.parse_patch_output(line)
                 printed_file = False
                 files.setdefault(pf, (None, None))
             elif line.find('with fuzz') >= 0:
                 fuzz = True
                 if not printed_file:
                     ui.warn(pf + '\n')
                     printed_file = True
                 ui.warn(line + '\n')
             elif line.find('saving rejects to file') >= 0:
                 ui.warn(line + '\n')
             elif line.find('FAILED') >= 0:
                 if not printed_file:
                     ui.warn(pf + '\n')
                     printed_file = True
                 ui.warn(line + '\n')
         code = fp.close()
         if code:
             raise util.Abort(_("patch command failed: %s") %
                              util.explain_exit(code)[0])
         return fuzz
 
     (dopatch, gitpatches) = readgitpatch(patchname)
     for gp in gitpatches:
         files[gp.path] = (gp.op, gp)
 
     fuzz = False
     if dopatch:
         if dopatch in ('filter', 'binary'):
             patchname = dogitpatch(patchname, gitpatches, cwd=cwd)
         try:
             if dopatch != 'binary':
                 fuzz = __patch(patchname)
         finally:
             if dopatch == 'filter':
                 os.unlink(patchname)
 
     return fuzz
 
 def diffopts(ui, opts={}, untrusted=False):
     def get(key, name=None):
         return (opts.get(key) or
                 ui.configbool('diff', name or key, None, untrusted=untrusted))
     return mdiff.diffopts(
         text=opts.get('text'),
         git=get('git'),
         nodates=get('nodates'),
         showfunc=get('show_function', 'showfunc'),
         ignorews=get('ignore_all_space', 'ignorews'),
         ignorewsamount=get('ignore_space_change', 'ignorewsamount'),
         ignoreblanklines=get('ignore_blank_lines', 'ignoreblanklines'))
 
 def updatedir(ui, repo, patches, wlock=None):
     '''Update dirstate after patch application according to metadata'''
     if not patches:
         return
     copies = []
     removes = {}
     cfiles = patches.keys()
     cwd = repo.getcwd()
     if cwd:
         cfiles = [util.pathto(cwd, f) for f in patches.keys()]
     for f in patches:
         ctype, gp = patches[f]
         if ctype == 'RENAME':
             copies.append((gp.oldpath, gp.path, gp.copymod))
             removes[gp.oldpath] = 1
         elif ctype == 'COPY':
             copies.append((gp.oldpath, gp.path, gp.copymod))
         elif ctype == 'DELETE':
             removes[gp.path] = 1
     for src, dst, after in copies:
         if not after:
             copyfile(src, dst, repo.root)
         repo.copy(src, dst, wlock=wlock)
     removes = removes.keys()
     if removes:
         removes.sort()
         repo.remove(removes, True, wlock=wlock)
     for f in patches:
         ctype, gp = patches[f]
         if gp and gp.mode:
             x = gp.mode & 0100 != 0
             dst = os.path.join(repo.root, gp.path)
             # patch won't create empty files
             if ctype == 'ADD' and not os.path.exists(dst):
                 repo.wwrite(gp.path, '')
             util.set_exec(dst, x)
     cmdutil.addremove(repo, cfiles, wlock=wlock)
     files = patches.keys()
     files.extend([r for r in removes if r not in files])
     files.sort()
 
     return files
 
 def b85diff(fp, to, tn):
     '''print base85-encoded binary diff'''
     def gitindex(text):
         if not text:
             return '0' * 40
         l = len(text)
         s = sha.new('blob %d\0' % l)
         s.update(text)
         return s.hexdigest()
 
     def fmtline(line):
         l = len(line)
         if l <= 26:
             l = chr(ord('A') + l - 1)
         else:
             l = chr(l - 26 + ord('a') - 1)
         return '%c%s\n' % (l, base85.b85encode(line, True))
 
     def chunk(text, csize=52):
         l = len(text)
         i = 0
         while i < l:
             yield text[i:i+csize]
             i += csize
 
     # TODO: deltas
     l = len(tn)
     fp.write('index %s..%s\nGIT binary patch\nliteral %s\n' %
              (gitindex(to), gitindex(tn), len(tn)))
 
     tn = ''.join([fmtline(l) for l in chunk(zlib.compress(tn))])
     fp.write(tn)
     fp.write('\n')
 
 def diff(repo, node1=None, node2=None, files=None, match=util.always,
          fp=None, changes=None, opts=None):
     '''print diff of changes to files between two nodes, or node and
     working directory.
 
     if node1 is None, use first dirstate parent instead.
     if node2 is None, compare node1 with working directory.'''
 
     if opts is None:
         opts = mdiff.defaultopts
     if fp is None:
         fp = repo.ui
 
     if not node1:
         node1 = repo.dirstate.parents()[0]
 
     clcache = {}
     def getchangelog(n):
         if n not in clcache:
             clcache[n] = repo.changelog.read(n)
         return clcache[n]
     mcache = {}
     def getmanifest(n):
         if n not in mcache:
             mcache[n] = repo.manifest.read(n)
         return mcache[n]
     fcache = {}
     def getfile(f):
         if f not in fcache:
             fcache[f] = repo.file(f)
         return fcache[f]
 
     # reading the data for node1 early allows it to play nicely
     # with repo.status and the revlog cache.
     change = getchangelog(node1)
     mmap = getmanifest(change[0])
     date1 = util.datestr(change[2])
 
     if not changes:
         changes = repo.status(node1, node2, files, match=match)[:5]
     modified, added, removed, deleted, unknown = changes
     if files:
         def filterfiles(filters):
             l = [x for x in filters if x in files]
 
             for t in files:
                 if not t.endswith("/"):
                     t += "/"
                 l += [x for x in filters if x.startswith(t)]
             return l
 
         modified, added, removed = map(filterfiles, (modified, added, removed))
 
     if not modified and not added and not removed:
         return
 
     # returns False if there was no rename between n1 and n2
     # returns None if the file was created between n1 and n2
     # returns the (file, node) present in n1 that was renamed to f in n2
     def renamedbetween(f, n1, n2):
         r1, r2 = map(repo.changelog.rev, (n1, n2))
         orig = f
         src = None
         while r2 > r1:
             cl = getchangelog(n2)
             if f in cl[3]:
                 m = getmanifest(cl[0])
                 try:
                     src = getfile(f).renamed(m[f])
                 except KeyError:
                     return None
                 if src:
                     f = src[0]
             n2 = repo.changelog.parents(n2)[0]
             r2 = repo.changelog.rev(n2)
         cl = getchangelog(n1)
         m = getmanifest(cl[0])
         if f not in m:
             return None
         if f == orig:
             return False
         return f, m[f]
 
     if node2:
         change = getchangelog(node2)
         mmap2 = getmanifest(change[0])
         _date2 = util.datestr(change[2])
         def date2(f):
             return _date2
         def read(f):
             return getfile(f).read(mmap2[f])
         def renamed(f):
             return renamedbetween(f, node1, node2)
     else:
         tz = util.makedate()[1]
         _date2 = util.datestr()
         def date2(f):
             try:
                 return util.datestr((os.lstat(repo.wjoin(f)).st_mtime, tz))
             except OSError, err:
                 if err.errno != errno.ENOENT: raise
                 return _date2
         def read(f):
             return repo.wread(f)
         def renamed(f):
             src = repo.dirstate.copied(f)
             parent = repo.dirstate.parents()[0]
             if src:
                 f = src
             of = renamedbetween(f, node1, parent)
             if of or of is None:
                 return of
             elif src:
                 cl = getchangelog(parent)[0]
                 return (src, getmanifest(cl)[src])
             else:
                 return None
 
     if repo.ui.quiet:
         r = None
     else:
         hexfunc = repo.ui.debugflag and hex or short
         r = [hexfunc(node) for node in [node1, node2] if node]
 
     if opts.git:
         copied = {}
         for f in added:
             src = renamed(f)
             if src:
                 copied[f] = src
         srcs = [x[1][0] for x in copied.items()]
 
     all = modified + added + removed
     all.sort()
+    gone = {}
     for f in all:
         to = None
         tn = None
         dodiff = True
         header = []
         if f in mmap:
             to = getfile(f).read(mmap[f])
         if f not in removed:
             tn = read(f)
         if opts.git:
             def gitmode(x):
                 return x and '100755' or '100644'
             def addmodehdr(header, omode, nmode):
                 if omode != nmode:
                     header.append('old mode %s\n' % omode)
                     header.append('new mode %s\n' % nmode)
 
             a, b = f, f
             if f in added:
                 if node2:
                     mode = gitmode(mmap2.execf(f))
                 else:
                     mode = gitmode(util.is_exec(repo.wjoin(f), None))
                 if f in copied:
                     a, arev = copied[f]
                     omode = gitmode(mmap.execf(a))
                     addmodehdr(header, omode, mode)
-                    op = a in removed and 'rename' or 'copy'
+                    if a in removed and a not in gone:
+                        op = 'rename'
+                        gone[a] = 1
+                    else:
+                        op = 'copy'
                     header.append('%s from %s\n' % (op, a))
                     header.append('%s to %s\n' % (op, f))
                     to = getfile(a).read(arev)
                 else:
                     header.append('new file mode %s\n' % mode)
                     if util.binary(tn):
                         dodiff = 'binary'
             elif f in removed:
                 if f in srcs:
                     dodiff = False
                 else:
                     mode = gitmode(mmap.execf(f))
                     header.append('deleted file mode %s\n' % mode)
             else:
                 omode = gitmode(mmap.execf(f))
                 if node2:
                     nmode = gitmode(mmap2.execf(f))
                 else:
                     nmode = gitmode(util.is_exec(repo.wjoin(f), mmap.execf(f)))
                 addmodehdr(header, omode, nmode)
                 if util.binary(to) or util.binary(tn):
                     dodiff = 'binary'
             r = None
             header.insert(0, 'diff --git a/%s b/%s\n' % (a, b))
         if dodiff == 'binary':
             fp.write(''.join(header))
             b85diff(fp, to, tn)
         elif dodiff:
             text = mdiff.unidiff(to, date1, tn, date2(f), f, r, opts=opts)
             if text or len(header) > 1:
                 fp.write(''.join(header))
             fp.write(text)
 
 def export(repo, revs, template='hg-%h.patch', fp=None, switch_parent=False,
            opts=None):
     '''export changesets as hg patches.'''
 
     total = len(revs)
     revwidth = max(map(len, revs))
 
     def single(node, seqno, fp):
         parents = [p for p in repo.changelog.parents(node) if p != nullid]
         if switch_parent:
             parents.reverse()
         prev = (parents and parents[0]) or nullid
         change = repo.changelog.read(node)
 
         if not fp:
             fp = cmdutil.make_file(repo, template, node, total=total,
                                    seqno=seqno, revwidth=revwidth)
         if fp not in (sys.stdout, repo.ui):
             repo.ui.note("%s\n" % fp.name)
 
         fp.write("# HG changeset patch\n")
         fp.write("# User %s\n" % change[1])
         fp.write("# Date %d %d\n" % change[2])
         fp.write("# Node ID %s\n" % hex(node))
         fp.write("# Parent  %s\n" % hex(prev))
         if len(parents) > 1:
             fp.write("# Parent  %s\n" % hex(parents[1]))
         fp.write(change[4].rstrip())
         fp.write("\n\n")
 
         diff(repo, prev, node, fp=fp, opts=opts)
         if fp not in (sys.stdout, repo.ui):
             fp.close()
 
     for seqno, cset in enumerate(revs):
         single(cset, seqno, fp)
 
 def diffstat(patchlines):
     fd, name = tempfile.mkstemp(prefix="hg-patchbomb-", suffix=".txt")
     try:
         p = popen2.Popen3('diffstat -p1 -w79 2>/dev/null > ' + name)
         try:
             for line in patchlines: print >> p.tochild, line
             p.tochild.close()
             if p.wait(): return
             fp = os.fdopen(fd, 'r')
             stat = []
             for line in fp: stat.append(line.lstrip())
             last = stat.pop()
             stat.insert(0, last)
             stat = ''.join(stat)
             if stat.startswith('0 files'): raise ValueError
             return stat
         except: raise
     finally:
         try: os.unlink(name)
         except: pass

tests/test-git-export

@@ -1,129 +1,137 b''
 #!/bin/sh
 
 hg init a
 cd a
 
 echo start > start
 hg ci -Amstart -d '0 0'
 echo new > new
 hg ci -Amnew -d '0 0'
 echo '% new file'
 hg diff --git -r 0
 
 hg cp new copy
 hg ci -mcopy -d '0 0'
 echo '% copy'
 hg diff --git -r 1:tip
 
 hg mv copy rename
 hg ci -mrename -d '0 0'
 echo '% rename'
 hg diff --git -r 2:tip
 
 hg rm rename
 hg ci -mdelete -d '0 0'
 echo '% delete'
 hg diff --git -r 3:tip
 
 cat > src <<EOF
 1
 2
 3
 4
 5
 EOF
 hg ci -Amsrc -d '0 0'
 chmod +x src
 hg ci -munexec -d '0 0'
 echo '% chmod 644'
 hg diff --git -r 5:tip
 
 hg mv src dst
 chmod -x dst
 echo a >> dst
 hg ci -mrenamemod -d '0 0'
 echo '% rename+mod+chmod'
 hg diff --git -r 6:tip
 
 echo '% nonexistent in tip+chmod'
 hg diff --git -r 5:6
 
 echo '% binary diff'
 cp $TESTDIR/binfile.bin .
 hg add binfile.bin
 hg diff --git > b.diff
 cat b.diff
 
 echo '% import binary diff'
 hg revert binfile.bin
 rm binfile.bin
 hg import -mfoo b.diff
 cmp binfile.bin $TESTDIR/binfile.bin
 
 echo
 echo '% diff across many revisions'
 hg mv dst dst2
 hg ci -m 'mv dst dst2' -d '0 0'
 
 echo >> start
 hg ci -m 'change start' -d '0 0'
 
 hg revert -r -2 start
 hg mv dst2 dst3
 hg ci -m 'mv dst2 dst3; revert start' -d '0 0'
 
 hg diff --git -r 9:11
 
 echo a >> foo
 hg add foo
 hg ci -m 'add foo'
 echo b >> foo
 hg ci -m 'change foo'
 hg mv foo bar
 hg ci -m 'mv foo bar'
 echo c >> bar
 hg ci -m 'change bar'
 
 echo
 echo '% file created before r1 and renamed before r2'
 hg diff --git -r -3:-1
 echo
 echo '% file created in r1 and renamed before r2'
 hg diff --git -r -4:-1
 echo
 echo '% file created after r1 and renamed before r2'
 hg diff --git -r -5:-1
 
 echo
 echo '% comparing with the working dir'
 echo >> start
 hg ci -m 'change start again' -d '0 0'
 
 echo > created
 hg add created
 hg ci -m 'add created'
 
 hg mv created created2
 hg ci -m 'mv created created2'
 
 hg mv created2 created3
 echo "% there's a copy in the working dir..."
 hg diff --git
 echo
 echo "% ...but there's another copy between the original rev and the wd"
 hg diff --git -r -2
 echo
 echo "% ...but the source of the copy was created after the original rev"
 hg diff --git -r -3
 hg ci -m 'mv created2 created3'
 
 echo > brand-new
 hg add brand-new
 hg ci -m 'add brand-new'
 hg mv brand-new brand-new2
 echo '% created in parent of wd; renamed in the wd'
 hg diff --git
 
 echo
 echo '% created between r1 and parent of wd; renamed in the wd'
 hg diff --git -r -2
+hg ci -m 'mv brand-new brand-new2'
+
+echo '% one file is copied to many destinations and removed'
+hg cp brand-new2 brand-new3
+hg mv brand-new2 brand-new3-2
+hg ci -m 'multiple renames/copies'
+hg diff --git -r -2 -r -1
+

tests/test-git-export.out

@@ -1,135 +1,142 b''
 adding start
 adding new
 % new file
 diff --git a/new b/new
 new file mode 100644
 --- /dev/null
 +++ b/new
 @@ -0,0 +1,1 @@
 +new
 % copy
 diff --git a/new b/copy
 copy from new
 copy to copy
 % rename
 diff --git a/copy b/rename
 rename from copy
 rename to rename
 % delete
 diff --git a/rename b/rename
 deleted file mode 100644
 --- a/rename
 +++ /dev/null
 @@ -1,1 +0,0 @@
 -new
 adding src
 % chmod 644
 diff --git a/src b/src
 old mode 100644
 new mode 100755
 % rename+mod+chmod
 diff --git a/src b/dst
 old mode 100755
 new mode 100644
 rename from src
 rename to dst
 --- a/dst
 +++ b/dst
 @@ -3,3 +3,4 @@ 3
  3
  4
  5
 +a
 % nonexistent in tip+chmod
 diff --git a/src b/src
 old mode 100644
 new mode 100755
 % binary diff
 diff --git a/binfile.bin b/binfile.bin
 new file mode 100644
 index 0000000000000000000000000000000000000000..37ba3d1c6f17137d9c5f5776fa040caf5fe73ff9
 GIT binary patch
 literal 593
 zc$@)I0<QguP)<h;3K|Lk000e1NJLTq000mG000mO0ssI2kdbIM00009a7bBm000XU
 z000XU0RWnu7ytkO2XskIMF-Uh9TW;VpMjwv0005-Nkl<ZD9@FWPs=e;7{<>W$NUkd
 zX$nnYLt$-$V!?uy+1V%`z&Eh=ah|duER<4|QWhju3gb^nF*8iYobxWG-qqXl=2~5M
 z*IoDB)sG^CfNuoBmqLTVU^<;@nwHP!1wrWd`{(mHo6VNXWtyh{alzqmsH*yYzpvLT
 zLdY<T=ks|woh-`&01!ej#(xbV1f|pI*=%;d-%F*E*X#ZH`4I%6SS+$EJDE&ct=8po
 ziN#{?_j|kD%Cd|oiqds`xm@;oJ-^?NG3Gdqrs?5u*zI;{nogxsx~^|Fn^Y?Gdc6<;
 zfMJ+iF1J`LMx&A2?dEwNW8ClebzPTbIh{@$hS6*`kH@1d%Lo7fA#}N1)oN7`gm$~V
 z+wDx#)OFqMcE{s!JN0-xhG8ItAjVkJwEcb`3WWlJfU2r?;Pd%dmR+q@mSri5q9_W-
 zaR2~ECX?B2w+zELozC0s*6Z~|QG^f{3I#<`?)Q7U-JZ|q5W;9Q8i_=pBuSzunx=U;
 z9C)5jBoYw9^?EHyQl(M}1OlQcCX>lXB*ODN003Z&P17_@)3Pi=i0wb04<W?v-u}7K
 zXmmQA+wDgE!qR9o8jr`%=ab_&uh(l?R=r;Tjiqon91I2-hIu?57~@*4h7h9uORK#=
 fQItJW-{SoTm)8|5##k|m00000NkvXXu0mjf{mKw4
 
 % import binary diff
 applying b.diff
 
 % diff across many revisions
 diff --git a/dst2 b/dst3
 rename from dst2
 rename to dst3
 
 % file created before r1 and renamed before r2
 diff --git a/foo b/bar
 rename from foo
 rename to bar
 --- a/bar
 +++ b/bar
 @@ -1,2 +1,3 @@ a
  a
  b
 +c
 
 % file created in r1 and renamed before r2
 diff --git a/foo b/bar
 rename from foo
 rename to bar
 --- a/bar
 +++ b/bar
 @@ -1,1 +1,3 @@ a
  a
 +b
 +c
 
 % file created after r1 and renamed before r2
 diff --git a/bar b/bar
 new file mode 100644
 --- /dev/null
 +++ b/bar
 @@ -0,0 +1,3 @@
 +a
 +b
 +c
 
 % comparing with the working dir
 % there's a copy in the working dir...
 diff --git a/created2 b/created3
 rename from created2
 rename to created3
 
 % ...but there's another copy between the original rev and the wd
 diff --git a/created b/created3
 rename from created
 rename to created3
 
 % ...but the source of the copy was created after the original rev
 diff --git a/created3 b/created3
 new file mode 100644
 --- /dev/null
 +++ b/created3
 @@ -0,0 +1,1 @@
 +
 % created in parent of wd; renamed in the wd
 diff --git a/brand-new b/brand-new2
 rename from brand-new
 rename to brand-new2
 
 % created between r1 and parent of wd; renamed in the wd
 diff --git a/brand-new2 b/brand-new2
 new file mode 100644
 --- /dev/null
 +++ b/brand-new2
 @@ -0,0 +1,1 @@
 +
+% one file is copied to many destinations and removed
+diff --git a/brand-new2 b/brand-new3
+rename from brand-new2
+rename to brand-new3
+diff --git a/brand-new2 b/brand-new3-2
+copy from brand-new2
+copy to brand-new3-2