patch: use temporary files to handle intermediate copies

git patches may require copies to be handled out-of-order. For instance, take
the following sequence:

  * modify a
  * copy a into b

Here, we have to generate b from a before its modification. To do so,
applydiff() was scanning for copy metadata and performing the copies before
processing the other changes in-order. While smart and efficient, this approach
complicates things by handling file copies and file creations at different
places and times. While a new file must not exist before being patched a copied
file already exists before applying the first hunk.

Instead of copying the files at their final destination before patching, we
store them in a temporary file location and retrieve them when patching. The
filestore always stores file content in real files but nothing prevents adding
a cache layer. The filestore class was kept separate from fsbackend for at
least two reasons:

- This class is likely to be reused as a temporary result store for a future
  repository patching call (entries just have to be extended to contain copy
  sources).

- Delegating this role to backends might be more efficient in a repository
  backend case: the source files are already available in the repository itself
  and do not need to be copied again. It also means that third-parties backend
  would have to implement two other methods. If we ever decide to merge the
  filestore feature into backend, a minimalistic approach would be to compose
  with filestore directly. Keep in mind this copy overhead only applies for
  copy/rename sources, and may even be reduced to copy sources which have to
  handled ahead of time.

hgext/keyword.py

@@ -1,691 +1,692 b''
 # keyword.py - $Keyword$ expansion for Mercurial
 #
 # Copyright 2007-2010 Christian Ebert <[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.
 #
 # $Id$
 #
 # Keyword expansion hack against the grain of a DSCM
 #
 # There are many good reasons why this is not needed in a distributed
 # SCM, still it may be useful in very small projects based on single
 # files (like LaTeX packages), that are mostly addressed to an
 # audience not running a version control system.
 #
 # For in-depth discussion refer to
 # <http://mercurial.selenic.com/wiki/KeywordPlan>.
 #
 # Keyword expansion is based on Mercurial's changeset template mappings.
 #
 # Binary files are not touched.
 #
 # Files to act upon/ignore are specified in the [keyword] section.
 # Customized keyword template mappings in the [keywordmaps] section.
 #
 # Run "hg help keyword" and "hg kwdemo" to get info on configuration.
 
 '''expand keywords in tracked files
 
 This extension expands RCS/CVS-like or self-customized $Keywords$ in
 tracked text files selected by your configuration.
 
 Keywords are only expanded in local repositories and not stored in the
 change history. The mechanism can be regarded as a convenience for the
 current user or for archive distribution.
 
 Keywords expand to the changeset data pertaining to the latest change
 relative to the working directory parent of each file.
 
 Configuration is done in the [keyword], [keywordset] and [keywordmaps]
 sections of hgrc files.
 
 Example::
 
     [keyword]
     # expand keywords in every python file except those matching "x*"
     **.py =
     x*    = ignore
 
     [keywordset]
     # prefer svn- over cvs-like default keywordmaps
     svn = True
 
 .. note::
    The more specific you are in your filename patterns the less you
    lose speed in huge repositories.
 
 For [keywordmaps] template mapping and expansion demonstration and
 control run :hg:`kwdemo`. See :hg:`help templates` for a list of
 available templates and filters.
 
 Three additional date template filters are provided:
 
 :``utcdate``:    "2006/09/18 15:13:13"
 :``svnutcdate``: "2006-09-18 15:13:13Z"
 :``svnisodate``: "2006-09-18 08:13:13 -700 (Mon, 18 Sep 2006)"
 
 The default template mappings (view with :hg:`kwdemo -d`) can be
 replaced with customized keywords and templates. Again, run
 :hg:`kwdemo` to control the results of your configuration changes.
 
 Before changing/disabling active keywords, you must run :hg:`kwshrink`
 to avoid storing expanded keywords in the change history.
 
 To force expansion after enabling it, or a configuration change, run
 :hg:`kwexpand`.
 
 Expansions spanning more than one line and incremental expansions,
 like CVS' $Log$, are not supported. A keyword template map "Log =
 {desc}" expands to the first line of the changeset description.
 '''
 
 from mercurial import commands, context, cmdutil, dispatch, filelog, extensions
 from mercurial import localrepo, match, patch, templatefilters, templater, util
 from mercurial import scmutil
 from mercurial.hgweb import webcommands
 from mercurial.i18n import _
 import os, re, shutil, tempfile
 
 commands.optionalrepo += ' kwdemo'
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
 
 # hg commands that do not act on keywords
 nokwcommands = ('add addremove annotate bundle export grep incoming init log'
                 ' outgoing push tip verify convert email glog')
 
 # hg commands that trigger expansion only when writing to working dir,
 # not when reading filelog, and unexpand when reading from working dir
 restricted = 'merge kwexpand kwshrink record qrecord resolve transplant'
 
 # names of extensions using dorecord
 recordextensions = 'record'
 
 colortable = {
     'kwfiles.enabled': 'green bold',
     'kwfiles.deleted': 'cyan bold underline',
     'kwfiles.enabledunknown': 'green',
     'kwfiles.ignored': 'bold',
     'kwfiles.ignoredunknown': 'none'
 }
 
 # date like in cvs' $Date
 def utcdate(text):
     ''':utcdate: Date. Returns a UTC-date in this format: "2009/08/18 11:00:13".
     '''
     return util.datestr((text[0], 0), '%Y/%m/%d %H:%M:%S')
 # date like in svn's $Date
 def svnisodate(text):
     ''':svnisodate: Date. Returns a date in this format: "2009-08-18 13:00:13
     +0200 (Tue, 18 Aug 2009)".
     '''
     return util.datestr(text, '%Y-%m-%d %H:%M:%S %1%2 (%a, %d %b %Y)')
 # date like in svn's $Id
 def svnutcdate(text):
     ''':svnutcdate: Date. Returns a UTC-date in this format: "2009-08-18
     11:00:13Z".
     '''
     return util.datestr((text[0], 0), '%Y-%m-%d %H:%M:%SZ')
 
 templatefilters.filters.update({'utcdate': utcdate,
                                 'svnisodate': svnisodate,
                                 'svnutcdate': svnutcdate})
 
 # make keyword tools accessible
 kwtools = {'templater': None, 'hgcmd': ''}
 
 def _defaultkwmaps(ui):
     '''Returns default keywordmaps according to keywordset configuration.'''
     templates = {
         'Revision': '{node|short}',
         'Author': '{author|user}',
     }
     kwsets = ({
         'Date': '{date|utcdate}',
         'RCSfile': '{file|basename},v',
         'RCSFile': '{file|basename},v', # kept for backwards compatibility
                                         # with hg-keyword
         'Source': '{root}/{file},v',
         'Id': '{file|basename},v {node|short} {date|utcdate} {author|user}',
         'Header': '{root}/{file},v {node|short} {date|utcdate} {author|user}',
     }, {
         'Date': '{date|svnisodate}',
         'Id': '{file|basename},v {node|short} {date|svnutcdate} {author|user}',
         'LastChangedRevision': '{node|short}',
         'LastChangedBy': '{author|user}',
         'LastChangedDate': '{date|svnisodate}',
     })
     templates.update(kwsets[ui.configbool('keywordset', 'svn')])
     return templates
 
 def _shrinktext(text, subfunc):
     '''Helper for keyword expansion removal in text.
     Depending on subfunc also returns number of substitutions.'''
     return subfunc(r'$\1$', text)
 
 def _preselect(wstatus, changed):
     '''Retrieves modfied and added files from a working directory state
     and returns the subset of each contained in given changed files
     retrieved from a change context.'''
     modified, added = wstatus[:2]
     modified = [f for f in modified if f in changed]
     added = [f for f in added if f in changed]
     return modified, added
 
 
 class kwtemplater(object):
     '''
     Sets up keyword templates, corresponding keyword regex, and
     provides keyword substitution functions.
     '''
 
     def __init__(self, ui, repo, inc, exc):
         self.ui = ui
         self.repo = repo
         self.match = match.match(repo.root, '', [], inc, exc)
         self.restrict = kwtools['hgcmd'] in restricted.split()
         self.record = False
 
         kwmaps = self.ui.configitems('keywordmaps')
         if kwmaps: # override default templates
             self.templates = dict((k, templater.parsestring(v, False))
                                   for k, v in kwmaps)
         else:
             self.templates = _defaultkwmaps(self.ui)
 
     @util.propertycache
     def escape(self):
         '''Returns bar-separated and escaped keywords.'''
         return '|'.join(map(re.escape, self.templates.keys()))
 
     @util.propertycache
     def rekw(self):
         '''Returns regex for unexpanded keywords.'''
         return re.compile(r'\$(%s)\$' % self.escape)
 
     @util.propertycache
     def rekwexp(self):
         '''Returns regex for expanded keywords.'''
         return re.compile(r'\$(%s): [^$\n\r]*? \$' % self.escape)
 
     def substitute(self, data, path, ctx, subfunc):
         '''Replaces keywords in data with expanded template.'''
         def kwsub(mobj):
             kw = mobj.group(1)
             ct = cmdutil.changeset_templater(self.ui, self.repo,
                                              False, None, '', False)
             ct.use_template(self.templates[kw])
             self.ui.pushbuffer()
             ct.show(ctx, root=self.repo.root, file=path)
             ekw = templatefilters.firstline(self.ui.popbuffer())
             return '$%s: %s $' % (kw, ekw)
         return subfunc(kwsub, data)
 
     def linkctx(self, path, fileid):
         '''Similar to filelog.linkrev, but returns a changectx.'''
         return self.repo.filectx(path, fileid=fileid).changectx()
 
     def expand(self, path, node, data):
         '''Returns data with keywords expanded.'''
         if not self.restrict and self.match(path) and not util.binary(data):
             ctx = self.linkctx(path, node)
             return self.substitute(data, path, ctx, self.rekw.sub)
         return data
 
     def iskwfile(self, cand, ctx):
         '''Returns subset of candidates which are configured for keyword
         expansion are not symbolic links.'''
         return [f for f in cand if self.match(f) and not 'l' in ctx.flags(f)]
 
     def overwrite(self, ctx, candidates, lookup, expand, rekw=False):
         '''Overwrites selected files expanding/shrinking keywords.'''
         if self.restrict or lookup or self.record: # exclude kw_copy
             candidates = self.iskwfile(candidates, ctx)
         if not candidates:
             return
         kwcmd = self.restrict and lookup # kwexpand/kwshrink
         if self.restrict or expand and lookup:
             mf = ctx.manifest()
         lctx = ctx
         re_kw = (self.restrict or rekw) and self.rekw or self.rekwexp
         msg = (expand and _('overwriting %s expanding keywords\n')
                or _('overwriting %s shrinking keywords\n'))
         for f in candidates:
             if self.restrict:
                 data = self.repo.file(f).read(mf[f])
             else:
                 data = self.repo.wread(f)
             if util.binary(data):
                 continue
             if expand:
                 if lookup:
                     lctx = self.linkctx(f, mf[f])
                 data, found = self.substitute(data, f, lctx, re_kw.subn)
             elif self.restrict:
                 found = re_kw.search(data)
             else:
                 data, found = _shrinktext(data, re_kw.subn)
             if found:
                 self.ui.note(msg % f)
                 self.repo.wwrite(f, data, ctx.flags(f))
                 if kwcmd:
                     self.repo.dirstate.normal(f)
                 elif self.record:
                     self.repo.dirstate.normallookup(f)
 
     def shrink(self, fname, text):
         '''Returns text with all keyword substitutions removed.'''
         if self.match(fname) and not util.binary(text):
             return _shrinktext(text, self.rekwexp.sub)
         return text
 
     def shrinklines(self, fname, lines):
         '''Returns lines with keyword substitutions removed.'''
         if self.match(fname):
             text = ''.join(lines)
             if not util.binary(text):
                 return _shrinktext(text, self.rekwexp.sub).splitlines(True)
         return lines
 
     def wread(self, fname, data):
         '''If in restricted mode returns data read from wdir with
         keyword substitutions removed.'''
         return self.restrict and self.shrink(fname, data) or data
 
 class kwfilelog(filelog.filelog):
     '''
     Subclass of filelog to hook into its read, add, cmp methods.
     Keywords are "stored" unexpanded, and processed on reading.
     '''
     def __init__(self, opener, kwt, path):
         super(kwfilelog, self).__init__(opener, path)
         self.kwt = kwt
         self.path = path
 
     def read(self, node):
         '''Expands keywords when reading filelog.'''
         data = super(kwfilelog, self).read(node)
         if self.renamed(node):
             return data
         return self.kwt.expand(self.path, node, data)
 
     def add(self, text, meta, tr, link, p1=None, p2=None):
         '''Removes keyword substitutions when adding to filelog.'''
         text = self.kwt.shrink(self.path, text)
         return super(kwfilelog, self).add(text, meta, tr, link, p1, p2)
 
     def cmp(self, node, text):
         '''Removes keyword substitutions for comparison.'''
         text = self.kwt.shrink(self.path, text)
         return super(kwfilelog, self).cmp(node, text)
 
 def _status(ui, repo, kwt, *pats, **opts):
     '''Bails out if [keyword] configuration is not active.
     Returns status of working directory.'''
     if kwt:
         return repo.status(match=scmutil.match(repo, pats, opts), clean=True,
                            unknown=opts.get('unknown') or opts.get('all'))
     if ui.configitems('keyword'):
         raise util.Abort(_('[keyword] patterns cannot match'))
     raise util.Abort(_('no [keyword] patterns configured'))
 
 def _kwfwrite(ui, repo, expand, *pats, **opts):
     '''Selects files and passes them to kwtemplater.overwrite.'''
     wctx = repo[None]
     if len(wctx.parents()) > 1:
         raise util.Abort(_('outstanding uncommitted merge'))
     kwt = kwtools['templater']
     wlock = repo.wlock()
     try:
         status = _status(ui, repo, kwt, *pats, **opts)
         modified, added, removed, deleted, unknown, ignored, clean = status
         if modified or added or removed or deleted:
             raise util.Abort(_('outstanding uncommitted changes'))
         kwt.overwrite(wctx, clean, True, expand)
     finally:
         wlock.release()
 
 @command('kwdemo',
          [('d', 'default', None, _('show default keyword template maps')),
           ('f', 'rcfile', '',
            _('read maps from rcfile'), _('FILE'))],
          _('hg kwdemo [-d] [-f RCFILE] [TEMPLATEMAP]...'))
 def demo(ui, repo, *args, **opts):
     '''print [keywordmaps] configuration and an expansion example
 
     Show current, custom, or default keyword template maps and their
     expansions.
 
     Extend the current configuration by specifying maps as arguments
     and using -f/--rcfile to source an external hgrc file.
 
     Use -d/--default to disable current configuration.
 
     See :hg:`help templates` for information on templates and filters.
     '''
     def demoitems(section, items):
         ui.write('[%s]\n' % section)
         for k, v in sorted(items):
             ui.write('%s = %s\n' % (k, v))
 
     fn = 'demo.txt'
     tmpdir = tempfile.mkdtemp('', 'kwdemo.')
     ui.note(_('creating temporary repository at %s\n') % tmpdir)
     repo = localrepo.localrepository(ui, tmpdir, True)
     ui.setconfig('keyword', fn, '')
     svn = ui.configbool('keywordset', 'svn')
     # explicitly set keywordset for demo output
     ui.setconfig('keywordset', 'svn', svn)
 
     uikwmaps = ui.configitems('keywordmaps')
     if args or opts.get('rcfile'):
         ui.status(_('\n\tconfiguration using custom keyword template maps\n'))
         if uikwmaps:
             ui.status(_('\textending current template maps\n'))
         if opts.get('default') or not uikwmaps:
             if svn:
                 ui.status(_('\toverriding default svn keywordset\n'))
             else:
                 ui.status(_('\toverriding default cvs keywordset\n'))
         if opts.get('rcfile'):
             ui.readconfig(opts.get('rcfile'))
         if args:
             # simulate hgrc parsing
             rcmaps = ['[keywordmaps]\n'] + [a + '\n' for a in args]
             fp = repo.opener('hgrc', 'w')
             fp.writelines(rcmaps)
             fp.close()
             ui.readconfig(repo.join('hgrc'))
         kwmaps = dict(ui.configitems('keywordmaps'))
     elif opts.get('default'):
         if svn:
             ui.status(_('\n\tconfiguration using default svn keywordset\n'))
         else:
             ui.status(_('\n\tconfiguration using default cvs keywordset\n'))
         kwmaps = _defaultkwmaps(ui)
         if uikwmaps:
             ui.status(_('\tdisabling current template maps\n'))
             for k, v in kwmaps.iteritems():
                 ui.setconfig('keywordmaps', k, v)
     else:
         ui.status(_('\n\tconfiguration using current keyword template maps\n'))
         kwmaps = dict(uikwmaps) or _defaultkwmaps(ui)
 
     uisetup(ui)
     reposetup(ui, repo)
     ui.write('[extensions]\nkeyword =\n')
     demoitems('keyword', ui.configitems('keyword'))
     demoitems('keywordset', ui.configitems('keywordset'))
     demoitems('keywordmaps', kwmaps.iteritems())
     keywords = '$' + '$\n$'.join(sorted(kwmaps.keys())) + '$\n'
     repo.wopener.write(fn, keywords)
     repo[None].add([fn])
     ui.note(_('\nkeywords written to %s:\n') % fn)
     ui.note(keywords)
     repo.dirstate.setbranch('demobranch')
     for name, cmd in ui.configitems('hooks'):
         if name.split('.', 1)[0].find('commit') > -1:
             repo.ui.setconfig('hooks', name, '')
     msg = _('hg keyword configuration and expansion example')
     ui.note("hg ci -m '%s'\n" % msg)
     repo.commit(text=msg)
     ui.status(_('\n\tkeywords expanded\n'))
     ui.write(repo.wread(fn))
     shutil.rmtree(tmpdir, ignore_errors=True)
 
 @command('kwexpand', commands.walkopts, _('hg kwexpand [OPTION]... [FILE]...'))
 def expand(ui, repo, *pats, **opts):
     '''expand keywords in the working directory
 
     Run after (re)enabling keyword expansion.
 
     kwexpand refuses to run if given files contain local changes.
     '''
     # 3rd argument sets expansion to True
     _kwfwrite(ui, repo, True, *pats, **opts)
 
 @command('kwfiles',
          [('A', 'all', None, _('show keyword status flags of all files')),
           ('i', 'ignore', None, _('show files excluded from expansion')),
           ('u', 'unknown', None, _('only show unknown (not tracked) files')),
          ] + commands.walkopts,
          _('hg kwfiles [OPTION]... [FILE]...'))
 def files(ui, repo, *pats, **opts):
     '''show files configured for keyword expansion
 
     List which files in the working directory are matched by the
     [keyword] configuration patterns.
 
     Useful to prevent inadvertent keyword expansion and to speed up
     execution by including only files that are actual candidates for
     expansion.
 
     See :hg:`help keyword` on how to construct patterns both for
     inclusion and exclusion of files.
 
     With -A/--all and -v/--verbose the codes used to show the status
     of files are::
 
       K = keyword expansion candidate
       k = keyword expansion candidate (not tracked)
       I = ignored
       i = ignored (not tracked)
     '''
     kwt = kwtools['templater']
     status = _status(ui, repo, kwt, *pats, **opts)
     cwd = pats and repo.getcwd() or ''
     modified, added, removed, deleted, unknown, ignored, clean = status
     files = []
     if not opts.get('unknown') or opts.get('all'):
         files = sorted(modified + added + clean)
     wctx = repo[None]
     kwfiles = kwt.iskwfile(files, wctx)
     kwdeleted = kwt.iskwfile(deleted, wctx)
     kwunknown = kwt.iskwfile(unknown, wctx)
     if not opts.get('ignore') or opts.get('all'):
         showfiles = kwfiles, kwdeleted, kwunknown
     else:
         showfiles = [], [], []
     if opts.get('all') or opts.get('ignore'):
         showfiles += ([f for f in files if f not in kwfiles],
                       [f for f in unknown if f not in kwunknown])
     kwlabels = 'enabled deleted enabledunknown ignored ignoredunknown'.split()
     kwstates = zip('K!kIi', showfiles, kwlabels)
     for char, filenames, kwstate in kwstates:
         fmt = (opts.get('all') or ui.verbose) and '%s %%s\n' % char or '%s\n'
         for f in filenames:
             ui.write(fmt % repo.pathto(f, cwd), label='kwfiles.' + kwstate)
 
 @command('kwshrink', commands.walkopts, _('hg kwshrink [OPTION]... [FILE]...'))
 def shrink(ui, repo, *pats, **opts):
     '''revert expanded keywords in the working directory
 
     Must be run before changing/disabling active keywords.
 
     kwshrink refuses to run if given files contain local changes.
     '''
     # 3rd argument sets expansion to False
     _kwfwrite(ui, repo, False, *pats, **opts)
 
 
 def uisetup(ui):
     ''' Monkeypatches dispatch._parse to retrieve user command.'''
 
     def kwdispatch_parse(orig, ui, args):
         '''Monkeypatch dispatch._parse to obtain running hg command.'''
         cmd, func, args, options, cmdoptions = orig(ui, args)
         kwtools['hgcmd'] = cmd
         return cmd, func, args, options, cmdoptions
 
     extensions.wrapfunction(dispatch, '_parse', kwdispatch_parse)
 
 def reposetup(ui, repo):
     '''Sets up repo as kwrepo for keyword substitution.
     Overrides file method to return kwfilelog instead of filelog
     if file matches user configuration.
     Wraps commit to overwrite configured files with updated
     keyword substitutions.
     Monkeypatches patch and webcommands.'''
 
     try:
         if (not repo.local() or kwtools['hgcmd'] in nokwcommands.split()
             or '.hg' in util.splitpath(repo.root)
             or repo._url.startswith('bundle:')):
             return
     except AttributeError:
         pass
 
     inc, exc = [], ['.hg*']
     for pat, opt in ui.configitems('keyword'):
         if opt != 'ignore':
             inc.append(pat)
         else:
             exc.append(pat)
     if not inc:
         return
 
     kwtools['templater'] = kwt = kwtemplater(ui, repo, inc, exc)
 
     class kwrepo(repo.__class__):
         def file(self, f):
             if f[0] == '/':
                 f = f[1:]
             return kwfilelog(self.sopener, kwt, f)
 
         def wread(self, filename):
             data = super(kwrepo, self).wread(filename)
             return kwt.wread(filename, data)
 
         def commit(self, *args, **opts):
             # use custom commitctx for user commands
             # other extensions can still wrap repo.commitctx directly
             self.commitctx = self.kwcommitctx
             try:
                 return super(kwrepo, self).commit(*args, **opts)
             finally:
                 del self.commitctx
 
         def kwcommitctx(self, ctx, error=False):
             n = super(kwrepo, self).commitctx(ctx, error)
             # no lock needed, only called from repo.commit() which already locks
             if not kwt.record:
                 restrict = kwt.restrict
                 kwt.restrict = True
                 kwt.overwrite(self[n], sorted(ctx.added() + ctx.modified()),
                               False, True)
                 kwt.restrict = restrict
             return n
 
         def rollback(self, dryrun=False):
             wlock = self.wlock()
             try:
                 if not dryrun:
                     changed = self['.'].files()
                 ret = super(kwrepo, self).rollback(dryrun)
                 if not dryrun:
                     ctx = self['.']
                     modified, added = _preselect(self[None].status(), changed)
                     kwt.overwrite(ctx, modified, True, True)
                     kwt.overwrite(ctx, added, True, False)
                 return ret
             finally:
                 wlock.release()
 
     # monkeypatches
-    def kwpatchfile_init(orig, self, ui, fname, backend, mode, create, remove,
-                         missing=False, eolmode=None):
+    def kwpatchfile_init(orig, self, ui, fname, backend, store, mode, create,
+                         remove, eolmode=None, copysource=None):
         '''Monkeypatch/wrap patch.patchfile.__init__ to avoid
         rejects or conflicts due to expanded keywords in working dir.'''
-        orig(self, ui, fname, backend, mode, create, remove, missing, eolmode)
+        orig(self, ui, fname, backend, store, mode, create, remove,
+             eolmode, copysource)
         # shrink keywords read from working dir
         self.lines = kwt.shrinklines(self.fname, self.lines)
 
     def kw_diff(orig, repo, node1=None, node2=None, match=None, changes=None,
                 opts=None, prefix=''):
         '''Monkeypatch patch.diff to avoid expansion.'''
         kwt.restrict = True
         return orig(repo, node1, node2, match, changes, opts, prefix)
 
     def kwweb_skip(orig, web, req, tmpl):
         '''Wraps webcommands.x turning off keyword expansion.'''
         kwt.match = util.never
         return orig(web, req, tmpl)
 
     def kw_copy(orig, ui, repo, pats, opts, rename=False):
         '''Wraps cmdutil.copy so that copy/rename destinations do not
         contain expanded keywords.
         Note that the source of a regular file destination may also be a
         symlink:
         hg cp sym x                -> x is symlink
         cp sym x; hg cp -A sym x   -> x is file (maybe expanded keywords)
         For the latter we have to follow the symlink to find out whether its
         target is configured for expansion and we therefore must unexpand the
         keywords in the destination.'''
         orig(ui, repo, pats, opts, rename)
         if opts.get('dry_run'):
             return
         wctx = repo[None]
         cwd = repo.getcwd()
 
         def haskwsource(dest):
             '''Returns true if dest is a regular file and configured for
             expansion or a symlink which points to a file configured for
             expansion. '''
             source = repo.dirstate.copied(dest)
             if 'l' in wctx.flags(source):
                 source = scmutil.canonpath(repo.root, cwd,
                                            os.path.realpath(source))
             return kwt.match(source)
 
         candidates = [f for f in repo.dirstate.copies() if
                       not 'l' in wctx.flags(f) and haskwsource(f)]
         kwt.overwrite(wctx, candidates, False, False)
 
     def kw_dorecord(orig, ui, repo, commitfunc, *pats, **opts):
         '''Wraps record.dorecord expanding keywords after recording.'''
         wlock = repo.wlock()
         try:
             # record returns 0 even when nothing has changed
             # therefore compare nodes before and after
             kwt.record = True
             ctx = repo['.']
             wstatus = repo[None].status()
             ret = orig(ui, repo, commitfunc, *pats, **opts)
             recctx = repo['.']
             if ctx != recctx:
                 modified, added = _preselect(wstatus, recctx.files())
                 kwt.restrict = False
                 kwt.overwrite(recctx, modified, False, True)
                 kwt.overwrite(recctx, added, False, True, True)
                 kwt.restrict = True
             return ret
         finally:
             wlock.release()
 
     def kwfilectx_cmp(orig, self, fctx):
         # keyword affects data size, comparing wdir and filelog size does
         # not make sense
         if (fctx._filerev is None and
             (self._repo._encodefilterpats or
              kwt.match(fctx.path()) and not 'l' in fctx.flags()) or
             self.size() == fctx.size()):
             return self._filelog.cmp(self._filenode, fctx.data())
         return True
 
     extensions.wrapfunction(context.filectx, 'cmp', kwfilectx_cmp)
     extensions.wrapfunction(patch.patchfile, '__init__', kwpatchfile_init)
     extensions.wrapfunction(patch, 'diff', kw_diff)
     extensions.wrapfunction(cmdutil, 'copy', kw_copy)
     for c in 'annotate changeset rev filediff diff'.split():
         extensions.wrapfunction(webcommands, c, kwweb_skip)
     for name in recordextensions.split():
         try:
             record = extensions.find(name)
             extensions.wrapfunction(record, 'dorecord', kw_dorecord)
         except KeyError:
             pass
 
     repo.__class__ = kwrepo

mercurial/patch.py

@@ -1,1751 +1,1780 b''
 # patch.py - patch file parsing routines
 #
 # Copyright 2006 Brendan Cully <[e-mail]>
 # Copyright 2007 Chris Mason <[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.
 
 import cStringIO, email.Parser, os, errno, re
-import tempfile, zlib
+import tempfile, zlib, shutil
 
 from i18n import _
 from node import hex, nullid, short
 import base85, mdiff, scmutil, util, diffhelpers, copies, encoding
 
 gitre = re.compile('diff --git a/(.*) b/(.*)')
 
 class PatchError(Exception):
     pass
 
 
 # public functions
 
 def split(stream):
     '''return an iterator of individual patches from a stream'''
     def isheader(line, inheader):
         if inheader and line[0] in (' ', '\t'):
             # continuation
             return True
         if line[0] in (' ', '-', '+'):
             # diff line - don't check for header pattern in there
             return False
         l = line.split(': ', 1)
         return len(l) == 2 and ' ' not in l[0]
 
     def chunk(lines):
         return cStringIO.StringIO(''.join(lines))
 
     def hgsplit(stream, cur):
         inheader = True
 
         for line in stream:
             if not line.strip():
                 inheader = False
             if not inheader and line.startswith('# HG changeset patch'):
                 yield chunk(cur)
                 cur = []
                 inheader = True
 
             cur.append(line)
 
         if cur:
             yield chunk(cur)
 
     def mboxsplit(stream, cur):
         for line in stream:
             if line.startswith('From '):
                 for c in split(chunk(cur[1:])):
                     yield c
                 cur = []
 
             cur.append(line)
 
         if cur:
             for c in split(chunk(cur[1:])):
                 yield c
 
     def mimesplit(stream, cur):
         def msgfp(m):
             fp = cStringIO.StringIO()
             g = email.Generator.Generator(fp, mangle_from_=False)
             g.flatten(m)
             fp.seek(0)
             return fp
 
         for line in stream:
             cur.append(line)
         c = chunk(cur)
 
         m = email.Parser.Parser().parse(c)
         if not m.is_multipart():
             yield msgfp(m)
         else:
             ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
             for part in m.walk():
                 ct = part.get_content_type()
                 if ct not in ok_types:
                     continue
                 yield msgfp(part)
 
     def headersplit(stream, cur):
         inheader = False
 
         for line in stream:
             if not inheader and isheader(line, inheader):
                 yield chunk(cur)
                 cur = []
                 inheader = True
             if inheader and not isheader(line, inheader):
                 inheader = False
 
             cur.append(line)
 
         if cur:
             yield chunk(cur)
 
     def remainder(cur):
         yield chunk(cur)
 
     class fiter(object):
         def __init__(self, fp):
             self.fp = fp
 
         def __iter__(self):
             return self
 
         def next(self):
             l = self.fp.readline()
             if not l:
                 raise StopIteration
             return l
 
     inheader = False
     cur = []
 
     mimeheaders = ['content-type']
 
     if not hasattr(stream, 'next'):
         # http responses, for example, have readline but not next
         stream = fiter(stream)
 
     for line in stream:
         cur.append(line)
         if line.startswith('# HG changeset patch'):
             return hgsplit(stream, cur)
         elif line.startswith('From '):
             return mboxsplit(stream, cur)
         elif isheader(line, inheader):
             inheader = True
             if line.split(':', 1)[0].lower() in mimeheaders:
                 # let email parser handle this
                 return mimesplit(stream, cur)
         elif line.startswith('--- ') and inheader:
             # No evil headers seen by diff start, split by hand
             return headersplit(stream, cur)
         # Not enough info, keep reading
 
     # if we are here, we have a very plain patch
     return remainder(cur)
 
 def extract(ui, fileobj):
     '''extract patch from data read from fileobj.
 
     patch can be a normal patch or contained in an email message.
 
     return tuple (filename, message, user, date, branch, node, p1, p2).
     Any item in the returned tuple can be None. If filename is None,
     fileobj did not contain a patch. Caller must unlink filename when done.'''
 
     # attempt to detect the start of a patch
     # (this heuristic is borrowed from quilt)
     diffre = re.compile(r'^(?:Index:[ \t]|diff[ \t]|RCS file: |'
                         r'retrieving revision [0-9]+(\.[0-9]+)*$|'
                         r'---[ \t].*?^\+\+\+[ \t]|'
                         r'\*\*\*[ \t].*?^---[ \t])', re.MULTILINE|re.DOTALL)
 
     fd, tmpname = tempfile.mkstemp(prefix='hg-patch-')
     tmpfp = os.fdopen(fd, 'w')
     try:
         msg = email.Parser.Parser().parse(fileobj)
 
         subject = msg['Subject']
         user = msg['From']
         if not subject and not user:
             # Not an email, restore parsed headers if any
             subject = '\n'.join(': '.join(h) for h in msg.items()) + '\n'
 
         gitsendmail = 'git-send-email' in msg.get('X-Mailer', '')
         # should try to parse msg['Date']
         date = None
         nodeid = None
         branch = None
         parents = []
 
         if subject:
             if subject.startswith('[PATCH'):
                 pend = subject.find(']')
                 if pend >= 0:
                     subject = subject[pend + 1:].lstrip()
             subject = subject.replace('\n\t', ' ')
             ui.debug('Subject: %s\n' % subject)
         if user:
             ui.debug('From: %s\n' % user)
         diffs_seen = 0
         ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
         message = ''
         for part in msg.walk():
             content_type = part.get_content_type()
             ui.debug('Content-Type: %s\n' % content_type)
             if content_type not in ok_types:
                 continue
             payload = part.get_payload(decode=True)
             m = diffre.search(payload)
             if m:
                 hgpatch = False
                 hgpatchheader = False
                 ignoretext = False
 
                 ui.debug('found patch at byte %d\n' % m.start(0))
                 diffs_seen += 1
                 cfp = cStringIO.StringIO()
                 for line in payload[:m.start(0)].splitlines():
                     if line.startswith('# HG changeset patch') and not hgpatch:
                         ui.debug('patch generated by hg export\n')
                         hgpatch = True
                         hgpatchheader = True
                         # drop earlier commit message content
                         cfp.seek(0)
                         cfp.truncate()
                         subject = None
                     elif hgpatchheader:
                         if line.startswith('# User '):
                             user = line[7:]
                             ui.debug('From: %s\n' % user)
                         elif line.startswith("# Date "):
                             date = line[7:]
                         elif line.startswith("# Branch "):
                             branch = line[9:]
                         elif line.startswith("# Node ID "):
                             nodeid = line[10:]
                         elif line.startswith("# Parent "):
                             parents.append(line[10:])
                         elif not line.startswith("# "):
                             hgpatchheader = False
                     elif line == '---' and gitsendmail:
                         ignoretext = True
                     if not hgpatchheader and not ignoretext:
                         cfp.write(line)
                         cfp.write('\n')
                 message = cfp.getvalue()
                 if tmpfp:
                     tmpfp.write(payload)
                     if not payload.endswith('\n'):
                         tmpfp.write('\n')
             elif not diffs_seen and message and content_type == 'text/plain':
                 message += '\n' + payload
     except:
         tmpfp.close()
         os.unlink(tmpname)
         raise
 
     if subject and not message.startswith(subject):
         message = '%s\n%s' % (subject, message)
     tmpfp.close()
     if not diffs_seen:
         os.unlink(tmpname)
         return None, message, user, date, branch, None, None, None
     p1 = parents and parents.pop(0) or None
     p2 = parents and parents.pop(0) or None
     return tmpname, message, user, date, branch, nodeid, p1, p2
 
 class patchmeta(object):
     """Patched file metadata
 
     'op' is the performed operation within ADD, DELETE, RENAME, MODIFY
     or COPY.  'path' is patched file path. 'oldpath' is set to the
     origin file when 'op' is either COPY or RENAME, None otherwise. If
     file mode is changed, 'mode' is a tuple (islink, isexec) where
     'islink' is True if the file is a symlink and 'isexec' is True if
     the file is executable. Otherwise, 'mode' is None.
     """
     def __init__(self, path):
         self.path = path
         self.oldpath = None
         self.mode = None
         self.op = 'MODIFY'
         self.binary = False
 
     def setmode(self, mode):
         islink = mode & 020000
         isexec = mode & 0100
         self.mode = (islink, isexec)
 
     def __repr__(self):
         return "<patchmeta %s %r>" % (self.op, self.path)
 
 def readgitpatch(lr):
     """extract git-style metadata about patches from <patchname>"""
 
     # Filter patch for git information
     gp = None
     gitpatches = []
     for line in lr:
         line = line.rstrip(' \r\n')
         if line.startswith('diff --git'):
             m = gitre.match(line)
             if m:
                 if gp:
                     gitpatches.append(gp)
                 dst = m.group(2)
                 gp = patchmeta(dst)
         elif gp:
             if line.startswith('--- '):
                 gitpatches.append(gp)
                 gp = None
                 continue
             if line.startswith('rename from '):
                 gp.op = 'RENAME'
                 gp.oldpath = line[12:]
             elif line.startswith('rename to '):
                 gp.path = line[10:]
             elif line.startswith('copy from '):
                 gp.op = 'COPY'
                 gp.oldpath = line[10:]
             elif line.startswith('copy to '):
                 gp.path = line[8:]
             elif line.startswith('deleted file'):
                 gp.op = 'DELETE'
             elif line.startswith('new file mode '):
                 gp.op = 'ADD'
                 gp.setmode(int(line[-6:], 8))
             elif line.startswith('new mode '):
                 gp.setmode(int(line[-6:], 8))
             elif line.startswith('GIT binary patch'):
                 gp.binary = True
     if gp:
         gitpatches.append(gp)
 
     return gitpatches
 
 class linereader(object):
     # simple class to allow pushing lines back into the input stream
     def __init__(self, fp):
         self.fp = fp
         self.buf = []
 
     def push(self, line):
         if line is not None:
             self.buf.append(line)
 
     def readline(self):
         if self.buf:
             l = self.buf[0]
             del self.buf[0]
             return l
         return self.fp.readline()
 
     def __iter__(self):
         while 1:
             l = self.readline()
             if not l:
                 break
             yield l
 
 class abstractbackend(object):
     def __init__(self, ui):
         self.ui = ui
 
     def getfile(self, fname):
         """Return target file data and flags as a (data, (islink,
         isexec)) tuple.
         """
         raise NotImplementedError
 
-    def setfile(self, fname, data, mode):
+    def setfile(self, fname, data, mode, copysource):
         """Write data to target file fname and set its mode. mode is a
         (islink, isexec) tuple. If data is None, the file content should
-        be left unchanged.
+        be left unchanged. If the file is modified after being copied,
+        copysource is set to the original file name.
         """
         raise NotImplementedError
 
     def unlink(self, fname):
         """Unlink target file."""
         raise NotImplementedError
 
     def writerej(self, fname, failed, total, lines):
         """Write rejected lines for fname. total is the number of hunks
         which failed to apply and total the total number of hunks for this
         files.
         """
         pass
 
-    def copy(self, src, dst):
-        """Copy src file into dst file. Create intermediate directories if
-        necessary. Files are specified relatively to the patching base
-        directory.
-        """
-        raise NotImplementedError
-
     def exists(self, fname):
         raise NotImplementedError
 
 class fsbackend(abstractbackend):
     def __init__(self, ui, basedir):
         super(fsbackend, self).__init__(ui)
         self.opener = scmutil.opener(basedir)
 
     def _join(self, f):
         return os.path.join(self.opener.base, f)
 
     def getfile(self, fname):
         path = self._join(fname)
         if os.path.islink(path):
             return (os.readlink(path), (True, False))
         isexec, islink = False, False
         try:
             isexec = os.lstat(path).st_mode & 0100 != 0
             islink = os.path.islink(path)
         except OSError, e:
             if e.errno != errno.ENOENT:
                 raise
         return (self.opener.read(fname), (islink, isexec))
 
-    def setfile(self, fname, data, mode):
+    def setfile(self, fname, data, mode, copysource):
         islink, isexec = mode
         if data is None:
             util.setflags(self._join(fname), islink, isexec)
             return
         if islink:
             self.opener.symlink(data, fname)
         else:
             self.opener.write(fname, data)
             if isexec:
                 util.setflags(self._join(fname), False, True)
 
     def unlink(self, fname):
         try:
             util.unlinkpath(self._join(fname))
         except OSError, inst:
             if inst.errno != errno.ENOENT:
                 raise
 
     def writerej(self, fname, failed, total, lines):
         fname = fname + ".rej"
         self.ui.warn(
             _("%d out of %d hunks FAILED -- saving rejects to file %s\n") %
             (failed, total, fname))
         fp = self.opener(fname, 'w')
         fp.writelines(lines)
         fp.close()
 
-    def copy(self, src, dst):
-        basedir = self.opener.base
-        abssrc, absdst = [scmutil.canonpath(basedir, basedir, x)
-                          for x in [src, dst]]
-        if os.path.lexists(absdst):
-            raise util.Abort(_("cannot create %s: destination already exists")
-                             % dst)
-        dstdir = os.path.dirname(absdst)
-        if dstdir and not os.path.isdir(dstdir):
-            try:
-                os.makedirs(dstdir)
-            except IOError:
-                raise util.Abort(
-                    _("cannot create %s: unable to create destination directory")
-                    % dst)
-        util.copyfile(abssrc, absdst)
-
     def exists(self, fname):
         return os.path.lexists(self._join(fname))
 
 class workingbackend(fsbackend):
     def __init__(self, ui, repo, similarity):
         super(workingbackend, self).__init__(ui, repo.root)
         self.repo = repo
         self.similarity = similarity
         self.removed = set()
         self.changed = set()
         self.copied = []
 
-    def setfile(self, fname, data, mode):
-        super(workingbackend, self).setfile(fname, data, mode)
+    def setfile(self, fname, data, mode, copysource):
+        super(workingbackend, self).setfile(fname, data, mode, copysource)
+        if copysource is not None:
+            self.copied.append((copysource, fname))
         self.changed.add(fname)
 
     def unlink(self, fname):
         super(workingbackend, self).unlink(fname)
         self.removed.add(fname)
         self.changed.add(fname)
 
-    def copy(self, src, dst):
-        super(workingbackend, self).copy(src, dst)
-        self.copied.append((src, dst))
-        self.changed.add(dst)
-
     def close(self):
         wctx = self.repo[None]
         addremoved = set(self.changed)
         for src, dst in self.copied:
             scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst)
             addremoved.discard(src)
         if (not self.similarity) and self.removed:
             wctx.forget(sorted(self.removed))
         if addremoved:
             cwd = self.repo.getcwd()
             if cwd:
                 addremoved = [util.pathto(self.repo.root, cwd, f)
                               for f in addremoved]
             scmutil.addremove(self.repo, addremoved, similarity=self.similarity)
         return sorted(self.changed)
 
+class filestore(object):
+    def __init__(self):
+        self.opener = None
+        self.files = {}
+        self.created = 0
+
+    def setfile(self, fname, data, mode):
+        if self.opener is None:
+            root = tempfile.mkdtemp(prefix='hg-patch-')
+            self.opener = scmutil.opener(root)
+        # Avoid filename issues with these simple names
+        fn = str(self.created)
+        self.opener.write(fn, data)
+        self.created += 1
+        self.files[fname] = (fn, mode)
+
+    def getfile(self, fname):
+        if fname not in self.files:
+            raise IOError()
+        fn, mode = self.files[fname]
+        return self.opener.read(fn), mode
+
+    def close(self):
+        if self.opener:
+            shutil.rmtree(self.opener.base)
+
 # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
 unidesc = re.compile('@@ -(\d+)(,(\d+))? \+(\d+)(,(\d+))? @@')
 contextdesc = re.compile('(---|\*\*\*) (\d+)(,(\d+))? (---|\*\*\*)')
 eolmodes = ['strict', 'crlf', 'lf', 'auto']
 
 class patchfile(object):
-    def __init__(self, ui, fname, backend, mode, create, remove, missing=False,
-                 eolmode='strict'):
+    def __init__(self, ui, fname, backend, store, mode, create, remove,
+                 eolmode='strict', copysource=None):
         self.fname = fname
         self.eolmode = eolmode
         self.eol = None
         self.backend = backend
         self.ui = ui
         self.lines = []
         self.exists = False
-        self.missing = missing
+        self.missing = True
         self.mode = mode
+        self.copysource = copysource
         self.create = create
         self.remove = remove
-        if not missing:
             try:
-                data, mode = self.backend.getfile(fname)
+            if copysource is None:
+                data, mode = backend.getfile(fname)
+                self.exists = True
+            else:
+                data, mode = store.getfile(copysource)
+                self.exists = backend.exists(fname)
+            self.missing = False
                 if data:
                     self.lines = data.splitlines(True)
                 if self.mode is None:
                     self.mode = mode
                 if self.lines:
                     # Normalize line endings
                     if self.lines[0].endswith('\r\n'):
                         self.eol = '\r\n'
                     elif self.lines[0].endswith('\n'):
                         self.eol = '\n'
                     if eolmode != 'strict':
                         nlines = []
                         for l in self.lines:
                             if l.endswith('\r\n'):
                                 l = l[:-2] + '\n'
                             nlines.append(l)
                         self.lines = nlines
-                self.exists = True
             except IOError:
+            if create:
+                self.missing = False
                 if self.mode is None:
                     self.mode = (False, False)
-        else:
+        if self.missing:
             self.ui.warn(_("unable to find '%s' for patching\n") % self.fname)
 
         self.hash = {}
         self.dirty = 0
         self.offset = 0
         self.skew = 0
         self.rej = []
         self.fileprinted = False
         self.printfile(False)
         self.hunks = 0
 
     def writelines(self, fname, lines, mode):
         if self.eolmode == 'auto':
             eol = self.eol
         elif self.eolmode == 'crlf':
             eol = '\r\n'
         else:
             eol = '\n'
 
         if self.eolmode != 'strict' and eol and eol != '\n':
             rawlines = []
             for l in lines:
                 if l and l[-1] == '\n':
                     l = l[:-1] + eol
                 rawlines.append(l)
             lines = rawlines
 
-        self.backend.setfile(fname, ''.join(lines), mode)
+        self.backend.setfile(fname, ''.join(lines), mode, self.copysource)
 
     def printfile(self, warn):
         if self.fileprinted:
             return
         if warn or self.ui.verbose:
             self.fileprinted = True
         s = _("patching file %s\n") % self.fname
         if warn:
             self.ui.warn(s)
         else:
             self.ui.note(s)
 
 
     def findlines(self, l, linenum):
         # looks through the hash and finds candidate lines.  The
         # result is a list of line numbers sorted based on distance
         # from linenum
 
         cand = self.hash.get(l, [])
         if len(cand) > 1:
             # resort our list of potentials forward then back.
             cand.sort(key=lambda x: abs(x - linenum))
         return cand
 
     def write_rej(self):
         # our rejects are a little different from patch(1).  This always
         # creates rejects in the same form as the original patch.  A file
         # header is inserted so that you can run the reject through patch again
         # without having to type the filename.
         if not self.rej:
             return
         base = os.path.basename(self.fname)
         lines = ["--- %s\n+++ %s\n" % (base, base)]
         for x in self.rej:
             for l in x.hunk:
                 lines.append(l)
                 if l[-1] != '\n':
                     lines.append("\n\ No newline at end of file\n")
         self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)
 
     def apply(self, h):
         if not h.complete():
             raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %
                             (h.number, h.desc, len(h.a), h.lena, len(h.b),
                             h.lenb))
 
         self.hunks += 1
 
         if self.missing:
             self.rej.append(h)
             return -1
 
         if self.exists and self.create:
+            if self.copysource:
+                self.ui.warn(_("cannot create %s: destination already "
+                               "exists\n" % self.fname))
+            else:
             self.ui.warn(_("file %s already exists\n") % self.fname)
             self.rej.append(h)
             return -1
 
         if isinstance(h, binhunk):
             if self.remove:
                 self.backend.unlink(self.fname)
             else:
                 self.lines[:] = h.new()
                 self.offset += len(h.new())
                 self.dirty = True
             return 0
 
         horig = h
         if (self.eolmode in ('crlf', 'lf')
             or self.eolmode == 'auto' and self.eol):
             # If new eols are going to be normalized, then normalize
             # hunk data before patching. Otherwise, preserve input
             # line-endings.
             h = h.getnormalized()
 
         # fast case first, no offsets, no fuzz
         old = h.old()
         # patch starts counting at 1 unless we are adding the file
         if h.starta == 0:
             start = 0
         else:
             start = h.starta + self.offset - 1
         orig_start = start
         # if there's skew we want to emit the "(offset %d lines)" even
         # when the hunk cleanly applies at start + skew, so skip the
         # fast case code
         if self.skew == 0 and diffhelpers.testhunk(old, self.lines, start) == 0:
             if self.remove:
                 self.backend.unlink(self.fname)
             else:
                 self.lines[start : start + h.lena] = h.new()
                 self.offset += h.lenb - h.lena
                 self.dirty = True
             return 0
 
         # ok, we couldn't match the hunk. Lets look for offsets and fuzz it
         self.hash = {}
         for x, s in enumerate(self.lines):
             self.hash.setdefault(s, []).append(x)
         if h.hunk[-1][0] != ' ':
             # if the hunk tried to put something at the bottom of the file
             # override the start line and use eof here
             search_start = len(self.lines)
         else:
             search_start = orig_start + self.skew
 
         for fuzzlen in xrange(3):
             for toponly in [True, False]:
                 old = h.old(fuzzlen, toponly)
 
                 cand = self.findlines(old[0][1:], search_start)
                 for l in cand:
                     if diffhelpers.testhunk(old, self.lines, l) == 0:
                         newlines = h.new(fuzzlen, toponly)
                         self.lines[l : l + len(old)] = newlines
                         self.offset += len(newlines) - len(old)
                         self.skew = l - orig_start
                         self.dirty = True
                         offset = l - orig_start - fuzzlen
                         if fuzzlen:
                             msg = _("Hunk #%d succeeded at %d "
                                     "with fuzz %d "
                                     "(offset %d lines).\n")
                             self.printfile(True)
                             self.ui.warn(msg %
                                 (h.number, l + 1, fuzzlen, offset))
                         else:
                             msg = _("Hunk #%d succeeded at %d "
                                     "(offset %d lines).\n")
                             self.ui.note(msg % (h.number, l + 1, offset))
                         return fuzzlen
         self.printfile(True)
         self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))
         self.rej.append(horig)
         return -1
 
     def close(self):
         if self.dirty:
             self.writelines(self.fname, self.lines, self.mode)
         self.write_rej()
         return len(self.rej)
 
 class hunk(object):
     def __init__(self, desc, num, lr, context):
         self.number = num
         self.desc = desc
         self.hunk = [desc]
         self.a = []
         self.b = []
         self.starta = self.lena = None
         self.startb = self.lenb = None
         if lr is not None:
             if context:
                 self.read_context_hunk(lr)
             else:
                 self.read_unified_hunk(lr)
 
     def getnormalized(self):
         """Return a copy with line endings normalized to LF."""
 
         def normalize(lines):
             nlines = []
             for line in lines:
                 if line.endswith('\r\n'):
                     line = line[:-2] + '\n'
                 nlines.append(line)
             return nlines
 
         # Dummy object, it is rebuilt manually
         nh = hunk(self.desc, self.number, None, None)
         nh.number = self.number
         nh.desc = self.desc
         nh.hunk = self.hunk
         nh.a = normalize(self.a)
         nh.b = normalize(self.b)
         nh.starta = self.starta
         nh.startb = self.startb
         nh.lena = self.lena
         nh.lenb = self.lenb
         return nh
 
     def read_unified_hunk(self, lr):
         m = unidesc.match(self.desc)
         if not m:
             raise PatchError(_("bad hunk #%d") % self.number)
         self.starta, foo, self.lena, self.startb, foo2, self.lenb = m.groups()
         if self.lena is None:
             self.lena = 1
         else:
             self.lena = int(self.lena)
         if self.lenb is None:
             self.lenb = 1
         else:
             self.lenb = int(self.lenb)
         self.starta = int(self.starta)
         self.startb = int(self.startb)
         diffhelpers.addlines(lr, self.hunk, self.lena, self.lenb, self.a, self.b)
         # if we hit eof before finishing out the hunk, the last line will
         # be zero length.  Lets try to fix it up.
         while len(self.hunk[-1]) == 0:
             del self.hunk[-1]
             del self.a[-1]
             del self.b[-1]
             self.lena -= 1
             self.lenb -= 1
         self._fixnewline(lr)
 
     def read_context_hunk(self, lr):
         self.desc = lr.readline()
         m = contextdesc.match(self.desc)
         if not m:
             raise PatchError(_("bad hunk #%d") % self.number)
         foo, self.starta, foo2, aend, foo3 = m.groups()
         self.starta = int(self.starta)
         if aend is None:
             aend = self.starta
         self.lena = int(aend) - self.starta
         if self.starta:
             self.lena += 1
         for x in xrange(self.lena):
             l = lr.readline()
             if l.startswith('---'):
                 # lines addition, old block is empty
                 lr.push(l)
                 break
             s = l[2:]
             if l.startswith('- ') or l.startswith('! '):
                 u = '-' + s
             elif l.startswith('  '):
                 u = ' ' + s
             else:
                 raise PatchError(_("bad hunk #%d old text line %d") %
                                  (self.number, x))
             self.a.append(u)
             self.hunk.append(u)
 
         l = lr.readline()
         if l.startswith('\ '):
             s = self.a[-1][:-1]
             self.a[-1] = s
             self.hunk[-1] = s
             l = lr.readline()
         m = contextdesc.match(l)
         if not m:
             raise PatchError(_("bad hunk #%d") % self.number)
         foo, self.startb, foo2, bend, foo3 = m.groups()
         self.startb = int(self.startb)
         if bend is None:
             bend = self.startb
         self.lenb = int(bend) - self.startb
         if self.startb:
             self.lenb += 1
         hunki = 1
         for x in xrange(self.lenb):
             l = lr.readline()
             if l.startswith('\ '):
                 # XXX: the only way to hit this is with an invalid line range.
                 # The no-eol marker is not counted in the line range, but I
                 # guess there are diff(1) out there which behave differently.
                 s = self.b[-1][:-1]
                 self.b[-1] = s
                 self.hunk[hunki - 1] = s
                 continue
             if not l:
                 # line deletions, new block is empty and we hit EOF
                 lr.push(l)
                 break
             s = l[2:]
             if l.startswith('+ ') or l.startswith('! '):
                 u = '+' + s
             elif l.startswith('  '):
                 u = ' ' + s
             elif len(self.b) == 0:
                 # line deletions, new block is empty
                 lr.push(l)
                 break
             else:
                 raise PatchError(_("bad hunk #%d old text line %d") %
                                  (self.number, x))
             self.b.append(s)
             while True:
                 if hunki >= len(self.hunk):
                     h = ""
                 else:
                     h = self.hunk[hunki]
                 hunki += 1
                 if h == u:
                     break
                 elif h.startswith('-'):
                     continue
                 else:
                     self.hunk.insert(hunki - 1, u)
                     break
 
         if not self.a:
             # this happens when lines were only added to the hunk
             for x in self.hunk:
                 if x.startswith('-') or x.startswith(' '):
                     self.a.append(x)
         if not self.b:
             # this happens when lines were only deleted from the hunk
             for x in self.hunk:
                 if x.startswith('+') or x.startswith(' '):
                     self.b.append(x[1:])
         # @@ -start,len +start,len @@
         self.desc = "@@ -%d,%d +%d,%d @@\n" % (self.starta, self.lena,
                                              self.startb, self.lenb)
         self.hunk[0] = self.desc
         self._fixnewline(lr)
 
     def _fixnewline(self, lr):
         l = lr.readline()
         if l.startswith('\ '):
             diffhelpers.fix_newline(self.hunk, self.a, self.b)
         else:
             lr.push(l)
 
     def complete(self):
         return len(self.a) == self.lena and len(self.b) == self.lenb
 
     def fuzzit(self, l, fuzz, toponly):
         # this removes context lines from the top and bottom of list 'l'.  It
         # checks the hunk to make sure only context lines are removed, and then
         # returns a new shortened list of lines.
         fuzz = min(fuzz, len(l)-1)
         if fuzz:
             top = 0
             bot = 0
             hlen = len(self.hunk)
             for x in xrange(hlen - 1):
                 # the hunk starts with the @@ line, so use x+1
                 if self.hunk[x + 1][0] == ' ':
                     top += 1
                 else:
                     break
             if not toponly:
                 for x in xrange(hlen - 1):
                     if self.hunk[hlen - bot - 1][0] == ' ':
                         bot += 1
                     else:
                         break
 
             # top and bot now count context in the hunk
             # adjust them if either one is short
             context = max(top, bot, 3)
             if bot < context:
                 bot = max(0, fuzz - (context - bot))
             else:
                 bot = min(fuzz, bot)
             if top < context:
                 top = max(0, fuzz - (context - top))
             else:
                 top = min(fuzz, top)
 
             return l[top:len(l)-bot]
         return l
 
     def old(self, fuzz=0, toponly=False):
         return self.fuzzit(self.a, fuzz, toponly)
 
     def new(self, fuzz=0, toponly=False):
         return self.fuzzit(self.b, fuzz, toponly)
 
 class binhunk:
     'A binary patch file. Only understands literals so far.'
     def __init__(self, lr):
         self.text = None
         self.hunk = ['GIT binary patch\n']
         self._read(lr)
 
     def complete(self):
         return self.text is not None
 
     def new(self):
         return [self.text]
 
     def _read(self, lr):
         line = lr.readline()
         self.hunk.append(line)
         while line and not line.startswith('literal '):
             line = lr.readline()
             self.hunk.append(line)
         if not line:
             raise PatchError(_('could not extract binary patch'))
         size = int(line[8:].rstrip())
         dec = []
         line = lr.readline()
         self.hunk.append(line)
         while len(line) > 1:
             l = line[0]
             if l <= 'Z' and l >= 'A':
                 l = ord(l) - ord('A') + 1
             else:
                 l = ord(l) - ord('a') + 27
             dec.append(base85.b85decode(line[1:-1])[:l])
             line = lr.readline()
             self.hunk.append(line)
         text = zlib.decompress(''.join(dec))
         if len(text) != size:
             raise PatchError(_('binary patch is %d bytes, not %d') %
                              len(text), size)
         self.text = text
 
 def parsefilename(str):
     # --- filename \t|space stuff
     s = str[4:].rstrip('\r\n')
     i = s.find('\t')
     if i < 0:
         i = s.find(' ')
         if i < 0:
             return s
     return s[:i]
 
 def pathstrip(path, strip):
     pathlen = len(path)
     i = 0
     if strip == 0:
         return '', path.rstrip()
     count = strip
     while count > 0:
         i = path.find('/', i)
         if i == -1:
             raise PatchError(_("unable to strip away %d of %d dirs from %s") %
                              (count, strip, path))
         i += 1
         # consume '//' in the path
         while i < pathlen - 1 and path[i] == '/':
             i += 1
         count -= 1
     return path[:i].lstrip(), path[i:].rstrip()
 
 def selectfile(backend, afile_orig, bfile_orig, hunk, strip, gp):
     if gp:
         # Git patches do not play games. Excluding copies from the
         # following heuristic avoids a lot of confusion
         fname = pathstrip(gp.path, strip - 1)[1]
-        create = gp.op == 'ADD'
+        create = gp.op in ('ADD', 'COPY', 'RENAME')
         remove = gp.op == 'DELETE'
         missing = not create and not backend.exists(fname)
-        return fname, missing, create, remove
+        return fname, create, remove
     nulla = afile_orig == "/dev/null"
     nullb = bfile_orig == "/dev/null"
     create = nulla and hunk.starta == 0 and hunk.lena == 0
     remove = nullb and hunk.startb == 0 and hunk.lenb == 0
     abase, afile = pathstrip(afile_orig, strip)
     gooda = not nulla and backend.exists(afile)
     bbase, bfile = pathstrip(bfile_orig, strip)
     if afile == bfile:
         goodb = gooda
     else:
         goodb = not nullb and backend.exists(bfile)
     missing = not goodb and not gooda and not create
 
     # some diff programs apparently produce patches where the afile is
     # not /dev/null, but afile starts with bfile
     abasedir = afile[:afile.rfind('/') + 1]
     bbasedir = bfile[:bfile.rfind('/') + 1]
     if (missing and abasedir == bbasedir and afile.startswith(bfile)
         and hunk.starta == 0 and hunk.lena == 0):
         create = True
         missing = False
 
     # If afile is "a/b/foo" and bfile is "a/b/foo.orig" we assume the
     # diff is between a file and its backup. In this case, the original
     # file should be patched (see original mpatch code).
     isbackup = (abase == bbase and bfile.startswith(afile))
     fname = None
     if not missing:
         if gooda and goodb:
             fname = isbackup and afile or bfile
         elif gooda:
             fname = afile
 
     if not fname:
         if not nullb:
             fname = isbackup and afile or bfile
         elif not nulla:
             fname = afile
         else:
             raise PatchError(_("undefined source and destination files"))
 
-    return fname, missing, create, remove
+    return fname, create, remove
 
 def scangitpatch(lr, firstline):
     """
     Git patches can emit:
     - rename a to b
     - change b
     - copy a to c
     - change c
 
     We cannot apply this sequence as-is, the renamed 'a' could not be
     found for it would have been renamed already. And we cannot copy
     from 'b' instead because 'b' would have been changed already. So
     we scan the git patch for copy and rename commands so we can
     perform the copies ahead of time.
     """
     pos = 0
     try:
         pos = lr.fp.tell()
         fp = lr.fp
     except IOError:
         fp = cStringIO.StringIO(lr.fp.read())
     gitlr = linereader(fp)
     gitlr.push(firstline)
     gitpatches = readgitpatch(gitlr)
     fp.seek(pos)
     return gitpatches
 
 def iterhunks(fp):
     """Read a patch and yield the following events:
     - ("file", afile, bfile, firsthunk): select a new target file.
     - ("hunk", hunk): a new hunk is ready to be applied, follows a
     "file" event.
     - ("git", gitchanges): current diff is in git format, gitchanges
     maps filenames to gitpatch records. Unique event.
     """
     afile = ""
     bfile = ""
     state = None
     hunknum = 0
     emitfile = newfile = False
     gitpatches = None
 
     # our states
     BFILE = 1
     context = None
     lr = linereader(fp)
 
     while True:
         x = lr.readline()
         if not x:
             break
         if state == BFILE and (
             (not context and x[0] == '@')
             or (context is not False and x.startswith('***************'))
             or x.startswith('GIT binary patch')):
             gp = None
             if gitpatches and gitpatches[-1][0] == bfile:
                 gp = gitpatches.pop()[1]
             if x.startswith('GIT binary patch'):
                 h = binhunk(lr)
             else:
                 if context is None and x.startswith('***************'):
                     context = True
                 h = hunk(x, hunknum + 1, lr, context)
             hunknum += 1
             if emitfile:
                 emitfile = False
                 yield 'file', (afile, bfile, h, gp)
             yield 'hunk', h
         elif x.startswith('diff --git'):
             m = gitre.match(x)
             if not m:
                 continue
             if gitpatches is None:
                 # scan whole input for git metadata
                 gitpatches = [('b/' + gp.path, gp) for gp
                               in scangitpatch(lr, x)]
                 yield 'git', [g[1] for g in gitpatches
                               if g[1].op in ('COPY', 'RENAME')]
                 gitpatches.reverse()
             afile = 'a/' + m.group(1)
             bfile = 'b/' + m.group(2)
             while bfile != gitpatches[-1][0]:
                 gp = gitpatches.pop()[1]
                 yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp)
             gp = gitpatches[-1][1]
             # copy/rename + modify should modify target, not source
             if gp.op in ('COPY', 'DELETE', 'RENAME', 'ADD') or gp.mode:
                 afile = bfile
             newfile = True
         elif x.startswith('---'):
             # check for a unified diff
             l2 = lr.readline()
             if not l2.startswith('+++'):
                 lr.push(l2)
                 continue
             newfile = True
             context = False
             afile = parsefilename(x)
             bfile = parsefilename(l2)
         elif x.startswith('***'):
             # check for a context diff
             l2 = lr.readline()
             if not l2.startswith('---'):
                 lr.push(l2)
                 continue
             l3 = lr.readline()
             lr.push(l3)
             if not l3.startswith("***************"):
                 lr.push(l2)
                 continue
             newfile = True
             context = True
             afile = parsefilename(x)
             bfile = parsefilename(l2)
 
         if newfile:
             newfile = False
             emitfile = True
             state = BFILE
             hunknum = 0
 
     while gitpatches:
         gp = gitpatches.pop()[1]
         yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp)
 
-def applydiff(ui, fp, changed, backend, strip=1, eolmode='strict'):
+def applydiff(ui, fp, changed, backend, store, strip=1, eolmode='strict'):
     """Reads a patch from fp and tries to apply it.
 
     The dict 'changed' is filled in with all of the filenames changed
     by the patch. Returns 0 for a clean patch, -1 if any rejects were
     found and 1 if there was any fuzz.
 
     If 'eolmode' is 'strict', the patch content and patched file are
     read in binary mode. Otherwise, line endings are ignored when
     patching then normalized according to 'eolmode'.
     """
-    return _applydiff(ui, fp, patchfile, backend, changed, strip=strip,
+    return _applydiff(ui, fp, patchfile, backend, store, changed, strip=strip,
                       eolmode=eolmode)
 
-def _applydiff(ui, fp, patcher, backend, changed, strip=1, eolmode='strict'):
+def _applydiff(ui, fp, patcher, backend, store, changed, strip=1,
+               eolmode='strict'):
 
     def pstrip(p):
         return pathstrip(p, strip - 1)[1]
 
     rejects = 0
     err = 0
     current_file = None
 
     for state, values in iterhunks(fp):
         if state == 'hunk':
             if not current_file:
                 continue
             ret = current_file.apply(values)
             if ret >= 0:
                 changed.setdefault(current_file.fname, None)
                 if ret > 0:
                     err = 1
         elif state == 'file':
             if current_file:
                 rejects += current_file.close()
                 current_file = None
             afile, bfile, first_hunk, gp = values
+            copysource = None
             if gp:
                 path = pstrip(gp.path)
+                if gp.oldpath:
+                    copysource = pstrip(gp.oldpath)
                 changed[path] = gp
                 if gp.op == 'DELETE':
                     backend.unlink(path)
                     continue
                 if gp.op == 'RENAME':
-                    backend.unlink(pstrip(gp.oldpath))
-                if gp.mode and not first_hunk:
-                    data = None
+                    backend.unlink(copysource)
+                if not first_hunk:
+                    data, mode = None, None
+                    if gp.op in ('RENAME', 'COPY'):
+                        data, mode = store.getfile(copysource)
+                    if gp.mode:
+                        mode = gp.mode
                     if gp.op == 'ADD':
                         # Added files without content have no hunk and
                         # must be created
                         data = ''
-                    backend.setfile(path, data, gp.mode)
+                    if data or mode:
+                        if (gp.op in ('ADD', 'RENAME', 'COPY')
+                            and backend.exists(path)):
+                            raise PatchError(_("cannot create %s: destination "
+                                               "already exists") % path)
+                        backend.setfile(path, data, mode, copysource)
             if not first_hunk:
                 continue
             try:
                 mode = gp and gp.mode or None
-                current_file, missing, create, remove = selectfile(
+                current_file, create, remove = selectfile(
                     backend, afile, bfile, first_hunk, strip, gp)
-                current_file = patcher(ui, current_file, backend, mode,
-                                       create, remove, missing=missing,
-                                       eolmode=eolmode)
+                current_file = patcher(ui, current_file, backend, store, mode,
+                                       create, remove, eolmode=eolmode,
+                                       copysource=copysource)
             except PatchError, inst:
                 ui.warn(str(inst) + '\n')
                 current_file = None
                 rejects += 1
                 continue
         elif state == 'git':
             for gp in values:
-                backend.copy(pstrip(gp.oldpath), pstrip(gp.path))
+                path = pstrip(gp.oldpath)
+                data, mode = backend.getfile(path)
+                store.setfile(path, data, mode)
         else:
             raise util.Abort(_('unsupported parser state: %s') % state)
 
     if current_file:
         rejects += current_file.close()
 
     if rejects:
         return -1
     return err
 
 def _externalpatch(ui, repo, patcher, patchname, strip, files,
                    similarity):
     """use <patcher> to apply <patchname> to the working directory.
     returns whether patch was applied with fuzz factor."""
 
     fuzz = False
     args = []
     cwd = repo.root
     if cwd:
         args.append('-d %s' % util.shellquote(cwd))
     fp = util.popen('%s %s -p%d < %s' % (patcher, ' '.join(args), strip,
                                        util.shellquote(patchname)))
     try:
         for line in fp:
             line = line.rstrip()
             ui.note(line + '\n')
             if line.startswith('patching file '):
                 pf = util.parsepatchoutput(line)
                 printed_file = False
                 files.setdefault(pf, 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')
     finally:
         if files:
             cfiles = list(files)
             cwd = repo.getcwd()
             if cwd:
                 cfiles = [util.pathto(repo.root, cwd, f)
                           for f in cfile]
             scmutil.addremove(repo, cfiles, similarity=similarity)
     code = fp.close()
     if code:
         raise PatchError(_("patch command failed: %s") %
                          util.explainexit(code)[0])
     return fuzz
 
 def internalpatch(ui, repo, patchobj, strip, files=None, eolmode='strict',
                   similarity=0):
     """use builtin patch to apply <patchobj> to the working directory.
     returns whether patch was applied with fuzz factor."""
 
     if files is None:
         files = {}
     if eolmode is None:
         eolmode = ui.config('patch', 'eol', 'strict')
     if eolmode.lower() not in eolmodes:
         raise util.Abort(_('unsupported line endings type: %s') % eolmode)
     eolmode = eolmode.lower()
 
+    store = filestore()
     backend = workingbackend(ui, repo, similarity)
     try:
         fp = open(patchobj, 'rb')
     except TypeError:
         fp = patchobj
     try:
-        ret = applydiff(ui, fp, files, backend, strip=strip, eolmode=eolmode)
+        ret = applydiff(ui, fp, files, backend, store, strip=strip,
+                        eolmode=eolmode)
     finally:
         if fp != patchobj:
             fp.close()
         files.update(dict.fromkeys(backend.close()))
+        store.close()
     if ret < 0:
         raise PatchError(_('patch failed to apply'))
     return ret > 0
 
 def patch(ui, repo, patchname, strip=1, files=None, eolmode='strict',
           similarity=0):
     """Apply <patchname> to the working directory.
 
     'eolmode' specifies how end of lines should be handled. It can be:
     - 'strict': inputs are read in binary mode, EOLs are preserved
     - 'crlf': EOLs are ignored when patching and reset to CRLF
     - 'lf': EOLs are ignored when patching and reset to LF
     - None: get it from user settings, default to 'strict'
     'eolmode' is ignored when using an external patcher program.
 
     Returns whether patch was applied with fuzz factor.
     """
     patcher = ui.config('ui', 'patch')
     if files is None:
         files = {}
     try:
         if patcher:
             return _externalpatch(ui, repo, patcher, patchname, strip,
                                   files, similarity)
         return internalpatch(ui, repo, patchname, strip, files, eolmode,
                              similarity)
     except PatchError, err:
         raise util.Abort(str(err))
 
 def changedfiles(ui, repo, patchpath, strip=1):
     backend = fsbackend(ui, repo.root)
     fp = open(patchpath, 'rb')
     try:
         changed = set()
         for state, values in iterhunks(fp):
             if state == 'file':
                 afile, bfile, first_hunk, gp = values
                 if gp:
                     changed.add(pathstrip(gp.path, strip - 1)[1])
                     if gp.op == 'RENAME':
                         changed.add(pathstrip(gp.oldpath, strip - 1)[1])
                 if not first_hunk:
                     continue
-                current_file, missing, create, remove = selectfile(
+                current_file, create, remove = selectfile(
                     backend, afile, bfile, first_hunk, strip, gp)
                 changed.add(current_file)
             elif state not in ('hunk', 'git'):
                 raise util.Abort(_('unsupported parser state: %s') % state)
         return changed
     finally:
         fp.close()
 
 def b85diff(to, tn):
     '''print base85-encoded binary diff'''
     def gitindex(text):
         if not text:
             return hex(nullid)
         l = len(text)
         s = util.sha1('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
 
     tohash = gitindex(to)
     tnhash = gitindex(tn)
     if tohash == tnhash:
         return ""
 
     # TODO: deltas
     ret = ['index %s..%s\nGIT binary patch\nliteral %s\n' %
            (tohash, tnhash, len(tn))]
     for l in chunk(zlib.compress(tn)):
         ret.append(fmtline(l))
     ret.append('\n')
     return ''.join(ret)
 
 class GitDiffRequired(Exception):
     pass
 
 def diffopts(ui, opts=None, untrusted=False):
     def get(key, name=None, getter=ui.configbool):
         return ((opts and opts.get(key)) or
                 getter('diff', name or key, None, untrusted=untrusted))
     return mdiff.diffopts(
         text=opts and 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'),
         context=get('unified', getter=ui.config))
 
 def diff(repo, node1=None, node2=None, match=None, changes=None, opts=None,
          losedatafn=None, prefix=''):
     '''yields 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.
 
     losedatafn(**kwarg) is a callable run when opts.upgrade=True and
     every time some change cannot be represented with the current
     patch format. Return False to upgrade to git patch format, True to
     accept the loss or raise an exception to abort the diff. It is
     called with the name of current file being diffed as 'fn'. If set
     to None, patches will always be upgraded to git format when
     necessary.
 
     prefix is a filename prefix that is prepended to all filenames on
     display (used for subrepos).
     '''
 
     if opts is None:
         opts = mdiff.defaultopts
 
     if not node1 and not node2:
         node1 = repo.dirstate.p1()
 
     def lrugetfilectx():
         cache = {}
         order = []
         def getfilectx(f, ctx):
             fctx = ctx.filectx(f, filelog=cache.get(f))
             if f not in cache:
                 if len(cache) > 20:
                     del cache[order.pop(0)]
                 cache[f] = fctx.filelog()
             else:
                 order.remove(f)
             order.append(f)
             return fctx
         return getfilectx
     getfilectx = lrugetfilectx()
 
     ctx1 = repo[node1]
     ctx2 = repo[node2]
 
     if not changes:
         changes = repo.status(ctx1, ctx2, match=match)
     modified, added, removed = changes[:3]
 
     if not modified and not added and not removed:
         return []
 
     revs = None
     if not repo.ui.quiet:
         hexfunc = repo.ui.debugflag and hex or short
         revs = [hexfunc(node) for node in [node1, node2] if node]
 
     copy = {}
     if opts.git or opts.upgrade:
         copy = copies.copies(repo, ctx1, ctx2, repo[nullid])[0]
 
     difffn = lambda opts, losedata: trydiff(repo, revs, ctx1, ctx2,
                  modified, added, removed, copy, getfilectx, opts, losedata, prefix)
     if opts.upgrade and not opts.git:
         try:
             def losedata(fn):
                 if not losedatafn or not losedatafn(fn=fn):
                     raise GitDiffRequired()
             # Buffer the whole output until we are sure it can be generated
             return list(difffn(opts.copy(git=False), losedata))
         except GitDiffRequired:
             return difffn(opts.copy(git=True), None)
     else:
         return difffn(opts, None)
 
 def difflabel(func, *args, **kw):
     '''yields 2-tuples of (output, label) based on the output of func()'''
     prefixes = [('diff', 'diff.diffline'),
                 ('copy', 'diff.extended'),
                 ('rename', 'diff.extended'),
                 ('old', 'diff.extended'),
                 ('new', 'diff.extended'),
                 ('deleted', 'diff.extended'),
                 ('---', 'diff.file_a'),
                 ('+++', 'diff.file_b'),
                 ('@@', 'diff.hunk'),
                 ('-', 'diff.deleted'),
                 ('+', 'diff.inserted')]
 
     for chunk in func(*args, **kw):
         lines = chunk.split('\n')
         for i, line in enumerate(lines):
             if i != 0:
                 yield ('\n', '')
             stripline = line
             if line and line[0] in '+-':
                 # highlight trailing whitespace, but only in changed lines
                 stripline = line.rstrip()
             for prefix, label in prefixes:
                 if stripline.startswith(prefix):
                     yield (stripline, label)
                     break
             else:
                 yield (line, '')
             if line != stripline:
                 yield (line[len(stripline):], 'diff.trailingwhitespace')
 
 def diffui(*args, **kw):
     '''like diff(), but yields 2-tuples of (output, label) for ui.write()'''
     return difflabel(diff, *args, **kw)
 
 
 def _addmodehdr(header, omode, nmode):
     if omode != nmode:
         header.append('old mode %s\n' % omode)
         header.append('new mode %s\n' % nmode)
 
 def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
             copy, getfilectx, opts, losedatafn, prefix):
 
     def join(f):
         return os.path.join(prefix, f)
 
     date1 = util.datestr(ctx1.date())
     man1 = ctx1.manifest()
 
     gone = set()
     gitmode = {'l': '120000', 'x': '100755', '': '100644'}
 
     copyto = dict([(v, k) for k, v in copy.items()])
 
     if opts.git:
         revs = None
 
     for f in sorted(modified + added + removed):
         to = None
         tn = None
         dodiff = True
         header = []
         if f in man1:
             to = getfilectx(f, ctx1).data()
         if f not in removed:
             tn = getfilectx(f, ctx2).data()
         a, b = f, f
         if opts.git or losedatafn:
             if f in added:
                 mode = gitmode[ctx2.flags(f)]
                 if f in copy or f in copyto:
                     if opts.git:
                         if f in copy:
                             a = copy[f]
                         else:
                             a = copyto[f]
                         omode = gitmode[man1.flags(a)]
                         _addmodehdr(header, omode, mode)
                         if a in removed and a not in gone:
                             op = 'rename'
                             gone.add(a)
                         else:
                             op = 'copy'
                         header.append('%s from %s\n' % (op, join(a)))
                         header.append('%s to %s\n' % (op, join(f)))
                         to = getfilectx(a, ctx1).data()
                     else:
                         losedatafn(f)
                 else:
                     if opts.git:
                         header.append('new file mode %s\n' % mode)
                     elif ctx2.flags(f):
                         losedatafn(f)
                 # In theory, if tn was copied or renamed we should check
                 # if the source is binary too but the copy record already
                 # forces git mode.
                 if util.binary(tn):
                     if opts.git:
                         dodiff = 'binary'
                     else:
                         losedatafn(f)
                 if not opts.git and not tn:
                     # regular diffs cannot represent new empty file
                     losedatafn(f)
             elif f in removed:
                 if opts.git:
                     # have we already reported a copy above?
                     if ((f in copy and copy[f] in added
                          and copyto[copy[f]] == f) or
                         (f in copyto and copyto[f] in added
                          and copy[copyto[f]] == f)):
                         dodiff = False
                     else:
                         header.append('deleted file mode %s\n' %
                                       gitmode[man1.flags(f)])
                 elif not to or util.binary(to):
                     # regular diffs cannot represent empty file deletion
                     losedatafn(f)
             else:
                 oflag = man1.flags(f)
                 nflag = ctx2.flags(f)
                 binary = util.binary(to) or util.binary(tn)
                 if opts.git:
                     _addmodehdr(header, gitmode[oflag], gitmode[nflag])
                     if binary:
                         dodiff = 'binary'
                 elif binary or nflag != oflag:
                     losedatafn(f)
             if opts.git:
                 header.insert(0, mdiff.diffline(revs, join(a), join(b), opts))
 
         if dodiff:
             if dodiff == 'binary':
                 text = b85diff(to, tn)
             else:
                 text = mdiff.unidiff(to, date1,
                                     # ctx2 date may be dynamic
                                     tn, util.datestr(ctx2.date()),
                                     join(a), join(b), revs, opts=opts)
             if header and (text or len(header) > 1):
                 yield ''.join(header)
             if text:
                 yield text
 
 def diffstatsum(stats):
     maxfile, maxtotal, addtotal, removetotal, binary = 0, 0, 0, 0, False
     for f, a, r, b in stats:
         maxfile = max(maxfile, encoding.colwidth(f))
         maxtotal = max(maxtotal, a + r)
         addtotal += a
         removetotal += r
         binary = binary or b
 
     return maxfile, maxtotal, addtotal, removetotal, binary
 
 def diffstatdata(lines):
     diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$')
 
     results = []
     filename, adds, removes = None, 0, 0
 
     def addresult():
         if filename:
             isbinary = adds == 0 and removes == 0
             results.append((filename, adds, removes, isbinary))
 
     for line in lines:
         if line.startswith('diff'):
             addresult()
             # set numbers to 0 anyway when starting new file
             adds, removes = 0, 0
             if line.startswith('diff --git'):
                 filename = gitre.search(line).group(1)
             elif line.startswith('diff -r'):
                 # format: "diff -r ... -r ... filename"
                 filename = diffre.search(line).group(1)
         elif line.startswith('+') and not line.startswith('+++'):
             adds += 1
         elif line.startswith('-') and not line.startswith('---'):
             removes += 1
     addresult()
     return results
 
 def diffstat(lines, width=80, git=False):
     output = []
     stats = diffstatdata(lines)
     maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats)
 
     countwidth = len(str(maxtotal))
     if hasbinary and countwidth < 3:
         countwidth = 3
     graphwidth = width - countwidth - maxname - 6
     if graphwidth < 10:
         graphwidth = 10
 
     def scale(i):
         if maxtotal <= graphwidth:
             return i
         # If diffstat runs out of room it doesn't print anything,
         # which isn't very useful, so always print at least one + or -
         # if there were at least some changes.
         return max(i * graphwidth // maxtotal, int(bool(i)))
 
     for filename, adds, removes, isbinary in stats:
         if git and isbinary:
             count = 'Bin'
         else:
             count = adds + removes
         pluses = '+' * scale(adds)
         minuses = '-' * scale(removes)
         output.append(' %s%s |  %*s %s%s\n' %
                       (filename, ' ' * (maxname - encoding.colwidth(filename)),
                        countwidth, count, pluses, minuses))
 
     if stats:
         output.append(_(' %d files changed, %d insertions(+), %d deletions(-)\n')
                       % (len(stats), totaladds, totalremoves))
 
     return ''.join(output)
 
 def diffstatui(*args, **kw):
     '''like diffstat(), but yields 2-tuples of (output, label) for
     ui.write()
     '''
 
     for line in diffstat(*args, **kw).splitlines():
         if line and line[-1] in '+-':
             name, graph = line.rsplit(' ', 1)
             yield (name + ' ', '')
             m = re.search(r'\++', graph)
             if m:
                 yield (m.group(0), 'diffstat.inserted')
             m = re.search(r'-+', graph)
             if m:
                 yield (m.group(0), 'diffstat.deleted')
         else:
             yield (line, '')
         yield ('\n', '')

tests/test-git-import.t

@@ -1,443 +1,445 b''
 
   $ hg init
 
 New file:
 
   $ hg import -d "1000000 0" -mnew - <<EOF
   > diff --git a/new b/new
   > new file mode 100644
   > index 0000000..7898192
   > --- /dev/null
   > +++ b/new
   > @@ -0,0 +1 @@
   > +a
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   0:ae3ee40d2079
 
 New empty file:
 
   $ hg import -d "1000000 0" -mempty - <<EOF
   > diff --git a/empty b/empty
   > new file mode 100644
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   1:ab199dc869b5
 
   $ hg locate empty
   empty
 
 chmod +x:
 
   $ hg import -d "1000000 0" -msetx - <<EOF
   > diff --git a/new b/new
   > old mode 100644
   > new mode 100755
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   2:3a34410f282e
 
   $ test -x new
 
 Copy:
 
   $ hg import -d "1000000 0" -mcopy - <<EOF
   > diff --git a/new b/copy
   > old mode 100755
   > new mode 100644
   > similarity index 100%
   > copy from new
   > copy to copy
   > diff --git a/new b/copyx
   > similarity index 100%
   > copy from new
   > copy to copyx
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   3:37bacb7ca14d
 
   $ if "$TESTDIR/hghave" -q execbit; then
   >     test -f copy -a ! -x copy || echo bad
   >     test -x copyx || echo bad
   > else
   >     test -f copy || echo bad
   > fi
 
   $ cat copy
   a
 
   $ hg cat copy
   a
 
 Rename:
 
   $ hg import -d "1000000 0" -mrename - <<EOF
   > diff --git a/copy b/rename
   > similarity index 100%
   > rename from copy
   > rename to rename
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   4:47b81a94361d
 
   $ hg locate
   copyx
   empty
   new
   rename
 
 Delete:
 
   $ hg import -d "1000000 0" -mdelete - <<EOF
   > diff --git a/copyx b/copyx
   > deleted file mode 100755
   > index 7898192..0000000
   > --- a/copyx
   > +++ /dev/null
   > @@ -1 +0,0 @@
   > -a
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   5:d9b001d98336
 
   $ hg locate
   empty
   new
   rename
 
   $ test -f copyx
   [1]
 
 Regular diff:
 
   $ hg import -d "1000000 0" -mregular - <<EOF
   > diff --git a/rename b/rename
   > index 7898192..72e1fe3 100644
   > --- a/rename
   > +++ b/rename
   > @@ -1 +1,5 @@
   >  a
   > +a
   > +a
   > +a
   > +a
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   6:ebe901e7576b
 
 Copy and modify:
 
   $ hg import -d "1000000 0" -mcopymod - <<EOF
   > diff --git a/rename b/copy2
   > similarity index 80%
   > copy from rename
   > copy to copy2
   > index 72e1fe3..b53c148 100644
   > --- a/rename
   > +++ b/copy2
   > @@ -1,5 +1,5 @@
   >  a
   >  a
   > -a
   > +b
   >  a
   >  a
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   7:18f368958ecd
 
   $ hg cat copy2
   a
   a
   b
   a
   a
 
 Rename and modify:
 
   $ hg import -d "1000000 0" -mrenamemod - <<EOF
   > diff --git a/copy2 b/rename2
   > similarity index 80%
   > rename from copy2
   > rename to rename2
   > index b53c148..8f81e29 100644
   > --- a/copy2
   > +++ b/rename2
   > @@ -1,5 +1,5 @@
   >  a
   >  a
   >  b
   > -a
   > +c
   >  a
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   8:c32b0d7e6f44
 
   $ hg locate copy2
   [1]
   $ hg cat rename2
   a
   a
   b
   c
   a
 
 One file renamed multiple times:
 
   $ hg import -d "1000000 0" -mmultirenames - <<EOF
   > diff --git a/rename2 b/rename3
   > rename from rename2
   > rename to rename3
   > diff --git a/rename2 b/rename3-2
   > rename from rename2
   > rename to rename3-2
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   9:034a6bf95330
 
   $ hg log -vr. --template '{rev} {files} / {file_copies}\n'
   9 rename2 rename3 rename3-2 / rename3 (rename2)rename3-2 (rename2)
 
   $ hg locate rename2 rename3 rename3-2
   rename3
   rename3-2
 
   $ hg cat rename3
   a
   a
   b
   c
   a
 
   $ hg cat rename3-2
   a
   a
   b
   c
   a
 
   $ echo foo > foo
   $ hg add foo
   $ hg ci -m 'add foo'
 
 Binary files and regular patch hunks:
 
   $ hg import -d "1000000 0" -m binaryregular - <<EOF
   > diff --git a/binary b/binary
   > new file mode 100644
   > index 0000000000000000000000000000000000000000..593f4708db84ac8fd0f5cc47c634f38c013fe9e4
   > GIT binary patch
   > literal 4
   > Lc\${NkU|;|M00aO5
   > 
   > diff --git a/foo b/foo2
   > rename from foo
   > rename to foo2
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   11:c39bce63e786
 
   $ cat foo2
   foo
 
   $ hg manifest --debug | grep binary
   045c85ba38952325e126c70962cc0f9d9077bc67 644   binary
 
 Multiple binary files:
 
   $ hg import -d "1000000 0" -m multibinary - <<EOF
   > diff --git a/mbinary1 b/mbinary1
   > new file mode 100644
   > index 0000000000000000000000000000000000000000..593f4708db84ac8fd0f5cc47c634f38c013fe9e4
   > GIT binary patch
   > literal 4
   > Lc\${NkU|;|M00aO5
   > 
   > diff --git a/mbinary2 b/mbinary2
   > new file mode 100644
   > index 0000000000000000000000000000000000000000..112363ac1917b417ffbd7f376ca786a1e5fa7490
   > GIT binary patch
   > literal 5
   > Mc\${NkU|\`?^000jF3jhEB
   > 
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   12:30b530085242
 
   $ hg manifest --debug | grep mbinary
   045c85ba38952325e126c70962cc0f9d9077bc67 644   mbinary1
   a874b471193996e7cb034bb301cac7bdaf3e3f46 644   mbinary2
 
 Filenames with spaces:
 
   $ hg import -d "1000000 0" -m spaces - <<EOF
   > diff --git a/foo bar b/foo bar
   > new file mode 100644
   > index 0000000..257cc56
   > --- /dev/null
   > +++ b/foo bar	
   > @@ -0,0 +1 @@
   > +foo
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   13:04750ef42fb3
 
   $ cat "foo bar"
   foo
 
 Copy then modify the original file:
 
   $ hg import -d "1000000 0" -m copy-mod-orig - <<EOF
   > diff --git a/foo2 b/foo2
   > index 257cc56..fe08ec6 100644
   > --- a/foo2
   > +++ b/foo2
   > @@ -1 +1,2 @@
   >  foo
   > +new line
   > diff --git a/foo2 b/foo3
   > similarity index 100%
   > copy from foo2
   > copy to foo3
   > EOF
   applying patch from stdin
 
   $ hg tip -q
   14:c4cd9cdeaa74
 
   $ cat foo3
   foo
 
 Move text file and patch as binary
 
   $ echo a > text2
   $ hg ci -Am0
   adding text2
   $ hg import -d "1000000 0" -m rename-as-binary - <<"EOF"
   > diff --git a/text2 b/binary2
   > rename from text2
   > rename to binary2
   > index 78981922613b2afb6025042ff6bd878ac1994e85..10efcb362e9f3b3420fcfbfc0e37f3dc16e29757
   > GIT binary patch
   > literal 5
   > Mc$`b*O5$Pw00T?_*Z=?k
   > 
   > EOF
   applying patch from stdin
 
   $ cat binary2
   a
   b
   \x00 (no-eol) (esc)
 
   $ hg st --copies --change . 
   A binary2
     text2
   R text2
   $ cd ..
 
 Consecutive import with renames (issue2459)
 
   $ hg init issue2459
   $ cd issue2459
   $ hg import --no-commit --force - <<EOF
   > diff --git a/a b/a
   > new file mode 100644
   > EOF
   applying patch from stdin
   $ hg import --no-commit --force - <<EOF
   > diff --git a/a b/b
   > rename from a
   > rename to b
   > EOF
   applying patch from stdin
   a has not been committed yet, so no copy data will be stored for b.
   $ hg debugstate
   a   0         -1 unset               b
   $ hg ci -m done
   $ cd ..
 
 Renames and strip
 
   $ hg init renameandstrip
   $ cd renameandstrip
   $ echo a > a
   $ hg ci -Am adda
   adding a
   $ hg import --no-commit -p2 - <<EOF
   > diff --git a/foo/a b/foo/b
   > rename from foo/a
   > rename to foo/b
   > EOF
   applying patch from stdin
   $ hg st --copies
   A b
     a
   R a
   $ cd ..
 
 Pure copy with existing destination
 
   $ hg init copytoexisting
   $ cd copytoexisting
   $ echo a > a
   $ echo b > b
   $ hg ci -Am add
   adding a
   adding b
   $ hg import --no-commit - <<EOF
   > diff --git a/a b/b
   > copy from a
   > copy to b
   > EOF
   applying patch from stdin
   abort: cannot create b: destination already exists
   [255]
   $ cat b
   b
 
 Copy and changes with existing destination
 
   $ hg import --no-commit - <<EOF
   > diff --git a/a b/b
   > copy from a
   > copy to b
   > --- a/a
   > +++ b/b
   > @@ -1,1 +1,2 @@
   > a
   > +b
   > EOF
   applying patch from stdin
-  abort: cannot create b: destination already exists
+  cannot create b: destination already exists
+  1 out of 1 hunks FAILED -- saving rejects to file b.rej
+  abort: patch failed to apply
   [255]
   $ cat b
   b
   $ cd ..

tests/test-import.t

@@ -1,930 +1,930 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'
 
 
 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
 
   $ 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 ../exported-tip.patch
 
 message and committer 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
 
   $ cat > dummypatch.py <<EOF
   > print 'patching file a'
   > file('a', 'wb').write('line2\n')
   > EOF
   $ chmod +x dummypatch.py
   $ 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 --config ui.patch='python ../dummypatch.py' --cwd b import ../exported-tip.patch
   applying ../exported-tip.patch
   $ cat b/a
   line2
   $ rm -r b
 
 
 import of plain diff should fail without 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 ../diffed-tip.patch
   applying ../diffed-tip.patch
   abort: empty commit message
   [255]
   $ 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
 
   $ 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
 
   $ 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 --no-commit ../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
   applied 80971e65b431
   $ 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'
   > sys.stdout.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 | 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'
   > sys.stdout.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 | 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 ../patch1 ../patch2
   applying ../patch1
   applying ../patch2
   applied 1d4bd90af0e4
   $ hg --cwd b rollback
   repository tip rolled back to revision 1 (undo commit)
   working directory now based on revision 1
   $ hg --cwd b parents --template 'parent: {rev}\n'
   parent: 1
   $ 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 --no-commit -v fuzzy-tip.patch
   applying fuzzy-tip.patch
   patching file a
   Hunk #1 succeeded at 1 with fuzz 2 (offset -2 lines).
   $ 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 1 with fuzz 2 (offset -2 lines).
   $ 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 -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
   $ 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: ../outside/foo not under root
+  abort: path contains illegal component: ../outside/foo
   [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
   removing a
   adding b
   recording removal of a as rename to b (88% similar)
   $ 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
   removing a
   adding b
   $ 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
   > 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
   $ 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
 
 
 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
   # 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
   $ hg sum
   parent: 1:d59915696727 tip
    help management of empty pkg and lib directories in perforce
   branch: default
   commit: (clean)
   update: (current)
   $ 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
   $ 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 ..
 

tests/test-mq-qrefresh.t

@@ -1,524 +1,525 b''
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "mq=" >> $HGRCPATH
   $ echo "[diff]" >> $HGRCPATH
   $ echo "nodates=1" >> $HGRCPATH
 
   $ hg init a
   $ cd a
 
   $ mkdir 1 2
   $ echo 'base' > 1/base
   $ echo 'base' > 2/base
   $ hg ci -Ambase
   adding 1/base
   adding 2/base
 
   $ hg qnew -mmqbase mqbase
 
   $ echo 'patched' > 1/base
   $ echo 'patched' > 2/base
   $ hg qrefresh
 
   $ hg qdiff
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
   $ hg qdiff .
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
   $ cat .hg/patches/mqbase
   # HG changeset patch
   # Parent e7af5904b465cd1f4f3cf6b26fe14e8db6f63eaa
   mqbase
   
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
   $ echo 'patched again' > base
   $ hg qrefresh 1
 
   $ hg qdiff
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
   $ hg qdiff .
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
   $ cat .hg/patches/mqbase
   # HG changeset patch
   # Parent e7af5904b465cd1f4f3cf6b26fe14e8db6f63eaa
   mqbase
   
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
 qrefresh . in subdir:
 
   $ ( cd 1 ; hg qrefresh . )
 
   $ hg qdiff
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
   $ hg qdiff .
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
   $ cat .hg/patches/mqbase
   # HG changeset patch
   # Parent e7af5904b465cd1f4f3cf6b26fe14e8db6f63eaa
   mqbase
   
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
 qrefresh in hg-root again:
 
   $ hg qrefresh
 
   $ hg qdiff
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
   $ hg qdiff .
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
   $ cat .hg/patches/mqbase
   # HG changeset patch
   # Parent e7af5904b465cd1f4f3cf6b26fe14e8db6f63eaa
   mqbase
   
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
 
 qrefresh --short tests:
 
   $ echo 'orphan' > orphanchild
   $ hg add orphanchild
   $ hg qrefresh nonexistingfilename # clear patch
   $ hg qrefresh --short 1/base
   $ hg qrefresh --short 2/base
 
   $ hg qdiff
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 orphanchild
   --- /dev/null
   +++ b/orphanchild
   @@ -0,0 +1,1 @@
   +orphan
 
   $ cat .hg/patches/mqbase
   # HG changeset patch
   # Parent e7af5904b465cd1f4f3cf6b26fe14e8db6f63eaa
   mqbase
   
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
   $ hg st
   A orphanchild
   ? base
 
 diff shows what is not in patch:
 
   $ hg diff
   diff -r ???????????? orphanchild (glob)
   --- /dev/null
   +++ b/orphanchild
   @@ -0,0 +1,1 @@
   +orphan
 
 Before starting exclusive tests:
 
   $ cat .hg/patches/mqbase
   # HG changeset patch
   # Parent e7af5904b465cd1f4f3cf6b26fe14e8db6f63eaa
   mqbase
   
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
 Exclude 2/base:
 
   $ hg qref -s -X 2/base
 
   $ cat .hg/patches/mqbase
   # HG changeset patch
   # Parent e7af5904b465cd1f4f3cf6b26fe14e8db6f63eaa
   mqbase
   
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
 status shows 2/base as dirty:
 
   $ hg status
   M 2/base
   A orphanchild
   ? base
 
 Remove 1/base and add 2/base again but not orphanchild:
 
   $ hg qref -s -X orphanchild -X 1/base 2/base orphanchild
 
   $ cat .hg/patches/mqbase
   # HG changeset patch
   # Parent e7af5904b465cd1f4f3cf6b26fe14e8db6f63eaa
   mqbase
   
   diff -r e7af5904b465 2/base
   --- a/2/base
   +++ b/2/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
 Add 1/base with include filter - and thus remove 2/base from patch:
 
   $ hg qref -s -I 1/ o* */*
 
   $ cat .hg/patches/mqbase
   # HG changeset patch
   # Parent e7af5904b465cd1f4f3cf6b26fe14e8db6f63eaa
   mqbase
   
   diff -r e7af5904b465 1/base
   --- a/1/base
   +++ b/1/base
   @@ -1,1 +1,1 @@
   -base
   +patched
 
   $ cd ..
 
 
 Test qrefresh --git losing copy metadata:
 
   $ hg init repo
   $ cd repo
 
   $ echo "[diff]" >> .hg/hgrc
   $ echo "git=True" >> .hg/hgrc
   $ echo a > a
 
   $ hg ci -Am adda
   adding a
   $ hg copy a ab
   $ echo b >> ab
   $ hg copy a ac
   $ echo c >> ac
 
 Capture changes:
 
   $ hg qnew -f p1
 
   $ hg qdiff
   diff --git a/a b/ab
   copy from a
   copy to ab
   --- a/a
   +++ b/ab
   @@ -1,1 +1,2 @@
    a
   +b
   diff --git a/a b/ac
   copy from a
   copy to ac
   --- a/a
   +++ b/ac
   @@ -1,1 +1,2 @@
    a
   +c
 
 Refresh and check changes again:
 
   $ hg qrefresh
 
   $ hg qdiff
   diff --git a/a b/ab
   copy from a
   copy to ab
   --- a/a
   +++ b/ab
   @@ -1,1 +1,2 @@
    a
   +b
   diff --git a/a b/ac
   copy from a
   copy to ac
   --- a/a
   +++ b/ac
   @@ -1,1 +1,2 @@
    a
   +c
 
   $ cd ..
 
 
 Issue1441: qrefresh confused after hg rename:
 
   $ hg init repo-1441
   $ cd repo-1441
   $ echo a > a
   $ hg add a
   $ hg qnew -f p
   $ hg mv a b
   $ hg qrefresh
 
   $ hg qdiff
   diff -r 000000000000 b
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,1 @@
   +a
 
   $ cd ..
 
 
 Issue2025: qrefresh does not honor filtering options when tip !=
 qtip:
 
   $ hg init repo-2025
   $ cd repo-2025
   $ echo a > a
   $ echo b > b
   $ hg ci -qAm addab
   $ echo a >> a
   $ echo b >> b
   $ hg qnew -f patch
   $ hg up -qC 0
   $ echo c > c
   $ hg ci -qAm addc
   $ hg up -qC 1
 
 refresh with tip != qtip:
 
   $ hg --config diff.nodates=1 qrefresh -I b
 
   $ hg st
   M a
 
   $ cat b
   b
   b
 
   $ cat .hg/patches/patch
   # HG changeset patch
   # Parent 1a60229be7ac3e4a7f647508e99b87bef1f03593
   
   diff -r 1a60229be7ac b
   --- a/b
   +++ b/b
   @@ -1,1 +1,2 @@
    b
   +b
 
   $ cd ..
 
 
 Issue1441 with git patches:
 
   $ hg init repo-1441-git
   $ cd repo-1441-git
 
   $ echo "[diff]" >> .hg/hgrc
   $ echo "git=True" >> .hg/hgrc
 
   $ echo a > a
   $ hg add a
   $ hg qnew -f p
   $ hg mv a b
   $ hg qrefresh
 
   $ hg qdiff --nodates
   diff --git a/b b/b
   new file mode 100644
   --- /dev/null
   +++ b/b
   @@ -0,0 +1,1 @@
   +a
 
   $ cd ..
 
 Refresh with bad usernames. Mercurial used to abort on bad usernames,
 but only after writing the bad name into the patch.
 
   $ hg init bad-usernames
   $ cd bad-usernames
   $ touch a
   $ hg add a
   $ hg qnew a
   $ hg qrefresh -u 'foo
   > bar'
   transaction abort!
   rollback completed
   refresh interrupted while patch was popped! (revert --all, qpush to recover)
   abort: username 'foo\nbar' contains a newline!
   [255]
+  $ rm a
   $ cat .hg/patches/a
   # HG changeset patch
   # Parent 0000000000000000000000000000000000000000
   diff --git a/a b/a
   new file mode 100644
   $ hg qpush
   applying a
   now at: a
   $ hg qrefresh -u ' '
   transaction abort!
   rollback completed
   refresh interrupted while patch was popped! (revert --all, qpush to recover)
   abort: empty username!
   [255]
   $ cat .hg/patches/a
   # HG changeset patch
   # Parent 0000000000000000000000000000000000000000
   diff --git a/a b/a
   new file mode 100644
   $ cd ..

tests/test-mq-symlinks.t

@@ -1,121 +1,123 b''
   $ "$TESTDIR/hghave" symlink || exit 80
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "mq=" >> $HGRCPATH
 
   $ hg init
   $ hg qinit
   $ hg qnew base.patch
   $ echo aaa > a
   $ echo bbb > b
   $ echo ccc > c
   $ hg add a b c
   $ hg qrefresh
   $ $TESTDIR/readlink.py a
   a -> a not a symlink
 
 
 test replacing a file with a symlink
 
   $ hg qnew symlink.patch
   $ rm a
   $ ln -s b a
   $ hg qrefresh --git
   $ $TESTDIR/readlink.py a
   a -> b
 
   $ hg qpop
   popping symlink.patch
   now at: base.patch
   $ hg qpush
   applying symlink.patch
   now at: symlink.patch
   $ $TESTDIR/readlink.py a
   a -> b
 
 
 test updating a symlink
 
   $ rm a
   $ ln -s c a
   $ hg qnew --git -f updatelink
   $ $TESTDIR/readlink.py a
   a -> c
   $ hg qpop
   popping updatelink
   now at: symlink.patch
   $ hg qpush --debug
   applying updatelink
   patching file a
   a
   now at: updatelink
   $ $TESTDIR/readlink.py a
   a -> c
   $ hg st
 
 
 test replacing a symlink with a file
 
   $ ln -s c s
   $ hg add s
   $ hg qnew --git -f addlink
   $ rm s
   $ echo sss > s
   $ hg qnew --git -f replacelinkwithfile
   $ hg qpop
   popping replacelinkwithfile
   now at: addlink
   $ hg qpush
   applying replacelinkwithfile
   now at: replacelinkwithfile
   $ cat s
   sss
   $ hg st
 
 
 test symlink removal
 
   $ hg qnew removesl.patch
   $ hg rm a
   $ hg qrefresh --git
   $ hg qpop
   popping removesl.patch
   now at: replacelinkwithfile
   $ hg qpush
   applying removesl.patch
   now at: removesl.patch
   $ hg st -c
   C b
   C c
   C s
 
 replace broken symlink with another broken symlink
 
   $ ln -s linka linka
   $ hg add linka
   $ hg qnew link
   $ hg mv linka linkb
   $ rm linkb
   $ ln -s linkb linkb
   $ hg qnew movelink
   $ hg qpop
   popping movelink
   now at: link
   $ hg qpush
   applying movelink
   now at: movelink
   $ $TESTDIR/readlink.py linkb
   linkb -> linkb
 
 check patch does not overwrite untracked symlinks
 
   $ hg qpop
   popping movelink
   now at: link
   $ ln -s linkbb linkb
   $ hg qpush
   applying movelink
+  cannot create linkb: destination already exists
+  1 out of 1 hunks FAILED -- saving rejects to file linkb.rej
   patch failed, unable to continue (try -v)
   patch failed, rejects left in working dir
   errors during apply, please fix and refresh movelink
   [2]