extdiff: escape path for docstring (issue5301)

The existing code (a) assumed path would be specified in
encoding.encoding and (b) assumed unicode() objects wouldn't cause
other parts of Mercurial to blow up. Both are dangerous assumptions.

Since we don't know the encoding of path and can't pass non-ASCII
through docstrings, just escape the path and drop the early _(). Will
have to suffice until we can teach docstrings to handle UTF-8b
escaping.

This has the side-effect that the line containing the path is now
variable by the time it reaches _() and thus can't be translated.

hgext/extdiff.py

@@ -1,390 +1,384 b''
 # extdiff.py - external diff program support for mercurial
 #
 # Copyright 2006 Vadim Gelfer <[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.
 
 '''command to allow external programs to compare revisions
 
 The extdiff Mercurial extension allows you to use external programs
 to compare revisions, or revision with working directory. The external
 diff programs are called with a configurable set of options and two
 non-option arguments: paths to directories containing snapshots of
 files to compare.
 
 The extdiff extension also allows you to configure new diff commands, so
 you do not need to type :hg:`extdiff -p kdiff3` always. ::
 
   [extdiff]
   # add new command that runs GNU diff(1) in 'context diff' mode
   cdiff = gdiff -Nprc5
   ## or the old way:
   #cmd.cdiff = gdiff
   #opts.cdiff = -Nprc5
 
   # add new command called meld, runs meld (no need to name twice).  If
   # the meld executable is not available, the meld tool in [merge-tools]
   # will be used, if available
   meld =
 
   # add new command called vimdiff, runs gvimdiff with DirDiff plugin
   # (see http://www.vim.org/scripts/script.php?script_id=102) Non
   # English user, be sure to put "let g:DirDiffDynamicDiffText = 1" in
   # your .vimrc
   vimdiff = gvim -f "+next" \\
             "+execute 'DirDiff' fnameescape(argv(0)) fnameescape(argv(1))"
 
 Tool arguments can include variables that are expanded at runtime::
 
   $parent1, $plabel1 - filename, descriptive label of first parent
   $child,   $clabel  - filename, descriptive label of child revision
   $parent2, $plabel2 - filename, descriptive label of second parent
   $root              - repository root
   $parent is an alias for $parent1.
 
 The extdiff extension will look in your [diff-tools] and [merge-tools]
 sections for diff tool arguments, when none are specified in [extdiff].
 
 ::
 
   [extdiff]
   kdiff3 =
 
   [diff-tools]
   kdiff3.diffargs=--L1 '$plabel1' --L2 '$clabel' $parent $child
 
 You can use -I/-X and list of file or directory names like normal
 :hg:`diff` command. The extdiff extension makes snapshots of only
 needed files, so running the external diff program will actually be
 pretty fast (at least faster than having to compare the entire tree).
 '''
 
 from __future__ import absolute_import
 
 import os
 import re
 import shlex
 import shutil
 import tempfile
 from mercurial.i18n import _
 from mercurial.node import (
     nullid,
     short,
 )
 from mercurial import (
     archival,
     cmdutil,
     commands,
-    encoding,
     error,
     filemerge,
     scmutil,
     util,
 )
 
 cmdtable = {}
 command = cmdutil.command(cmdtable)
 # Note for extension authors: ONLY specify testedwith = 'internal' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = 'internal'
 
 def snapshot(ui, repo, files, node, tmproot, listsubrepos):
     '''snapshot files as of some revision
     if not using snapshot, -I/-X does not work and recursive diff
     in tools like kdiff3 and meld displays too many files.'''
     dirname = os.path.basename(repo.root)
     if dirname == "":
         dirname = "root"
     if node is not None:
         dirname = '%s.%s' % (dirname, short(node))
     base = os.path.join(tmproot, dirname)
     os.mkdir(base)
     fns_and_mtime = []
 
     if node is not None:
         ui.note(_('making snapshot of %d files from rev %s\n') %
                 (len(files), short(node)))
     else:
         ui.note(_('making snapshot of %d files from working directory\n') %
             (len(files)))
 
     if files:
         repo.ui.setconfig("ui", "archivemeta", False)
 
         archival.archive(repo, base, node, 'files',
                          matchfn=scmutil.matchfiles(repo, files),
                          subrepos=listsubrepos)
 
         for fn in sorted(files):
             wfn = util.pconvert(fn)
             ui.note('  %s\n' % wfn)
 
             if node is None:
                 dest = os.path.join(base, wfn)
 
                 fns_and_mtime.append((dest, repo.wjoin(fn),
                                       os.lstat(dest).st_mtime))
     return dirname, fns_and_mtime
 
 def dodiff(ui, repo, cmdline, pats, opts):
     '''Do the actual diff:
 
     - copy to a temp structure if diffing 2 internal revisions
     - copy to a temp structure if diffing working revision with
       another one and more than 1 file is changed
     - just invoke the diff for a single file in the working dir
     '''
 
     revs = opts.get('rev')
     change = opts.get('change')
     do3way = '$parent2' in cmdline
 
     if revs and change:
         msg = _('cannot specify --rev and --change at the same time')
         raise error.Abort(msg)
     elif change:
         node2 = scmutil.revsingle(repo, change, None).node()
         node1a, node1b = repo.changelog.parents(node2)
     else:
         node1a, node2 = scmutil.revpair(repo, revs)
         if not revs:
             node1b = repo.dirstate.p2()
         else:
             node1b = nullid
 
     # Disable 3-way merge if there is only one parent
     if do3way:
         if node1b == nullid:
             do3way = False
 
     subrepos=opts.get('subrepos')
 
     matcher = scmutil.match(repo[node2], pats, opts)
 
     if opts.get('patch'):
         if subrepos:
             raise error.Abort(_('--patch cannot be used with --subrepos'))
         if node2 is None:
             raise error.Abort(_('--patch requires two revisions'))
     else:
         mod_a, add_a, rem_a = map(set, repo.status(node1a, node2, matcher,
                                                    listsubrepos=subrepos)[:3])
         if do3way:
             mod_b, add_b, rem_b = map(set,
                                       repo.status(node1b, node2, matcher,
                                                   listsubrepos=subrepos)[:3])
         else:
             mod_b, add_b, rem_b = set(), set(), set()
         modadd = mod_a | add_a | mod_b | add_b
         common = modadd | rem_a | rem_b
         if not common:
             return 0
 
     tmproot = tempfile.mkdtemp(prefix='extdiff.')
     try:
         if not opts.get('patch'):
             # Always make a copy of node1a (and node1b, if applicable)
             dir1a_files = mod_a | rem_a | ((mod_b | add_b) - add_a)
             dir1a = snapshot(ui, repo, dir1a_files, node1a, tmproot,
                              subrepos)[0]
             rev1a = '@%d' % repo[node1a].rev()
             if do3way:
                 dir1b_files = mod_b | rem_b | ((mod_a | add_a) - add_b)
                 dir1b = snapshot(ui, repo, dir1b_files, node1b, tmproot,
                                  subrepos)[0]
                 rev1b = '@%d' % repo[node1b].rev()
             else:
                 dir1b = None
                 rev1b = ''
 
             fns_and_mtime = []
 
             # If node2 in not the wc or there is >1 change, copy it
             dir2root = ''
             rev2 = ''
             if node2:
                 dir2 = snapshot(ui, repo, modadd, node2, tmproot, subrepos)[0]
                 rev2 = '@%d' % repo[node2].rev()
             elif len(common) > 1:
                 #we only actually need to get the files to copy back to
                 #the working dir in this case (because the other cases
                 #are: diffing 2 revisions or single file -- in which case
                 #the file is already directly passed to the diff tool).
                 dir2, fns_and_mtime = snapshot(ui, repo, modadd, None, tmproot,
                                                subrepos)
             else:
                 # This lets the diff tool open the changed file directly
                 dir2 = ''
                 dir2root = repo.root
 
             label1a = rev1a
             label1b = rev1b
             label2 = rev2
 
             # If only one change, diff the files instead of the directories
             # Handle bogus modifies correctly by checking if the files exist
             if len(common) == 1:
                 common_file = util.localpath(common.pop())
                 dir1a = os.path.join(tmproot, dir1a, common_file)
                 label1a = common_file + rev1a
                 if not os.path.isfile(dir1a):
                     dir1a = os.devnull
                 if do3way:
                     dir1b = os.path.join(tmproot, dir1b, common_file)
                     label1b = common_file + rev1b
                     if not os.path.isfile(dir1b):
                         dir1b = os.devnull
                 dir2 = os.path.join(dir2root, dir2, common_file)
                 label2 = common_file + rev2
         else:
             template = 'hg-%h.patch'
             cmdutil.export(repo, [repo[node1a].rev(), repo[node2].rev()],
                            template=repo.vfs.reljoin(tmproot, template),
                            match=matcher)
             label1a = cmdutil.makefilename(repo, template, node1a)
             label2 = cmdutil.makefilename(repo, template, node2)
             dir1a = repo.vfs.reljoin(tmproot, label1a)
             dir2 = repo.vfs.reljoin(tmproot, label2)
             dir1b = None
             label1b = None
             fns_and_mtime = []
 
         # Function to quote file/dir names in the argument string.
         # When not operating in 3-way mode, an empty string is
         # returned for parent2
         replace = {'parent': dir1a, 'parent1': dir1a, 'parent2': dir1b,
                    'plabel1': label1a, 'plabel2': label1b,
                    'clabel': label2, 'child': dir2,
                    'root': repo.root}
         def quote(match):
             pre = match.group(2)
             key = match.group(3)
             if not do3way and key == 'parent2':
                 return pre
             return pre + util.shellquote(replace[key])
 
         # Match parent2 first, so 'parent1?' will match both parent1 and parent
         regex = (r'''(['"]?)([^\s'"$]*)'''
                  r'\$(parent2|parent1?|child|plabel1|plabel2|clabel|root)\1')
         if not do3way and not re.search(regex, cmdline):
             cmdline += ' $parent1 $child'
         cmdline = re.sub(regex, quote, cmdline)
 
         ui.debug('running %r in %s\n' % (cmdline, tmproot))
         ui.system(cmdline, cwd=tmproot)
 
         for copy_fn, working_fn, mtime in fns_and_mtime:
             if os.lstat(copy_fn).st_mtime != mtime:
                 ui.debug('file changed while diffing. '
                          'Overwriting: %s (src: %s)\n' % (working_fn, copy_fn))
                 util.copyfile(copy_fn, working_fn)
 
         return 1
     finally:
         ui.note(_('cleaning up temp directory\n'))
         shutil.rmtree(tmproot)
 
 extdiffopts = [
     ('o', 'option', [],
      _('pass option to comparison program'), _('OPT')),
     ('r', 'rev', [], _('revision'), _('REV')),
     ('c', 'change', '', _('change made by revision'), _('REV')),
     ('', 'patch', None, _('compare patches for two revisions'))
     ] + commands.walkopts + commands.subrepoopts
 
 @command('extdiff',
     [('p', 'program', '', _('comparison program to run'), _('CMD')),
      ] + extdiffopts,
     _('hg extdiff [OPT]... [FILE]...'),
     inferrepo=True)
 def extdiff(ui, repo, *pats, **opts):
     '''use external program to diff repository (or selected files)
 
     Show differences between revisions for the specified files, using
     an external program. The default program used is diff, with
     default options "-Npru".
 
     To select a different program, use the -p/--program option. The
     program will be passed the names of two directories to compare. To
     pass additional options to the program, use -o/--option. These
     will be passed before the names of the directories to compare.
 
     When two revision arguments are given, then changes are shown
     between those revisions. If only one revision is specified then
     that revision is compared to the working directory, and, when no
     revisions are specified, the working directory files are compared
     to its parent.'''
     program = opts.get('program')
     option = opts.get('option')
     if not program:
         program = 'diff'
         option = option or ['-Npru']
     cmdline = ' '.join(map(util.shellquote, [program] + option))
     return dodiff(ui, repo, cmdline, pats, opts)
 
 def uisetup(ui):
     for cmd, path in ui.configitems('extdiff'):
         path = util.expandpath(path)
         if cmd.startswith('cmd.'):
             cmd = cmd[4:]
             if not path:
                 path = util.findexe(cmd)
                 if path is None:
                     path = filemerge.findexternaltool(ui, cmd) or cmd
             diffopts = ui.config('extdiff', 'opts.' + cmd, '')
             cmdline = util.shellquote(path)
             if diffopts:
                 cmdline += ' ' + diffopts
         elif cmd.startswith('opts.'):
             continue
         else:
             if path:
                 # case "cmd = path opts"
                 cmdline = path
                 diffopts = len(shlex.split(cmdline)) > 1
             else:
                 # case "cmd ="
                 path = util.findexe(cmd)
                 if path is None:
                     path = filemerge.findexternaltool(ui, cmd) or cmd
                 cmdline = util.shellquote(path)
                 diffopts = False
         # look for diff arguments in [diff-tools] then [merge-tools]
         if not diffopts:
             args = ui.config('diff-tools', cmd+'.diffargs') or \
                    ui.config('merge-tools', cmd+'.diffargs')
             if args:
                 cmdline += ' ' + args
         def save(cmdline):
             '''use closure to save diff command to use'''
             def mydiff(ui, repo, *pats, **opts):
                 options = ' '.join(map(util.shellquote, opts['option']))
                 if options:
                     options = ' ' + options
                 return dodiff(ui, repo, cmdline + options, pats, opts)
-            doc = _('''\
+            # We can't pass non-ASCII through docstrings (and path is
+            # in an unknown encoding anyway)
+            docpath = path.encode("string-escape")
+            mydiff.__doc__ = '''\
 use %(path)s to diff repository (or selected files)
 
     Show differences between revisions for the specified files, using
     the %(path)s program.
 
     When two revision arguments are given, then changes are shown
     between those revisions. If only one revision is specified then
     that revision is compared to the working directory, and, when no
     revisions are specified, the working directory files are compared
     to its parent.\
-''') % {'path': util.uirepr(path)}
-
-            # We must translate the docstring right away since it is
-            # used as a format string. The string will unfortunately
-            # be translated again in commands.helpcmd and this will
-            # fail when the docstring contains non-ASCII characters.
-            # Decoding the string to a Unicode string here (using the
-            # right encoding) prevents that.
-            mydiff.__doc__ = doc.decode(encoding.encoding)
+''' % {'path': util.uirepr(docpath)}
             return mydiff
         command(cmd, extdiffopts[:], _('hg %s [OPTION]... [FILE]...') % cmd,
                 inferrepo=True)(save(cmdline))

tests/test-extdiff.t

@@ -1,391 +1,411 b''
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "extdiff=" >> $HGRCPATH
 
   $ hg init a
   $ cd a
   $ echo a > a
   $ echo b > b
   $ hg add
   adding a
   adding b
 
 Should diff cloned directories:
 
   $ hg extdiff -o -r $opt
   Only in a: a
   Only in a: b
   [1]
 
   $ cat <<EOF >> $HGRCPATH
   > [extdiff]
   > cmd.falabala = echo
   > opts.falabala = diffing
   > cmd.edspace = echo
   > opts.edspace = "name  <[e-mail]>"
   > EOF
 
   $ hg falabala
   diffing a.000000000000 a
   [1]
 
   $ hg help falabala
   hg falabala [OPTION]... [FILE]...
   
   use 'echo' to diff repository (or selected files)
   
       Show differences between revisions for the specified files, using the
       'echo' program.
   
       When two revision arguments are given, then changes are shown between
       those revisions. If only one revision is specified then that revision is
       compared to the working directory, and, when no revisions are specified,
       the working directory files are compared to its parent.
   
   options ([+] can be repeated):
   
    -o --option OPT [+]      pass option to comparison program
    -r --rev REV [+]         revision
    -c --change REV          change made by revision
       --patch               compare patches for two revisions
    -I --include PATTERN [+] include names matching the given patterns
    -X --exclude PATTERN [+] exclude names matching the given patterns
    -S --subrepos            recurse into subrepositories
   
   (some details hidden, use --verbose to show complete help)
 
   $ hg ci -d '0 0' -mtest1
 
   $ echo b >> a
   $ hg ci -d '1 0' -mtest2
 
 Should diff cloned files directly:
 
 #if windows
   $ hg falabala -r 0:1
   diffing "*\\extdiff.*\\a.8a5febb7f867\\a" "a.34eed99112ab\\a" (glob)
   [1]
 #else
   $ hg falabala -r 0:1
   diffing */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 #endif
 
 Specifying an empty revision should abort.
 
   $ hg extdiff -p diff --patch --rev 'ancestor()' --rev 1
   abort: empty revision on one side of range
   [255]
 
 Test diff during merge:
 
   $ hg update -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo c >> c
   $ hg add c
   $ hg ci -m "new branch" -d '1 0'
   created new head
   $ hg merge 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 Should diff cloned file against wc file:
 
 #if windows
   $ hg falabala
   diffing "*\\extdiff.*\\a.2a13a4d2da36\\a" "*\\a\\a" (glob)
   [1]
 #else
   $ hg falabala
   diffing */extdiff.*/a.2a13a4d2da36/a */a/a (glob)
   [1]
 #endif
 
 
 Test --change option:
 
   $ hg ci -d '2 0' -mtest3
 #if windows
   $ hg falabala -c 1
   diffing "*\\extdiff.*\\a.8a5febb7f867\\a" "a.34eed99112ab\\a" (glob)
   [1]
 #else
   $ hg falabala -c 1
   diffing */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 #endif
 
 Check diff are made from the first parent:
 
 #if windows
   $ hg falabala -c 3 || echo "diff-like tools yield a non-zero exit code"
   diffing "*\\extdiff.*\\a.2a13a4d2da36\\a" "a.46c0e4daeb72\\a" (glob)
   diff-like tools yield a non-zero exit code
 #else
   $ hg falabala -c 3 || echo "diff-like tools yield a non-zero exit code"
   diffing */extdiff.*/a.2a13a4d2da36/a a.46c0e4daeb72/a (glob)
   diff-like tools yield a non-zero exit code
 #endif
 
 issue3153: ensure using extdiff with removed subrepos doesn't crash:
 
   $ hg init suba
   $ cd suba
   $ echo suba > suba
   $ hg add
   adding suba
   $ hg ci -m "adding suba file"
   $ cd ..
   $ echo suba=suba > .hgsub
   $ hg add
   adding .hgsub
   $ hg ci -Sm "adding subrepo"
   $ echo > .hgsub
   $ hg ci -m "removing subrepo"
   $ hg falabala -r 4 -r 5 -S
   diffing a.398e36faf9c6 a.5ab95fb166c4
   [1]
 
 issue4463: usage of command line configuration without additional quoting
 
   $ cat <<EOF >> $HGRCPATH
   > [extdiff]
   > cmd.4463a = echo
   > opts.4463a = a-naked 'single quoted' "double quoted"
   > 4463b = echo b-naked 'single quoted' "double quoted"
   > echo =
   > EOF
   $ hg update -q -C 0
   $ echo a >> a
 #if windows
   $ hg --debug 4463a | grep '^running'
   running 'echo a-naked \'single quoted\' "double quoted" "*\\a" "*\\a"' in */extdiff.* (glob)
   $ hg --debug 4463b | grep '^running'
   running 'echo b-naked \'single quoted\' "double quoted" "*\\a" "*\\a"' in */extdiff.* (glob)
   $ hg --debug echo | grep '^running'
   running '*echo* "*\\a" "*\\a"' in */extdiff.* (glob)
 #else
   $ hg --debug 4463a | grep '^running'
   running 'echo a-naked \'single quoted\' "double quoted" */a $TESTTMP/a/a' in */extdiff.* (glob)
   $ hg --debug 4463b | grep '^running'
   running 'echo b-naked \'single quoted\' "double quoted" */a $TESTTMP/a/a' in */extdiff.* (glob)
   $ hg --debug echo | grep '^running'
   running '*echo */a $TESTTMP/a/a' in */extdiff.* (glob)
 #endif
 
 (getting options from other than extdiff section)
 
   $ cat <<EOF >> $HGRCPATH
   > [extdiff]
   > # using diff-tools diffargs
   > 4463b2 = echo
   > # using merge-tools diffargs
   > 4463b3 = echo
   > # no diffargs
   > 4463b4 = echo
   > [diff-tools]
   > 4463b2.diffargs = b2-naked 'single quoted' "double quoted"
   > [merge-tools]
   > 4463b3.diffargs = b3-naked 'single quoted' "double quoted"
   > EOF
 #if windows
   $ hg --debug 4463b2 | grep '^running'
   running 'echo b2-naked \'single quoted\' "double quoted" "*\\a" "*\\a"' in */extdiff.* (glob)
   $ hg --debug 4463b3 | grep '^running'
   running 'echo b3-naked \'single quoted\' "double quoted" "*\\a" "*\\a"' in */extdiff.* (glob)
   $ hg --debug 4463b4 | grep '^running'
   running 'echo "*\\a" "*\\a"' in */extdiff.* (glob)
   $ hg --debug 4463b4 --option b4-naked --option 'being quoted' | grep '^running'
   running 'echo b4-naked "being quoted" "*\\a" "*\\a"' in */extdiff.* (glob)
   $ hg --debug extdiff -p echo --option echo-naked --option 'being quoted' | grep '^running'
   running 'echo echo-naked "being quoted" "*\\a" "*\\a"' in */extdiff.* (glob)
 #else
   $ hg --debug 4463b2 | grep '^running'
   running 'echo b2-naked \'single quoted\' "double quoted" */a $TESTTMP/a/a' in */extdiff.* (glob)
   $ hg --debug 4463b3 | grep '^running'
   running 'echo b3-naked \'single quoted\' "double quoted" */a $TESTTMP/a/a' in */extdiff.* (glob)
   $ hg --debug 4463b4 | grep '^running'
   running 'echo */a $TESTTMP/a/a' in */extdiff.* (glob)
   $ hg --debug 4463b4 --option b4-naked --option 'being quoted' | grep '^running'
   running "echo b4-naked 'being quoted' */a $TESTTMP/a/a" in */extdiff.* (glob)
   $ hg --debug extdiff -p echo --option echo-naked --option 'being quoted' | grep '^running'
   running "echo echo-naked 'being quoted' */a $TESTTMP/a/a" in */extdiff.* (glob)
 #endif
 
   $ touch 'sp ace'
   $ hg add 'sp ace'
   $ hg ci -m 'sp ace'
   created new head
   $ echo > 'sp ace'
 
 Test pre-72a89cf86fcd backward compatibility with half-baked manual quoting
 
   $ cat <<EOF >> $HGRCPATH
   > [extdiff]
   > odd =
   > [merge-tools]
   > odd.diffargs = --foo='\$clabel' '\$clabel' "--bar=\$clabel" "\$clabel"
   > odd.executable = echo
   > EOF
 #if windows
 TODO
 #else
   $ hg --debug odd | grep '^running'
   running "*/echo --foo='sp ace' 'sp ace' --bar='sp ace' 'sp ace'" in * (glob)
 #endif
 
 Empty argument must be quoted
 
   $ cat <<EOF >> $HGRCPATH
   > [extdiff]
   > kdiff3 = echo
   > [merge-tools]
   > kdiff3.diffargs=--L1 \$plabel1 --L2 \$clabel \$parent \$child
   > EOF
 #if windows
   $ hg --debug kdiff3 -r0 | grep '^running'
   running 'echo --L1 "@0" --L2 "" a.8a5febb7f867 a' in * (glob)
 #else
   $ hg --debug kdiff3 -r0 | grep '^running'
   running "echo --L1 '@0' --L2 '' a.8a5febb7f867 a" in * (glob)
 #endif
 
 #if execbit
 
 Test extdiff of multiple files in tmp dir:
 
   $ hg update -C 0 > /dev/null
   $ echo changed > a
   $ echo changed > b
   $ chmod +x b
 
 Diff in working directory, before:
 
   $ hg diff --git
   diff --git a/a b/a
   --- a/a
   +++ b/a
   @@ -1,1 +1,1 @@
   -a
   +changed
   diff --git a/b b/b
   old mode 100644
   new mode 100755
   --- a/b
   +++ b/b
   @@ -1,1 +1,1 @@
   -b
   +changed
 
 
 Edit with extdiff -p:
 
 Prepare custom diff/edit tool:
 
   $ cat > 'diff tool.py' << EOT
   > #!/usr/bin/env python
   > import time
   > time.sleep(1) # avoid unchanged-timestamp problems
   > file('a/a', 'ab').write('edited\n')
   > file('a/b', 'ab').write('edited\n')
   > EOT
 
   $ chmod +x 'diff tool.py'
 
 will change to /tmp/extdiff.TMP and populate directories a.TMP and a
 and start tool
 
   $ hg extdiff -p "`pwd`/diff tool.py"
   [1]
 
 Diff in working directory, after:
 
   $ hg diff --git
   diff --git a/a b/a
   --- a/a
   +++ b/a
   @@ -1,1 +1,2 @@
   -a
   +changed
   +edited
   diff --git a/b b/b
   old mode 100644
   new mode 100755
   --- a/b
   +++ b/b
   @@ -1,1 +1,2 @@
   -b
   +changed
   +edited
 
 Test extdiff with --option:
 
   $ hg extdiff -p echo -o this -c 1
   this */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 
   $ hg falabala -o this -c 1
   diffing this */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 
 Test extdiff's handling of options with spaces in them:
 
   $ hg edspace -c 1
   name  <[e-mail]> */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 
   $ hg extdiff -p echo -o "name  <[e-mail]>" -c 1
   name  <[e-mail]> */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 
 Test with revsets:
 
   $ hg extdif -p echo -c "rev(1)"
   */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 
   $ hg extdif -p echo -r "0::1"
   */extdiff.*/a.8a5febb7f867/a a.34eed99112ab/a (glob)
   [1]
 
 Fallback to merge-tools.tool.executable|regkey
   $ mkdir dir
   $ cat > 'dir/tool.sh' << EOF
   > #!/bin/sh
   > echo "** custom diff **"
   > EOF
   $ chmod +x dir/tool.sh
   $ tool=`pwd`/dir/tool.sh
   $ hg --debug tl --config extdiff.tl= --config merge-tools.tl.executable=$tool
   making snapshot of 2 files from rev * (glob)
     a
     b
   making snapshot of 2 files from working directory
     a
     b
   running '$TESTTMP/a/dir/tool.sh a.* a' in */extdiff.* (glob)
   ** custom diff **
   cleaning up temp directory
   [1]
 
   $ cd ..
 
 #endif
 
 #if symlink
 
 Test symlinks handling (issue1909)
 
   $ hg init testsymlinks
   $ cd testsymlinks
   $ echo a > a
   $ hg ci -Am adda
   adding a
   $ echo a >> a
   $ ln -s missing linka
   $ hg add linka
   $ hg falabala -r 0 --traceback
   diffing testsymlinks.07f494440405 testsymlinks
   [1]
   $ cd ..
 
 #endif
+
+Test handling of non-ASCII paths in generated docstrings (issue5301)
+
+  >>> open("u", "w").write("\xa5\xa5")
+  $ U=`cat u`
+
+  $ HGPLAIN=1 hg --config hgext.extdiff= --config extdiff.cmd.td=hi help -k xyzzy
+  abort: no matches
+  (try "hg help" for a list of topics)
+  [255]
+
+  $ HGPLAIN=1 hg --config hgext.extdiff= --config extdiff.cmd.td=hi help td > /dev/null
+
+  $ LC_MESSAGES=ja_JP.UTF-8 hg --config hgext.extdiff= --config extdiff.cmd.td=$U help -k xyzzy
+  abort: no matches
+  (try "hg help" for a list of topics)
+  [255]
+
+  $ LC_MESSAGES=ja_JP.UTF-8 hg --config hgext.extdiff= --config extdiff.cmd.td=$U help td | grep "^use"
+  use '\xa5\xa5' to diff repository (or selected files)