|
|
# record.py
|
|
|
#
|
|
|
# Copyright 2007 Bryan O'Sullivan <bos@serpentine.com>
|
|
|
#
|
|
|
# This software may be used and distributed according to the terms of the
|
|
|
# GNU General Public License version 2 or any later version.
|
|
|
|
|
|
'''commands to interactively select changes for commit/qrefresh'''
|
|
|
|
|
|
from mercurial.i18n import gettext, _
|
|
|
from mercurial import cmdutil, commands, extensions, hg, patch
|
|
|
from mercurial import util
|
|
|
import copy, cStringIO, errno, os, re, shutil, tempfile
|
|
|
|
|
|
cmdtable = {}
|
|
|
command = cmdutil.command(cmdtable)
|
|
|
testedwith = 'internal'
|
|
|
|
|
|
lines_re = re.compile(r'@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)')
|
|
|
|
|
|
diffopts = [
|
|
|
('w', 'ignore-all-space', False,
|
|
|
_('ignore white space when comparing lines')),
|
|
|
('b', 'ignore-space-change', None,
|
|
|
_('ignore changes in the amount of white space')),
|
|
|
('B', 'ignore-blank-lines', None,
|
|
|
_('ignore changes whose lines are all blank')),
|
|
|
]
|
|
|
|
|
|
def scanpatch(fp):
|
|
|
"""like patch.iterhunks, but yield different events
|
|
|
|
|
|
- ('file', [header_lines + fromfile + tofile])
|
|
|
- ('context', [context_lines])
|
|
|
- ('hunk', [hunk_lines])
|
|
|
- ('range', (-start,len, +start,len, proc))
|
|
|
"""
|
|
|
lr = patch.linereader(fp)
|
|
|
|
|
|
def scanwhile(first, p):
|
|
|
"""scan lr while predicate holds"""
|
|
|
lines = [first]
|
|
|
while True:
|
|
|
line = lr.readline()
|
|
|
if not line:
|
|
|
break
|
|
|
if p(line):
|
|
|
lines.append(line)
|
|
|
else:
|
|
|
lr.push(line)
|
|
|
break
|
|
|
return lines
|
|
|
|
|
|
while True:
|
|
|
line = lr.readline()
|
|
|
if not line:
|
|
|
break
|
|
|
if line.startswith('diff --git a/') or line.startswith('diff -r '):
|
|
|
def notheader(line):
|
|
|
s = line.split(None, 1)
|
|
|
return not s or s[0] not in ('---', 'diff')
|
|
|
header = scanwhile(line, notheader)
|
|
|
fromfile = lr.readline()
|
|
|
if fromfile.startswith('---'):
|
|
|
tofile = lr.readline()
|
|
|
header += [fromfile, tofile]
|
|
|
else:
|
|
|
lr.push(fromfile)
|
|
|
yield 'file', header
|
|
|
elif line[0] == ' ':
|
|
|
yield 'context', scanwhile(line, lambda l: l[0] in ' \\')
|
|
|
elif line[0] in '-+':
|
|
|
yield 'hunk', scanwhile(line, lambda l: l[0] in '-+\\')
|
|
|
else:
|
|
|
m = lines_re.match(line)
|
|
|
if m:
|
|
|
yield 'range', m.groups()
|
|
|
else:
|
|
|
yield 'other', line
|
|
|
|
|
|
class header(object):
|
|
|
"""patch header
|
|
|
|
|
|
XXX shouldn't we move this to mercurial/patch.py ?
|
|
|
"""
|
|
|
diffgit_re = re.compile('diff --git a/(.*) b/(.*)$')
|
|
|
diff_re = re.compile('diff -r .* (.*)$')
|
|
|
allhunks_re = re.compile('(?:index|new file|deleted file) ')
|
|
|
pretty_re = re.compile('(?:new file|deleted file) ')
|
|
|
special_re = re.compile('(?:index|new|deleted|copy|rename) ')
|
|
|
|
|
|
def __init__(self, header):
|
|
|
self.header = header
|
|
|
self.hunks = []
|
|
|
|
|
|
def binary(self):
|
|
|
return util.any(h.startswith('index ') for h in self.header)
|
|
|
|
|
|
def pretty(self, fp):
|
|
|
for h in self.header:
|
|
|
if h.startswith('index '):
|
|
|
fp.write(_('this modifies a binary file (all or nothing)\n'))
|
|
|
break
|
|
|
if self.pretty_re.match(h):
|
|
|
fp.write(h)
|
|
|
if self.binary():
|
|
|
fp.write(_('this is a binary file\n'))
|
|
|
break
|
|
|
if h.startswith('---'):
|
|
|
fp.write(_('%d hunks, %d lines changed\n') %
|
|
|
(len(self.hunks),
|
|
|
sum([max(h.added, h.removed) for h in self.hunks])))
|
|
|
break
|
|
|
fp.write(h)
|
|
|
|
|
|
def write(self, fp):
|
|
|
fp.write(''.join(self.header))
|
|
|
|
|
|
def allhunks(self):
|
|
|
return util.any(self.allhunks_re.match(h) for h in self.header)
|
|
|
|
|
|
def files(self):
|
|
|
match = self.diffgit_re.match(self.header[0])
|
|
|
if match:
|
|
|
fromfile, tofile = match.groups()
|
|
|
if fromfile == tofile:
|
|
|
return [fromfile]
|
|
|
return [fromfile, tofile]
|
|
|
else:
|
|
|
return self.diff_re.match(self.header[0]).groups()
|
|
|
|
|
|
def filename(self):
|
|
|
return self.files()[-1]
|
|
|
|
|
|
def __repr__(self):
|
|
|
return '<header %s>' % (' '.join(map(repr, self.files())))
|
|
|
|
|
|
def special(self):
|
|
|
return util.any(self.special_re.match(h) for h in self.header)
|
|
|
|
|
|
def countchanges(hunk):
|
|
|
"""hunk -> (n+,n-)"""
|
|
|
add = len([h for h in hunk if h[0] == '+'])
|
|
|
rem = len([h for h in hunk if h[0] == '-'])
|
|
|
return add, rem
|
|
|
|
|
|
class hunk(object):
|
|
|
"""patch hunk
|
|
|
|
|
|
XXX shouldn't we merge this with patch.hunk ?
|
|
|
"""
|
|
|
maxcontext = 3
|
|
|
|
|
|
def __init__(self, header, fromline, toline, proc, before, hunk, after):
|
|
|
def trimcontext(number, lines):
|
|
|
delta = len(lines) - self.maxcontext
|
|
|
if False and delta > 0:
|
|
|
return number + delta, lines[:self.maxcontext]
|
|
|
return number, lines
|
|
|
|
|
|
self.header = header
|
|
|
self.fromline, self.before = trimcontext(fromline, before)
|
|
|
self.toline, self.after = trimcontext(toline, after)
|
|
|
self.proc = proc
|
|
|
self.hunk = hunk
|
|
|
self.added, self.removed = countchanges(self.hunk)
|
|
|
|
|
|
def write(self, fp):
|
|
|
delta = len(self.before) + len(self.after)
|
|
|
if self.after and self.after[-1] == '\\ No newline at end of file\n':
|
|
|
delta -= 1
|
|
|
fromlen = delta + self.removed
|
|
|
tolen = delta + self.added
|
|
|
fp.write('@@ -%d,%d +%d,%d @@%s\n' %
|
|
|
(self.fromline, fromlen, self.toline, tolen,
|
|
|
self.proc and (' ' + self.proc)))
|
|
|
fp.write(''.join(self.before + self.hunk + self.after))
|
|
|
|
|
|
pretty = write
|
|
|
|
|
|
def filename(self):
|
|
|
return self.header.filename()
|
|
|
|
|
|
def __repr__(self):
|
|
|
return '<hunk %r@%d>' % (self.filename(), self.fromline)
|
|
|
|
|
|
def parsepatch(fp):
|
|
|
"""patch -> [] of headers -> [] of hunks """
|
|
|
class parser(object):
|
|
|
"""patch parsing state machine"""
|
|
|
def __init__(self):
|
|
|
self.fromline = 0
|
|
|
self.toline = 0
|
|
|
self.proc = ''
|
|
|
self.header = None
|
|
|
self.context = []
|
|
|
self.before = []
|
|
|
self.hunk = []
|
|
|
self.headers = []
|
|
|
|
|
|
def addrange(self, limits):
|
|
|
fromstart, fromend, tostart, toend, proc = limits
|
|
|
self.fromline = int(fromstart)
|
|
|
self.toline = int(tostart)
|
|
|
self.proc = proc
|
|
|
|
|
|
def addcontext(self, context):
|
|
|
if self.hunk:
|
|
|
h = hunk(self.header, self.fromline, self.toline, self.proc,
|
|
|
self.before, self.hunk, context)
|
|
|
self.header.hunks.append(h)
|
|
|
self.fromline += len(self.before) + h.removed
|
|
|
self.toline += len(self.before) + h.added
|
|
|
self.before = []
|
|
|
self.hunk = []
|
|
|
self.proc = ''
|
|
|
self.context = context
|
|
|
|
|
|
def addhunk(self, hunk):
|
|
|
if self.context:
|
|
|
self.before = self.context
|
|
|
self.context = []
|
|
|
self.hunk = hunk
|
|
|
|
|
|
def newfile(self, hdr):
|
|
|
self.addcontext([])
|
|
|
h = header(hdr)
|
|
|
self.headers.append(h)
|
|
|
self.header = h
|
|
|
|
|
|
def addother(self, line):
|
|
|
pass # 'other' lines are ignored
|
|
|
|
|
|
def finished(self):
|
|
|
self.addcontext([])
|
|
|
return self.headers
|
|
|
|
|
|
transitions = {
|
|
|
'file': {'context': addcontext,
|
|
|
'file': newfile,
|
|
|
'hunk': addhunk,
|
|
|
'range': addrange},
|
|
|
'context': {'file': newfile,
|
|
|
'hunk': addhunk,
|
|
|
'range': addrange,
|
|
|
'other': addother},
|
|
|
'hunk': {'context': addcontext,
|
|
|
'file': newfile,
|
|
|
'range': addrange},
|
|
|
'range': {'context': addcontext,
|
|
|
'hunk': addhunk},
|
|
|
'other': {'other': addother},
|
|
|
}
|
|
|
|
|
|
p = parser()
|
|
|
|
|
|
state = 'context'
|
|
|
for newstate, data in scanpatch(fp):
|
|
|
try:
|
|
|
p.transitions[state][newstate](p, data)
|
|
|
except KeyError:
|
|
|
raise patch.PatchError('unhandled transition: %s -> %s' %
|
|
|
(state, newstate))
|
|
|
state = newstate
|
|
|
return p.finished()
|
|
|
|
|
|
def filterpatch(ui, headers):
|
|
|
"""Interactively filter patch chunks into applied-only chunks"""
|
|
|
|
|
|
def prompt(skipfile, skipall, query, chunk):
|
|
|
"""prompt query, and process base inputs
|
|
|
|
|
|
- y/n for the rest of file
|
|
|
- y/n for the rest
|
|
|
- ? (help)
|
|
|
- q (quit)
|
|
|
|
|
|
Return True/False and possibly updated skipfile and skipall.
|
|
|
"""
|
|
|
newpatches = None
|
|
|
if skipall is not None:
|
|
|
return skipall, skipfile, skipall, newpatches
|
|
|
if skipfile is not None:
|
|
|
return skipfile, skipfile, skipall, newpatches
|
|
|
while True:
|
|
|
resps = _('[Ynesfdaq?]')
|
|
|
choices = (_('&Yes, record this change'),
|
|
|
_('&No, skip this change'),
|
|
|
_('&Edit the change manually'),
|
|
|
_('&Skip remaining changes to this file'),
|
|
|
_('Record remaining changes to this &file'),
|
|
|
_('&Done, skip remaining changes and files'),
|
|
|
_('Record &all changes to all remaining files'),
|
|
|
_('&Quit, recording no changes'),
|
|
|
_('&?'))
|
|
|
r = ui.promptchoice("%s %s" % (query, resps), choices)
|
|
|
ui.write("\n")
|
|
|
if r == 8: # ?
|
|
|
doc = gettext(record.__doc__)
|
|
|
c = doc.find('::') + 2
|
|
|
for l in doc[c:].splitlines():
|
|
|
if l.startswith(' '):
|
|
|
ui.write(l.strip(), '\n')
|
|
|
continue
|
|
|
elif r == 0: # yes
|
|
|
ret = True
|
|
|
elif r == 1: # no
|
|
|
ret = False
|
|
|
elif r == 2: # Edit patch
|
|
|
if chunk is None:
|
|
|
ui.write(_('cannot edit patch for whole file'))
|
|
|
ui.write("\n")
|
|
|
continue
|
|
|
if chunk.header.binary():
|
|
|
ui.write(_('cannot edit patch for binary file'))
|
|
|
ui.write("\n")
|
|
|
continue
|
|
|
# Patch comment based on the Git one (based on comment at end of
|
|
|
# http://mercurial.selenic.com/wiki/RecordExtension)
|
|
|
phelp = '---' + _("""
|
|
|
To remove '-' lines, make them ' ' lines (context).
|
|
|
To remove '+' lines, delete them.
|
|
|
Lines starting with # will be removed from the patch.
|
|
|
|
|
|
If the patch applies cleanly, the edited hunk will immediately be
|
|
|
added to the record list. If it does not apply cleanly, a rejects
|
|
|
file will be generated: you can use that when you try again. If
|
|
|
all lines of the hunk are removed, then the edit is aborted and
|
|
|
the hunk is left unchanged.
|
|
|
""")
|
|
|
(patchfd, patchfn) = tempfile.mkstemp(prefix="hg-editor-",
|
|
|
suffix=".diff", text=True)
|
|
|
ncpatchfp = None
|
|
|
try:
|
|
|
# Write the initial patch
|
|
|
f = os.fdopen(patchfd, "w")
|
|
|
chunk.header.write(f)
|
|
|
chunk.write(f)
|
|
|
f.write('\n'.join(['# ' + i for i in phelp.splitlines()]))
|
|
|
f.close()
|
|
|
# Start the editor and wait for it to complete
|
|
|
editor = ui.geteditor()
|
|
|
util.system("%s \"%s\"" % (editor, patchfn),
|
|
|
environ={'HGUSER': ui.username()},
|
|
|
onerr=util.Abort, errprefix=_("edit failed"),
|
|
|
out=ui.fout)
|
|
|
# Remove comment lines
|
|
|
patchfp = open(patchfn)
|
|
|
ncpatchfp = cStringIO.StringIO()
|
|
|
for line in patchfp:
|
|
|
if not line.startswith('#'):
|
|
|
ncpatchfp.write(line)
|
|
|
patchfp.close()
|
|
|
ncpatchfp.seek(0)
|
|
|
newpatches = parsepatch(ncpatchfp)
|
|
|
finally:
|
|
|
os.unlink(patchfn)
|
|
|
del ncpatchfp
|
|
|
# Signal that the chunk shouldn't be applied as-is, but
|
|
|
# provide the new patch to be used instead.
|
|
|
ret = False
|
|
|
elif r == 3: # Skip
|
|
|
ret = skipfile = False
|
|
|
elif r == 4: # file (Record remaining)
|
|
|
ret = skipfile = True
|
|
|
elif r == 5: # done, skip remaining
|
|
|
ret = skipall = False
|
|
|
elif r == 6: # all
|
|
|
ret = skipall = True
|
|
|
elif r == 7: # quit
|
|
|
raise util.Abort(_('user quit'))
|
|
|
return ret, skipfile, skipall, newpatches
|
|
|
|
|
|
seen = set()
|
|
|
applied = {} # 'filename' -> [] of chunks
|
|
|
skipfile, skipall = None, None
|
|
|
pos, total = 1, sum(len(h.hunks) for h in headers)
|
|
|
for h in headers:
|
|
|
pos += len(h.hunks)
|
|
|
skipfile = None
|
|
|
fixoffset = 0
|
|
|
hdr = ''.join(h.header)
|
|
|
if hdr in seen:
|
|
|
continue
|
|
|
seen.add(hdr)
|
|
|
if skipall is None:
|
|
|
h.pretty(ui)
|
|
|
msg = (_('examine changes to %s?') %
|
|
|
_(' and ').join("'%s'" % f for f in h.files()))
|
|
|
r, skipfile, skipall, np = prompt(skipfile, skipall, msg, None)
|
|
|
if not r:
|
|
|
continue
|
|
|
applied[h.filename()] = [h]
|
|
|
if h.allhunks():
|
|
|
applied[h.filename()] += h.hunks
|
|
|
continue
|
|
|
for i, chunk in enumerate(h.hunks):
|
|
|
if skipfile is None and skipall is None:
|
|
|
chunk.pretty(ui)
|
|
|
if total == 1:
|
|
|
msg = _("record this change to '%s'?") % chunk.filename()
|
|
|
else:
|
|
|
idx = pos - len(h.hunks) + i
|
|
|
msg = _("record change %d/%d to '%s'?") % (idx, total,
|
|
|
chunk.filename())
|
|
|
r, skipfile, skipall, newpatches = prompt(skipfile,
|
|
|
skipall, msg, chunk)
|
|
|
if r:
|
|
|
if fixoffset:
|
|
|
chunk = copy.copy(chunk)
|
|
|
chunk.toline += fixoffset
|
|
|
applied[chunk.filename()].append(chunk)
|
|
|
elif newpatches is not None:
|
|
|
for newpatch in newpatches:
|
|
|
for newhunk in newpatch.hunks:
|
|
|
if fixoffset:
|
|
|
newhunk.toline += fixoffset
|
|
|
applied[newhunk.filename()].append(newhunk)
|
|
|
else:
|
|
|
fixoffset += chunk.removed - chunk.added
|
|
|
return sum([h for h in applied.itervalues()
|
|
|
if h[0].special() or len(h) > 1], [])
|
|
|
|
|
|
@command("record",
|
|
|
# same options as commit + white space diff options
|
|
|
commands.table['^commit|ci'][1][:] + diffopts,
|
|
|
_('hg record [OPTION]... [FILE]...'))
|
|
|
def record(ui, repo, *pats, **opts):
|
|
|
'''interactively select changes to commit
|
|
|
|
|
|
If a list of files is omitted, all changes reported by :hg:`status`
|
|
|
will be candidates for recording.
|
|
|
|
|
|
See :hg:`help dates` for a list of formats valid for -d/--date.
|
|
|
|
|
|
You will be prompted for whether to record changes to each
|
|
|
modified file, and for files with multiple changes, for each
|
|
|
change to use. For each query, the following responses are
|
|
|
possible::
|
|
|
|
|
|
y - record this change
|
|
|
n - skip this change
|
|
|
e - edit this change manually
|
|
|
|
|
|
s - skip remaining changes to this file
|
|
|
f - record remaining changes to this file
|
|
|
|
|
|
d - done, skip remaining changes and files
|
|
|
a - record all changes to all remaining files
|
|
|
q - quit, recording no changes
|
|
|
|
|
|
? - display help
|
|
|
|
|
|
This command is not available when committing a merge.'''
|
|
|
|
|
|
dorecord(ui, repo, commands.commit, 'commit', False, *pats, **opts)
|
|
|
|
|
|
def qrefresh(origfn, ui, repo, *pats, **opts):
|
|
|
if not opts['interactive']:
|
|
|
return origfn(ui, repo, *pats, **opts)
|
|
|
|
|
|
mq = extensions.find('mq')
|
|
|
|
|
|
def committomq(ui, repo, *pats, **opts):
|
|
|
# At this point the working copy contains only changes that
|
|
|
# were accepted. All other changes were reverted.
|
|
|
# We can't pass *pats here since qrefresh will undo all other
|
|
|
# changed files in the patch that aren't in pats.
|
|
|
mq.refresh(ui, repo, **opts)
|
|
|
|
|
|
# backup all changed files
|
|
|
dorecord(ui, repo, committomq, 'qrefresh', True, *pats, **opts)
|
|
|
|
|
|
def qrecord(ui, repo, patch, *pats, **opts):
|
|
|
'''interactively record a new patch
|
|
|
|
|
|
See :hg:`help qnew` & :hg:`help record` for more information and
|
|
|
usage.
|
|
|
'''
|
|
|
|
|
|
try:
|
|
|
mq = extensions.find('mq')
|
|
|
except KeyError:
|
|
|
raise util.Abort(_("'mq' extension not loaded"))
|
|
|
|
|
|
repo.mq.checkpatchname(patch)
|
|
|
|
|
|
def committomq(ui, repo, *pats, **opts):
|
|
|
opts['checkname'] = False
|
|
|
mq.new(ui, repo, patch, *pats, **opts)
|
|
|
|
|
|
dorecord(ui, repo, committomq, 'qnew', False, *pats, **opts)
|
|
|
|
|
|
def qnew(origfn, ui, repo, patch, *args, **opts):
|
|
|
if opts['interactive']:
|
|
|
return qrecord(ui, repo, patch, *args, **opts)
|
|
|
return origfn(ui, repo, patch, *args, **opts)
|
|
|
|
|
|
def dorecord(ui, repo, commitfunc, cmdsuggest, backupall, *pats, **opts):
|
|
|
if not ui.interactive():
|
|
|
raise util.Abort(_('running non-interactively, use %s instead') %
|
|
|
cmdsuggest)
|
|
|
|
|
|
# make sure username is set before going interactive
|
|
|
ui.username()
|
|
|
|
|
|
def recordfunc(ui, repo, message, match, opts):
|
|
|
"""This is generic record driver.
|
|
|
|
|
|
Its job is to interactively filter local changes, and
|
|
|
accordingly prepare working directory into a state in which the
|
|
|
job can be delegated to a non-interactive commit command such as
|
|
|
'commit' or 'qrefresh'.
|
|
|
|
|
|
After the actual job is done by non-interactive command, the
|
|
|
working directory is restored to its original state.
|
|
|
|
|
|
In the end we'll record interesting changes, and everything else
|
|
|
will be left in place, so the user can continue working.
|
|
|
"""
|
|
|
|
|
|
merge = len(repo[None].parents()) > 1
|
|
|
if merge:
|
|
|
raise util.Abort(_('cannot partially commit a merge '
|
|
|
'(use "hg commit" instead)'))
|
|
|
|
|
|
changes = repo.status(match=match)[:3]
|
|
|
diffopts = patch.diffopts(ui, opts=dict(
|
|
|
git=True, nodates=True,
|
|
|
ignorews=opts.get('ignore_all_space'),
|
|
|
ignorewsamount=opts.get('ignore_space_change'),
|
|
|
ignoreblanklines=opts.get('ignore_blank_lines')))
|
|
|
chunks = patch.diff(repo, changes=changes, opts=diffopts)
|
|
|
fp = cStringIO.StringIO()
|
|
|
fp.write(''.join(chunks))
|
|
|
fp.seek(0)
|
|
|
|
|
|
# 1. filter patch, so we have intending-to apply subset of it
|
|
|
try:
|
|
|
chunks = filterpatch(ui, parsepatch(fp))
|
|
|
except patch.PatchError, err:
|
|
|
raise util.Abort(_('error parsing patch: %s') % err)
|
|
|
|
|
|
del fp
|
|
|
|
|
|
contenders = set()
|
|
|
for h in chunks:
|
|
|
try:
|
|
|
contenders.update(set(h.files()))
|
|
|
except AttributeError:
|
|
|
pass
|
|
|
|
|
|
changed = changes[0] + changes[1] + changes[2]
|
|
|
newfiles = [f for f in changed if f in contenders]
|
|
|
if not newfiles:
|
|
|
ui.status(_('no changes to record\n'))
|
|
|
return 0
|
|
|
|
|
|
modified = set(changes[0])
|
|
|
|
|
|
# 2. backup changed files, so we can restore them in the end
|
|
|
if backupall:
|
|
|
tobackup = changed
|
|
|
else:
|
|
|
tobackup = [f for f in newfiles if f in modified]
|
|
|
|
|
|
backups = {}
|
|
|
if tobackup:
|
|
|
backupdir = repo.join('record-backups')
|
|
|
try:
|
|
|
os.mkdir(backupdir)
|
|
|
except OSError, err:
|
|
|
if err.errno != errno.EEXIST:
|
|
|
raise
|
|
|
try:
|
|
|
# backup continues
|
|
|
for f in tobackup:
|
|
|
fd, tmpname = tempfile.mkstemp(prefix=f.replace('/', '_')+'.',
|
|
|
dir=backupdir)
|
|
|
os.close(fd)
|
|
|
ui.debug('backup %r as %r\n' % (f, tmpname))
|
|
|
util.copyfile(repo.wjoin(f), tmpname)
|
|
|
shutil.copystat(repo.wjoin(f), tmpname)
|
|
|
backups[f] = tmpname
|
|
|
|
|
|
fp = cStringIO.StringIO()
|
|
|
for c in chunks:
|
|
|
if c.filename() in backups:
|
|
|
c.write(fp)
|
|
|
dopatch = fp.tell()
|
|
|
fp.seek(0)
|
|
|
|
|
|
# 3a. apply filtered patch to clean repo (clean)
|
|
|
if backups:
|
|
|
hg.revert(repo, repo.dirstate.p1(),
|
|
|
lambda key: key in backups)
|
|
|
|
|
|
# 3b. (apply)
|
|
|
if dopatch:
|
|
|
try:
|
|
|
ui.debug('applying patch\n')
|
|
|
ui.debug(fp.getvalue())
|
|
|
patch.internalpatch(ui, repo, fp, 1, eolmode=None)
|
|
|
except patch.PatchError, err:
|
|
|
raise util.Abort(str(err))
|
|
|
del fp
|
|
|
|
|
|
# 4. We prepared working directory according to filtered
|
|
|
# patch. Now is the time to delegate the job to
|
|
|
# commit/qrefresh or the like!
|
|
|
|
|
|
# it is important to first chdir to repo root -- we'll call
|
|
|
# a highlevel command with list of pathnames relative to
|
|
|
# repo root
|
|
|
cwd = os.getcwd()
|
|
|
os.chdir(repo.root)
|
|
|
try:
|
|
|
commitfunc(ui, repo, *newfiles, **opts)
|
|
|
finally:
|
|
|
os.chdir(cwd)
|
|
|
|
|
|
return 0
|
|
|
finally:
|
|
|
# 5. finally restore backed-up files
|
|
|
try:
|
|
|
for realname, tmpname in backups.iteritems():
|
|
|
ui.debug('restoring %r to %r\n' % (tmpname, realname))
|
|
|
util.copyfile(tmpname, repo.wjoin(realname))
|
|
|
# Our calls to copystat() here and above are a
|
|
|
# hack to trick any editors that have f open that
|
|
|
# we haven't modified them.
|
|
|
#
|
|
|
# Also note that this racy as an editor could
|
|
|
# notice the file's mtime before we've finished
|
|
|
# writing it.
|
|
|
shutil.copystat(tmpname, repo.wjoin(realname))
|
|
|
os.unlink(tmpname)
|
|
|
if tobackup:
|
|
|
os.rmdir(backupdir)
|
|
|
except OSError:
|
|
|
pass
|
|
|
|
|
|
# wrap ui.write so diff output can be labeled/colorized
|
|
|
def wrapwrite(orig, *args, **kw):
|
|
|
label = kw.pop('label', '')
|
|
|
for chunk, l in patch.difflabel(lambda: args):
|
|
|
orig(chunk, label=label + l)
|
|
|
oldwrite = ui.write
|
|
|
extensions.wrapfunction(ui, 'write', wrapwrite)
|
|
|
try:
|
|
|
return cmdutil.commit(ui, repo, recordfunc, pats, opts)
|
|
|
finally:
|
|
|
ui.write = oldwrite
|
|
|
|
|
|
cmdtable["qrecord"] = \
|
|
|
(qrecord, [], # placeholder until mq is available
|
|
|
_('hg qrecord [OPTION]... PATCH [FILE]...'))
|
|
|
|
|
|
def uisetup(ui):
|
|
|
try:
|
|
|
mq = extensions.find('mq')
|
|
|
except KeyError:
|
|
|
return
|
|
|
|
|
|
cmdtable["qrecord"] = \
|
|
|
(qrecord,
|
|
|
# same options as qnew, but copy them so we don't get
|
|
|
# -i/--interactive for qrecord and add white space diff options
|
|
|
mq.cmdtable['^qnew'][1][:] + diffopts,
|
|
|
_('hg qrecord [OPTION]... PATCH [FILE]...'))
|
|
|
|
|
|
_wrapcmd('qnew', mq.cmdtable, qnew, _("interactively record a new patch"))
|
|
|
_wrapcmd('qrefresh', mq.cmdtable, qrefresh,
|
|
|
_("interactively select changes to refresh"))
|
|
|
|
|
|
def _wrapcmd(cmd, table, wrapfn, msg):
|
|
|
entry = extensions.wrapcommand(table, cmd, wrapfn)
|
|
|
entry[1].append(('i', 'interactive', None, msg))
|
|
|
|
|
|
commands.inferrepo += " record qrecord"
|
|
|
|
