From cc33d52dd6479096db8f77130e470ae8c56e0a91 Mon Sep 17 00:00:00 2001 From: René 'Necoro' Neumann Date: Tue, 3 Nov 2009 11:42:35 +0100 Subject: Add hg config stuff --- .hgext/hgshelve.py | 548 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 548 insertions(+) create mode 100644 .hgext/hgshelve.py (limited to '.hgext/hgshelve.py') diff --git a/.hgext/hgshelve.py b/.hgext/hgshelve.py new file mode 100644 index 0000000..cd159c9 --- /dev/null +++ b/.hgext/hgshelve.py @@ -0,0 +1,548 @@ +# shelve.py +# +# Copyright 2007 Bryan O'Sullivan +# Copyright 2007 TK Soh +# +# 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 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 '
' % (' '.join(map(repr, self.files()))) + + def special(self): + for h in self.header: + if self.special_re.match(h): + return True + +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 '' % (self.filename(), self.fromline) + +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 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]...')), +} -- cgit v1.2.3-70-g09d2