We are currently indexing your data, so search results may be incomplete until we finish.
status: add shelve/unshelve support
Changeset 39c2ac1c8584…
Parent 814130b27945…
by
Changes to 2 files · Browse files at 39c2ac1c8584 Showing diff from parent 814130b27945 Diff from another changeset...
|
|
|
@@ -0,0 +1,557 @@ + # shelve.py
+#
+# Copyright 2007 Bryan O'Sullivan <bos@serpentine.com>
+# Copyright 2007 TK Soh <teekaysoh@gmailcom>
+#
+# This software may be used and distributed according to the terms of
+# the GNU General Public License, incorporated herein by reference.
+
+'''interactive change selection to set aside that may be restored later'''
+
+from mercurial.i18n import _
+from mercurial import cmdutil, commands, cmdutil, hg, mdiff, patch, revlog
+from mercurial import util, fancyopts
+import copy, cStringIO, errno, operator, os, re, shutil, tempfile
+
+lines_re = re.compile(r'@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)')
+
+def internalpatch(patchobj, ui, strip, cwd, reverse=False, files={}):
+ """use builtin patch to apply <patchobj> to the working directory.
+ returns whether patch was applied with fuzz factor.
+
+ Adapted from patch.internalpatch() to support reverse patching.
+ """
+ try:
+ fp = file(patchobj, 'rb')
+ except TypeError:
+ fp = patchobj
+ if cwd:
+ curdir = os.getcwd()
+ os.chdir(cwd)
+ try:
+ ret = patch.applydiff(ui, fp, files, strip=strip,
+ reverse=reverse)
+ finally:
+ if cwd:
+ os.chdir(curdir)
+ if ret < 0:
+ raise PatchError
+ return ret > 0
+
+def scanpatch(fp):
+ lr = patch.linereader(fp)
+
+ def scanwhile(first, p):
+ 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/'):
+ 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:
+ raise patch.PatchError('unknown patch content: %r' % line)
+
+class header(object):
+ diff_re = re.compile('diff --git a/(.*) b/(.*)$')
+ 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):
+ for h in self.header:
+ if h.startswith('index '):
+ return True
+
+ 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([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):
+ for h in self.header:
+ if self.allhunks_re.match(h):
+ return True
+
+ def files(self):
+ fromfile, tofile = self.diff_re.match(self.header[0]).groups()
+ if fromfile == tofile:
+ return [fromfile]
+ return [fromfile, tofile]
+
+ def filename(self):
+ return self.files()[-1]
+
+ def __repr__(self):
+ return '<header %s>' % (' '.join(map(repr, self.files())))
+
+ def special(self):
+ for h in self.header:
+ if self.special_re.match(h):
+ return True
+
+ def __cmp__(self, other):
+ return cmp(repr(self), repr(other))
+
+def countchanges(hunk):
+ 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):
+ 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)
+ 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 __cmp__(self, other):
+ return cmp(repr(self), repr(other))
+
+def parsepatch(fp):
+ class parser(object):
+ def __init__(self):
+ self.fromline = 0
+ self.toline = 0
+ self.proc = ''
+ self.header = None
+ self.context = []
+ self.before = []
+ self.hunk = []
+ self.stream = []
+
+ def addrange(self, (fromstart, fromend, tostart, toend, proc)):
+ 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.stream.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 = data
+
+ def newfile(self, hdr):
+ self.addcontext([])
+ h = header(hdr)
+ self.stream.append(h)
+ self.header = h
+
+ def finished(self):
+ self.addcontext([])
+ return self.stream
+
+ transitions = {
+ 'file': {'context': addcontext,
+ 'file': newfile,
+ 'hunk': addhunk,
+ 'range': addrange},
+ 'context': {'file': newfile,
+ 'hunk': addhunk,
+ 'range': addrange},
+ 'hunk': {'context': addcontext,
+ 'file': newfile,
+ 'range': addrange},
+ 'range': {'context': addcontext,
+ 'hunk': addhunk},
+ }
+
+ 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, chunks):
+ chunks = list(chunks)
+ chunks.reverse()
+ seen = {}
+ def consumefile():
+ consumed = []
+ while chunks:
+ if isinstance(chunks[-1], header):
+ break
+ else:
+ consumed.append(chunks.pop())
+ return consumed
+ resp_all = [None]
+ resp_file = [None]
+ applied = {}
+ def prompt(query):
+ if resp_all[0] is not None:
+ return resp_all[0]
+ if resp_file[0] is not None:
+ return resp_file[0]
+ while True:
+ r = (ui.prompt(query + _(' [Ynsfdaq?] '), '(?i)[Ynsfdaq?]?$')
+ or 'y').lower()
+ if r == '?':
+ c = shelve.__doc__.find('y - shelve this change')
+ for l in shelve.__doc__[c:].splitlines():
+ if l: ui.write(_(l.strip()), '\n')
+ continue
+ elif r == 's':
+ r = resp_file[0] = 'n'
+ elif r == 'f':
+ r = resp_file[0] = 'y'
+ elif r == 'd':
+ r = resp_all[0] = 'n'
+ elif r == 'a':
+ r = resp_all[0] = 'y'
+ elif r == 'q':
+ raise util.Abort(_('user quit'))
+ return r
+ while chunks:
+ chunk = chunks.pop()
+ if isinstance(chunk, header):
+ resp_file = [None]
+ fixoffset = 0
+ hdr = ''.join(chunk.header)
+ if hdr in seen:
+ consumefile()
+ continue
+ seen[hdr] = True
+ if resp_all[0] is None:
+ chunk.pretty(ui)
+ r = prompt(_('shelve changes to %s?') %
+ _(' and ').join(map(repr, chunk.files())))
+ if r == 'y':
+ applied[chunk.filename()] = [chunk]
+ if chunk.allhunks():
+ applied[chunk.filename()] += consumefile()
+ else:
+ consumefile()
+ else:
+ if resp_file[0] is None and resp_all[0] is None:
+ chunk.pretty(ui)
+ r = prompt(_('shelve this change to %r?') %
+ chunk.filename())
+ if r == 'y':
+ if fixoffset:
+ chunk = copy.copy(chunk)
+ chunk.toline += fixoffset
+ applied[chunk.filename()].append(chunk)
+ else:
+ fixoffset += chunk.removed - chunk.added
+ return reduce(operator.add, [h for h in applied.itervalues()
+ if h[0].special() or len(h) > 1], [])
+
+def refilterpatch(allchunk, selected):
+ ''' return unshelved chunks of files to be shelved '''
+ l = []
+ fil = []
+ for c in allchunk:
+ if isinstance(c, header):
+ if len(l) > 1 and l[0] in selected:
+ fil += l
+ l = [c]
+ elif c not in selected:
+ l.append(c)
+ if len(l) > 1 and l[0] in selected:
+ fil += l
+ return fil
+
+def makebackup(ui, repo, dir, files):
+ try:
+ os.mkdir(dir)
+ except OSError, err:
+ if err.errno != errno.EEXIST:
+ raise
+
+ backups = {}
+ for f in files:
+ fd, tmpname = tempfile.mkstemp(prefix=f.replace('/', '_')+'.',
+ dir=dir)
+ os.close(fd)
+ ui.debug('backup %r as %r\n' % (f, tmpname))
+ util.copyfile(repo.wjoin(f), tmpname)
+ backups[f] = tmpname
+
+ return backups
+
+def get_shelve_filename(repo):
+ return repo.join('shelve')
+
+def shelve(ui, repo, *pats, **opts):
+ '''interactively select changes to set aside
+
+ If a list of files is omitted, all changes reported by "hg status"
+ will be candidates for shelveing.
+
+ You will be prompted for whether to shelve 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 - shelve this change
+ n - skip this change
+
+ s - skip remaining changes to this file
+ f - shelve remaining changes to this file
+
+ d - done, skip remaining changes and files
+ a - shelve all changes to all remaining files
+ q - quit, shelveing no changes
+
+ ? - display help'''
+
+ if not ui.interactive:
+ raise util.Abort(_('shelve can only be run interactively'))
+
+ forced = opts['force'] or opts['append']
+ if os.path.exists(repo.join('shelve')) and not forced:
+ raise util.Abort(_('shelve data already exists'))
+
+ 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)
+ 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('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 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
+ fancyopts.fancyopts([], commands.commitopts, opts)
+ return cmdutil.commit(ui, repo, shelvefunc, pats, opts)
+
+
+def unshelve(ui, repo, *pats, **opts):
+ '''restore shelved changes'''
+
+ try:
+ fp = cStringIO.StringIO()
+ fp.write(repo.opener('shelve').read())
+ if opts['inspect']:
+ ui.status(fp.getvalue())
+ else:
+ files = []
+ for chunk in parsepatch(fp):
+ if isinstance(chunk, header):
+ files += chunk.files()
+ backupdir = repo.join('shelve-backups')
+ backups = makebackup(ui, repo, backupdir, set(files))
+
+ ui.debug('applying shelved patch\n')
+ patchdone = 0
+ try:
+ try:
+ fp.seek(0)
+ internalpatch(fp, ui, 1, repo.root)
+ patchdone = 1
+ except:
+ if opts['force']:
+ patchdone = 1
+ else:
+ ui.status('restoring backup files\n')
+ for realname, tmpname in backups.iteritems():
+ ui.debug('restoring %r to %r\n' %
+ (tmpname, realname))
+ util.copyfile(tmpname, repo.wjoin(realname))
+ finally:
+ try:
+ ui.debug('removing backup files\n')
+ shutil.rmtree(backupdir, True)
+ except OSError:
+ pass
+
+ if patchdone:
+ ui.debug("removing shelved patches\n")
+ os.unlink(repo.join('shelve'))
+ ui.status("unshelve completed\n")
+ except IOError:
+ ui.warn('nothing to unshelve\n')
+
+cmdtable = {
+ "shelve":
+ (shelve,
+ [('A', 'addremove', None,
+ _('mark new/missing files as added/removed before shelving')),
+ ('f', 'force', None,
+ _('overwrite existing shelve data')),
+ ('a', 'append', None,
+ _('append to existing shelve data')),
+ ] + commands.walkopts,
+ _('hg shelve [OPTION]... [FILE]...')),
+ "unshelve":
+ (unshelve,
+ [('i', 'inspect', None, _('inspect shelved changes only')),
+ ('f', 'force', None,
+ _('proceed even if patches do not unshelve cleanly')),
+ ],
+ _('hg unshelve [OPTION]... [FILE]...')),
+}
|
|
|
@@ -23,13 +23,14 @@
from mercurial.i18n import _
from mercurial.node import *
-from mercurial import cmdutil, util, ui, hg, commands, patch
+from mercurial import cmdutil, util, ui, hg, commands, patch, mdiff
from mercurial import merge as merge_
from hgext import extdiff
from shlib import shell_notify
from hglib import toutf, rootpath, gettabwidth
from gdialog import *
from dialog import entry_dialog
+import hgshelve
class GStatus(GDialog):
"""GTK+ based dialog for displaying repository status
@@ -168,6 +169,17 @@ self.showdiff_toggle.set_active(False)
self._showdiff_toggled_id = self.showdiff_toggle.connect('toggled', self._showdiff_toggled )
tbuttons.append(self.showdiff_toggle)
+
+ self.shelve_btn = self.make_toolbutton(gtk.STOCK_FILE, 'Shelve',
+ self._shelve_clicked, tip='set aside selected changes')
+ self.unshelve_btn = self.make_toolbutton(gtk.STOCK_EDIT, 'Unshelve',
+ self._unshelve_clicked, tip='restore shelved changes')
+ tbuttons += [
+ gtk.SeparatorToolItem(),
+ self.shelve_btn,
+ self.unshelve_btn,
+ ]
+
return tbuttons
@@ -298,7 +310,24 @@ self.diff_text.set_wrap_mode(gtk.WRAP_NONE)
self.diff_text.set_editable(False)
self.diff_text.modify_font(pango.FontDescription(self.fontdiff))
- scroller.add(self.diff_text)
+
+ # use treeview to diff hunks
+ self.diff_model = gtk.ListStore(bool, str, 'gboolean')
+ self.diff_tree = gtk.TreeView(self.diff_model)
+ self.diff_tree.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
+ self.diff_tree.modify_font(pango.FontDescription(self.fontlist))
+ self.diff_tree.set_property('enable-grid-lines', True)
+ self.diff_tree.connect('button-press-event',
+ self._diff_tree_button_press)
+
+ diff_hunk_cell = gtk.CellRendererText()
+ diff_hunk_cell.set_property('cell-background', '#EEEEEE')
+ diffcol = gtk.TreeViewColumn('diff', diff_hunk_cell, markup=1,
+ cell_background_set=2)
+ diffcol.set_resizable(True)
+ self.diff_tree.append_column(diffcol)
+
+ scroller.add(self.diff_tree)
if self.diffbottom:
self._diffpane = gtk.VPaned()
@@ -487,6 +516,9 @@ self._update_check_count()
return True
+ def _select_diff_toggle(self, cellrenderer, path):
+ self.diff_model[path][0] = not self.diff_model[path][0]
+ return True
def _show_toggle(self, check, type):
self.opts[type] = check.get_active()
@@ -617,6 +649,43 @@
def _tree_selection_changed(self, selection, force):
+ if self.showdiff_toggle.get_active():
+ files = [self.model[iter][2] for iter in self.tree.get_selection().get_selected_rows()[1]]
+ if force or files != self._last_files:
+ self._last_files = files
+ #self._show_diff_text(files)
+ self._show_diff_hunks(files)
+ return False
+
+ def _diff_tree_button_press(self, widget, event):
+ if event.button == 1:
+ tup = widget.get_path_at_pos(int(event.x), int(event.y))
+ if tup is None:
+ return False
+ path = tup[0]
+
+ def get_hunk_pos(filename):
+ l = []
+ for n, hunk in enumerate(self._shelve_chunks):
+ if hunk.filename() == filename:
+ l.append(n)
+ return l
+
+ # cliked on header hunk to select/unselect all hunks in file
+ hunk = self._shelve_chunks[path[0]]
+ if isinstance(hunk, hgshelve.header):
+ l = get_hunk_pos(hunk.filename())
+ selection = self.diff_tree.get_selection()
+ selected = selection.path_is_selected(path)
+ for i in l:
+ if selected:
+ selection.unselect_path((i,))
+ else:
+ selection.select_path((i,))
+ return True # stop further event handling
+ return False # try next handler
+
+ def _show_diff_text(self, files):
''' Update the diff text '''
def dohgdiff():
difftext = []
@@ -655,13 +724,67 @@
self.diff_text.set_buffer(buffer)
- if self.showdiff_toggle.get_active():
- files = [self.model[iter][3] for iter in self.tree.get_selection().get_selected_rows()[1]]
- if force or files != self._last_files:
- self._last_files = files
- self._hg_call_wrapper('Diff', dohgdiff)
- return False
+ self._hg_call_wrapper('Diff', dohgdiff)
+
+ def _show_diff_hunks(self, files):
+ ''' Update the diff text '''
+ def markup(chunk):
+ import cgi
+ hunk = ""
+ chunk.seek(0)
+ lines = chunk.readlines()
+ lines[-1] = lines[-1].strip('\n\r')
+ for line in lines:
+ line = cgi.escape(util.fromlocal(line))
+ if line.startswith('---') or line.startswith('+++'):
+ hunk += '<span foreground="#000090">%s</span>' % line
+ elif line.startswith('-'):
+ hunk += '<span foreground="#900000">%s</span>' % line
+ elif line.startswith('+'):
+ hunk += '<span foreground="#006400">%s</span>' % line
+ elif line.startswith('@@'):
+ hunk = '<span foreground="#FF8000">%s</span>' % line
+ else:
+ hunk += line
+ return hunk
+
+ def dohgdiff():
+ self.diff_model.clear()
+ try:
+ difftext = []
+ if len(files) != 0:
+ wfiles = [self.repo.wjoin(x) for x in files]
+ matcher = cmdutil.match(self.repo, wfiles, self.opts)
+ diffopts = mdiff.diffopts(git=True, nodates=True)
+ for s in patch.diff(self.repo, self._node1, self._node2,
+ match=matcher, opts=diffopts):
+ difftext.extend(s.splitlines(True))
+ difftext = StringIO.StringIO(''.join(difftext))
+ difftext.seek(0)
+ self._shelve_chunks = hgshelve.parsepatch(difftext)
+
+ for chunk in self._shelve_chunks:
+ fp = StringIO.StringIO()
+ chunk.pretty(fp)
+ markedup = markup(fp)
+ isheader = isinstance(chunk, hgshelve.header)
+ self.diff_model.append([True, markedup, isheader])
+ finally:
+ difftext.close()
+
+ self._hg_call_wrapper('Diff', dohgdiff)
+
+ def _has_shelve_file(self):
+ return os.path.exists(self.repo.join('shelve'))
+
+ def _activate_shelve_buttons(self, status):
+ if status:
+ self.shelve_btn.set_sensitive(True)
+ self.unshelve_btn.set_sensitive(self._has_shelve_file())
+ else:
+ self.shelve_btn.set_sensitive(False)
+ self.unshelve_btn.set_sensitive(False)
def _showdiff_toggled(self, togglebutton, data=None):
# prevent movement events while setting position
@@ -675,6 +798,7 @@ self._diffpane.set_position(64000)
self.diff_text.set_buffer(gtk.TextBuffer())
+ self._activate_shelve_buttons(togglebutton.get_active())
self._diffpane.handler_unblock(self._diffpane_moved_id)
return True
@@ -695,6 +819,7 @@ self.showdiff_toggle.set_active(True)
self._tree_selection_changed(self.tree.get_selection(), True)
+ self._activate_shelve_buttons(self.showdiff_toggle.get_active())
self.showdiff_toggle.handler_unblock(self._showdiff_toggled_id)
return False
@@ -783,6 +908,73 @@ shell_notify(wfiles)
self.reload_status()
+ def _shelve_selected(self):
+ treeselection = self.diff_tree.get_selection()
+ (model, pathlist) = treeselection.get_selected_rows()
+ hlist = [x[0] for x in pathlist]
+ if not hlist:
+ Prompt('Shelve', 'Please select diff chunks to shelve',
+ self).run()
+ return
+
+ doforce = False
+ doappend = False
+ if self._has_shelve_file():
+ from gtklib import MessageDialog
+ dialog = MessageDialog(flags=gtk.DIALOG_MODAL)
+ dialog.set_title('Shelve')
+ dialog.set_markup('<b>Shelve file exists!</b>')
+ dialog.add_buttons('Overwrite', 1, 'Append', 2, 'Cancel', -1)
+ dialog.set_transient_for(self)
+ rval = dialog.run()
+ dialog.destroy()
+ if rval == -1:
+ return
+ if rval == 1:
+ doforce = True
+ if rval == 2:
+ doappend = True
+
+ # capture the selected hunks to shelve
+ fc = []
+ sc = []
+ for n, c in enumerate(self._shelve_chunks):
+ if isinstance(c, hgshelve.header):
+ if len(fc) > 1 or (len(fc) == 1 and fc[0].binary()):
+ sc += fc
+ fc = [c]
+ elif n in hlist:
+ fc.append(c)
+ if len(fc) > 1 or (len(fc) == 1 and fc[0].binary()):
+ sc += fc
+
+ def filter_patch(ui, chunks):
+ return sc
+
+ # shelve them!
+ self.ui.interactive = True # hgshelve only works 'interactively'
+ opts = {'addremove': None, 'include': [], 'force': doforce,
+ 'append': doappend, 'exclude': []}
+ hgshelve.filterpatch = filter_patch
+ hgshelve.shelve(self.ui, self.repo, **opts)
+ self.reload_status()
+
+ def _unshelve(self):
+ opts = {'addremove': None, 'include': [], 'force': None,
+ 'append': None, 'exclude': [], 'inspect': None}
+ try:
+ hgshelve.unshelve(self.ui, self.repo, **opts)
+ self.reload_status()
+ except:
+ pass
+
+ def _shelve_clicked(self, toolbutton, data=None):
+ self._shelve_selected()
+ self._activate_shelve_buttons(True)
+
+ def _unshelve_clicked(self, toolbutton, data=None):
+ self._unshelve()
+ self._activate_shelve_buttons(True)
def _remove_clicked(self, toolbutton, data=None):
remove_list = self._relevant_files('C')
@@ -975,7 +1167,7 @@
def run(root='', cwd='', files=[], **opts):
u = ui.ui()
- u.updateopts(debug=False, traceback=False)
+ u.updateopts(debug=False, traceback=False, quiet=True)
repo = hg.repository(u, path=root)
cmdoptions = {
|
|
Add a tag
Loading...