templatekw: force noprefix=False to insure diffstat consistency (issue4755)

The result of diffstatdata should not depend on having noprefix set or not, as
was reported in issue 4755. Forcing noprefix to false on call makes sure the
parser receives the diff in the correct format and returns the proper result.

Another way to fix this would have been to change the regular expressions in
path.diffstatdata(), but that would have introduced many unecessary special
cases.

mercurial/templatekw.py

@@ -1,607 +1,607 b''
 # templatekw.py - common changeset template keywords
 #
 # Copyright 2005-2009 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from __future__ import absolute_import
 
 from .node import hex, nullid
 from . import (
     encoding,
     error,
     hbisect,
     patch,
     registrar,
     scmutil,
     util,
 )
 
 # This helper class allows us to handle both:
 #  "{files}" (legacy command-line-specific list hack) and
 #  "{files % '{file}\n'}" (hgweb-style with inlining and function support)
 # and to access raw values:
 #  "{ifcontains(file, files, ...)}", "{ifcontains(key, extras, ...)}"
 #  "{get(extras, key)}"
 
 class _hybrid(object):
     def __init__(self, gen, values, makemap, joinfmt):
         self.gen = gen
         self.values = values
         self._makemap = makemap
         self.joinfmt = joinfmt
     def __iter__(self):
         return self.gen
     def itermaps(self):
         makemap = self._makemap
         for x in self.values:
             yield makemap(x)
     def __contains__(self, x):
         return x in self.values
     def __len__(self):
         return len(self.values)
     def __getattr__(self, name):
         if name != 'get':
             raise AttributeError(name)
         return getattr(self.values, name)
 
 def showlist(name, values, plural=None, element=None, separator=' ', **args):
     if not element:
         element = name
     f = _showlist(name, values, plural, separator, **args)
     return _hybrid(f, values, lambda x: {element: x}, lambda d: d[element])
 
 def _showlist(name, values, plural=None, separator=' ', **args):
     '''expand set of values.
     name is name of key in template map.
     values is list of strings or dicts.
     plural is plural of name, if not simply name + 's'.
     separator is used to join values as a string
 
     expansion works like this, given name 'foo'.
 
     if values is empty, expand 'no_foos'.
 
     if 'foo' not in template map, return values as a string,
     joined by 'separator'.
 
     expand 'start_foos'.
 
     for each value, expand 'foo'. if 'last_foo' in template
     map, expand it instead of 'foo' for last key.
 
     expand 'end_foos'.
     '''
     templ = args['templ']
     if plural:
         names = plural
     else: names = name + 's'
     if not values:
         noname = 'no_' + names
         if noname in templ:
             yield templ(noname, **args)
         return
     if name not in templ:
         if isinstance(values[0], str):
             yield separator.join(values)
         else:
             for v in values:
                 yield dict(v, **args)
         return
     startname = 'start_' + names
     if startname in templ:
         yield templ(startname, **args)
     vargs = args.copy()
     def one(v, tag=name):
         try:
             vargs.update(v)
         except (AttributeError, ValueError):
             try:
                 for a, b in v:
                     vargs[a] = b
             except ValueError:
                 vargs[name] = v
         return templ(tag, **vargs)
     lastname = 'last_' + name
     if lastname in templ:
         last = values.pop()
     else:
         last = None
     for v in values:
         yield one(v)
     if last is not None:
         yield one(last, tag=lastname)
     endname = 'end_' + names
     if endname in templ:
         yield templ(endname, **args)
 
 def _formatrevnode(ctx):
     """Format changeset as '{rev}:{node|formatnode}', which is the default
     template provided by cmdutil.changeset_templater"""
     repo = ctx.repo()
     if repo.ui.debugflag:
         hexnode = ctx.hex()
     else:
         hexnode = ctx.hex()[:12]
     return '%d:%s' % (scmutil.intrev(ctx.rev()), hexnode)
 
 def getfiles(repo, ctx, revcache):
     if 'files' not in revcache:
         revcache['files'] = repo.status(ctx.p1(), ctx)[:3]
     return revcache['files']
 
 def getlatesttags(repo, ctx, cache, pattern=None):
     '''return date, distance and name for the latest tag of rev'''
 
     cachename = 'latesttags'
     if pattern is not None:
         cachename += '-' + pattern
         match = util.stringmatcher(pattern)[2]
     else:
         match = util.always
 
     if cachename not in cache:
         # Cache mapping from rev to a tuple with tag date, tag
         # distance and tag name
         cache[cachename] = {-1: (0, 0, ['null'])}
     latesttags = cache[cachename]
 
     rev = ctx.rev()
     todo = [rev]
     while todo:
         rev = todo.pop()
         if rev in latesttags:
             continue
         ctx = repo[rev]
         tags = [t for t in ctx.tags()
                 if (repo.tagtype(t) and repo.tagtype(t) != 'local'
                     and match(t))]
         if tags:
             latesttags[rev] = ctx.date()[0], 0, [t for t in sorted(tags)]
             continue
         try:
             # The tuples are laid out so the right one can be found by
             # comparison.
             pdate, pdist, ptag = max(
                 latesttags[p.rev()] for p in ctx.parents())
         except KeyError:
             # Cache miss - recurse
             todo.append(rev)
             todo.extend(p.rev() for p in ctx.parents())
             continue
         latesttags[rev] = pdate, pdist + 1, ptag
     return latesttags[rev]
 
 def getrenamedfn(repo, endrev=None):
     rcache = {}
     if endrev is None:
         endrev = len(repo)
 
     def getrenamed(fn, rev):
         '''looks up all renames for a file (up to endrev) the first
         time the file is given. It indexes on the changerev and only
         parses the manifest if linkrev != changerev.
         Returns rename info for fn at changerev rev.'''
         if fn not in rcache:
             rcache[fn] = {}
             fl = repo.file(fn)
             for i in fl:
                 lr = fl.linkrev(i)
                 renamed = fl.renamed(fl.node(i))
                 rcache[fn][lr] = renamed
                 if lr >= endrev:
                     break
         if rev in rcache[fn]:
             return rcache[fn][rev]
 
         # If linkrev != rev (i.e. rev not found in rcache) fallback to
         # filectx logic.
         try:
             return repo[rev][fn].renamed()
         except error.LookupError:
             return None
 
     return getrenamed
 
 # keywords are callables like:
 # fn(repo, ctx, templ, cache, revcache, **args)
 # with:
 # repo - current repository instance
 # ctx - the changectx being displayed
 # templ - the templater instance
 # cache - a cache dictionary for the whole templater run
 # revcache - a cache dictionary for the current revision
 keywords = {}
 
 templatekeyword = registrar.templatekeyword(keywords)
 
 @templatekeyword('author')
 def showauthor(repo, ctx, templ, **args):
     """String. The unmodified author of the changeset."""
     return ctx.user()
 
 @templatekeyword('bisect')
 def showbisect(repo, ctx, templ, **args):
     """String. The changeset bisection status."""
     return hbisect.label(repo, ctx.node())
 
 @templatekeyword('branch')
 def showbranch(**args):
     """String. The name of the branch on which the changeset was
     committed.
     """
     return args['ctx'].branch()
 
 @templatekeyword('branches')
 def showbranches(**args):
     """List of strings. The name of the branch on which the
     changeset was committed. Will be empty if the branch name was
     default. (DEPRECATED)
     """
     branch = args['ctx'].branch()
     if branch != 'default':
         return showlist('branch', [branch], plural='branches', **args)
     return showlist('branch', [], plural='branches', **args)
 
 @templatekeyword('bookmarks')
 def showbookmarks(**args):
     """List of strings. Any bookmarks associated with the
     changeset. Also sets 'active', the name of the active bookmark.
     """
     repo = args['ctx']._repo
     bookmarks = args['ctx'].bookmarks()
     active = repo._activebookmark
     makemap = lambda v: {'bookmark': v, 'active': active, 'current': active}
     f = _showlist('bookmark', bookmarks, **args)
     return _hybrid(f, bookmarks, makemap, lambda x: x['bookmark'])
 
 @templatekeyword('children')
 def showchildren(**args):
     """List of strings. The children of the changeset."""
     ctx = args['ctx']
     childrevs = ['%d:%s' % (cctx, cctx) for cctx in ctx.children()]
     return showlist('children', childrevs, element='child', **args)
 
 # Deprecated, but kept alive for help generation a purpose.
 @templatekeyword('currentbookmark')
 def showcurrentbookmark(**args):
     """String. The active bookmark, if it is
     associated with the changeset (DEPRECATED)"""
     return showactivebookmark(**args)
 
 @templatekeyword('activebookmark')
 def showactivebookmark(**args):
     """String. The active bookmark, if it is
     associated with the changeset"""
     active = args['repo']._activebookmark
     if active and active in args['ctx'].bookmarks():
         return active
     return ''
 
 @templatekeyword('date')
 def showdate(repo, ctx, templ, **args):
     """Date information. The date when the changeset was committed."""
     return ctx.date()
 
 @templatekeyword('desc')
 def showdescription(repo, ctx, templ, **args):
     """String. The text of the changeset description."""
     s = ctx.description()
     if isinstance(s, encoding.localstr):
         # try hard to preserve utf-8 bytes
         return encoding.tolocal(encoding.fromlocal(s).strip())
     else:
         return s.strip()
 
 @templatekeyword('diffstat')
 def showdiffstat(repo, ctx, templ, **args):
     """String. Statistics of changes with the following format:
     "modified files: +added/-removed lines"
     """
-    stats = patch.diffstatdata(util.iterlines(ctx.diff()))
+    stats = patch.diffstatdata(util.iterlines(ctx.diff(noprefix=False)))
     maxname, maxtotal, adds, removes, binary = patch.diffstatsum(stats)
     return '%s: +%s/-%s' % (len(stats), adds, removes)
 
 @templatekeyword('extras')
 def showextras(**args):
     """List of dicts with key, value entries of the 'extras'
     field of this changeset."""
     extras = args['ctx'].extra()
     extras = util.sortdict((k, extras[k]) for k in sorted(extras))
     makemap = lambda k: {'key': k, 'value': extras[k]}
     c = [makemap(k) for k in extras]
     f = _showlist('extra', c, plural='extras', **args)
     return _hybrid(f, extras, makemap,
                    lambda x: '%s=%s' % (x['key'], x['value']))
 
 @templatekeyword('file_adds')
 def showfileadds(**args):
     """List of strings. Files added by this changeset."""
     repo, ctx, revcache = args['repo'], args['ctx'], args['revcache']
     return showlist('file_add', getfiles(repo, ctx, revcache)[1],
                     element='file', **args)
 
 @templatekeyword('file_copies')
 def showfilecopies(**args):
     """List of strings. Files copied in this changeset with
     their sources.
     """
     cache, ctx = args['cache'], args['ctx']
     copies = args['revcache'].get('copies')
     if copies is None:
         if 'getrenamed' not in cache:
             cache['getrenamed'] = getrenamedfn(args['repo'])
         copies = []
         getrenamed = cache['getrenamed']
         for fn in ctx.files():
             rename = getrenamed(fn, ctx.rev())
             if rename:
                 copies.append((fn, rename[0]))
 
     copies = util.sortdict(copies)
     makemap = lambda k: {'name': k, 'source': copies[k]}
     c = [makemap(k) for k in copies]
     f = _showlist('file_copy', c, plural='file_copies', **args)
     return _hybrid(f, copies, makemap,
                    lambda x: '%s (%s)' % (x['name'], x['source']))
 
 # showfilecopiesswitch() displays file copies only if copy records are
 # provided before calling the templater, usually with a --copies
 # command line switch.
 @templatekeyword('file_copies_switch')
 def showfilecopiesswitch(**args):
     """List of strings. Like "file_copies" but displayed
     only if the --copied switch is set.
     """
     copies = args['revcache'].get('copies') or []
     copies = util.sortdict(copies)
     makemap = lambda k: {'name': k, 'source': copies[k]}
     c = [makemap(k) for k in copies]
     f = _showlist('file_copy', c, plural='file_copies', **args)
     return _hybrid(f, copies, makemap,
                    lambda x: '%s (%s)' % (x['name'], x['source']))
 
 @templatekeyword('file_dels')
 def showfiledels(**args):
     """List of strings. Files removed by this changeset."""
     repo, ctx, revcache = args['repo'], args['ctx'], args['revcache']
     return showlist('file_del', getfiles(repo, ctx, revcache)[2],
                     element='file', **args)
 
 @templatekeyword('file_mods')
 def showfilemods(**args):
     """List of strings. Files modified by this changeset."""
     repo, ctx, revcache = args['repo'], args['ctx'], args['revcache']
     return showlist('file_mod', getfiles(repo, ctx, revcache)[0],
                     element='file', **args)
 
 @templatekeyword('files')
 def showfiles(**args):
     """List of strings. All files modified, added, or removed by this
     changeset.
     """
     return showlist('file', args['ctx'].files(), **args)
 
 @templatekeyword('graphnode')
 def showgraphnode(repo, ctx, **args):
     """String. The character representing the changeset node in
     an ASCII revision graph"""
     wpnodes = repo.dirstate.parents()
     if wpnodes[1] == nullid:
         wpnodes = wpnodes[:1]
     if ctx.node() in wpnodes:
         return '@'
     elif ctx.obsolete():
         return 'x'
     elif ctx.closesbranch():
         return '_'
     else:
         return 'o'
 
 @templatekeyword('latesttag')
 def showlatesttag(**args):
     """List of strings. The global tags on the most recent globally
     tagged ancestor of this changeset.
     """
     return showlatesttags(None, **args)
 
 def showlatesttags(pattern, **args):
     """helper method for the latesttag keyword and function"""
     repo, ctx = args['repo'], args['ctx']
     cache = args['cache']
     latesttags = getlatesttags(repo, ctx, cache, pattern)
 
     # latesttag[0] is an implementation detail for sorting csets on different
     # branches in a stable manner- it is the date the tagged cset was created,
     # not the date the tag was created.  Therefore it isn't made visible here.
     makemap = lambda v: {
         'changes': _showchangessincetag,
         'distance': latesttags[1],
         'latesttag': v,   # BC with {latesttag % '{latesttag}'}
         'tag': v
     }
 
     tags = latesttags[2]
     f = _showlist('latesttag', tags, separator=':', **args)
     return _hybrid(f, tags, makemap, lambda x: x['latesttag'])
 
 @templatekeyword('latesttagdistance')
 def showlatesttagdistance(repo, ctx, templ, cache, **args):
     """Integer. Longest path to the latest tag."""
     return getlatesttags(repo, ctx, cache)[1]
 
 @templatekeyword('changessincelatesttag')
 def showchangessincelatesttag(repo, ctx, templ, cache, **args):
     """Integer. All ancestors not in the latest tag."""
     latesttag = getlatesttags(repo, ctx, cache)[2][0]
 
     return _showchangessincetag(repo, ctx, tag=latesttag, **args)
 
 def _showchangessincetag(repo, ctx, **args):
     offset = 0
     revs = [ctx.rev()]
     tag = args['tag']
 
     # The only() revset doesn't currently support wdir()
     if ctx.rev() is None:
         offset = 1
         revs = [p.rev() for p in ctx.parents()]
 
     return len(repo.revs('only(%ld, %s)', revs, tag)) + offset
 
 @templatekeyword('manifest')
 def showmanifest(**args):
     repo, ctx, templ = args['repo'], args['ctx'], args['templ']
     mnode = ctx.manifestnode()
     if mnode is None:
         # just avoid crash, we might want to use the 'ff...' hash in future
         return
     args = args.copy()
     args.update({'rev': repo.manifestlog._revlog.rev(mnode),
                  'node': hex(mnode)})
     return templ('manifest', **args)
 
 def shownames(namespace, **args):
     """helper method to generate a template keyword for a namespace"""
     ctx = args['ctx']
     repo = ctx.repo()
     ns = repo.names[namespace]
     names = ns.names(repo, ctx.node())
     return showlist(ns.templatename, names, plural=namespace, **args)
 
 @templatekeyword('namespaces')
 def shownamespaces(**args):
     """Dict of lists. Names attached to this changeset per
     namespace."""
     ctx = args['ctx']
     repo = ctx.repo()
     namespaces = util.sortdict((k, showlist('name', ns.names(repo, ctx.node()),
                                             **args))
                                for k, ns in repo.names.iteritems())
     f = _showlist('namespace', list(namespaces), **args)
     return _hybrid(f, namespaces,
                    lambda k: {'namespace': k, 'names': namespaces[k]},
                    lambda x: x['namespace'])
 
 @templatekeyword('node')
 def shownode(repo, ctx, templ, **args):
     """String. The changeset identification hash, as a 40 hexadecimal
     digit string.
     """
     return ctx.hex()
 
 @templatekeyword('p1rev')
 def showp1rev(repo, ctx, templ, **args):
     """Integer. The repository-local revision number of the changeset's
     first parent, or -1 if the changeset has no parents."""
     return ctx.p1().rev()
 
 @templatekeyword('p2rev')
 def showp2rev(repo, ctx, templ, **args):
     """Integer. The repository-local revision number of the changeset's
     second parent, or -1 if the changeset has no second parent."""
     return ctx.p2().rev()
 
 @templatekeyword('p1node')
 def showp1node(repo, ctx, templ, **args):
     """String. The identification hash of the changeset's first parent,
     as a 40 digit hexadecimal string. If the changeset has no parents, all
     digits are 0."""
     return ctx.p1().hex()
 
 @templatekeyword('p2node')
 def showp2node(repo, ctx, templ, **args):
     """String. The identification hash of the changeset's second
     parent, as a 40 digit hexadecimal string. If the changeset has no second
     parent, all digits are 0."""
     return ctx.p2().hex()
 
 @templatekeyword('parents')
 def showparents(**args):
     """List of strings. The parents of the changeset in "rev:node"
     format. If the changeset has only one "natural" parent (the predecessor
     revision) nothing is shown."""
     repo = args['repo']
     ctx = args['ctx']
     pctxs = scmutil.meaningfulparents(repo, ctx)
     prevs = [str(p.rev()) for p in pctxs]  # ifcontains() needs a list of str
     parents = [[('rev', p.rev()),
                 ('node', p.hex()),
                 ('phase', p.phasestr())]
                for p in pctxs]
     f = _showlist('parent', parents, **args)
     return _hybrid(f, prevs, lambda x: {'ctx': repo[int(x)], 'revcache': {}},
                    lambda d: _formatrevnode(d['ctx']))
 
 @templatekeyword('phase')
 def showphase(repo, ctx, templ, **args):
     """String. The changeset phase name."""
     return ctx.phasestr()
 
 @templatekeyword('phaseidx')
 def showphaseidx(repo, ctx, templ, **args):
     """Integer. The changeset phase index."""
     return ctx.phase()
 
 @templatekeyword('rev')
 def showrev(repo, ctx, templ, **args):
     """Integer. The repository-local changeset revision number."""
     return scmutil.intrev(ctx.rev())
 
 def showrevslist(name, revs, **args):
     """helper to generate a list of revisions in which a mapped template will
     be evaluated"""
     repo = args['ctx'].repo()
     revs = [str(r) for r in revs]  # ifcontains() needs a list of str
     f = _showlist(name, revs, **args)
     return _hybrid(f, revs,
                    lambda x: {name: x, 'ctx': repo[int(x)], 'revcache': {}},
                    lambda d: d[name])
 
 @templatekeyword('subrepos')
 def showsubrepos(**args):
     """List of strings. Updated subrepositories in the changeset."""
     ctx = args['ctx']
     substate = ctx.substate
     if not substate:
         return showlist('subrepo', [], **args)
     psubstate = ctx.parents()[0].substate or {}
     subrepos = []
     for sub in substate:
         if sub not in psubstate or substate[sub] != psubstate[sub]:
             subrepos.append(sub) # modified or newly added in ctx
     for sub in psubstate:
         if sub not in substate:
             subrepos.append(sub) # removed in ctx
     return showlist('subrepo', sorted(subrepos), **args)
 
 # don't remove "showtags" definition, even though namespaces will put
 # a helper function for "tags" keyword into "keywords" map automatically,
 # because online help text is built without namespaces initialization
 @templatekeyword('tags')
 def showtags(**args):
     """List of strings. Any tags associated with the changeset."""
     return shownames('tags', **args)
 
 def loadkeyword(ui, extname, registrarobj):
     """Load template keyword from specified registrarobj
     """
     for name, func in registrarobj._table.iteritems():
         keywords[name] = func
 
 @templatekeyword('termwidth')
 def termwidth(repo, ctx, templ, **args):
     """Integer. The width of the current terminal."""
     return repo.ui.termwidth()
 
 @templatekeyword('troubles')
 def showtroubles(**args):
     """List of strings. Evolution troubles affecting the changeset.
 
     (EXPERIMENTAL)
     """
     return showlist('trouble', args['ctx'].troubles(), **args)
 
 # tell hggettext to extract docstrings from these functions:
 i18nfunctions = keywords.values()

tests/test-import.t

@@ -1,1805 +1,1812 b''
   $ hg init a
   $ mkdir a/d1
   $ mkdir a/d1/d2
   $ echo line 1 > a/a
   $ echo line 1 > a/d1/d2/a
   $ hg --cwd a ci -Ama
   adding a
   adding d1/d2/a
 
   $ echo line 2 >> a/a
   $ hg --cwd a ci -u someone -d '1 0' -m'second change'
 
 import with no args:
 
   $ hg --cwd a import
   abort: need at least one patch to import
   [255]
 
 generate patches for the test
 
   $ hg --cwd a export tip > exported-tip.patch
   $ hg --cwd a diff -r0:1 > diffed-tip.patch
 
 
 import exported patch
 (this also tests that editor is not invoked, if the patch contains the
 commit message and '--edit' is not specified)
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ HGEDITOR=cat hg --cwd b import ../exported-tip.patch
   applying ../exported-tip.patch
 
 message and committer and date should be same
 
   $ hg --cwd b tip
   changeset:   1:1d4bd90af0e4
   tag:         tip
   user:        someone
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     second change
   
   $ rm -r b
 
 
 import exported patch with external patcher
 (this also tests that editor is invoked, if the '--edit' is specified,
 regardless of the commit message in the patch)
 
   $ cat > dummypatch.py <<EOF
   > from __future__ import print_function
   > print('patching file a')
   > file('a', 'wb').write('line2\n')
   > EOF
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ HGEDITOR=cat hg --config ui.patch='python ../dummypatch.py' --cwd b import --edit ../exported-tip.patch
   applying ../exported-tip.patch
   second change
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: someone
   HG: branch 'default'
   HG: changed a
   $ cat b/a
   line2
   $ rm -r b
 
 
 import of plain diff should fail without message
 (this also tests that editor is invoked, if the patch doesn't contain
 the commit message, regardless of '--edit')
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat > $TESTTMP/editor.sh <<EOF
   > env | grep HGEDITFORM
   > cat \$1
   > EOF
   $ HGEDITOR="sh $TESTTMP/editor.sh" hg --cwd b import ../diffed-tip.patch
   applying ../diffed-tip.patch
   HGEDITFORM=import.normal.normal
   
   
   HG: Enter commit message.  Lines beginning with 'HG:' are removed.
   HG: Leave message empty to abort commit.
   HG: --
   HG: user: test
   HG: branch 'default'
   HG: changed a
   abort: empty commit message
   [255]
 
 Test avoiding editor invocation at applying the patch with --exact,
 even if commit message is empty
 
   $ echo a >> b/a
   $ hg --cwd b commit -m ' '
   $ hg --cwd b tip -T "{node}\n"
   d8804f3f5396d800812f579c8452796a5993bdb2
   $ hg --cwd b export -o ../empty-log.diff .
   $ hg --cwd b update -q -C ".^1"
   $ hg --cwd b --config extensions.strip= strip -q tip
   $ HGEDITOR=cat hg --cwd b import --exact ../empty-log.diff
   applying ../empty-log.diff
   $ hg --cwd b tip -T "{node}\n"
   d8804f3f5396d800812f579c8452796a5993bdb2
 
   $ rm -r b
 
 
 import of plain diff should be ok with message
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg --cwd b import -mpatch ../diffed-tip.patch
   applying ../diffed-tip.patch
   $ rm -r b
 
 
 import of plain diff with specific date and user
 (this also tests that editor is not invoked, if
 '--message'/'--logfile' is specified and '--edit' is not)
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg --cwd b import -mpatch -d '1 0' -u '[e-mail]' ../diffed-tip.patch
   applying ../diffed-tip.patch
   $ hg -R b tip -pv
   changeset:   1:ca68f19f3a40
   tag:         tip
   user:        [e-mail]
   date:        Thu Jan 01 00:00:01 1970 +0000
   files:       a
   description:
   patch
   
   
   diff -r 80971e65b431 -r ca68f19f3a40 a
   --- a/a	Thu Jan 01 00:00:00 1970 +0000
   +++ b/a	Thu Jan 01 00:00:01 1970 +0000
   @@ -1,1 +1,2 @@
    line 1
   +line 2
   
   $ rm -r b
 
 
 import of plain diff should be ok with --no-commit
 (this also tests that editor is not invoked, if '--no-commit' is
 specified, regardless of '--edit')
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ HGEDITOR=cat hg --cwd b import --no-commit --edit ../diffed-tip.patch
   applying ../diffed-tip.patch
   $ hg --cwd b diff --nodates
   diff -r 80971e65b431 a
   --- a/a
   +++ b/a
   @@ -1,1 +1,2 @@
    line 1
   +line 2
   $ rm -r b
 
 
 import of malformed plain diff should fail
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ sed 's/1,1/foo/' < diffed-tip.patch > broken.patch
   $ hg --cwd b import -mpatch ../broken.patch
   applying ../broken.patch
   abort: bad hunk #1
   [255]
   $ rm -r b
 
 
 hg -R repo import
 put the clone in a subdir - having a directory named "a"
 used to hide a bug.
 
   $ mkdir dir
   $ hg clone -r0 a dir/b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd dir
   $ hg -R b import ../exported-tip.patch
   applying ../exported-tip.patch
   $ cd ..
   $ rm -r dir
 
 
 import from stdin
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg --cwd b import - < exported-tip.patch
   applying patch from stdin
   $ rm -r b
 
 
 import two patches in one stream
 
   $ hg init b
   $ hg --cwd a export 0:tip | hg --cwd b import -
   applying patch from stdin
   $ hg --cwd a id
   1d4bd90af0e4 tip
   $ hg --cwd b id
   1d4bd90af0e4 tip
   $ rm -r b
 
 
 override commit message
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg --cwd b import -m 'override' - < exported-tip.patch
   applying patch from stdin
   $ hg --cwd b tip | grep override
   summary:     override
   $ rm -r b
 
   $ cat > mkmsg.py <<EOF
   > import email.Message, sys
   > msg = email.Message.Message()
   > patch = open(sys.argv[1], 'rb').read()
   > msg.set_payload('email commit message\n' + patch)
   > msg['Subject'] = 'email patch'
   > msg['From'] = 'email patcher'
   > file(sys.argv[2], 'wb').write(msg.as_string())
   > EOF
 
 
 plain diff in email, subject, message body
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ python mkmsg.py diffed-tip.patch msg.patch
   $ hg --cwd b import ../msg.patch
   applying ../msg.patch
   $ hg --cwd b tip | grep email
   user:        email patcher
   summary:     email patch
   $ rm -r b
 
 
 plain diff in email, no subject, message body
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ grep -v '^Subject:' msg.patch | hg --cwd b import -
   applying patch from stdin
   $ rm -r b
 
 
 plain diff in email, subject, no message body
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ grep -v '^email ' msg.patch | hg --cwd b import -
   applying patch from stdin
   $ rm -r b
 
 
 plain diff in email, no subject, no message body, should fail
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ egrep -v '^(Subject|email)' msg.patch | hg --cwd b import -
   applying patch from stdin
   abort: empty commit message
   [255]
   $ rm -r b
 
 
 hg export in email, should use patch header
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ python mkmsg.py exported-tip.patch msg.patch
   $ cat msg.patch | hg --cwd b import -
   applying patch from stdin
   $ hg --cwd b tip | grep second
   summary:     second change
   $ rm -r b
 
 
 subject: duplicate detection, removal of [PATCH]
 The '---' tests the gitsendmail handling without proper mail headers
 
   $ cat > mkmsg2.py <<EOF
   > import email.Message, sys
   > msg = email.Message.Message()
   > patch = open(sys.argv[1], 'rb').read()
   > msg.set_payload('email patch\n\nnext line\n---\n' + patch)
   > msg['Subject'] = '[PATCH] email patch'
   > msg['From'] = 'email patcher'
   > file(sys.argv[2], 'wb').write(msg.as_string())
   > EOF
 
 
 plain diff in email, [PATCH] subject, message body with subject
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ python mkmsg2.py diffed-tip.patch msg.patch
   $ cat msg.patch | hg --cwd b import -
   applying patch from stdin
   $ hg --cwd b tip --template '{desc}\n'
   email patch
   
   next line
   $ rm -r b
 
 
 Issue963: Parent of working dir incorrect after import of multiple
 patches and rollback
 
 We weren't backing up the correct dirstate file when importing many
 patches: import patch1 patch2; rollback
 
   $ echo line 3 >> a/a
   $ hg --cwd a ci -m'third change'
   $ hg --cwd a export -o '../patch%R' 1 2
   $ hg clone -qr0 a b
   $ hg --cwd b parents --template 'parent: {rev}\n'
   parent: 0
   $ hg --cwd b import -v ../patch1 ../patch2
   applying ../patch1
   patching file a
   committing files:
   a
   committing manifest
   committing changelog
   created 1d4bd90af0e4
   applying ../patch2
   patching file a
   committing files:
   a
   committing manifest
   committing changelog
   created 6d019af21222
   $ hg --cwd b rollback
   repository tip rolled back to revision 0 (undo import)
   working directory now based on revision 0
   $ hg --cwd b parents --template 'parent: {rev}\n'
   parent: 0
 
 Test that "hg rollback" doesn't restore dirstate to one at the
 beginning of the rolled back transaction in not-"parent-gone" case.
 
 invoking pretxncommit hook will cause marking '.hg/dirstate' as a file
 to be restored when rolling back, after DirstateTransactionPlan (see wiki
 page for detail).
 
   $ hg --cwd b branch -q foobar
   $ hg --cwd b commit -m foobar
   $ hg --cwd b update 0 -q
   $ hg --cwd b import ../patch1 ../patch2 --config hooks.pretxncommit=true
   applying ../patch1
   applying ../patch2
   $ hg --cwd b update -q 1
   $ hg --cwd b rollback -q
   $ hg --cwd b parents --template 'parent: {rev}\n'
   parent: 1
 
   $ hg --cwd b update -q -C 0
   $ hg --cwd b --config extensions.strip= strip -q 1
 
 Test visibility of in-memory dirstate changes inside transaction to
 external process
 
   $ echo foo > a/foo
   $ hg --cwd a commit -A -m 'adding foo' foo
   $ hg --cwd a export -o '../patch%R' 3
 
   $ cat > $TESTTMP/checkvisibility.sh <<EOF
   > echo "===="
   > hg parents --template "VISIBLE {rev}:{node|short}\n"
   > hg status -amr
   > # test that pending changes are hidden
   > unset HG_PENDING
   > hg parents --template "ACTUAL  {rev}:{node|short}\n"
   > hg status -amr
   > echo "===="
   > EOF
 
 == test visibility to external editor
 
   $ (cd b && sh "$TESTTMP/checkvisibility.sh")
   ====
   VISIBLE 0:80971e65b431
   ACTUAL  0:80971e65b431
   ====
 
   $ HGEDITOR="sh $TESTTMP/checkvisibility.sh" hg --cwd b import -v --edit ../patch1 ../patch2 ../patch3
   applying ../patch1
   patching file a
   ====
   VISIBLE 0:80971e65b431
   M a
   ACTUAL  0:80971e65b431
   M a
   ====
   committing files:
   a
   committing manifest
   committing changelog
   created 1d4bd90af0e4
   applying ../patch2
   patching file a
   ====
   VISIBLE 1:1d4bd90af0e4
   M a
   ACTUAL  0:80971e65b431
   M a
   ====
   committing files:
   a
   committing manifest
   committing changelog
   created 6d019af21222
   applying ../patch3
   patching file foo
   adding foo
   ====
   VISIBLE 2:6d019af21222
   A foo
   ACTUAL  0:80971e65b431
   M a
   ====
   committing files:
   foo
   committing manifest
   committing changelog
   created 55e3f75b2378
 
   $ hg --cwd b rollback -q
 
 (content of file "a" is already changed and it should be recognized as
 "M", even though dirstate is restored to one before "hg import")
 
   $ (cd b && sh "$TESTTMP/checkvisibility.sh")
   ====
   VISIBLE 0:80971e65b431
   M a
   ACTUAL  0:80971e65b431
   M a
   ====
   $ hg --cwd b revert --no-backup a
   $ rm -f b/foo
 
 == test visibility to precommit external hook
 
   $ cat >> b/.hg/hgrc <<EOF
   > [hooks]
   > precommit.visibility = sh $TESTTMP/checkvisibility.sh
   > EOF
 
   $ (cd b && sh "$TESTTMP/checkvisibility.sh")
   ====
   VISIBLE 0:80971e65b431
   ACTUAL  0:80971e65b431
   ====
 
   $ hg --cwd b import ../patch1 ../patch2 ../patch3
   applying ../patch1
   ====
   VISIBLE 0:80971e65b431
   M a
   ACTUAL  0:80971e65b431
   M a
   ====
   applying ../patch2
   ====
   VISIBLE 1:1d4bd90af0e4
   M a
   ACTUAL  0:80971e65b431
   M a
   ====
   applying ../patch3
   ====
   VISIBLE 2:6d019af21222
   A foo
   ACTUAL  0:80971e65b431
   M a
   ====
 
   $ hg --cwd b rollback -q
   $ (cd b && sh "$TESTTMP/checkvisibility.sh")
   ====
   VISIBLE 0:80971e65b431
   M a
   ACTUAL  0:80971e65b431
   M a
   ====
   $ hg --cwd b revert --no-backup a
   $ rm -f b/foo
 
   $ cat >> b/.hg/hgrc <<EOF
   > [hooks]
   > precommit.visibility =
   > EOF
 
 == test visibility to pretxncommit external hook
 
   $ cat >> b/.hg/hgrc <<EOF
   > [hooks]
   > pretxncommit.visibility = sh $TESTTMP/checkvisibility.sh
   > EOF
 
   $ (cd b && sh "$TESTTMP/checkvisibility.sh")
   ====
   VISIBLE 0:80971e65b431
   ACTUAL  0:80971e65b431
   ====
 
   $ hg --cwd b import ../patch1 ../patch2 ../patch3
   applying ../patch1
   ====
   VISIBLE 0:80971e65b431
   M a
   ACTUAL  0:80971e65b431
   M a
   ====
   applying ../patch2
   ====
   VISIBLE 1:1d4bd90af0e4
   M a
   ACTUAL  0:80971e65b431
   M a
   ====
   applying ../patch3
   ====
   VISIBLE 2:6d019af21222
   A foo
   ACTUAL  0:80971e65b431
   M a
   ====
 
   $ hg --cwd b rollback -q
   $ (cd b && sh "$TESTTMP/checkvisibility.sh")
   ====
   VISIBLE 0:80971e65b431
   M a
   ACTUAL  0:80971e65b431
   M a
   ====
   $ hg --cwd b revert --no-backup a
   $ rm -f b/foo
 
   $ cat >> b/.hg/hgrc <<EOF
   > [hooks]
   > pretxncommit.visibility =
   > EOF
 
   $ rm -r b
 
 
 importing a patch in a subdirectory failed at the commit stage
 
   $ echo line 2 >> a/d1/d2/a
   $ hg --cwd a ci -u someoneelse -d '1 0' -m'subdir change'
 
 hg import in a subdirectory
 
   $ hg clone -r0 a b
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg --cwd a export tip > tmp
   $ sed -e 's/d1\/d2\///' < tmp > subdir-tip.patch
   $ dir=`pwd`
   $ cd b/d1/d2 2>&1 > /dev/null
   $ hg import  ../../../subdir-tip.patch
   applying ../../../subdir-tip.patch
   $ cd "$dir"
 
 message should be 'subdir change'
 committer should be 'someoneelse'
 
   $ hg --cwd b tip
   changeset:   1:3577f5aea227
   tag:         tip
   user:        someoneelse
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     subdir change
   
 
 should be empty
 
   $ hg --cwd b status
 
 
 Test fuzziness (ambiguous patch location, fuzz=2)
 
   $ hg init fuzzy
   $ cd fuzzy
   $ echo line1 > a
   $ echo line0 >> a
   $ echo line3 >> a
   $ hg ci -Am adda
   adding a
   $ echo line1 > a
   $ echo line2 >> a
   $ echo line0 >> a
   $ echo line3 >> a
   $ hg ci -m change a
   $ hg export tip > fuzzy-tip.patch
   $ hg up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo line1 > a
   $ echo line0 >> a
   $ echo line1 >> a
   $ echo line0 >> a
   $ hg ci -m brancha
   created new head
   $ hg import --config patch.fuzz=0 -v fuzzy-tip.patch
   applying fuzzy-tip.patch
   patching file a
   Hunk #1 FAILED at 0
   1 out of 1 hunks FAILED -- saving rejects to file a.rej
   abort: patch failed to apply
   [255]
   $ hg import --no-commit -v fuzzy-tip.patch
   applying fuzzy-tip.patch
   patching file a
   Hunk #1 succeeded at 2 with fuzz 1 (offset 0 lines).
   applied to working directory
   $ hg revert -a
   reverting a
 
 
 import with --no-commit should have written .hg/last-message.txt
 
   $ cat .hg/last-message.txt
   change (no-eol)
 
 
 test fuzziness with eol=auto
 
   $ hg --config patch.eol=auto import --no-commit -v fuzzy-tip.patch
   applying fuzzy-tip.patch
   patching file a
   Hunk #1 succeeded at 2 with fuzz 1 (offset 0 lines).
   applied to working directory
   $ cd ..
 
 
 Test hunk touching empty files (issue906)
 
   $ hg init empty
   $ cd empty
   $ touch a
   $ touch b1
   $ touch c1
   $ echo d > d
   $ hg ci -Am init
   adding a
   adding b1
   adding c1
   adding d
   $ echo a > a
   $ echo b > b1
   $ hg mv b1 b2
   $ echo c > c1
   $ hg copy c1 c2
   $ rm d
   $ touch d
   $ hg diff --git
   diff --git a/a b/a
   --- a/a
   +++ b/a
   @@ -0,0 +1,1 @@
   +a
   diff --git a/b1 b/b2
   rename from b1
   rename to b2
   --- a/b1
   +++ b/b2
   @@ -0,0 +1,1 @@
   +b
   diff --git a/c1 b/c1
   --- a/c1
   +++ b/c1
   @@ -0,0 +1,1 @@
   +c
   diff --git a/c1 b/c2
   copy from c1
   copy to c2
   --- a/c1
   +++ b/c2
   @@ -0,0 +1,1 @@
   +c
   diff --git a/d b/d
   --- a/d
   +++ b/d
   @@ -1,1 +0,0 @@
   -d
   $ hg ci -m empty
   $ hg export --git tip > empty.diff
   $ hg up -C 0
   4 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg import empty.diff
   applying empty.diff
   $ for name in a b1 b2 c1 c2 d; do
   >   echo % $name file
   >   test -f $name && cat $name
   >   done
   % a file
   a
   % b1 file
   % b2 file
   b
   % c1 file
   c
   % c2 file
   c
   % d file
   $ cd ..
 
 
 Test importing a patch ending with a binary file removal
 
   $ hg init binaryremoval
   $ cd binaryremoval
   $ echo a > a
   $ $PYTHON -c "file('b', 'wb').write('a\x00b')"
   $ hg ci -Am addall
   adding a
   adding b
   $ hg rm a
   $ hg rm b
   $ hg st
   R a
   R b
   $ hg ci -m remove
   $ hg export --git . > remove.diff
   $ cat remove.diff | grep git
   diff --git a/a b/a
   diff --git a/b b/b
   $ hg up -C 0
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg import remove.diff
   applying remove.diff
   $ hg manifest
   $ cd ..
 
 
 Issue927: test update+rename with common name
 
   $ hg init t
   $ cd t
   $ touch a
   $ hg ci -Am t
   adding a
   $ echo a > a
 
 Here, bfile.startswith(afile)
 
   $ hg copy a a2
   $ hg ci -m copya
   $ hg export --git tip > copy.diff
   $ hg up -C 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg import copy.diff
   applying copy.diff
 
 a should contain an 'a'
 
   $ cat a
   a
 
 and a2 should have duplicated it
 
   $ cat a2
   a
   $ cd ..
 
 
 test -p0
 
   $ hg init p0
   $ cd p0
   $ echo a > a
   $ hg ci -Am t
   adding a
   $ hg import -p foo
   abort: invalid value 'foo' for option -p, expected int
   [255]
   $ hg import -p0 - << EOF
   > foobar
   > --- a	Sat Apr 12 22:43:58 2008 -0400
   > +++ a	Sat Apr 12 22:44:05 2008 -0400
   > @@ -1,1 +1,1 @@
   > -a
   > +bb
   > EOF
   applying patch from stdin
   $ hg status
   $ cat a
   bb
 
 test --prefix
 
   $ mkdir -p dir/dir2
   $ echo b > dir/dir2/b
   $ hg ci -Am b
   adding dir/dir2/b
   $ hg import -p2 --prefix dir - << EOF
   > foobar
   > --- drop1/drop2/dir2/b
   > +++ drop1/drop2/dir2/b
   > @@ -1,1 +1,1 @@
   > -b
   > +cc
   > EOF
   applying patch from stdin
   $ hg status
   $ cat dir/dir2/b
   cc
   $ cd ..
 
 
 test paths outside repo root
 
   $ mkdir outside
   $ touch outside/foo
   $ hg init inside
   $ cd inside
   $ hg import - <<EOF
   > diff --git a/a b/b
   > rename from ../outside/foo
   > rename to bar
   > EOF
   applying patch from stdin
   abort: path contains illegal component: ../outside/foo (glob)
   [255]
   $ cd ..
 
 
 test import with similarity and git and strip (issue295 et al.)
 
   $ hg init sim
   $ cd sim
   $ echo 'this is a test' > a
   $ hg ci -Ama
   adding a
   $ cat > ../rename.diff <<EOF
   > diff --git a/foo/a b/foo/a
   > deleted file mode 100644
   > --- a/foo/a
   > +++ /dev/null
   > @@ -1,1 +0,0 @@
   > -this is a test
   > diff --git a/foo/b b/foo/b
   > new file mode 100644
   > --- /dev/null
   > +++ b/foo/b
   > @@ -0,0 +1,2 @@
   > +this is a test
   > +foo
   > EOF
   $ hg import --no-commit -v -s 1 ../rename.diff -p2
   applying ../rename.diff
   patching file a
   patching file b
   adding b
   recording removal of a as rename to b (88% similar)
   applied to working directory
   $ hg st -C
   A b
     a
   R a
   $ hg revert -a
   undeleting a
   forgetting b
   $ rm b
   $ hg import --no-commit -v -s 100 ../rename.diff -p2
   applying ../rename.diff
   patching file a
   patching file b
   adding b
   applied to working directory
   $ hg st -C
   A b
   R a
   $ cd ..
 
 
 Issue1495: add empty file from the end of patch
 
   $ hg init addemptyend
   $ cd addemptyend
   $ touch a
   $ hg addremove
   adding a
   $ hg ci -m "commit"
   $ cat > a.patch <<EOF
   > add a, b
   > diff --git a/a b/a
   > --- a/a
   > +++ b/a
   > @@ -0,0 +1,1 @@
   > +a
   > diff --git a/b b/b
   > new file mode 100644
   > EOF
   $ hg import --no-commit a.patch
   applying a.patch
 
 apply a good patch followed by an empty patch (mainly to ensure
 that dirstate is *not* updated when import crashes)
   $ hg update -q -C .
   $ rm b
   $ touch empty.patch
   $ hg import a.patch empty.patch
   applying a.patch
   applying empty.patch
   transaction abort!
   rollback completed
   abort: empty.patch: no diffs found
   [255]
   $ hg tip --template '{rev}  {desc|firstline}\n'
   0  commit
   $ hg -q status
   M a
   $ cd ..
 
 create file when source is not /dev/null
 
   $ cat > create.patch <<EOF
   > diff -Naur proj-orig/foo proj-new/foo
   > --- proj-orig/foo       1969-12-31 16:00:00.000000000 -0800
   > +++ proj-new/foo        2009-07-17 16:50:45.801368000 -0700
   > @@ -0,0 +1,1 @@
   > +a
   > EOF
 
 some people have patches like the following too
 
   $ cat > create2.patch <<EOF
   > diff -Naur proj-orig/foo proj-new/foo
   > --- proj-orig/foo.orig  1969-12-31 16:00:00.000000000 -0800
   > +++ proj-new/foo        2009-07-17 16:50:45.801368000 -0700
   > @@ -0,0 +1,1 @@
   > +a
   > EOF
   $ hg init oddcreate
   $ cd oddcreate
   $ hg import --no-commit ../create.patch
   applying ../create.patch
   $ cat foo
   a
   $ rm foo
   $ hg revert foo
   $ hg import --no-commit ../create2.patch
   applying ../create2.patch
   $ cat foo
   a
 
   $ cd ..
 
 Issue1859: first line mistaken for email headers
 
   $ hg init emailconfusion
   $ cd emailconfusion
   $ cat > a.patch <<EOF
   > module: summary
   > 
   > description
   > 
   > 
   > diff -r 000000000000 -r 9b4c1e343b55 test.txt
   > --- /dev/null
   > +++ b/a
   > @@ -0,0 +1,1 @@
   > +a
   > EOF
   $ hg import -d '0 0' a.patch
   applying a.patch
   $ hg parents -v
   changeset:   0:5a681217c0ad
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       a
   description:
   module: summary
   
   description
   
   
   $ cd ..
 
 
 in commit message
 
   $ hg init commitconfusion
   $ cd commitconfusion
   $ cat > a.patch <<EOF
   > module: summary
   > 
   > --- description
   > 
   > diff --git a/a b/a
   > new file mode 100644
   > --- /dev/null
   > +++ b/a
   > @@ -0,0 +1,1 @@
   > +a
   > EOF
   > hg import -d '0 0' a.patch
   > hg parents -v
   > cd ..
   > 
   > echo '% tricky header splitting'
   > cat > trickyheaders.patch <<EOF
   > From: User A <user@a>
   > Subject: [PATCH] from: tricky!
   > 
   > # HG changeset patch
   > # User User B
   > # Date 1266264441 18000
   > # Branch stable
   > # Node ID f2be6a1170ac83bf31cb4ae0bad00d7678115bc0
   > # Parent  0000000000000000000000000000000000000000
   > from: tricky!
   > 
   > That is not a header.
   > 
   > diff -r 000000000000 -r f2be6a1170ac foo
   > --- /dev/null
   > +++ b/foo
   > @@ -0,0 +1,1 @@
   > +foo
   > EOF
   applying a.patch
   changeset:   0:f34d9187897d
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       a
   description:
   module: summary
   
   
   % tricky header splitting
 
   $ hg init trickyheaders
   $ cd trickyheaders
   $ hg import -d '0 0' ../trickyheaders.patch
   applying ../trickyheaders.patch
   $ hg export --git tip
   # HG changeset patch
   # User User B
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID eb56ab91903632294ac504838508cb370c0901d2
   # Parent  0000000000000000000000000000000000000000
   from: tricky!
   
   That is not a header.
   
   diff --git a/foo b/foo
   new file mode 100644
   --- /dev/null
   +++ b/foo
   @@ -0,0 +1,1 @@
   +foo
   $ cd ..
 
 
 Issue2102: hg export and hg import speak different languages
 
   $ hg init issue2102
   $ cd issue2102
   $ mkdir -p src/cmd/gc
   $ touch src/cmd/gc/mksys.bash
   $ hg ci -Am init
   adding src/cmd/gc/mksys.bash
   $ hg import - <<EOF
   > # HG changeset patch
   > # User Rob Pike
   > # Date 1216685449 25200
   > # Node ID 03aa2b206f499ad6eb50e6e207b9e710d6409c98
   > # Parent  93d10138ad8df586827ca90b4ddb5033e21a3a84
   > help management of empty pkg and lib directories in perforce
   > 
   > R=gri
   > DELTA=4  (4 added, 0 deleted, 0 changed)
   > OCL=13328
   > CL=13328
   > 
   > diff --git a/lib/place-holder b/lib/place-holder
   > new file mode 100644
   > --- /dev/null
   > +++ b/lib/place-holder
   > @@ -0,0 +1,2 @@
   > +perforce does not maintain empty directories.
   > +this file helps.
   > diff --git a/pkg/place-holder b/pkg/place-holder
   > new file mode 100644
   > --- /dev/null
   > +++ b/pkg/place-holder
   > @@ -0,0 +1,2 @@
   > +perforce does not maintain empty directories.
   > +this file helps.
   > diff --git a/src/cmd/gc/mksys.bash b/src/cmd/gc/mksys.bash
   > old mode 100644
   > new mode 100755
   > EOF
   applying patch from stdin
 
 #if execbit
 
   $ hg sum
   parent: 1:d59915696727 tip
    help management of empty pkg and lib directories in perforce
   branch: default
   commit: (clean)
   update: (current)
   phases: 2 draft
 
   $ hg diff --git -c tip
   diff --git a/lib/place-holder b/lib/place-holder
   new file mode 100644
   --- /dev/null
   +++ b/lib/place-holder
   @@ -0,0 +1,2 @@
   +perforce does not maintain empty directories.
   +this file helps.
   diff --git a/pkg/place-holder b/pkg/place-holder
   new file mode 100644
   --- /dev/null
   +++ b/pkg/place-holder
   @@ -0,0 +1,2 @@
   +perforce does not maintain empty directories.
   +this file helps.
   diff --git a/src/cmd/gc/mksys.bash b/src/cmd/gc/mksys.bash
   old mode 100644
   new mode 100755
 
 #else
 
   $ hg sum
   parent: 1:28f089cc9ccc tip
    help management of empty pkg and lib directories in perforce
   branch: default
   commit: (clean)
   update: (current)
   phases: 2 draft
 
   $ hg diff --git -c tip
   diff --git a/lib/place-holder b/lib/place-holder
   new file mode 100644
   --- /dev/null
   +++ b/lib/place-holder
   @@ -0,0 +1,2 @@
   +perforce does not maintain empty directories.
   +this file helps.
   diff --git a/pkg/place-holder b/pkg/place-holder
   new file mode 100644
   --- /dev/null
   +++ b/pkg/place-holder
   @@ -0,0 +1,2 @@
   +perforce does not maintain empty directories.
   +this file helps.
 
 /* The mode change for mksys.bash is missing here, because on platforms  */
 /* that don't support execbits, mode changes in patches are ignored when */
 /* they are imported. This is obviously also the reason for why the hash */
 /* in the created changeset is different to the one you see above the    */
 /* #else clause */
 
 #endif
   $ cd ..
 
 
 diff lines looking like headers
 
   $ hg init difflineslikeheaders
   $ cd difflineslikeheaders
   $ echo a >a
   $ echo b >b
   $ echo c >c
   $ hg ci -Am1
   adding a
   adding b
   adding c
 
   $ echo "key: value" >>a
   $ echo "key: value" >>b
   $ echo "foo" >>c
   $ hg ci -m2
 
   $ hg up -C 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg diff --git -c1 >want
   $ hg diff -c1 | hg import --no-commit -
   applying patch from stdin
   $ hg diff --git >have
   $ diff want have
   $ cd ..
 
 import a unified diff with no lines of context (diff -U0)
 
   $ hg init diffzero
   $ cd diffzero
   $ cat > f << EOF
   > c2
   > c4
   > c5
   > EOF
   $ hg commit -Am0
   adding f
 
   $ hg import --no-commit - << EOF
   > # HG changeset patch
   > # User test
   > # Date 0 0
   > # Node ID f4974ab632f3dee767567b0576c0ec9a4508575c
   > # Parent  8679a12a975b819fae5f7ad3853a2886d143d794
   > 1
   > diff -r 8679a12a975b -r f4974ab632f3 f
   > --- a/f	Thu Jan 01 00:00:00 1970 +0000
   > +++ b/f	Thu Jan 01 00:00:00 1970 +0000
   > @@ -0,0 +1,1 @@
   > +c1
   > @@ -1,0 +3,1 @@
   > +c3
   > @@ -3,1 +4,0 @@
   > -c5
   > EOF
   applying patch from stdin
 
   $ cat f
   c1
   c2
   c3
   c4
 
   $ cd ..
 
 no segfault while importing a unified diff which start line is zero but chunk
 size is non-zero
 
   $ hg init startlinezero
   $ cd startlinezero
   $ echo foo > foo
   $ hg commit -Amfoo
   adding foo
 
   $ hg import --no-commit - << EOF
   > diff a/foo b/foo
   > --- a/foo
   > +++ b/foo
   > @@ -0,1 +0,1 @@
   >  foo
   > EOF
   applying patch from stdin
 
   $ cd ..
 
 Test corner case involving fuzz and skew
 
   $ hg init morecornercases
   $ cd morecornercases
 
   $ cat > 01-no-context-beginning-of-file.diff <<EOF
   > diff --git a/a b/a
   > --- a/a
   > +++ b/a
   > @@ -1,0 +1,1 @@
   > +line
   > EOF
 
   $ cat > 02-no-context-middle-of-file.diff <<EOF
   > diff --git a/a b/a
   > --- a/a
   > +++ b/a
   > @@ -1,1 +1,1 @@
   > -2
   > +add some skew
   > @@ -2,0 +2,1 @@
   > +line
   > EOF
 
   $ cat > 03-no-context-end-of-file.diff <<EOF
   > diff --git a/a b/a
   > --- a/a
   > +++ b/a
   > @@ -10,0 +10,1 @@
   > +line
   > EOF
 
   $ cat > 04-middle-of-file-completely-fuzzed.diff <<EOF
   > diff --git a/a b/a
   > --- a/a
   > +++ b/a
   > @@ -1,1 +1,1 @@
   > -2
   > +add some skew
   > @@ -2,2 +2,3 @@
   >  not matching, should fuzz
   >  ... a bit
   > +line
   > EOF
 
   $ cat > a <<EOF
   > 1
   > 2
   > 3
   > 4
   > EOF
   $ hg ci -Am adda a
   $ for p in *.diff; do
   >   hg import -v --no-commit $p
   >   cat a
   >   hg revert -aqC a
   >   # patch -p1 < $p
   >   # cat a
   >   # hg revert -aC a
   > done
   applying 01-no-context-beginning-of-file.diff
   patching file a
   applied to working directory
   1
   line
   2
   3
   4
   applying 02-no-context-middle-of-file.diff
   patching file a
   Hunk #1 succeeded at 2 (offset 1 lines).
   Hunk #2 succeeded at 4 (offset 1 lines).
   applied to working directory
   1
   add some skew
   3
   line
   4
   applying 03-no-context-end-of-file.diff
   patching file a
   Hunk #1 succeeded at 5 (offset -6 lines).
   applied to working directory
   1
   2
   3
   4
   line
   applying 04-middle-of-file-completely-fuzzed.diff
   patching file a
   Hunk #1 succeeded at 2 (offset 1 lines).
   Hunk #2 succeeded at 5 with fuzz 2 (offset 1 lines).
   applied to working directory
   1
   add some skew
   3
   4
   line
   $ cd ..
 
 Test partial application
 ------------------------
 
 prepare a stack of patches depending on each other
 
   $ hg init partial
   $ cd partial
   $ cat << EOF > a
   > one
   > two
   > three
   > four
   > five
   > six
   > seven
   > EOF
   $ hg add a
   $ echo 'b' > b
   $ hg add b
   $ hg commit -m 'initial' -u Babar
   $ cat << EOF > a
   > one
   > two
   > 3
   > four
   > five
   > six
   > seven
   > EOF
   $ hg commit -m 'three' -u Celeste
   $ cat << EOF > a
   > one
   > two
   > 3
   > 4
   > five
   > six
   > seven
   > EOF
   $ hg commit -m 'four' -u Rataxes
   $ cat << EOF > a
   > one
   > two
   > 3
   > 4
   > 5
   > six
   > seven
   > EOF
   $ echo bb >> b
   $ hg commit -m 'five' -u Arthur
   $ echo 'Babar' > jungle
   $ hg add jungle
   $ hg ci -m 'jungle' -u Zephir
   $ echo 'Celeste' >> jungle
   $ hg ci -m 'extended jungle' -u Cornelius
   $ hg log -G --template '{desc|firstline} [{author}] {diffstat}\n'
   @  extended jungle [Cornelius] 1: +1/-0
   |
   o  jungle [Zephir] 1: +1/-0
   |
   o  five [Arthur] 2: +2/-1
   |
   o  four [Rataxes] 1: +1/-1
   |
   o  three [Celeste] 1: +1/-1
   |
   o  initial [Babar] 2: +8/-0
   
+Adding those config options should not change the output of diffstat. Bugfix #4755.
+
+  $ hg log -r . --template '{diffstat}\n'
+  1: +1/-0
+  $ hg log -r . --template '{diffstat}\n' --config diff.git=1 \
+  >   --config diff.noprefix=1
+  1: +1/-0
 
 Importing with some success and some errors:
 
   $ hg update --rev 'desc(initial)'
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg export --rev 'desc(five)' | hg import --partial -
   applying patch from stdin
   patching file a
   Hunk #1 FAILED at 1
   1 out of 1 hunks FAILED -- saving rejects to file a.rej
   patch applied partially
   (fix the .rej files and run `hg commit --amend`)
   [1]
 
   $ hg log -G --template '{desc|firstline} [{author}] {diffstat}\n'
   @  five [Arthur] 1: +1/-0
   |
   | o  extended jungle [Cornelius] 1: +1/-0
   | |
   | o  jungle [Zephir] 1: +1/-0
   | |
   | o  five [Arthur] 2: +2/-1
   | |
   | o  four [Rataxes] 1: +1/-1
   | |
   | o  three [Celeste] 1: +1/-1
   |/
   o  initial [Babar] 2: +8/-0
   
   $ hg export
   # HG changeset patch
   # User Arthur
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 26e6446bb2526e2be1037935f5fca2b2706f1509
   # Parent  8e4f0351909eae6b9cf68c2c076cb54c42b54b2e
   five
   
   diff -r 8e4f0351909e -r 26e6446bb252 b
   --- a/b	Thu Jan 01 00:00:00 1970 +0000
   +++ b/b	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,1 +1,2 @@
    b
   +bb
   $ hg status -c .
   C a
   C b
   $ ls
   a
   a.rej
   b
 
 Importing with zero success:
 
   $ hg update --rev 'desc(initial)'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg export --rev 'desc(four)' | hg import --partial -
   applying patch from stdin
   patching file a
   Hunk #1 FAILED at 0
   1 out of 1 hunks FAILED -- saving rejects to file a.rej
   patch applied partially
   (fix the .rej files and run `hg commit --amend`)
   [1]
 
   $ hg log -G --template '{desc|firstline} [{author}] {diffstat}\n'
   @  four [Rataxes] 0: +0/-0
   |
   | o  five [Arthur] 1: +1/-0
   |/
   | o  extended jungle [Cornelius] 1: +1/-0
   | |
   | o  jungle [Zephir] 1: +1/-0
   | |
   | o  five [Arthur] 2: +2/-1
   | |
   | o  four [Rataxes] 1: +1/-1
   | |
   | o  three [Celeste] 1: +1/-1
   |/
   o  initial [Babar] 2: +8/-0
   
   $ hg export
   # HG changeset patch
   # User Rataxes
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID cb9b1847a74d9ad52e93becaf14b98dbcc274e1e
   # Parent  8e4f0351909eae6b9cf68c2c076cb54c42b54b2e
   four
   
   $ hg status -c .
   C a
   C b
   $ ls
   a
   a.rej
   b
 
 Importing with unknown file:
 
   $ hg update --rev 'desc(initial)'
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg export --rev 'desc("extended jungle")' | hg import --partial -
   applying patch from stdin
   unable to find 'jungle' for patching
   (use '--prefix' to apply patch relative to the current directory)
   1 out of 1 hunks FAILED -- saving rejects to file jungle.rej
   patch applied partially
   (fix the .rej files and run `hg commit --amend`)
   [1]
 
   $ hg log -G --template '{desc|firstline} [{author}] {diffstat}\n'
   @  extended jungle [Cornelius] 0: +0/-0
   |
   | o  four [Rataxes] 0: +0/-0
   |/
   | o  five [Arthur] 1: +1/-0
   |/
   | o  extended jungle [Cornelius] 1: +1/-0
   | |
   | o  jungle [Zephir] 1: +1/-0
   | |
   | o  five [Arthur] 2: +2/-1
   | |
   | o  four [Rataxes] 1: +1/-1
   | |
   | o  three [Celeste] 1: +1/-1
   |/
   o  initial [Babar] 2: +8/-0
   
   $ hg export
   # HG changeset patch
   # User Cornelius
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 1fb1f86bef43c5a75918178f8d23c29fb0a7398d
   # Parent  8e4f0351909eae6b9cf68c2c076cb54c42b54b2e
   extended jungle
   
   $ hg status -c .
   C a
   C b
   $ ls
   a
   a.rej
   b
   jungle.rej
 
 Importing multiple failing patches:
 
   $ hg update --rev 'desc(initial)'
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 'B' > b # just to make another commit
   $ hg commit -m "a new base"
   created new head
   $ hg export --rev 'desc("four") + desc("extended jungle")' | hg import --partial -
   applying patch from stdin
   patching file a
   Hunk #1 FAILED at 0
   1 out of 1 hunks FAILED -- saving rejects to file a.rej
   patch applied partially
   (fix the .rej files and run `hg commit --amend`)
   [1]
   $ hg log -G --template '{desc|firstline} [{author}] {diffstat}\n'
   @  four [Rataxes] 0: +0/-0
   |
   o  a new base [test] 1: +1/-1
   |
   | o  extended jungle [Cornelius] 0: +0/-0
   |/
   | o  four [Rataxes] 0: +0/-0
   |/
   | o  five [Arthur] 1: +1/-0
   |/
   | o  extended jungle [Cornelius] 1: +1/-0
   | |
   | o  jungle [Zephir] 1: +1/-0
   | |
   | o  five [Arthur] 2: +2/-1
   | |
   | o  four [Rataxes] 1: +1/-1
   | |
   | o  three [Celeste] 1: +1/-1
   |/
   o  initial [Babar] 2: +8/-0
   
   $ hg export
   # HG changeset patch
   # User Rataxes
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID a9d7b6d0ffbb4eb12b7d5939250fcd42e8930a1d
   # Parent  f59f8d2e95a8ca5b1b4ca64320140da85f3b44fd
   four
   
   $ hg status -c .
   C a
   C b
 
 Importing some extra header
 ===========================
 
   $ cat > $TESTTMP/parseextra.py <<EOF
   > import mercurial.patch
   > import mercurial.cmdutil
   > 
   > def processfoo(repo, data, extra, opts):
   >     if 'foo' in data:
   >         extra['foo'] = data['foo']
   > def postimport(ctx):
   >     if 'foo' in ctx.extra():
   >         ctx.repo().ui.write('imported-foo: %s\n' % ctx.extra()['foo'])
   > 
   > mercurial.patch.patchheadermap.append(('Foo', 'foo'))
   > mercurial.cmdutil.extrapreimport.append('foo')
   > mercurial.cmdutil.extrapreimportmap['foo'] = processfoo
   > mercurial.cmdutil.extrapostimport.append('foo')
   > mercurial.cmdutil.extrapostimportmap['foo'] = postimport
   > EOF
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > parseextra=$TESTTMP/parseextra.py
   > EOF
   $ hg up -C tip
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat > $TESTTMP/foo.patch <<EOF
   > # HG changeset patch
   > # User Rataxes
   > # Date 0 0
   > #      Thu Jan 01 00:00:00 1970 +0000
   > # Foo bar
   > height
   > 
   > --- a/a	Thu Jan 01 00:00:00 1970 +0000
   > +++ b/a	Wed Oct 07 09:17:44 2015 +0000
   > @@ -5,3 +5,4 @@
   >  five
   >  six
   >  seven
   > +heigt
   > EOF
   $ hg import $TESTTMP/foo.patch
   applying $TESTTMP/foo.patch
   imported-foo: bar
   $ hg log --debug -r . | grep extra
   extra:       branch=default
   extra:       foo=bar
 
 Warn the user that paths are relative to the root of
 repository when file not found for patching
 
   $ mkdir filedir
   $ echo "file1" >> filedir/file1
   $ hg add filedir/file1
   $ hg commit -m "file1"
   $ cd filedir
   $ hg import -p 2 - <<EOF
   > # HG changeset patch
   > # User test
   > # Date 0 0
   > file2
   > 
   > diff --git a/filedir/file1 b/filedir/file1
   > --- a/filedir/file1
   > +++ b/filedir/file1
   > @@ -1,1 +1,2 @@
   >  file1
   > +file2
   > EOF
   applying patch from stdin
   unable to find 'file1' for patching
   (use '--prefix' to apply patch relative to the current directory)
   1 out of 1 hunks FAILED -- saving rejects to file file1.rej
   abort: patch failed to apply
   [255]
 
 test import crash (issue5375)
   $ cd ..
   $ hg init repo
   $ cd repo
   $ printf "diff --git a/a b/b\nrename from a\nrename to b" | hg import -
   applying patch from stdin
   a not tracked!
   abort: source file 'a' does not exist
   [255]