def _shelvecreatedcommit(ui, repo, node, name, tr):
shelvedfile(repo, name, 'oshelve').writeobsshelveinfo({
'node': nodemod.hex(node)
})
if util.safehasattr(cmdutil, 'exportfile'):
# Mercurial 4.6 and later
cmdutil.exportfile(repo.unfiltered(), [node],
shelvedfile(repo, name, patchextension).opener('wb'),
opts=mdiff.diffopts(git=True))
else:
# Mercurial 4.5 and earlier
cmdutil.export(repo.unfiltered(), [node],
fp=shelvedfile(repo, name, patchextension).opener('wb'),
opts=mdiff.diffopts(git=True))
def get_gitdiff(filenode_old, filenode_new):
"""Returns mercurial style git diff between given
``filenode_old`` and ``filenode_new``.
"""
for filenode in (filenode_old, filenode_new):
if not isinstance(filenode, FileNode):
raise VCSError("Given object should be FileNode object, not %s"
% filenode.__class__)
repo = filenode_new.changeset.repository
old_raw_id = getattr(filenode_old.changeset, 'raw_id', '0' * 40)
new_raw_id = getattr(filenode_new.changeset, 'raw_id', '0' * 40)
root = filenode_new.changeset.repository.path
file_filter = match(root, '', [filenode_new.path])
if isinstance(repo, MercurialRepository):
vcs_gitdiff = patch.diff(repo._repo,
old_raw_id,
new_raw_id,
match=file_filter,
opts=diffopts(git=True))
else:
vcs_gitdiff = repo._get_diff(old_raw_id, new_raw_id, filenode_new.path)
return vcs_gitdiff
def qrefresh_wrapper(orig, self, repo, *pats, **opts):
mqmessage = opts.pop('mqmessage', '') or '%a: %p\n%s%Q'
mqcommit, q, r = mqcommit_info(self, repo, opts)
diffstat = ""
if mqcommit and mqmessage:
if mqmessage.find("%s") != -1:
self.pushbuffer()
m = cmdutil.matchmod.match(repo.root, repo.getcwd(), [],
opts.get('include'), opts.get('exclude'),
'relpath', auditor=repo.auditor)
diffordiffstat(self, repo, mdiff.diffopts(),
repo.dirstate.parents()[0], None, m,
stat=True)
diffstat = self.popbuffer()
ret = orig(self, repo, *pats, **opts)
if ret:
return ret
if mqcommit and len(q.applied) > 0:
patch = q.applied[-1].name
if r is None:
raise error.Abort("no patch repository found when using -Q option")
mqmessage = substitute_mqmessage(mqmessage, repo, { 'p': patch,
'a': 'UPDATE',
's': diffstat })
commands.commit(r.ui, r, message=mqmessage)
def qrefresh_wrapper(orig, self, repo, *pats, **opts):
mqmessage = opts.pop('mqmessage', '') or '%a: %p\n%s%Q'
mqcommit, q, r = mqcommit_info(self, repo, opts)
diffstat = ""
if mqcommit and mqmessage:
if mqmessage.find("%s") != -1:
self.pushbuffer()
m = cmdutil.matchmod.match(repo.root, repo.getcwd(), [],
opts.get('include'), opts.get('exclude'),
'relpath', auditor=repo.auditor)
cmdutil.diffordiffstat(self, repo, mdiff.diffopts(),
repo.dirstate.parents()[0], None, m,
stat=True)
diffstat = self.popbuffer()
ret = orig(self, repo, *pats, **opts)
if ret:
return ret
if mqcommit and len(q.applied) > 0:
patch = q.applied[-1].name
if r is None:
raise util.Abort("no patch repository found when using -Q option")
mqmessage = substitute_mqmessage(mqmessage, repo, { 'p': patch,
'a': 'UPDATE',
's': diffstat })
commands.commit(r.ui, r, message=mqmessage)
def qrefresh_wrapper(self, repo, *pats, **opts):
mqmessage = opts.pop('mqmessage', None)
mqcommit, q, r = mqcommit_info(self, repo, opts)
diffstat = ""
if mqcommit and mqmessage:
if mqmessage.find("%s") != -1:
buffer = StringIO.StringIO()
m = cmdutil.match(repo, None, {})
diffopts = mdiff.diffopts()
cmdutil.diffordiffstat(self, repo, diffopts,
repo.dirstate.parents()[0], None, m,
stat=True, fp = buffer)
diffstat = buffer.getvalue()
buffer.close()
mq.refresh(self, repo, *pats, **opts)
if mqcommit and len(q.applied) > 0:
patch = q.applied[-1].name
if r is None:
raise util.Abort("no patch repository found when using -Q option")
mqmessage = mqmessage.replace("%p", patch)
mqmessage = mqmessage.replace("%a", 'UPDATE')
mqmessage = mqmessage.replace("%s", diffstat)
commands.commit(r.ui, r, message=mqmessage)
def recordfunc(ui, repo, files, message, match, opts):
"""This is generic record driver.
It's job is to interactively filter local changes, and accordingly
prepare working dir into a state, where the job can be delegated to
non-interactive commit command such as 'commit' or 'qrefresh'.
After the actual job is done by non-interactive command, working dir
state is restored to original.
In the end we'll record intresting changes, and everything else will be
left in place, so the user can continue his work.
"""
if files:
changes = None
else:
changes = repo.status(files=files, match=match)[:5]
modified, added, removed = changes[:3]
files = modified + added + removed
diffopts = mdiff.diffopts(git=True, nodates=True)
fp = cStringIO.StringIO()
patch.diff(repo,
repo.dirstate.parents()[0],
files=files,
match=match,
changes=changes,
opts=diffopts,
fp=fp)
fp.seek(0)
# 1. filter patch, so we have intending-to apply subset of it
chunks = filterpatch(ui, parsepatch(fp))
del fp
contenders = {}
for h in chunks:
try:
contenders.update(dict.fromkeys(h.files()))
except AttributeError:
pass
newfiles = [f for f in files if f in contenders]
if not newfiles:
ui.status(_('no changes to record\n'))
return 0
if changes is None:
changes = repo.status(files=newfiles, match=match)[:5]
modified = dict.fromkeys(changes[0])
# 2. backup changed files, so we can restore them in the end
backups = {}
backupdir = repo.join('record-backups')
try:
os.mkdir(backupdir)
except OSError, err:
if err.errno != errno.EEXIST:
raise
def recordfunc(ui, repo, message, match, opts):
"""This is generic record driver.
It's job is to interactively filter local changes, and accordingly
prepare working dir into a state, where the job can be delegated to
non-interactive commit command such as 'commit' or 'qrefresh'.
After the actual job is done by non-interactive command, working dir
state is restored to original.
In the end we'll record intresting changes, and everything else will be
left in place, so the user can continue his work.
"""
if match.files():
changes = None
else:
changes = repo.status(match=match)[:3]
modified, added, removed = changes
match = cmdutil.matchfiles(repo, modified + added + removed)
diffopts = mdiff.diffopts(git=True, nodates=True)
chunks = patch.diff(repo, repo.dirstate.parents()[0], match=match,
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
if changes is not None:
chunks = filterpatch(opts, parsepatch(changes, fp), chunkselector)
else:
chgs = repo.status(match=match)[:3]
chunks = filterpatch(opts, parsepatch(chgs, fp), chunkselector)
del fp
contenders = {}
for h in chunks:
try: contenders.update(dict.fromkeys(h.files()))
except AttributeError: pass
newfiles = [f for f in match.files() if f in contenders]
if not newfiles:
ui.status(_('no changes to record\n'))
return 0
if changes is None:
match = cmdutil.matchfiles(repo, newfiles)
changes = repo.status(match=match)
modified = dict.fromkeys(changes[0])
# 2. backup changed files, so we can restore them in the end
backups = {}
backupdir = repo.join('record-backups')
try:
os.mkdir(backupdir)
except OSError, err:
if err.errno != errno.EEXIST:
raise
def recordfunc(ui, repo, message, match, opts):
"""This is generic record driver.
Its job is to interactively filter local changes, and accordingly
prepare working dir into a state, where the job can be delegated to
non-interactive commit command such as 'commit' or 'qrefresh'.
After the actual job is done by non-interactive command, working dir
state is restored to original.
In the end we'll record interesting changes, and everything else will be
left in place, so the user can continue his work.
"""
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 = mdiff.diffopts(git=True, nodates=True)
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
chunks = crpatch.filterpatch(opts, crpatch.parsepatch(changes, fp),
chunk_selector.chunkselector, ui)
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
backups = {}
backupdir = repo.join('record-backups')
try:
os.mkdir(backupdir)
except OSError, err:
if err.errno != errno.EEXIST:
raise
def recordfunc(ui, repo, message, match, opts):
"""This is generic record driver.
Its job is to interactively filter local changes, and accordingly
prepare working dir into a state, where the job can be delegated to
non-interactive commit command such as 'commit' or 'qrefresh'.
After the actual job is done by non-interactive command, working dir
state is restored to original.
In the end we'll record interesting changes, and everything else will be
left in place, so the user can continue his work.
"""
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 = mdiff.diffopts(git=True, nodates=True)
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
chunks = crpatch.filterpatch(opts,
crpatch.parsepatch(changes, fp),
chunk_selector.chunkselector, ui)
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
backups = {}
backupdir = repo.join('record-backups')
try:
os.mkdir(backupdir)
except OSError, err:
if err.errno != errno.EEXIST:
raise
def creatediff(ctx):
"""create a Differential Diff"""
repo = ctx.repo()
repophid = getrepophid(repo)
# Create a "Differential Diff" via "differential.createrawdiff" API
params = {b'diff': getdiff(ctx, mdiff.diffopts(git=True, context=32767))}
if repophid:
params[b'repositoryPHID'] = repophid
diff = callconduit(repo, b'differential.createrawdiff', params)
if not diff:
raise error.Abort(_(b'cannot create diff for %s') % ctx)
return diff
def creatediff(ctx):
"""create a Differential Diff"""
repo = ctx.repo()
repophid = getrepophid(repo)
# Create a "Differential Diff" via "differential.createrawdiff" API
params = {b'diff': getdiff(ctx, mdiff.diffopts(git=True, context=32767))}
if repophid:
params[b'repositoryPHID'] = repophid
diff = callconduit(repo, b'differential.createrawdiff', params)
if not diff:
raise error.Abort(_(b'cannot create diff for %s') % ctx)
return diff
def _shelvecreatedcommit(repo, node, name):
info = {'node': nodemod.hex(node)}
shelvedfile(repo, name, 'shelve').writeinfo(info)
bases = list(mutableancestors(repo[node]))
shelvedfile(repo, name, 'hg').writebundle(bases, node)
# Create a matcher so that prefetch doesn't attempt to fetch the entire
# repository pointlessly.
match = scmutil.matchfiles(repo, repo[node].files())
with shelvedfile(repo, name, patchextension).opener('wb') as fp:
cmdutil.exportfile(repo, [node],
fp,
opts=mdiff.diffopts(git=True),
match=match)
def read_file_chunks(self, wfile):
'Get diffs of working file, parse into (c)hunks'
difftext = cStringIO.StringIO()
pfile = util.pconvert(wfile)
lines = check_max_diff(self.stat.get_ctx(), pfile)
if lines:
difftext.writelines(lines)
difftext.seek(0)
else:
matcher = cmdutil.matchfiles(self.stat.repo, [pfile])
diffopts = mdiff.diffopts(git=True, nodates=True)
try:
node1, node2 = self.stat.nodes()
for s in patch.diff(self.stat.repo, node1, node2,
match=matcher, opts=diffopts):
difftext.writelines(s.splitlines(True))
except (IOError, error.RepoError, error.LookupError, util.Abort), e:
self.stat.stbar.set_text(str(e))
difftext.seek(0)
def append_diff(self, wfile):
if not wfile:
return
buf, rev = self._buffer, self.currev
n1, n2 = self.curnodes
eob = buf.get_end_iter()
offset = eob.get_offset()
size = 0
try:
ctx = self.repo[rev]
if wfile in ctx:
fctx = ctx.filectx(wfile)
size = fctx._filelog.rawsize(fctx.filerev())
except error.LookupError:
pass
if size > hglib.getmaxdiffsize(self.repo.ui):
lines = ['diff',
_(' %s is larger than the specified max diff size') % wfile]
else:
lines = []
M, A, R = self.changes
if wfile in M:
changes = [wfile], [], []
elif wfile in A:
changes = [], [wfile], []
else:
changes = [], [], [wfile]
opts = mdiff.diffopts(git=True, nodates=True)
try:
for s in patch.diff(self.repo, n1, n2, changes=changes, opts=opts):
lines.extend(s.splitlines())
except (error.RepoError, error.LookupError), e:
err = _('Repository Error: %s, refresh suggested') % str(e)
lines = ['diff', '', err]
def testannotatepair(self):
self.maxDiff = None # camelcase-required
oldfctx = b'old'
p1fctx, p2fctx, childfctx = b'p1', b'p2', b'c'
olddata = b'a\nb\n'
p1data = b'a\nb\nc\n'
p2data = b'a\nc\nd\n'
childdata = b'a\nb2\nc\nc2\nd\n'
diffopts = mdiff.diffopts()
def decorate(text, fctx):
n = text.count(b'\n')
linenos = pycompat.rangelist(1, n + 1)
return _annotatedfile([fctx] * n, linenos, [False] * n, text)
# Basic usage
oldann = decorate(olddata, oldfctx)
p1ann = decorate(p1data, p1fctx)
p1ann = _annotatepair([oldann], p1fctx, p1ann, False, diffopts)
self.assertEqual(tr(p1ann), [
annotateline(b'old', 1),
annotateline(b'old', 2),
annotateline(b'p1', 3),
])
p2ann = decorate(p2data, p2fctx)
p2ann = _annotatepair([oldann], p2fctx, p2ann, False, diffopts)
self.assertEqual(tr(p2ann), [
annotateline(b'old', 1),
annotateline(b'p2', 2),
annotateline(b'p2', 3),
])
# Test with multiple parents (note the difference caused by ordering)
childann = decorate(childdata, childfctx)
childann = _annotatepair([p1ann, p2ann], childfctx, childann, False,
diffopts)
self.assertEqual(tr(childann), [
annotateline(b'old', 1),
annotateline(b'c', 2),
annotateline(b'p2', 2),
annotateline(b'c', 4),
annotateline(b'p2', 3),
])
childann = decorate(childdata, childfctx)
childann = _annotatepair([p2ann, p1ann], childfctx, childann, False,
diffopts)
self.assertEqual(tr(childann), [
annotateline(b'old', 1),
annotateline(b'c', 2),
annotateline(b'p1', 3),
annotateline(b'c', 4),
annotateline(b'p2', 3),
])
# Test with skipchild (note the difference caused by ordering)
childann = decorate(childdata, childfctx)
childann = _annotatepair([p1ann, p2ann], childfctx, childann, True,
diffopts)
self.assertEqual(
tr(childann),
[
annotateline(b'old', 1),
annotateline(b'old', 2, True),
# note that this line was carried over from earlier so it is *not*
# marked skipped
annotateline(b'p2', 2),
annotateline(b'p2', 2, True),
annotateline(b'p2', 3),
])
childann = decorate(childdata, childfctx)
childann = _annotatepair([p2ann, p1ann], childfctx, childann, True,
diffopts)
self.assertEqual(tr(childann), [
annotateline(b'old', 1),
annotateline(b'old', 2, True),
annotateline(b'p1', 3),
annotateline(b'p1', 3, True),
annotateline(b'p2', 3),
])
def createcmd(ui, repo, pats, opts):
"""subcommand that creates a new shelve"""
def publicancestors(ctx):
"""Compute the public ancestors of a commit.
Much faster than the revset ancestors(ctx) & draft()"""
seen = set([nullrev])
visit = util.deque()
visit.append(ctx)
while visit:
ctx = visit.popleft()
yield ctx.node()
for parent in ctx.parents():
rev = parent.rev()
if rev not in seen:
seen.add(rev)
if parent.mutable():
visit.append(parent)
wctx = repo[None]
parents = wctx.parents()
if len(parents) > 1:
raise util.Abort(_('cannot shelve while merging'))
parent = parents[0]
# we never need the user, so we use a generic user for all shelve operations
user = '******'
label = repo._bookmarkcurrent or parent.branch() or 'default'
# slashes aren't allowed in filenames, therefore we rename it
label = label.replace('/', '_')
def gennames():
yield label
for i in xrange(1, 100):
yield '%s-%02d' % (label, i)
shelvedfiles = []
def commitfunc(ui, repo, message, match, opts):
# check modified, added, removed, deleted only
for flist in repo.status(match=match)[:4]:
shelvedfiles.extend(flist)
hasmq = util.safehasattr(repo, 'mq')
if hasmq:
saved, repo.mq.checkapplied = repo.mq.checkapplied, False
try:
return repo.commit(message, user, opts.get('date'), match,
editor=cmdutil.getcommiteditor(**opts))
finally:
if hasmq:
repo.mq.checkapplied = saved
if parent.node() != nullid:
desc = "changes to '%s'" % parent.description().split('\n', 1)[0]
else:
desc = '(changes in empty repository)'
if not opts['message']:
opts['message'] = desc
name = opts['name']
wlock = lock = tr = bms = None
try:
wlock = repo.wlock()
lock = repo.lock()
bms = repo._bookmarks.copy()
# use an uncommitted transaction to generate the bundle to avoid
# pull races. ensure we don't print the abort message to stderr.
tr = repo.transaction('commit', report=lambda x: None)
if name:
if shelvedfile(repo, name, 'hg').exists():
raise util.Abort(_("a shelved change named '%s' already exists")
% name)
else:
for n in gennames():
if not shelvedfile(repo, n, 'hg').exists():
name = n
break
else:
raise util.Abort(_("too many shelved changes named '%s'") %
label)
# ensure we are not creating a subdirectory or a hidden file
if '/' in name or '\\' in name:
raise util.Abort(_('shelved change names may not contain slashes'))
if name.startswith('.'):
raise util.Abort(_("shelved change names may not start with '.'"))
node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
if not node:
stat = repo.status(match=scmutil.match(repo[None], pats, opts))
if stat[3]:
ui.status(_("nothing changed (%d missing files, see "
"'hg status')\n") % len(stat[3]))
else:
ui.status(_("nothing changed\n"))
return 1
phases.retractboundary(repo, phases.secret, [node])
fp = shelvedfile(repo, name, 'files').opener('wb')
fp.write('\0'.join(shelvedfiles))
bases = list(publicancestors(repo[node]))
cg = changegroup.changegroupsubset(repo, bases, [node], 'shelve')
shelvedfile(repo, name, 'hg').writebundle(cg)
cmdutil.export(repo, [node],
fp=shelvedfile(repo, name, 'patch').opener('wb'),
opts=mdiff.diffopts(git=True))
if ui.formatted():
desc = util.ellipsis(desc, ui.termwidth())
ui.status(_('shelved as %s\n') % name)
hg.update(repo, parent.node())
finally:
if bms:
# restore old bookmarks
repo._bookmarks.update(bms)
repo._bookmarks.write()
if tr:
tr.abort()
lockmod.release(lock, wlock)
def _docreatecmd(ui, repo, pats, opts):
def mutableancestors(ctx):
"""return all mutable ancestors for ctx (included)
Much faster than the revset ancestors(ctx) & draft()"""
seen = set([nodemod.nullrev])
visit = collections.deque()
visit.append(ctx)
while visit:
ctx = visit.popleft()
yield ctx.node()
for parent in ctx.parents():
rev = parent.rev()
if rev not in seen:
seen.add(rev)
if parent.mutable():
visit.append(parent)
wctx = repo[None]
parents = wctx.parents()
if len(parents) > 1:
raise error.Abort(_('cannot shelve while merging'))
parent = parents[0]
origbranch = wctx.branch()
# we never need the user, so we use a generic user for all shelve operations
user = '******'
label = repo._activebookmark or parent.branch() or 'default'
# slashes aren't allowed in filenames, therefore we rename it
label = label.replace('/', '_')
def gennames():
yield label
for i in xrange(1, 100):
yield '%s-%02d' % (label, i)
if parent.node() != nodemod.nullid:
desc = "changes to: %s" % parent.description().split('\n', 1)[0]
else:
desc = '(changes in empty repository)'
if not opts.get('message'):
opts['message'] = desc
name = opts.get('name')
lock = tr = None
try:
lock = repo.lock()
# use an uncommitted transaction to generate the bundle to avoid
# pull races. ensure we don't print the abort message to stderr.
tr = repo.transaction('commit', report=lambda x: None)
if name:
if shelvedfile(repo, name, 'hg').exists():
raise error.Abort(
_("a shelved change named '%s' already exists") % name)
else:
for n in gennames():
if not shelvedfile(repo, n, 'hg').exists():
name = n
break
else:
raise error.Abort(
_("too many shelved changes named '%s'") % label)
# ensure we are not creating a subdirectory or a hidden file
if '/' in name or '\\' in name:
raise error.Abort(
_('shelved change names may not contain slashes'))
if name.startswith('.'):
raise error.Abort(_("shelved change names may not start with '.'"))
interactive = opts.get('interactive', False)
includeunknown = (opts.get('unknown', False)
and not opts.get('addremove', False))
extra = {}
if includeunknown:
s = repo.status(match=scmutil.match(repo[None], pats, opts),
unknown=True)
if s.unknown:
extra['shelve_unknown'] = '\0'.join(s.unknown)
repo[None].add(s.unknown)
if _iswctxonnewbranch(repo) and not _isbareshelve(pats, opts):
# In non-bare shelve we don't store newly created branch
# at bundled commit
repo.dirstate.setbranch(repo['.'].branch())
def commitfunc(ui, repo, message, match, opts):
hasmq = util.safehasattr(repo, 'mq')
if hasmq:
saved, repo.mq.checkapplied = repo.mq.checkapplied, False
backup = repo.ui.backupconfig('phases', 'new-commit')
try:
repo.ui.setconfig('phases', 'new-commit', phases.secret)
editor = cmdutil.getcommiteditor(editform='shelve.shelve',
**opts)
return repo.commit(message,
user,
opts.get('date'),
match,
editor=editor,
extra=extra)
finally:
repo.ui.restoreconfig(backup)
if hasmq:
repo.mq.checkapplied = saved
def interactivecommitfunc(ui, repo, *pats, **opts):
match = scmutil.match(repo['.'], pats, {})
message = opts['message']
return commitfunc(ui, repo, message, match, opts)
if not interactive:
node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
else:
node = cmdutil.dorecord(ui, repo, interactivecommitfunc, None,
False, cmdutil.recordfilter, *pats, **opts)
if not node:
stat = repo.status(match=scmutil.match(repo[None], pats, opts))
if stat.deleted:
ui.status(
_("nothing changed (%d missing files, see "
"'hg status')\n") % len(stat.deleted))
else:
ui.status(_("nothing changed\n"))
return 1
bases = list(mutableancestors(repo[node]))
shelvedfile(repo, name, 'hg').writebundle(bases, node)
cmdutil.export(repo, [node],
fp=shelvedfile(repo, name, 'patch').opener('wb'),
opts=mdiff.diffopts(git=True))
if ui.formatted():
desc = util.ellipsis(desc, ui.termwidth())
ui.status(_('shelved as %s\n') % name)
hg.update(repo, parent.node())
if origbranch != repo['.'].branch() and not _isbareshelve(pats, opts):
repo.dirstate.setbranch(origbranch)
_aborttransaction(repo)
finally:
lockmod.release(tr, lock)
def shelvefunc(ui, repo, message, match, opts):
changes = repo.status(match=match)[:5]
modified, added, removed = changes[:3]
files = modified + added + removed
diffopts = mdiff.diffopts(git=True, nodates=True)
patch_diff = ''.join(patch.diff(repo, repo.dirstate.parents()[0],
match=match, changes=changes, opts=diffopts))
fp = cStringIO.StringIO(patch_diff)
ac = parsepatch(fp)
fp.close()
chunks = filterpatch(ui, ac, not opts['all'])
rc = refilterpatch(ac, chunks)
contenders = {}
for h in chunks:
try: contenders.update(dict.fromkeys(h.files()))
except AttributeError: pass
newfiles = [f for f in files if f in contenders]
if not newfiles:
ui.status(_('no changes to shelve\n'))
return 0
modified = dict.fromkeys(changes[0])
backupdir = repo.join('shelve-backups')
try:
bkfiles = [f for f in newfiles if f in modified]
backups = makebackup(ui, repo, backupdir, bkfiles)
# patch to shelve
sp = cStringIO.StringIO()
for c in chunks:
if c.filename() in backups:
c.write(sp)
doshelve = sp.tell()
sp.seek(0)
# patch to apply to shelved files
fp = cStringIO.StringIO()
for c in rc:
if c.filename() in backups:
c.write(fp)
dopatch = fp.tell()
fp.seek(0)
try:
# 3a. apply filtered patch to clean repo (clean)
if backups:
hg.revert(repo, repo.dirstate.parents()[0], backups.has_key)
# 3b. apply filtered patch to clean repo (apply)
if dopatch:
ui.debug('applying patch\n')
ui.debug(fp.getvalue())
patch.internalpatch(fp, ui, 1, repo.root)
del fp
# 3c. apply filtered patch to clean repo (shelve)
if doshelve:
ui.debug("saving patch to shelve\n")
if opts['append']:
f = repo.opener(shelfpath, "a")
else:
f = repo.opener(shelfpath, "w")
f.write(sp.getvalue())
del f
del sp
except:
try:
for realname, tmpname in backups.iteritems():
ui.debug('restoring %r to %r\n' % (tmpname, realname))
util.copyfile(tmpname, repo.wjoin(realname))
ui.debug('removing shelve file\n')
os.unlink(repo.join(shelfpath))
except OSError:
pass
return 0
finally:
try:
for realname, tmpname in backups.iteritems():
ui.debug('removing backup for %r : %r\n' % (realname, tmpname))
os.unlink(tmpname)
os.rmdir(backupdir)
except OSError:
pass
def _processpushreview(repo, req, ldap_username):
"""Handle a request to turn changesets into review requests.
``ldap_username`` is the LDAP username to associate with the MozReview
account whose credentials are passed as part of the request. We implicitly
trust the passed LDAP username has been authenticated to belong to the
MozReview account.
"""
bzusername = req.get('bzusername')
bzapikey = req.get('bzapikey')
if not bzusername or not bzapikey:
return errorresponse('Bugzilla API keys not configured; see '
'https://mozilla-version-control-tools.readthedocs.io/en/latest/mozreview/install.html#bugzilla-credentials '
'for instructions on how to configure your client')
identifier = req['identifier']
nodes = []
precursors = {}
for cset in req['changesets']:
node = cset['node']
nodes.append(node)
if 'precursors' in cset:
precursors[node] = cset['precursors']
diffopts = mdiff.diffopts(context=8, showfunc=True, git=True)
commits = {
'individual': [],
'squashed': {},
'obsolescence': req.get('obsolescence', False),
}
# We do multiple passes over the changesets requested for review because
# some operations could be slow or may involve queries to external
# resources. We want to run the fast checks first so we don't waste
# resources before finding the error. The drawback here is the client
# will not see the full set of errors. We may revisit this decision
# later.
for node in nodes:
ctx = repo[node]
# Reviewing merge commits doesn't make much sense and only makes
# situations more complicated. So disallow the practice.
if len(ctx.parents()) > 1:
msg = 'cannot review merge commits (%s)' % short(ctx.node())
return errorresponse(msg)
# Invalid or confidental bugs will raise errors in the Review Board
# interface later. Fail fast to minimize wasted time and resources.
try:
reviewid = ReviewID(identifier)
except error.Abort as e:
return errorresponse(str(e))
# We use xmlrpc here because the Bugsy REST client doesn't currently handle
# errors in responses.
# We don't use available Bugzilla credentials because that's the
# easiest way to test for confidential bugs. If/when we support posting
# reviews to confidential bugs, we'll need to change this.
xmlrpc_url = repo.ui.config('bugzilla', 'url').rstrip('/') + '/xmlrpc.cgi'
proxy = xmlrpclib.ServerProxy(xmlrpc_url)
try:
proxy.Bug.get({'ids': [reviewid.bug]})
except xmlrpclib.Fault as f:
if f.faultCode == 101:
return errorresponse('bug %s does not exist; '
'please change the review id (%s)' % (reviewid.bug,
reviewid.full))
elif f.faultCode == 102:
return errorresponse('bug %s could not be accessed '
'(we do not currently allow posting of reviews to '
'confidential bugs)' % reviewid.bug)
return errorresponse('server error verifying bug %s exists; '
'please retry or report a bug' % reviewid.bug)
# Find the first public node in the ancestry of this series. This is
# used by MozReview to query the upstream repo for additional context.
first_public_ancestor = None
for node in repo[nodes[0]].ancestors():
ctx = repo[node]
if ctx.phase() == phases.public:
first_public_ancestor = ctx.hex()
break
commits['squashed']['first_public_ancestor'] = first_public_ancestor
# Note patch.diff() appears to accept anything that can be fed into
# repo[]. However, it blindly does a hex() on the argument as opposed
# to the changectx, so we need to pass in the binary node.
base_ctx = repo[nodes[0]].p1()
base_parent_node = base_ctx.node()
for i, node in enumerate(nodes):
ctx = repo[node]
p1 = ctx.p1().node()
diff = ''.join(patch.diff(repo, node1=p1, node2=ctx.node(), opts=diffopts)) + '\n'
if i:
base_commit_id = nodes[i-1]
else:
base_commit_id = base_ctx.hex()
summary = encoding.fromlocal(ctx.description().splitlines()[0])
if req.get('deduce-reviewers', True):
reviewers = list(commitparser.parse_rquestion_reviewers(summary))
requal_reviewers = list(commitparser.parse_requal_reviewers(summary))
else:
reviewers = []
requal_reviewers = []
commits['individual'].append({
'id': node,
'author': encoding.fromlocal(ctx.user()),
'precursors': precursors.get(node, []),
'message': encoding.fromlocal(ctx.description()),
# Diffs are arbitrary byte sequences. json.dump() will try to
# interpret str as UTF-8, which could fail. Instead of trying
# to coerce the str to a unicode or use ensure_ascii=False (which
# is a giant pain), just base64 encode the diff in the JSON.
'diff_b64': diff.encode('base64'),
'bug': str(reviewid.bug),
'base_commit_id': base_commit_id,
'first_public_ancestor': first_public_ancestor,
'reviewers': reviewers,
'requal_reviewers': requal_reviewers
})
squashed_diff = b''.join(patch.diff(repo,
node1=base_parent_node,
node2=repo[nodes[-1]].node(),
opts=diffopts)) + '\n'
commits['squashed']['diff_b64'] = squashed_diff.encode('base64')
commits['squashed']['base_commit_id'] = base_ctx.hex()
rburl = repo.ui.config('reviewboard', 'url', None).rstrip('/')
repoid = repo.ui.configint('reviewboard', 'repoid', None)
privileged_rb_username = repo.ui.config('reviewboard', 'username', None)
privileged_rb_password = repo.ui.config('reviewboard', 'password', None)
if ldap_username:
associate_ldap_username(rburl, ldap_username, privileged_rb_username,
privileged_rb_password, username=bzusername,
apikey=bzapikey)
res = {
'rburl': rburl,
'reviewid': identifier,
'reviewrequests': {},
'display': [],
}
try:
parentrid, commitmap, reviews, warnings = \
post_reviews(rburl, repoid, identifier, commits,
privileged_rb_username, privileged_rb_password,
username=bzusername, apikey=bzapikey)
res['display'].extend(warnings)
res['parentrrid'] = parentrid
res['reviewrequests'][parentrid] = {
'status': reviews[parentrid]['status'],
'public': reviews[parentrid]['public'],
}
for node, rid in commitmap.items():
rd = reviews[rid]
res['reviewrequests'][rid] = {
'node': node,
'status': rd['status'],
'public': rd['public'],
}
if rd['reviewers']:
res['reviewrequests'][rid]['reviewers'] = list(rd['reviewers'])
except AuthorizationError as e:
return errorresponse(str(e))
except BadRequestError as e:
return errorresponse(str(e))
return res
def createcmd(ui, repo, pats, opts):
"""subcommand that creates a new shelve"""
def publicancestors(ctx):
"""Compute the public ancestors of a commit.
Much faster than the revset ancestors(ctx) & draft()"""
seen = set([nullrev])
visit = util.deque()
visit.append(ctx)
while visit:
ctx = visit.popleft()
yield ctx.node()
for parent in ctx.parents():
rev = parent.rev()
if rev not in seen:
seen.add(rev)
if parent.mutable():
visit.append(parent)
wctx = repo[None]
parents = wctx.parents()
if len(parents) > 1:
raise util.Abort(_('cannot shelve while merging'))
parent = parents[0]
# we never need the user, so we use a generic user for all shelve operations
user = '******'
label = repo._bookmarkcurrent or parent.branch() or 'default'
# slashes aren't allowed in filenames, therefore we rename it
label = label.replace('/', '_')
def gennames():
yield label
for i in xrange(1, 100):
yield '%s-%02d' % (label, i)
shelvedfiles = []
def commitfunc(ui, repo, message, match, opts):
# check modified, added, removed, deleted only
for flist in repo.status(match=match)[:4]:
shelvedfiles.extend(flist)
hasmq = util.safehasattr(repo, 'mq')
if hasmq:
saved, repo.mq.checkapplied = repo.mq.checkapplied, False
try:
return repo.commit(message,
user,
opts.get('date'),
match,
editor=cmdutil.getcommiteditor(**opts))
finally:
if hasmq:
repo.mq.checkapplied = saved
if parent.node() != nullid:
desc = "changes to '%s'" % parent.description().split('\n', 1)[0]
else:
desc = '(changes in empty repository)'
if not opts['message']:
opts['message'] = desc
name = opts['name']
wlock = lock = tr = bms = None
try:
wlock = repo.wlock()
lock = repo.lock()
bms = repo._bookmarks.copy()
# use an uncommitted transaction to generate the bundle to avoid
# pull races. ensure we don't print the abort message to stderr.
tr = repo.transaction('commit', report=lambda x: None)
if name:
if shelvedfile(repo, name, 'hg').exists():
raise util.Abort(
_("a shelved change named '%s' already exists") % name)
else:
for n in gennames():
if not shelvedfile(repo, n, 'hg').exists():
name = n
break
else:
raise util.Abort(
_("too many shelved changes named '%s'") % label)
# ensure we are not creating a subdirectory or a hidden file
if '/' in name or '\\' in name:
raise util.Abort(_('shelved change names may not contain slashes'))
if name.startswith('.'):
raise util.Abort(_("shelved change names may not start with '.'"))
node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
if not node:
stat = repo.status(match=scmutil.match(repo[None], pats, opts))
if stat[3]:
ui.status(
_("nothing changed (%d missing files, see "
"'hg status')\n") % len(stat[3]))
else:
ui.status(_("nothing changed\n"))
return 1
phases.retractboundary(repo, phases.secret, [node])
fp = shelvedfile(repo, name, 'files').opener('wb')
fp.write('\0'.join(shelvedfiles))
bases = list(publicancestors(repo[node]))
cg = changegroup.changegroupsubset(repo, bases, [node], 'shelve')
shelvedfile(repo, name, 'hg').writebundle(cg)
cmdutil.export(repo, [node],
fp=shelvedfile(repo, name, 'patch').opener('wb'),
opts=mdiff.diffopts(git=True))
if ui.formatted():
desc = util.ellipsis(desc, ui.termwidth())
ui.status(_('shelved as %s\n') % name)
hg.update(repo, parent.node())
finally:
if bms:
# restore old bookmarks
repo._bookmarks.update(bms)
repo._bookmarks.write()
if tr:
tr.abort()
lockmod.release(lock, wlock)
def differ(org_repo, org_ref, other_repo, other_ref, discovery_data=None,
remote_compare=False, context=3, ignore_whitespace=False):
"""
General differ between branches, bookmarks, revisions of two remote or
local but related repositories
:param org_repo:
:param org_ref:
:param other_repo:
:type other_repo:
:type other_ref:
"""
org_repo_scm = org_repo.scm_instance
other_repo_scm = other_repo.scm_instance
org_repo = org_repo_scm._repo
other_repo = other_repo_scm._repo
org_ref = org_ref[1]
other_ref = other_ref[1]
if org_repo_scm == other_repo_scm:
log.debug('running diff between %s@%s and %s@%s'
% (org_repo.path, org_ref, other_repo.path, other_ref))
_diff = org_repo_scm.get_diff(rev1=org_ref, rev2=other_ref,
ignore_whitespace=ignore_whitespace, context=context)
return _diff
elif remote_compare:
opts = diffopts(git=True, ignorews=ignore_whitespace, context=context)
common, incoming, rheads = discovery_data
org_repo_peer = localrepo.locallegacypeer(org_repo.local())
# create a bundle (uncompressed if other repo is not local)
if org_repo_peer.capable('getbundle'):
# disable repo hooks here since it's just bundle !
# patch and reset hooks section of UI config to not run any
# hooks on fetching archives with subrepos
for k, _ in org_repo.ui.configitems('hooks'):
org_repo.ui.setconfig('hooks', k, None)
unbundle = org_repo.getbundle('incoming', common=None,
heads=None)
buf = BytesIO()
while True:
chunk = unbundle._stream.read(1024 * 4)
if not chunk:
break
buf.write(chunk)
buf.seek(0)
# replace chunked _stream with data that can do tell() and seek()
unbundle._stream = buf
ui = make_ui('db')
bundlerepo = InMemoryBundleRepo(ui, path=org_repo.root,
bundlestream=unbundle)
return ''.join(patch.diff(bundlerepo,
node1=other_repo[other_ref].node(),
node2=org_repo[org_ref].node(),
opts=opts))
return ''
def _get_diff(self, rev1, rev2, path=None, ignore_whitespace=False):
file_filter = match(self.path, '', [path])
return patch.diff(self._repo, rev1, rev2, match=file_filter,
opts=diffopts(git=True,
ignorews=ignore_whitespace))
def shelvefunc(ui, repo, message, match, opts):
# If an MQ patch is applied, consider all qdiff changes
if hasattr(repo, 'mq') and repo.mq.applied and repo['.'] == repo['qtip']:
qtip = repo['.']
basenode = qtip.parents()[0].node()
else:
basenode = repo.dirstate.parents()[0]
changes = repo.status(node1=basenode, match=match)[:5]
modified, added, removed = changes[:3]
files = modified + added + removed
diffopts = mdiff.diffopts(git=True, nodates=True)
patch_diff = ''.join(patch.diff(repo, basenode, match=match,
changes=changes, opts=diffopts))
fp = cStringIO.StringIO(patch_diff)
ac = parsepatch(fp)
fp.close()
chunks = filterpatch(ui, ac)
rc = refilterpatch(ac, chunks)
contenders = {}
for h in chunks:
try: contenders.update(dict.fromkeys(h.files()))
except AttributeError: pass
newfiles = [f for f in files if f in contenders]
if not newfiles:
ui.status(_('no changes to shelve\n'))
return 0
modified = dict.fromkeys(changes[0])
backupdir = repo.join('shelve-backups')
try:
bkfiles = [f for f in newfiles if f in modified]
backups = makebackup(ui, repo, backupdir, bkfiles)
# patch to shelve
sp = cStringIO.StringIO()
for c in chunks:
if c.filename() in backups:
c.write(sp)
doshelve = sp.tell()
sp.seek(0)
# patch to apply to shelved files
fp = cStringIO.StringIO()
for c in rc:
if c.filename() in backups:
c.write(fp)
dopatch = fp.tell()
fp.seek(0)
try:
# 3a. apply filtered patch to clean repo (clean)
if backups:
hg.revert(repo, basenode, backups.has_key)
# 3b. apply filtered patch to clean repo (apply)
if dopatch:
ui.debug(_('applying patch\n'))
ui.debug(fp.getvalue())
patch.internalpatch(fp, ui, 1, repo.root, eolmode=None)
del fp
# 3c. apply filtered patch to clean repo (shelve)
if doshelve:
ui.debug(_('saving patch to shelve\n'))
if opts['append']:
f = repo.opener('shelve', "a")
else:
f = repo.opener('shelve', "w")
f.write(sp.getvalue())
del f
del sp
except:
try:
for realname, tmpname in backups.iteritems():
ui.debug(_('restoring %r to %r\n') % (tmpname, realname))
util.copyfile(tmpname, repo.wjoin(realname))
ui.debug(_('removing shelve file\n'))
os.unlink(repo.join('shelve'))
except (IOError, OSError), e:
ui.warn(_('abort: backup restore failed, %s\n') % str(e))
return 0
def createcmd(ui, repo, pats, opts):
"""subcommand that creates a new shelve"""
def mutableancestors(ctx):
"""return all mutable ancestors for ctx (included)
Much faster than the revset ancestors(ctx) & draft()"""
seen = set([nullrev])
visit = collections.deque()
visit.append(ctx)
while visit:
ctx = visit.popleft()
yield ctx.node()
for parent in ctx.parents():
rev = parent.rev()
if rev not in seen:
seen.add(rev)
if parent.mutable():
visit.append(parent)
wctx = repo[None]
parents = wctx.parents()
if len(parents) > 1:
raise error.Abort(_('cannot shelve while merging'))
parent = parents[0]
# we never need the user, so we use a generic user for all shelve operations
user = '******'
label = repo._activebookmark or parent.branch() or 'default'
# slashes aren't allowed in filenames, therefore we rename it
label = label.replace('/', '_')
def gennames():
yield label
for i in xrange(1, 100):
yield '%s-%02d' % (label, i)
def commitfunc(ui, repo, message, match, opts):
hasmq = util.safehasattr(repo, 'mq')
if hasmq:
saved, repo.mq.checkapplied = repo.mq.checkapplied, False
backup = repo.ui.backupconfig('phases', 'new-commit')
try:
repo.ui. setconfig('phases', 'new-commit', phases.secret)
editor = cmdutil.getcommiteditor(editform='shelve.shelve', **opts)
return repo.commit(message, user, opts.get('date'), match,
editor=editor)
finally:
repo.ui.restoreconfig(backup)
if hasmq:
repo.mq.checkapplied = saved
if parent.node() != nullid:
desc = "changes to '%s'" % parent.description().split('\n', 1)[0]
else:
desc = '(changes in empty repository)'
if not opts['message']:
opts['message'] = desc
name = opts['name']
wlock = lock = tr = None
try:
wlock = repo.wlock()
lock = repo.lock()
# use an uncommitted transaction to generate the bundle to avoid
# pull races. ensure we don't print the abort message to stderr.
tr = repo.transaction('commit', report=lambda x: None)
if name:
if shelvedfile(repo, name, 'hg').exists():
raise error.Abort(_("a shelved change named '%s' already exists"
) % name)
else:
for n in gennames():
if not shelvedfile(repo, n, 'hg').exists():
name = n
break
else:
raise error.Abort(_("too many shelved changes named '%s'") %
label)
# ensure we are not creating a subdirectory or a hidden file
if '/' in name or '\\' in name:
raise error.Abort(_('shelved change names may not contain slashes'))
if name.startswith('.'):
raise error.Abort(_("shelved change names may not start with '.'"))
interactive = opts.get('interactive', False)
def interactivecommitfunc(ui, repo, *pats, **opts):
match = scmutil.match(repo['.'], pats, {})
message = opts['message']
return commitfunc(ui, repo, message, match, opts)
if not interactive:
node = cmdutil.commit(ui, repo, commitfunc, pats, opts)
else:
node = cmdutil.dorecord(ui, repo, interactivecommitfunc, None,
False, cmdutil.recordfilter, *pats, **opts)
if not node:
stat = repo.status(match=scmutil.match(repo[None], pats, opts))
if stat.deleted:
ui.status(_("nothing changed (%d missing files, see "
"'hg status')\n") % len(stat.deleted))
else:
ui.status(_("nothing changed\n"))
return 1
bases = list(mutableancestors(repo[node]))
shelvedfile(repo, name, 'hg').writebundle(bases, node)
cmdutil.export(repo, [node],
fp=shelvedfile(repo, name, 'patch').opener('wb'),
opts=mdiff.diffopts(git=True))
if ui.formatted():
desc = util.ellipsis(desc, ui.termwidth())
ui.status(_('shelved as %s\n') % name)
hg.update(repo, parent.node())
_aborttransaction(repo)
finally:
lockmod.release(tr, lock, wlock)
def reviewboard(repo, proto, args=None):
proto.redirect()
o = parsepayload(proto, args)
if isinstance(o, ServerError):
return formatresponse(str(o))
bzusername = o['bzusername']
bzapikey = o['bzapikey']
identifier, nodes, precursors = parseidentifier(o)
if not identifier:
return ['error %s' % _('no review identifier in request')]
diffopts = mdiff.diffopts(context=8, showfunc=True, git=True)
commits = {
'individual': [],
'squashed': {}
}
# We do multiple passes over the changesets requested for review because
# some operations could be slow or may involve queries to external
# resources. We want to run the fast checks first so we don't waste
# resources before finding the error. The drawback here is the client
# will not see the full set of errors. We may revisit this decision
# later.
for node in nodes:
ctx = repo[node]
# Reviewing merge commits doesn't make much sense and only makes
# situations more complicated. So disallow the practice.
if len(ctx.parents()) > 1:
msg = 'cannot review merge commits (%s)' % short(ctx.node())
return formatresponse('error %s' % msg)
# Invalid or confidental bugs will raise errors in the Review Board
# interface later. Fail fast to minimize wasted time and resources.
try:
reviewid = ReviewID(identifier)
except util.Abort as e:
return formatresponse('error %s' % e)
# We use xmlrpc here because the Bugsy REST client doesn't currently handle
# errors in responses.
# We don't use available Bugzilla credentials because that's the
# easiest way to test for confidential bugs. If/when we support posting
# reviews to confidential bugs, we'll need to change this.
xmlrpc_url = repo.ui.config('bugzilla', 'url').rstrip('/') + '/xmlrpc.cgi'
proxy = xmlrpclib.ServerProxy(xmlrpc_url)
try:
proxy.Bug.get({'ids': [reviewid.bug]})
except xmlrpclib.Fault as f:
if f.faultCode == 101:
return formatresponse('error bug %s does not exist; '
'please change the review id (%s)' % (reviewid.bug,
reviewid.full))
elif f.faultCode == 102:
return formatresponse('error bug %s could not be accessed '
'(we do not currently allow posting of reviews to '
'confidential bugs)' % reviewid.bug)
return formatresponse('error server error verifying bug %s exists; '
'please retry or report a bug' % reviewid.bug)
# Find the first public node in the ancestry of this series. This is
# used by MozReview to query the upstream repo for additional context.
first_public_ancestor = None
for node in repo[nodes[0]].ancestors():
ctx = repo[node]
if ctx.phase() == phases.public:
first_public_ancestor = ctx.hex()
break
commits['squashed']['first_public_ancestor'] = first_public_ancestor
# Note patch.diff() appears to accept anything that can be fed into
# repo[]. However, it blindly does a hex() on the argument as opposed
# to the changectx, so we need to pass in the binary node.
base_ctx = repo[nodes[0]].p1()
base_parent_node = base_ctx.node()
for i, node in enumerate(nodes):
ctx = repo[node]
p1 = ctx.p1().node()
diff = None
parent_diff = None
diff = ''.join(patch.diff(repo, node1=p1, node2=ctx.node(), opts=diffopts)) + '\n'
if i:
base_commit_id = nodes[i-1]
else:
base_commit_id = base_ctx.hex()
summary = encoding.fromlocal(ctx.description().splitlines()[0])
commits['individual'].append({
'id': node,
'precursors': precursors.get(node, []),
'message': encoding.fromlocal(ctx.description()),
'diff': diff,
'bug': str(reviewid.bug),
'base_commit_id': base_commit_id,
'first_public_ancestor': first_public_ancestor,
'reviewers': list(commitparser.parse_rquestion_reviewers(summary)),
'requal_reviewers': list(commitparser.parse_requal_reviewers(summary))
})
commits['squashed']['diff'] = ''.join(patch.diff(repo, node1=base_parent_node,
node2=repo[nodes[-1]].node(), opts=diffopts)) + '\n'
commits['squashed']['base_commit_id'] = base_ctx.hex()
rburl = repo.ui.config('reviewboard', 'url', None).rstrip('/')
repoid = repo.ui.configint('reviewboard', 'repoid', None)
privleged_rb_username = repo.ui.config('reviewboard', 'username', None)
privleged_rb_password = repo.ui.config('reviewboard', 'password', None)
# We support pushing via HTTP and SSH. REMOTE_USER will be set via HTTP.
# USER via SSH. But USER is a common variable and could also sneak into
# the HTTP environment.
#
# REMOTE_USER values come from Bugzilla. USER values come from LDAP.
# There is a potential privilege escalation vulnerability if someone
# obtains a Bugzilla account overlapping with a LDAP user having
# special privileges. So, we explicitly don't perform an LDAP lookup
# if REMOTE_USER is present because we could be crossing the user
# stores.
ldap_username = os.environ.get('USER')
remote_user = repo.ui.environ.get('REMOTE_USER', os.environ.get('REMOTE_USER'))
if ldap_username and not remote_user:
associate_ldap_username(rburl, ldap_username, privleged_rb_username,
privleged_rb_password, username=bzusername,
apikey=bzapikey)
lines = [
'rburl %s' % rburl,
'reviewid %s' % identifier,
]
try:
parentrid, commitmap, reviews = post_reviews(rburl, repoid, identifier,
commits, lines,
username=bzusername,
apikey=bzapikey)
lines.extend([
'parentreview %s' % parentrid,
'reviewdata %s status %s' % (
parentrid,
urllib.quote(reviews[parentrid]['status'].encode('utf-8'))),
'reviewdata %s public %s' % (
parentrid,
reviews[parentrid]['public']),
])
for node, rid in commitmap.items():
rd = reviews[rid]
lines.append('csetreview %s %s' % (node, rid))
lines.append('reviewdata %s status %s' % (rid,
urllib.quote(rd['status'].encode('utf-8'))))
lines.append('reviewdata %s public %s' % (rid, rd['public']))
if rd['reviewers']:
parts = [urllib.quote(r.encode('utf-8'))
for r in rd['reviewers']]
lines.append('reviewdata %s reviewers %s' %
(rid, ','.join(parts)))
except AuthorizationError as e:
lines.append('error %s' % str(e))
except BadRequestError as e:
lines.append('error %s' % str(e))
res = formatresponse(*lines)
return res
def reviewboard(repo, proto, args=None):
proto.redirect()
o = parsepayload(proto, args)
if isinstance(o, wireproto.pusherr):
return o
bzusername = o['bzusername']
bzpassword = o['bzpassword']
bzuserid = o['bzuserid']
bzcookie = o['bzcookie']
identifier = None
nodes = []
precursors = {}
for t, d in o['other']:
if t == 'reviewidentifier':
identifier = urllib.unquote(d)
elif t == 'csetreview':
# This detects old versions of the client from before official
# release.
fields = d.split(' ')
if len(fields) != 1:
return wireproto.pusherr(_('old reviewboard client detected; please upgrade'))
nodes.append(d)
elif t == 'precursors':
node, before = d.split(' ', 1)
precursors[node] = before.split()
if not identifier:
return wireproto.pusherr(_('no review identifier in request'))
diffopts = mdiff.diffopts(context=8, showfunc=True)
commits = {
'individual': [],
'squashed': {}
}
def formatresponse(*lines):
l = ['1'] + list(lines)
res = '\n'.join(l)
# It's easy for unicode to creep in from RBClient APIs. Mercurial
# doesn't like unicode type responses, so catch it early and avoid
# the crypic KeyError: <type 'unicode'> in Mercurial.
assert isinstance(res, str)
return res
# We do multiple passes over the changesets requested for review because
# some operations could be slow or may involve queries to external
# resources. We want to run the fast checks first so we don't waste
# resources before finding the error. The drawback here is the client
# will not see the full set of errors. We may revisit this decision
# later.
for node in nodes:
ctx = repo[node]
# Reviewing merge commits doesn't make much sense and only makes
# situations more complicated. So disallow the practice.
if len(ctx.parents()) > 1:
msg = 'cannot review merge commits (%s)' % short(ctx.node())
return formatresponse('error %s' % msg)
# Invalid or confidental bugs will raise errors in the Review Board
# interface later. Fail fast to minimize wasted time and resources.
try:
reviewid = ReviewID(identifier)
except util.Abort as e:
return formatresponse('error %s' % e)
if reviewid.bug:
# We use xmlrpc here because the Bugsy REST client doesn't currently handle
# errors in responses.
# We don't use available Bugzilla credentials because that's the
# easiest way to test for confidential bugs. If/when we support posting
# reviews to confidential bugs, we'll need to change this.
xmlrpc_url = repo.ui.config('bugzilla', 'url').rstrip('/') + '/xmlrpc.cgi'
proxy = xmlrpclib.ServerProxy(xmlrpc_url)
try:
proxy.Bug.get({'ids': [reviewid.bug]})
except xmlrpclib.Fault as f:
if f.faultCode == 101:
return formatresponse('error bug %s does not exist; '
'please change the review id (%s)' % (reviewid.bug,
reviewid.full))
elif f.faultCode == 102:
return formatresponse('error bug %s could not be accessed '
'(we do not currently allow posting of reviews to '
'confidential bugs)' % reviewid.bug)
return formatresponse('error server error verifying bug %s exists; '
'please retry or report a bug' % reviewid.bug)
# Note patch.diff() appears to accept anything that can be fed into
# repo[]. However, it blindly does a hex() on the argument as opposed
# to the changectx, so we need to pass in the binary node.
base_parent_node = repo[nodes[0]].p1().node()
for i, node in enumerate(nodes):
ctx = repo[node]
p1 = ctx.p1().node()
diff = None
parent_diff = None
diff = ''.join(patch.diff(repo, node1=p1, node2=ctx.node(), opts=diffopts))
if i:
parent_diff = ''.join(patch.diff(repo, node1=base_parent_node,
node2=repo[nodes[i-1]].node(), opts=diffopts))
commits['individual'].append({
'id': node,
'precursors': precursors.get(node, []),
'message': ctx.description(),
'diff': diff,
'parent_diff': parent_diff,
})
commits['squashed']['diff'] = ''.join(patch.diff(repo, node1=base_parent_node,
node2=repo[nodes[-1]].node(), opts=diffopts))
rburl = repo.ui.config('reviewboard', 'url', None).rstrip('/')
repoid = repo.ui.configint('reviewboard', 'repoid', None)
lines = [
'rburl %s' % rburl,
'reviewid %s' % identifier,
]
try:
parentrid, commitmap, reviews = post_reviews(rburl, repoid, identifier,
commits,
username=bzusername,
password=bzpassword,
userid=bzuserid,
cookie=bzcookie)
lines.extend([
'parentreview %s' % parentrid,
'reviewdata %s status %s' % (parentrid,
urllib.quote(reviews[parentrid].status.encode('utf-8'))),
])
for node, rid in commitmap.items():
rr = reviews[rid]
lines.append('csetreview %s %s' % (node, rid))
lines.append('reviewdata %s status %s' % (rid,
urllib.quote(rr.status.encode('utf-8'))))
except AuthError as e:
lines.append('error %s' % str(e))
res = formatresponse(*lines)
return res
def createdifferentialrevision(ctx, revid=None, parentrevid=None, oldnode=None,
olddiff=None, actions=None):
"""create or update a Differential Revision
If revid is None, create a new Differential Revision, otherwise update
revid. If parentrevid is not None, set it as a dependency.
If oldnode is not None, check if the patch content (without commit message
and metadata) has changed before creating another diff.
If actions is not None, they will be appended to the transaction.
"""
repo = ctx.repo()
if oldnode:
diffopts = mdiff.diffopts(git=True, context=32767)
oldctx = repo.unfiltered()[oldnode]
neednewdiff = (getdiff(ctx, diffopts) != getdiff(oldctx, diffopts))
else:
neednewdiff = True
transactions = []
if neednewdiff:
diff = creatediff(ctx)
transactions.append({b'type': b'update', b'value': diff[r'phid']})
else:
# Even if we don't need to upload a new diff because the patch content
# does not change. We might still need to update its metadata so
# pushers could know the correct node metadata.
assert olddiff
diff = olddiff
writediffproperties(ctx, diff)
# Use a temporary summary to set dependency. There might be better ways but
# I cannot find them for now. But do not do that if we are updating an
# existing revision (revid is not None) since that introduces visible
# churns (someone edited "Summary" twice) on the web page.
if parentrevid and revid is None:
summary = b'Depends on D%s' % parentrevid
transactions += [{b'type': b'summary', b'value': summary},
{b'type': b'summary', b'value': b' '}]
if actions:
transactions += actions
# Parse commit message and update related fields.
desc = ctx.description()
info = callconduit(repo, b'differential.parsecommitmessage',
{b'corpus': desc})
for k, v in info[r'fields'].items():
if k in [b'title', b'summary', b'testPlan']:
transactions.append({b'type': k, b'value': v})
params = {b'transactions': transactions}
if revid is not None:
# Update an existing Differential Revision
params[b'objectIdentifier'] = revid
revision = callconduit(repo, b'differential.revision.edit', params)
if not revision:
raise error.Abort(_(b'cannot create revision for %s') % ctx)
return revision, diff
def shelvefunc(ui, repo, message, match, opts):
parents = repo.dirstate.parents()
changes = repo.status(match=match)[:5]
modified, added, removed = changes[:3]
files = modified + added + removed
diffopts = mdiff.diffopts(git=True, nodates=True)
patch_diff = "".join(patch.diff(repo, parents[0], match=match, changes=changes, opts=diffopts))
fp = cStringIO.StringIO(patch_diff)
ac = parsepatch(fp)
fp.close()
chunks = filterpatch(ui, ac, not opts["all"])
rc = refilterpatch(ac, chunks)
# set of files to be processed
contenders = {}
for h in chunks:
try:
contenders.update(dict.fromkeys(h.files()))
except AttributeError:
pass
# exclude sources of copies that are otherwise untouched
newfiles = set(f for f in files if f in contenders)
if not newfiles:
ui.status(_("no changes to shelve\n"))
return 0
backupdir = repo.join("shelve-backups")
try:
backups = makebackup(ui, repo, backupdir, newfiles)
# patch to shelve
sp = cStringIO.StringIO()
for c in chunks:
c.write(sp)
# patch to apply to shelved files
fp = cStringIO.StringIO()
for c in rc:
# skip files not selected for shelving
if c.filename() in newfiles:
c.write(fp)
dopatch = fp.tell()
fp.seek(0)
try:
# 3a. apply filtered patch to clean repo (clean)
opts["no_backup"] = True
cmdutil.revert(ui, repo, repo["."], parents, *[os.path.join(repo.root, f) for f in newfiles], **opts)
for f in added:
if f in newfiles:
util.unlinkpath(repo.wjoin(f))
# 3b. apply filtered patch to clean repo (apply)
if dopatch:
ui.debug("applying patch\n")
ui.debug(fp.getvalue())
patch.internalpatch(ui, repo, fp, 1)
del fp
# 3c. apply filtered patch to clean repo (shelve)
ui.debug("saving patch to shelve\n")
if opts["append"]:
sp.write(repo.opener(shelfpath).read())
sp.seek(0)
f = repo.opener(shelfpath, "w")
f.write(sp.getvalue())
del f, sp
except:
ui.warn("shelving failed: %s\n" % sys.exc_info()[1])
try:
# re-schedule remove
matchremoved = scmutil.matchfiles(repo, removed)
cmdutil.forget(ui, repo, matchremoved, "", True)
for f in removed:
if f in newfiles and os.path.isfile(f):
os.unlink(f)
# copy back backups
for realname, tmpname in backups.iteritems():
ui.debug("restoring %r to %r\n" % (tmpname, realname))
util.copyfile(tmpname, repo.wjoin(realname))
# re-schedule add
matchadded = scmutil.matchfiles(repo, added)
cmdutil.add(ui, repo, matchadded, False, False, "", True)
ui.debug("removing shelve file\n")
if os.path.isfile(repo.wjoin(shelfpath)):
os.unlink(repo.join(shelfpath))
except OSError, err:
ui.warn("restoring backup failed: %s\n" % err)
return 0
def createdifferentialrevision(ctx, revid=None, parentrevid=None, oldnode=None,
olddiff=None, actions=None):
"""create or update a Differential Revision
If revid is None, create a new Differential Revision, otherwise update
revid. If parentrevid is not None, set it as a dependency.
If oldnode is not None, check if the patch content (without commit message
and metadata) has changed before creating another diff.
If actions is not None, they will be appended to the transaction.
"""
repo = ctx.repo()
if oldnode:
diffopts = mdiff.diffopts(git=True, context=32767)
oldctx = repo.unfiltered()[oldnode]
neednewdiff = (getdiff(ctx, diffopts) != getdiff(oldctx, diffopts))
else:
neednewdiff = True
transactions = []
if neednewdiff:
diff = creatediff(ctx)
transactions.append({b'type': b'update', b'value': diff[r'phid']})
else:
# Even if we don't need to upload a new diff because the patch content
# does not change. We might still need to update its metadata so
# pushers could know the correct node metadata.
assert olddiff
diff = olddiff
writediffproperties(ctx, diff)
# Use a temporary summary to set dependency. There might be better ways but
# I cannot find them for now. But do not do that if we are updating an
# existing revision (revid is not None) since that introduces visible
# churns (someone edited "Summary" twice) on the web page.
if parentrevid and revid is None:
summary = b'Depends on D%s' % parentrevid
transactions += [{b'type': b'summary', b'value': summary},
{b'type': b'summary', b'value': b' '}]
if actions:
transactions += actions
# Parse commit message and update related fields.
desc = ctx.description()
info = callconduit(repo, b'differential.parsecommitmessage',
{b'corpus': desc})
for k, v in info[r'fields'].items():
if k in [b'title', b'summary', b'testPlan']:
transactions.append({b'type': k, b'value': v})
params = {b'transactions': transactions}
if revid is not None:
# Update an existing Differential Revision
params[b'objectIdentifier'] = revid
revision = callconduit(repo, b'differential.revision.edit', params)
if not revision:
raise error.Abort(_(b'cannot create revision for %s') % ctx)
return revision, diff
def _processpushreview(repo, req, ldap_username):
"""Handle a request to turn changesets into review requests.
``ldap_username`` is the LDAP username to associate with the MozReview
account whose credentials are passed as part of the request. We implicitly
trust the passed LDAP username has been authenticated to belong to the
MozReview account.
"""
bzusername = req.get('bzusername')
bzapikey = req.get('bzapikey')
if not bzusername or not bzapikey:
return errorresponse(
'Bugzilla API keys not configured; see '
'https://mozilla-version-control-tools.readthedocs.io/en/latest/mozreview/install.html#obtaining-accounts-credentials-and-privileges '
'for instructions on how to configure your client')
identifier = req['identifier']
nodes = []
precursors = {}
for cset in req['changesets']:
node = cset['node']
nodes.append(node)
if 'precursors' in cset:
precursors[node] = cset['precursors']
diffopts = mdiff.diffopts(context=8, showfunc=True, git=True)
commits = {
'individual': [],
'squashed': {},
'obsolescence': req.get('obsolescence', False),
}
# We do multiple passes over the changesets requested for review because
# some operations could be slow or may involve queries to external
# resources. We want to run the fast checks first so we don't waste
# resources before finding the error. The drawback here is the client
# will not see the full set of errors. We may revisit this decision
# later.
for node in nodes:
ctx = repo[node]
# Reviewing merge commits doesn't make much sense and only makes
# situations more complicated. So disallow the practice.
if len(ctx.parents()) > 1:
msg = 'cannot review merge commits (%s)' % short(ctx.node())
return errorresponse(msg)
# Invalid or confidental bugs will raise errors in the Review Board
# interface later. Fail fast to minimize wasted time and resources.
try:
reviewid = ReviewID(identifier)
except error.Abort as e:
return errorresponse(str(e))
# We use xmlrpc here because the Bugsy REST client doesn't currently handle
# errors in responses.
# We don't use available Bugzilla credentials because that's the
# easiest way to test for confidential bugs. If/when we support posting
# reviews to confidential bugs, we'll need to change this.
xmlrpc_url = repo.ui.config('bugzilla', 'url').rstrip('/') + '/xmlrpc.cgi'
proxy = xmlrpclib.ServerProxy(xmlrpc_url)
try:
proxy.Bug.get({'ids': [reviewid.bug]})
except xmlrpclib.Fault as f:
if f.faultCode == 101:
return errorresponse('bug %s does not exist; '
'please change the review id (%s)' %
(reviewid.bug, reviewid.full))
elif f.faultCode == 102:
return errorresponse(
'bug %s could not be accessed '
'(we do not currently allow posting of reviews to '
'confidential bugs)' % reviewid.bug)
return errorresponse('server error verifying bug %s exists; '
'please retry or report a bug' % reviewid.bug)
# Find the first public node in the ancestry of this series. This is
# used by MozReview to query the upstream repo for additional context.
first_public_ancestor = None
for node in repo[nodes[0]].ancestors():
ctx = repo[node]
if ctx.phase() == phases.public:
first_public_ancestor = ctx.hex()
break
commits['squashed']['first_public_ancestor'] = first_public_ancestor
# Note patch.diff() appears to accept anything that can be fed into
# repo[]. However, it blindly does a hex() on the argument as opposed
# to the changectx, so we need to pass in the binary node.
base_ctx = repo[nodes[0]].p1()
base_parent_node = base_ctx.node()
for i, node in enumerate(nodes):
ctx = repo[node]
p1 = ctx.p1().node()
diff = ''.join(
patch.diff(repo, node1=p1, node2=ctx.node(), opts=diffopts)) + '\n'
if i:
base_commit_id = nodes[i - 1]
else:
base_commit_id = base_ctx.hex()
summary = encoding.fromlocal(ctx.description().splitlines()[0])
if req.get('deduce-reviewers', True):
reviewers = list(commitparser.parse_rquestion_reviewers(summary))
requal_reviewers = list(
commitparser.parse_requal_reviewers(summary))
else:
reviewers = []
requal_reviewers = []
commits['individual'].append({
'id':
node,
'author':
encoding.fromlocal(ctx.user()),
'precursors':
precursors.get(node, []),
'message':
encoding.fromlocal(ctx.description()),
# Diffs are arbitrary byte sequences. json.dump() will try to
# interpret str as UTF-8, which could fail. Instead of trying
# to coerce the str to a unicode or use ensure_ascii=False (which
# is a giant pain), just base64 encode the diff in the JSON.
'diff_b64':
diff.encode('base64'),
'bug':
str(reviewid.bug),
'base_commit_id':
base_commit_id,
'first_public_ancestor':
first_public_ancestor,
'reviewers':
reviewers,
'requal_reviewers':
requal_reviewers
})
squashed_diff = b''.join(
patch.diff(repo,
node1=base_parent_node,
node2=repo[nodes[-1]].node(),
opts=diffopts)) + '\n'
commits['squashed']['diff_b64'] = squashed_diff.encode('base64')
commits['squashed']['base_commit_id'] = base_ctx.hex()
rburl = repo.ui.config('reviewboard', 'url', None).rstrip('/')
repoid = repo.ui.configint('reviewboard', 'repoid', None)
privileged_rb_username = repo.ui.config('reviewboard', 'username', None)
privileged_rb_password = repo.ui.config('reviewboard', 'password', None)
if ldap_username:
associate_ldap_username(rburl,
ldap_username,
privileged_rb_username,
privileged_rb_password,
username=bzusername,
apikey=bzapikey)
res = {
'rburl': rburl,
'reviewid': identifier,
'reviewrequests': {},
'display': [],
}
try:
parentrid, commitmap, reviews, warnings = \
post_reviews(rburl, repoid, identifier, commits,
privileged_rb_username, privileged_rb_password,
username=bzusername, apikey=bzapikey)
res['display'].extend(warnings)
res['parentrrid'] = parentrid
res['reviewrequests'][parentrid] = {
'status': reviews[parentrid]['status'],
'public': reviews[parentrid]['public'],
}
for node, rid in commitmap.items():
rd = reviews[rid]
res['reviewrequests'][rid] = {
'node': node,
'status': rd['status'],
'public': rd['public'],
}
if rd['reviewers']:
res['reviewrequests'][rid]['reviewers'] = list(rd['reviewers'])
except AuthorizationError as e:
return errorresponse(str(e))
except BadRequestError as e:
return errorresponse(str(e))
return res
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 = mdiff.diffopts(
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
chunks = filterpatch(ui, parsepatch(fp))
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
def createdifferentialrevision(ctx,
revid=None,
parentrevphid=None,
oldnode=None,
olddiff=None,
actions=None,
comment=None):
"""create or update a Differential Revision
If revid is None, create a new Differential Revision, otherwise update
revid. If parentrevphid is not None, set it as a dependency.
If oldnode is not None, check if the patch content (without commit message
and metadata) has changed before creating another diff.
If actions is not None, they will be appended to the transaction.
"""
repo = ctx.repo()
if oldnode:
diffopts = mdiff.diffopts(git=True, context=32767)
oldctx = repo.unfiltered()[oldnode]
neednewdiff = (getdiff(ctx, diffopts) != getdiff(oldctx, diffopts))
else:
neednewdiff = True
transactions = []
if neednewdiff:
diff = creatediff(ctx)
transactions.append({b'type': b'update', b'value': diff[b'phid']})
if comment:
transactions.append({b'type': b'comment', b'value': comment})
else:
# Even if we don't need to upload a new diff because the patch content
# does not change. We might still need to update its metadata so
# pushers could know the correct node metadata.
assert olddiff
diff = olddiff
writediffproperties(ctx, diff)
# Set the parent Revision every time, so commit re-ordering is picked-up
if parentrevphid:
transactions.append({
b'type': b'parents.set',
b'value': [parentrevphid]
})
if actions:
transactions += actions
# Parse commit message and update related fields.
desc = ctx.description()
info = callconduit(repo.ui, b'differential.parsecommitmessage',
{b'corpus': desc})
for k, v in info[b'fields'].items():
if k in [b'title', b'summary', b'testPlan']:
transactions.append({b'type': k, b'value': v})
params = {b'transactions': transactions}
if revid is not None:
# Update an existing Differential Revision
params[b'objectIdentifier'] = revid
revision = callconduit(repo.ui, b'differential.revision.edit', params)
if not revision:
raise error.Abort(_(b'cannot create revision for %s') % ctx)
return revision, diff
def shelvefunc(ui, repo, message, match, opts):
parents = repo.dirstate.parents()
changes = repo.status(match=match)[:5]
modified, added, removed = changes[:3]
files = modified + added + removed
diffopts = mdiff.diffopts(git=True, nodates=True)
patch_diff = ''.join(
patch.diff(repo,
parents[0],
match=match,
changes=changes,
opts=diffopts))
fp = cStringIO.StringIO(patch_diff)
ac = parsepatch(fp)
fp.close()
chunks = filterpatch(ui, ac, not opts['all'])
rc = refilterpatch(ac, chunks)
# set of files to be processed
contenders = {}
for h in chunks:
try:
contenders.update(dict.fromkeys(h.files()))
except AttributeError:
pass
# exclude sources of copies that are otherwise untouched
newfiles = set(f for f in files if f in contenders)
if not newfiles:
ui.status(_('no changes to shelve\n'))
return 0
backupdir = repo.join('shelve-backups')
try:
backups = makebackup(ui, repo, backupdir, newfiles)
# patch to shelve
sp = cStringIO.StringIO()
for c in chunks:
c.write(sp)
# patch to apply to shelved files
fp = cStringIO.StringIO()
for c in rc:
# skip files not selected for shelving
if c.filename() in newfiles:
c.write(fp)
dopatch = fp.tell()
fp.seek(0)
try:
# 3a. apply filtered patch to clean repo (clean)
opts['no_backup'] = True
cmdutil.revert(ui, repo, repo['.'], parents,
*[os.path.join(repo.root, f) for f in newfiles],
**opts)
for f in added:
if f in newfiles:
util.unlinkpath(repo.wjoin(f))
# 3b. apply filtered patch to clean repo (apply)
if dopatch:
ui.debug('applying patch\n')
ui.debug(fp.getvalue())
patch.internalpatch(ui, repo, fp, 1)
del fp
# 3c. apply filtered patch to clean repo (shelve)
ui.debug("saving patch to shelve\n")
if opts['append']:
sp.write(repo.opener(shelfpath).read())
sp.seek(0)
f = repo.opener(shelfpath, "w")
f.write(sp.getvalue())
del f, sp
except:
ui.warn("shelving failed: %s\n" % sys.exc_info()[1])
try:
# re-schedule remove
matchremoved = scmutil.matchfiles(repo, removed)
cmdutil.forget(ui, repo, matchremoved, "", True)
for f in removed:
if f in newfiles and os.path.isfile(f):
os.unlink(f)
# copy back backups
for realname, tmpname in backups.iteritems():
ui.debug('restoring %r to %r\n' % (tmpname, realname))
util.copyfile(tmpname, repo.wjoin(realname))
# re-schedule add
matchadded = scmutil.matchfiles(repo, added)
cmdutil.add(ui, repo, matchadded, False, False, "", True)
ui.debug('removing shelve file\n')
if os.path.isfile(repo.wjoin(shelfpath)):
os.unlink(repo.join(shelfpath))
except OSError, err:
ui.warn("restoring backup failed: %s\n" % err)
return 0
def _shelvecreatedcommit(repo, node, name):
bases = list(mutableancestors(repo[node]))
shelvedfile(repo, name, 'hg').writebundle(bases, node)
with shelvedfile(repo, name, patchextension).opener('wb') as fp:
cmdutil.exportfile(repo, [node], fp, opts=mdiff.diffopts(git=True))
def shelvefunc(ui, repo, message, match, opts):
changes = repo.status(match=match)[:5]
modified, added, removed = changes[:3]
files = modified + added + removed
diffopts = mdiff.diffopts(git=True, nodates=True)
patch_diff = ''.join(
patch.diff(repo,
repo.dirstate.parents()[0],
match=match,
changes=changes,
opts=diffopts))
fp = cStringIO.StringIO(patch_diff)
ac = parsepatch(fp)
fp.close()
chunks = filterpatch(ui, ac, not opts['all'])
rc = refilterpatch(ac, chunks)
contenders = {}
for h in chunks:
try:
contenders.update(dict.fromkeys(h.files()))
except AttributeError:
pass
newfiles = [f for f in files if f in contenders]
if not newfiles:
ui.status(_('no changes to shelve\n'))
return 0
modified = dict.fromkeys(changes[0])
backupdir = repo.join('shelve-backups')
try:
bkfiles = [f for f in newfiles if f in modified]
backups = makebackup(ui, repo, backupdir, bkfiles)
# patch to shelve
sp = cStringIO.StringIO()
for c in chunks:
if c.filename() in backups:
c.write(sp)
doshelve = sp.tell()
sp.seek(0)
# patch to apply to shelved files
fp = cStringIO.StringIO()
for c in rc:
if c.filename() in backups:
c.write(fp)
dopatch = fp.tell()
fp.seek(0)
try:
# 3a. apply filtered patch to clean repo (clean)
if backups:
hg.revert(repo,
repo.dirstate.parents()[0], backups.has_key)
# 3b. apply filtered patch to clean repo (apply)
if dopatch:
ui.debug('applying patch\n')
ui.debug(fp.getvalue())
patch.internalpatch(fp, ui, 1, repo.root)
del fp
# 3c. apply filtered patch to clean repo (shelve)
if doshelve:
ui.debug("saving patch to shelve\n")
if opts['append']:
f = repo.opener(shelfpath, "a")
else:
f = repo.opener(shelfpath, "w")
f.write(sp.getvalue())
del f
del sp
except:
try:
for realname, tmpname in backups.iteritems():
ui.debug('restoring %r to %r\n' % (tmpname, realname))
util.copyfile(tmpname, repo.wjoin(realname))
ui.debug('removing shelve file\n')
os.unlink(repo.join(shelfpath))
except OSError:
pass
return 0
finally:
try:
for realname, tmpname in backups.iteritems():
ui.debug('removing backup for %r : %r\n' %
(realname, tmpname))
os.unlink(tmpname)
os.rmdir(backupdir)
except OSError:
pass
