extdiff.py
763 lines
| 24.0 KiB
| text/x-python
|
PythonLexer
/ hgext / extdiff.py
|
r2333 | # extdiff.py - external diff program support for mercurial | ||
# | ||||
# Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com> | ||||
# | ||||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r5245 | |||
|
r8934 | '''command to allow external programs to compare revisions | ||
|
r8873 | |||
|
r9286 | The extdiff Mercurial extension allows you to use external programs | ||
|
r9257 | to compare revisions, or revision with working directory. The external | ||
diff programs are called with a configurable set of options and two | ||||
|
r5245 | non-option arguments: paths to directories containing snapshots of | ||
files to compare. | ||||
|
r37226 | If there is more than one file being compared and the "child" revision | ||
is the working directory, any modifications made in the external diff | ||||
program will be copied back to the working directory from the temporary | ||||
directory. | ||||
|
r14327 | The extdiff extension also allows you to configure new diff commands, so | ||
|
r11191 | you do not need to type :hg:`extdiff -p kdiff3` always. :: | ||
|
r3127 | |||
|
r5245 | [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 | ||||
|
r3127 | |||
|
r23150 | # 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 | ||||
|
r5245 | meld = | ||
# add new command called vimdiff, runs gvimdiff with DirDiff plugin | ||||
|
r9257 | # (see http://www.vim.org/scripts/script.php?script_id=102) Non | ||
# English user, be sure to put "let g:DirDiffDynamicDiffText = 1" in | ||||
|
r5245 | # your .vimrc | ||
|
r16242 | vimdiff = gvim -f "+next" \\ | ||
"+execute 'DirDiff' fnameescape(argv(0)) fnameescape(argv(1))" | ||||
|
r5245 | |||
|
r11191 | Tool arguments can include variables that are expanded at runtime:: | ||
|
r11184 | |||
$parent1, $plabel1 - filename, descriptive label of first parent | ||||
$child, $clabel - filename, descriptive label of child revision | ||||
$parent2, $plabel2 - filename, descriptive label of second parent | ||||
|
r14045 | $root - repository root | ||
|
r11184 | $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]. | ||||
|
r11191 | :: | ||
|
r11184 | [extdiff] | ||
|
r11191 | kdiff3 = | ||
|
r11184 | |||
[diff-tools] | ||||
kdiff3.diffargs=--L1 '$plabel1' --L2 '$clabel' $parent $child | ||||
|
r41724 | If a program has a graphical interface, it might be interesting to tell | ||
Mercurial about it. It will prevent the program from being mistakenly | ||||
used in a terminal-only environment (such as an SSH terminal session), | ||||
and will make :hg:`extdiff --per-file` open multiple file diffs at once | ||||
instead of one by one (if you still want to open file diffs one by one, | ||||
you can use the --confirm option). | ||||
Declaring that a tool has a graphical interface can be done with the | ||||
``gui`` flag next to where ``diffargs`` are specified: | ||||
:: | ||||
[diff-tools] | ||||
kdiff3.diffargs=--L1 '$plabel1' --L2 '$clabel' $parent $child | ||||
kdiff3.gui = true | ||||
|
r11191 | 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). | ||||
|
r5245 | ''' | ||
|
r2333 | |||
|
r28970 | from __future__ import absolute_import | ||
import os | ||||
import re | ||||
import shutil | ||||
|
r36799 | import stat | ||
|
r41724 | import subprocess | ||
|
r38183 | |||
|
r3891 | from mercurial.i18n import _ | ||
|
r28970 | from mercurial.node import ( | ||
nullid, | ||||
short, | ||||
) | ||||
from mercurial import ( | ||||
archival, | ||||
cmdutil, | ||||
|
r41628 | encoding, | ||
|
r28970 | error, | ||
filemerge, | ||||
|
r37622 | formatter, | ||
|
r30678 | pycompat, | ||
|
r32337 | registrar, | ||
|
r28970 | scmutil, | ||
util, | ||||
) | ||||
|
r37102 | from mercurial.utils import ( | ||
|
r37138 | procutil, | ||
|
r37102 | stringutil, | ||
) | ||||
|
r5135 | |||
|
r21246 | cmdtable = {} | ||
|
r32337 | command = registrar.command(cmdtable) | ||
|
r34778 | |||
configtable = {} | ||||
configitem = registrar.configitem(configtable) | ||||
|
r43346 | configitem( | ||
|
r43347 | b'extdiff', br'opts\..*', default=b'', generic=True, | ||
|
r34778 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'extdiff', br'gui\..*', generic=True, | ||
|
r41724 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'diff-tools', br'.*\.diffargs$', default=None, generic=True, | ||
|
r34779 | ) | ||
|
r43346 | configitem( | ||
|
r43347 | b'diff-tools', br'.*\.gui$', generic=True, | ||
|
r41724 | ) | ||
|
r29841 | # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for | ||
|
r25186 | # 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. | ||||
|
r43347 | testedwith = b'ships-with-hg-core' | ||
|
r16743 | |||
|
r43346 | |||
|
r25813 | def snapshot(ui, repo, files, node, tmproot, listsubrepos): | ||
|
r8064 | '''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.''' | ||||
|
r5135 | dirname = os.path.basename(repo.root) | ||
|
r43347 | if dirname == b"": | ||
dirname = b"root" | ||||
|
r8064 | if node is not None: | ||
|
r43347 | dirname = b'%s.%s' % (dirname, short(node)) | ||
|
r5135 | base = os.path.join(tmproot, dirname) | ||
os.mkdir(base) | ||||
|
r32212 | fnsandstat = [] | ||
|
r25812 | |||
|
r8064 | if node is not None: | ||
|
r43346 | ui.note( | ||
|
r43347 | _(b'making snapshot of %d files from rev %s\n') | ||
|
r43346 | % (len(files), short(node)) | ||
) | ||||
|
r8064 | else: | ||
|
r43346 | ui.note( | ||
|
r43347 | _(b'making snapshot of %d files from working directory\n') | ||
|
r43346 | % (len(files)) | ||
) | ||||
|
r25812 | |||
if files: | ||||
|
r43347 | repo.ui.setconfig(b"ui", b"archivemeta", False) | ||
|
r25812 | |||
|
r43346 | archival.archive( | ||
repo, | ||||
base, | ||||
node, | ||||
|
r43347 | b'files', | ||
|
r43346 | match=scmutil.matchfiles(repo, files), | ||
subrepos=listsubrepos, | ||||
) | ||||
|
r25812 | |||
for fn in sorted(files): | ||||
wfn = util.pconvert(fn) | ||||
|
r43347 | ui.note(b' %s\n' % wfn) | ||
|
r25812 | |||
if node is None: | ||||
dest = os.path.join(base, wfn) | ||||
|
r32212 | fnsandstat.append((dest, repo.wjoin(fn), os.lstat(dest))) | ||
return dirname, fnsandstat | ||||
|
r5143 | |||
|
r43346 | |||
def formatcmdline( | ||||
cmdline, | ||||
repo_root, | ||||
do3way, | ||||
parent1, | ||||
plabel1, | ||||
parent2, | ||||
plabel2, | ||||
child, | ||||
clabel, | ||||
): | ||||
|
r41232 | # Function to quote file/dir names in the argument string. | ||
# When not operating in 3-way mode, an empty string is | ||||
# returned for parent2 | ||||
|
r43346 | replace = { | ||
|
r43347 | b'parent': parent1, | ||
b'parent1': parent1, | ||||
b'parent2': parent2, | ||||
b'plabel1': plabel1, | ||||
b'plabel2': plabel2, | ||||
b'child': child, | ||||
b'clabel': clabel, | ||||
b'root': repo_root, | ||||
|
r43346 | } | ||
|
r41232 | def quote(match): | ||
pre = match.group(2) | ||||
key = match.group(3) | ||||
|
r43347 | if not do3way and key == b'parent2': | ||
|
r41232 | return pre | ||
return pre + procutil.shellquote(replace[key]) | ||||
# Match parent2 first, so 'parent1?' will match both parent1 and parent | ||||
|
r43346 | regex = ( | ||
br'''(['"]?)([^\s'"$]*)''' | ||||
br'\$(parent2|parent1?|child|plabel1|plabel2|clabel|root)\1' | ||||
) | ||||
|
r41232 | if not do3way and not re.search(regex, cmdline): | ||
|
r43347 | cmdline += b' $parent1 $child' | ||
|
r41232 | return re.sub(regex, quote, cmdline) | ||
|
r43346 | |||
|
r41724 | def _systembackground(cmd, environ=None, cwd=None): | ||
''' like 'procutil.system', but returns the Popen object directly | ||||
so we don't have to wait on it. | ||||
''' | ||||
env = procutil.shellenviron(environ) | ||||
|
r43346 | proc = subprocess.Popen( | ||
procutil.tonativestr(cmd), | ||||
shell=True, | ||||
close_fds=procutil.closefds, | ||||
env=procutil.tonativeenv(env), | ||||
cwd=pycompat.rapply(procutil.tonativestr, cwd), | ||||
) | ||||
|
r41724 | return proc | ||
|
r43346 | |||
def _runperfilediff( | ||||
cmdline, | ||||
repo_root, | ||||
ui, | ||||
guitool, | ||||
do3way, | ||||
confirm, | ||||
commonfiles, | ||||
tmproot, | ||||
dir1a, | ||||
dir1b, | ||||
dir2root, | ||||
dir2, | ||||
rev1a, | ||||
rev1b, | ||||
rev2, | ||||
): | ||||
|
r41628 | # Note that we need to sort the list of files because it was | ||
# built in an "unstable" way and it's annoying to get files in a | ||||
# random order, especially when "confirm" mode is enabled. | ||||
|
r41724 | waitprocs = [] | ||
|
r41628 | totalfiles = len(commonfiles) | ||
for idx, commonfile in enumerate(sorted(commonfiles)): | ||||
path1a = os.path.join(tmproot, dir1a, commonfile) | ||||
label1a = commonfile + rev1a | ||||
if not os.path.isfile(path1a): | ||||
|
r44229 | path1a = pycompat.osdevnull | ||
|
r41628 | |||
|
r43347 | path1b = b'' | ||
label1b = b'' | ||||
|
r41628 | if do3way: | ||
path1b = os.path.join(tmproot, dir1b, commonfile) | ||||
label1b = commonfile + rev1b | ||||
if not os.path.isfile(path1b): | ||||
|
r44229 | path1b = pycompat.osdevnull | ||
|
r41628 | |||
path2 = os.path.join(dir2root, dir2, commonfile) | ||||
label2 = commonfile + rev2 | ||||
if confirm: | ||||
# Prompt before showing this diff | ||||
|
r43347 | difffiles = _(b'diff %s (%d of %d)') % ( | ||
|
r43346 | commonfile, | ||
idx + 1, | ||||
totalfiles, | ||||
) | ||||
responses = _( | ||||
|
r43347 | b'[Yns?]' | ||
b'$$ &Yes, show diff' | ||||
b'$$ &No, skip this diff' | ||||
b'$$ &Skip remaining diffs' | ||||
b'$$ &? (display help)' | ||||
|
r43346 | ) | ||
|
r43347 | r = ui.promptchoice(b'%s %s' % (difffiles, responses)) | ||
|
r43346 | if r == 3: # ? | ||
|
r41628 | while r == 3: | ||
for c, t in ui.extractchoices(responses)[1]: | ||||
|
r43347 | ui.write(b'%s - %s\n' % (c, encoding.lower(t))) | ||
r = ui.promptchoice(b'%s %s' % (difffiles, responses)) | ||||
|
r43346 | if r == 0: # yes | ||
|
r41628 | pass | ||
|
r43346 | elif r == 1: # no | ||
|
r41628 | continue | ||
|
r43346 | elif r == 2: # skip | ||
|
r41628 | break | ||
curcmdline = formatcmdline( | ||||
|
r43346 | cmdline, | ||
repo_root, | ||||
do3way=do3way, | ||||
parent1=path1a, | ||||
plabel1=label1a, | ||||
parent2=path1b, | ||||
plabel2=label1b, | ||||
child=path2, | ||||
clabel=label2, | ||||
) | ||||
|
r41628 | |||
|
r41724 | if confirm or not guitool: | ||
# Run the comparison program and wait for it to exit | ||||
# before we show the next file. | ||||
# This is because either we need to wait for confirmation | ||||
# from the user between each invocation, or because, as far | ||||
# as we know, the tool doesn't have a GUI, in which case | ||||
# we can't run multiple CLI programs at the same time. | ||||
|
r43346 | ui.debug( | ||
|
r43347 | b'running %r in %s\n' % (pycompat.bytestr(curcmdline), tmproot) | ||
|
r43346 | ) | ||
|
r43347 | ui.system(curcmdline, cwd=tmproot, blockedtag=b'extdiff') | ||
|
r41724 | else: | ||
# Run the comparison program but don't wait, as we're | ||||
# going to rapid-fire each file diff and then wait on | ||||
# the whole group. | ||||
|
r43346 | ui.debug( | ||
|
r43347 | b'running %r in %s (backgrounded)\n' | ||
|
r43346 | % (pycompat.bytestr(curcmdline), tmproot) | ||
) | ||||
|
r41724 | proc = _systembackground(curcmdline, cwd=tmproot) | ||
waitprocs.append(proc) | ||||
|
r41628 | |||
|
r41724 | if waitprocs: | ||
|
r43347 | with ui.timeblockedsection(b'extdiff'): | ||
|
r41724 | for proc in waitprocs: | ||
proc.wait() | ||||
|
r43346 | |||
|
r45689 | def diffpatch(ui, repo, node1, node2, tmproot, matcher, cmdline): | ||
|
r45686 | template = b'hg-%h.patch' | ||
|
r45689 | # write patches to temporary files | ||
|
r45686 | with formatter.nullformatter(ui, b'extdiff', {}) as fm: | ||
cmdutil.export( | ||||
repo, | ||||
|
r45689 | [repo[node1].rev(), repo[node2].rev()], | ||
|
r45686 | fm, | ||
fntemplate=repo.vfs.reljoin(tmproot, template), | ||||
match=matcher, | ||||
) | ||||
|
r45689 | label1 = cmdutil.makefilename(repo[node1], template) | ||
|
r45686 | label2 = cmdutil.makefilename(repo[node2], template) | ||
|
r45689 | file1 = repo.vfs.reljoin(tmproot, label1) | ||
file2 = repo.vfs.reljoin(tmproot, label2) | ||||
|
r45686 | cmdline = formatcmdline( | ||
cmdline, | ||||
repo.root, | ||||
|
r45688 | # no 3way while comparing patches | ||
do3way=False, | ||||
|
r45689 | parent1=file1, | ||
plabel1=label1, | ||||
# while comparing patches, there is no second parent | ||||
parent2=None, | ||||
plabel2=None, | ||||
child=file2, | ||||
|
r45686 | clabel=label2, | ||
) | ||||
ui.debug(b'running %r in %s\n' % (pycompat.bytestr(cmdline), tmproot)) | ||||
ui.system(cmdline, cwd=tmproot, blockedtag=b'extdiff') | ||||
return 1 | ||||
|
r45687 | def diffrevs( | ||
ui, | ||||
repo, | ||||
node1a, | ||||
node1b, | ||||
node2, | ||||
matcher, | ||||
tmproot, | ||||
cmdline, | ||||
do3way, | ||||
guitool, | ||||
opts, | ||||
): | ||||
subrepos = opts.get(b'subrepos') | ||||
|
r45690 | |||
# calculate list of files changed between both revs | ||||
|
r45687 | st = repo.status(node1a, node2, matcher, listsubrepos=subrepos) | ||
mod_a, add_a, rem_a = set(st.modified), set(st.added), set(st.removed) | ||||
if do3way: | ||||
stb = repo.status(node1b, node2, matcher, listsubrepos=subrepos) | ||||
mod_b, add_b, rem_b = ( | ||||
set(stb.modified), | ||||
set(stb.added), | ||||
set(stb.removed), | ||||
) | ||||
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 | ||||
|
r45690 | |||
|
r45687 | # Always make a copy of node1a (and node1b, if applicable) | ||
|
r45690 | # dir1a should contain files which are: | ||
# * modified or removed from node1a to node2 | ||||
# * modified or added from node1b to node2 | ||||
# (except file added from node1a to node2 as they were not present in | ||||
# node1a) | ||||
|
r45687 | dir1a_files = mod_a | rem_a | ((mod_b | add_b) - add_a) | ||
dir1a = snapshot(ui, repo, dir1a_files, node1a, tmproot, subrepos)[0] | ||||
rev1a = b'@%d' % repo[node1a].rev() | ||||
if do3way: | ||||
|
r45690 | # file calculation criteria same as dir1a | ||
|
r45687 | dir1b_files = mod_b | rem_b | ((mod_a | add_a) - add_b) | ||
dir1b = snapshot(ui, repo, dir1b_files, node1b, tmproot, subrepos)[0] | ||||
rev1b = b'@%d' % repo[node1b].rev() | ||||
else: | ||||
dir1b = None | ||||
rev1b = b'' | ||||
fnsandstat = [] | ||||
# If node2 in not the wc or there is >1 change, copy it | ||||
dir2root = b'' | ||||
rev2 = b'' | ||||
if node2: | ||||
dir2 = snapshot(ui, repo, modadd, node2, tmproot, subrepos)[0] | ||||
rev2 = b'@%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, fnsandstat = snapshot(ui, repo, modadd, None, tmproot, subrepos) | ||||
else: | ||||
# This lets the diff tool open the changed file directly | ||||
dir2 = b'' | ||||
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 = pycompat.osdevnull | ||||
if do3way: | ||||
dir1b = os.path.join(tmproot, dir1b, common_file) | ||||
label1b = common_file + rev1b | ||||
if not os.path.isfile(dir1b): | ||||
dir1b = pycompat.osdevnull | ||||
dir2 = os.path.join(dir2root, dir2, common_file) | ||||
label2 = common_file + rev2 | ||||
if not opts.get(b'per_file'): | ||||
# Run the external tool on the 2 temp directories or the patches | ||||
cmdline = formatcmdline( | ||||
cmdline, | ||||
repo.root, | ||||
do3way=do3way, | ||||
parent1=dir1a, | ||||
plabel1=label1a, | ||||
parent2=dir1b, | ||||
plabel2=label1b, | ||||
child=dir2, | ||||
clabel=label2, | ||||
) | ||||
ui.debug(b'running %r in %s\n' % (pycompat.bytestr(cmdline), tmproot)) | ||||
ui.system(cmdline, cwd=tmproot, blockedtag=b'extdiff') | ||||
else: | ||||
# Run the external tool once for each pair of files | ||||
_runperfilediff( | ||||
cmdline, | ||||
repo.root, | ||||
ui, | ||||
guitool=guitool, | ||||
do3way=do3way, | ||||
confirm=opts.get(b'confirm'), | ||||
commonfiles=common, | ||||
tmproot=tmproot, | ||||
dir1a=dir1a, | ||||
dir1b=dir1b, | ||||
dir2root=dir2root, | ||||
dir2=dir2, | ||||
rev1a=rev1a, | ||||
rev1b=rev1b, | ||||
rev2=rev2, | ||||
) | ||||
for copy_fn, working_fn, st in fnsandstat: | ||||
cpstat = os.lstat(copy_fn) | ||||
# Some tools copy the file and attributes, so mtime may not detect | ||||
# all changes. A size check will detect more cases, but not all. | ||||
# The only certain way to detect every case is to diff all files, | ||||
# which could be expensive. | ||||
# copyfile() carries over the permission, so the mode check could | ||||
# be in an 'elif' branch, but for the case where the file has | ||||
# changed without affecting mtime or size. | ||||
if ( | ||||
cpstat[stat.ST_MTIME] != st[stat.ST_MTIME] | ||||
or cpstat.st_size != st.st_size | ||||
or (cpstat.st_mode & 0o100) != (st.st_mode & 0o100) | ||||
): | ||||
ui.debug( | ||||
b'file changed while diffing. ' | ||||
b'Overwriting: %s (src: %s)\n' % (working_fn, copy_fn) | ||||
) | ||||
util.copyfile(copy_fn, working_fn) | ||||
return 1 | ||||
|
r41724 | def dodiff(ui, repo, cmdline, pats, opts, guitool=False): | ||
|
r17424 | '''Do the actual diff: | ||
|
r6103 | |||
- 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 | ||||
''' | ||||
|
r7758 | |||
|
r45322 | cmdutil.check_at_most_one_arg(opts, b'rev', b'change') | ||
|
r43347 | revs = opts.get(b'rev') | ||
change = opts.get(b'change') | ||||
do3way = b'$parent2' in cmdline | ||||
|
r7758 | |||
|
r45322 | if change: | ||
|
r37270 | ctx2 = scmutil.revsingle(repo, change, None) | ||
ctx1a, ctx1b = ctx2.p1(), ctx2.p2() | ||||
|
r7758 | else: | ||
|
r37270 | ctx1a, ctx2 = scmutil.revpair(repo, revs) | ||
|
r9512 | if not revs: | ||
|
r37270 | ctx1b = repo[None].p2() | ||
|
r9512 | else: | ||
|
r37270 | ctx1b = repo[nullid] | ||
node1a = ctx1a.node() | ||||
node1b = ctx1b.node() | ||||
node2 = ctx2.node() | ||||
|
r9512 | |||
# Disable 3-way merge if there is only one parent | ||||
if do3way: | ||||
if node1b == nullid: | ||||
do3way = False | ||||
|
r7758 | |||
|
r14671 | matcher = scmutil.match(repo[node2], pats, opts) | ||
|
r26227 | |||
|
r43347 | if opts.get(b'patch'): | ||
|
r45687 | if opts.get(b'subrepos'): | ||
|
r43347 | raise error.Abort(_(b'--patch cannot be used with --subrepos')) | ||
|
r45687 | if opts.get(b'per_file'): | ||
|
r43347 | raise error.Abort(_(b'--patch cannot be used with --per-file')) | ||
|
r26228 | if node2 is None: | ||
|
r43347 | raise error.Abort(_(b'--patch requires two revisions')) | ||
|
r2333 | |||
|
r43347 | tmproot = pycompat.mkdtemp(prefix=b'extdiff.') | ||
|
r2333 | try: | ||
|
r45686 | if opts.get(b'patch'): | ||
|
r45688 | return diffpatch(ui, repo, node1a, node2, tmproot, matcher, cmdline) | ||
|
r45686 | |||
|
r45687 | return diffrevs( | ||
ui, | ||||
repo, | ||||
node1a, | ||||
node1b, | ||||
node2, | ||||
matcher, | ||||
tmproot, | ||||
cmdline, | ||||
do3way, | ||||
guitool, | ||||
opts, | ||||
) | ||||
|
r5143 | |||
|
r2333 | finally: | ||
|
r43347 | ui.note(_(b'cleaning up temp directory\n')) | ||
|
r2333 | shutil.rmtree(tmproot) | ||
|
r27680 | |||
|
r43346 | extdiffopts = ( | ||
[ | ||||
( | ||||
|
r43347 | b'o', | ||
b'option', | ||||
[], | ||||
_(b'pass option to comparison program'), | ||||
_(b'OPT'), | ||||
), | ||||
(b'r', b'rev', [], _(b'revision'), _(b'REV')), | ||||
(b'c', b'change', b'', _(b'change made by revision'), _(b'REV')), | ||||
( | ||||
b'', | ||||
b'per-file', | ||||
|
r43346 | False, | ||
|
r43347 | _(b'compare each file instead of revision snapshots'), | ||
|
r43346 | ), | ||
( | ||||
|
r43347 | b'', | ||
b'confirm', | ||||
|
r43346 | False, | ||
|
r43347 | _(b'prompt user before each external program invocation'), | ||
|
r43346 | ), | ||
|
r43347 | (b'', b'patch', None, _(b'compare patches for two revisions')), | ||
|
r43346 | ] | ||
+ cmdutil.walkopts | ||||
+ cmdutil.subrepoopts | ||||
) | ||||
@command( | ||||
|
r43347 | b'extdiff', | ||
[(b'p', b'program', b'', _(b'comparison program to run'), _(b'CMD')),] | ||||
|
r43346 | + extdiffopts, | ||
|
r43347 | _(b'hg extdiff [OPT]... [FILE]...'), | ||
|
r40329 | helpcategory=command.CATEGORY_FILE_CONTENTS, | ||
|
r43346 | inferrepo=True, | ||
) | ||||
|
r2333 | def extdiff(ui, repo, *pats, **opts): | ||
'''use external program to diff repository (or selected files) | ||||
Show differences between revisions for the specified files, using | ||||
|
r7983 | an external program. The default program used is diff, with | ||
|
r2906 | default options "-Npru". | ||
|
r8076 | To select a different program, use the -p/--program option. The | ||
|
r41628 | program will be passed the names of two directories to compare, | ||
unless the --per-file option is specified (see below). To pass | ||||
additional options to the program, use -o/--option. These will be | ||||
passed before the names of the directories or files to compare. | ||||
|
r2333 | |||
|
r7990 | 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 | ||||
|
r41628 | to its parent. | ||
The --per-file option runs the external program repeatedly on each | ||||
|
r41724 | file to diff, instead of once on two directories. By default, | ||
this happens one by one, where the next file diff is open in the | ||||
external program only once the previous external program (for the | ||||
previous file diff) has exited. If the external program has a | ||||
graphical interface, it can open all the file diffs at once instead | ||||
of one by one. See :hg:`help -e extdiff` for information about how | ||||
to tell Mercurial that a given program has a graphical interface. | ||||
|
r41628 | |||
The --confirm option will prompt the user before each invocation of | ||||
the external program. It is ignored if --per-file isn't specified. | ||||
''' | ||||
|
r34977 | opts = pycompat.byteskwargs(opts) | ||
|
r43347 | program = opts.get(b'program') | ||
option = opts.get(b'option') | ||||
|
r9519 | if not program: | ||
|
r43347 | program = b'diff' | ||
option = option or [b'-Npru'] | ||||
cmdline = b' '.join(map(procutil.shellquote, [program] + option)) | ||||
|
r23680 | return dodiff(ui, repo, cmdline, pats, opts) | ||
|
r2333 | |||
|
r43346 | |||
|
r29721 | class savedcmd(object): | ||
|
r29723 | """use external program to diff repository (or selected files) | ||
|
r29721 | |||
Show differences between revisions for the specified files, using | ||||
|
r29723 | the following program:: | ||
%(path)s | ||||
|
r29721 | |||
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. | ||||
""" | ||||
|
r41724 | def __init__(self, path, cmdline, isgui): | ||
|
r29721 | # We can't pass non-ASCII through docstrings (and path is | ||
|
r40842 | # in an unknown encoding anyway), but avoid double separators on | ||
# Windows | ||||
docpath = stringutil.escapestr(path).replace(b'\\\\', b'\\') | ||||
|
r43906 | self.__doc__ %= {'path': pycompat.sysstr(stringutil.uirepr(docpath))} | ||
|
r29721 | self._cmdline = cmdline | ||
|
r41724 | self._isgui = isgui | ||
|
r29721 | |||
def __call__(self, ui, repo, *pats, **opts): | ||||
|
r34977 | opts = pycompat.byteskwargs(opts) | ||
|
r43347 | options = b' '.join(map(procutil.shellquote, opts[b'option'])) | ||
|
r29721 | if options: | ||
|
r43347 | options = b' ' + options | ||
|
r43346 | return dodiff( | ||
ui, repo, self._cmdline + options, pats, opts, guitool=self._isgui | ||||
) | ||||
|
r29721 | |||
|
r2333 | def uisetup(ui): | ||
|
r43347 | for cmd, path in ui.configitems(b'extdiff'): | ||
|
r24193 | path = util.expandpath(path) | ||
|
r43347 | if cmd.startswith(b'cmd.'): | ||
|
r5245 | cmd = cmd[4:] | ||
|
r10282 | if not path: | ||
|
r37138 | path = procutil.findexe(cmd) | ||
|
r23150 | if path is None: | ||
path = filemerge.findexternaltool(ui, cmd) or cmd | ||||
|
r43347 | diffopts = ui.config(b'extdiff', b'opts.' + cmd) | ||
|
r37138 | cmdline = procutil.shellquote(path) | ||
|
r23680 | if diffopts: | ||
|
r43347 | cmdline += b' ' + diffopts | ||
isgui = ui.configbool(b'extdiff', b'gui.' + cmd) | ||||
elif cmd.startswith(b'opts.') or cmd.startswith(b'gui.'): | ||||
|
r5245 | continue | ||
else: | ||||
if path: | ||||
|
r23680 | # case "cmd = path opts" | ||
cmdline = path | ||||
|
r30678 | diffopts = len(pycompat.shlexsplit(cmdline)) > 1 | ||
|
r5245 | else: | ||
|
r23680 | # case "cmd =" | ||
|
r37138 | path = procutil.findexe(cmd) | ||
|
r23150 | if path is None: | ||
path = filemerge.findexternaltool(ui, cmd) or cmd | ||||
|
r37138 | cmdline = procutil.shellquote(path) | ||
|
r23680 | diffopts = False | ||
|
r43347 | isgui = ui.configbool(b'extdiff', b'gui.' + cmd) | ||
|
r11184 | # look for diff arguments in [diff-tools] then [merge-tools] | ||
|
r23680 | if not diffopts: | ||
|
r43347 | key = cmd + b'.diffargs' | ||
for section in (b'diff-tools', b'merge-tools'): | ||||
|
r41724 | args = ui.config(section, key) | ||
if args: | ||||
|
r43347 | cmdline += b' ' + args | ||
|
r41724 | if isgui is None: | ||
|
r43347 | isgui = ui.configbool(section, cmd + b'.gui') or False | ||
|
r41724 | break | ||
|
r43346 | command( | ||
cmd, | ||||
extdiffopts[:], | ||||
|
r43347 | _(b'hg %s [OPTION]... [FILE]...') % cmd, | ||
|
r43346 | helpcategory=command.CATEGORY_FILE_CONTENTS, | ||
inferrepo=True, | ||||
)(savedcmd(path, cmdline, isgui)) | ||||
|
r29722 | |||
# tell hggettext to extract docstrings from these functions: | ||||
i18nfunctions = [savedcmd] | ||||