Mercurial: hgext/mq.py comparison

comparison hgext/mq.py @ 7639:ae7a614a6a57

mq: remove import of revlog

author	Matt Mackall <mpm@selenic.com>
date	Mon, 12 Jan 2009 10:59:08 -0600
parents	1d54e2f6c0b7
children	dd08e1e0cea1

comparison

equal deleted inserted replaced

-:f83a2b1d1a71
+:ae7a614a6a57
 remove patch from applied stack           qpop
 refresh contents of top applied patch     qrefresh
 '''
 from mercurial.i18n import _
-from mercurial.node import bin, hex, short
+from mercurial.node import bin, hex, short, nullid, nullrev
-from mercurial import commands, cmdutil, hg, patch, revlog, util
+from mercurial import commands, cmdutil, hg, patch, util
 from mercurial import repair, extensions, url, error
 import os, sys, re, errno
 commands.norepo += " qclone"
 return (0, n)
 def qparents(self, repo, rev=None):
 if rev is None:
 (p1, p2) = repo.dirstate.parents()
-if p2 == revlog.nullid:
+if p2 == nullid:
 return p1
 if len(self.applied) == 0:
 return None
-return revlog.bin(self.applied[-1].rev)
+return bin(self.applied[-1].rev)
 pp = repo.changelog.parents(rev)
-if pp[1] != revlog.nullid:
+if pp[1] != nullid:
 arevs = [ x.rev for x in self.applied ]
-p0 = revlog.hex(pp[0])
+p0 = hex(pp[0])
-p1 = revlog.hex(pp[1])
+p1 = hex(pp[1])
 if p0 in arevs:
 return pp[0]
 if p1 in arevs:
 return pp[1]
 return pp[0]
 # the first patch in the queue is never a merge patch
 #
 pname = ".hg.patches.merge.marker"
 n = repo.commit(None, '[mq]: merge marker', user=None, force=1)
 self.removeundo(repo)
-self.applied.append(statusentry(revlog.hex(n), pname))
+self.applied.append(statusentry(hex(n), pname))
 self.applied_dirty = 1
 head = self.qparents(repo)
 for patch in series:
 continue
 info = mergeq.isapplied(patch)
 if not info:
 self.ui.warn(_("patch %s is not applied\n") % patch)
 return (1, None)
-rev = revlog.bin(info[1])
+rev = bin(info[1])
 (err, head) = self.mergeone(repo, mergeq, head, patch, rev)
 if head:
-self.applied.append(statusentry(revlog.hex(head), patch))
+self.applied.append(statusentry(hex(head), patch))
 self.applied_dirty = 1
 if err:
 return (err, head)
 self.save_dirty()
 return (0, head)
 if n == None:
 raise util.Abort(_("repo commit failed"))
 if update_status:
-self.applied.append(statusentry(revlog.hex(n), patchname))
+self.applied.append(statusentry(hex(n), patchname))
 if patcherr:
 if not ph.haspatch:
 self.ui.warn(_("patch %s is empty\n") % patchname)
 err = 0
 appliedbase = 0
 patches = []
 for rev in util.sort(revs):
 if rev < firstrev:
 raise util.Abort(_('revision %d is not managed') % rev)
-base = revlog.bin(self.applied[appliedbase].rev)
+base = bin(self.applied[appliedbase].rev)
 node = repo.changelog.node(rev)
 if node != base:
 raise util.Abort(_('cannot delete revision %d above '
 'applied patches') % rev)
 patches.append(self.applied[appliedbase].name)
 revs.reverse()
 for rev in revs:
 if appliedbase >= len(self.applied):
 raise util.Abort(_("revision %d is not managed") % rev)
-base = revlog.bin(self.applied[appliedbase].rev)
+base = bin(self.applied[appliedbase].rev)
 node = repo.changelog.node(rev)
 if node != base:
 raise util.Abort(_("cannot delete revision %d above "
 "applied patches") % rev)
 realpatches.append(self.applied[appliedbase].name)
 self.applied_dirty = 1
 self._clean_series(realpatches)
 def check_toppatch(self, repo):
 if len(self.applied) > 0:
-top = revlog.bin(self.applied[-1].rev)
+top = bin(self.applied[-1].rev)
 pp = repo.dirstate.parents()
 if top not in pp:
 raise util.Abort(_("working directory revision is not qtip"))
 return top
 return None
 n = repo.commit(commitfiles, commitmsg, user, date, match=match, force=True)
 if n == None:
 raise util.Abort(_("repo commit failed"))
 try:
 self.full_series[insert:insert] = [patchfn]
-self.applied.append(statusentry(revlog.hex(n), patchfn))
+self.applied.append(statusentry(hex(n), patchfn))
 self.parse_series()
 self.series_dirty = 1
 self.applied_dirty = 1
 if msg:
 msg = msg + "\n\n"
 self.ui.warn(_("qpop: %s is already at the top\n") % patch)
 return
 if not update:
 parents = repo.dirstate.parents()
-rr = [ revlog.bin(x.rev) for x in self.applied ]
+rr = [ bin(x.rev) for x in self.applied ]
 for p in parents:
 if p in rr:
 self.ui.warn(_("qpop: forcing dirstate update\n"))
 update = True
 else:
 if not force and update:
 self.check_localchanges(repo)
 self.applied_dirty = 1
 end = len(self.applied)
-rev = revlog.bin(self.applied[start].rev)
+rev = bin(self.applied[start].rev)
 if update:
 top = self.check_toppatch(repo)
 try:
 heads = repo.changelog.heads(rev)
-except revlog.LookupError:
+except error.LookupError:
 node = short(rev)
 raise util.Abort(_('trying to pop unknown node %s') % node)
-if heads != [revlog.bin(self.applied[-1].rev)]:
+if heads != [bin(self.applied[-1].rev)]:
 raise util.Abort(_("popping would remove a revision not "
 "managed by this patch queue"))
 # we know there are no local changes, so we can make a simplified
 # form of hg.update.
 if e.errno != errno.ENOENT:
 raise
 try: os.removedirs(os.path.dirname(repo.wjoin(f)))
 except: pass
 repo.dirstate.forget(f)
-repo.dirstate.setparents(qp, revlog.nullid)
+repo.dirstate.setparents(qp, nullid)
 del self.applied[start:end]
 self.strip(repo, rev, update=False, backup='strip')
 if len(self.applied):
 self.ui.write(_("now at: %s\n") % self.applied[-1].name)
 else:
 newdate = '%d %d' % util.parsedate(newdate)
 wlock = repo.wlock()
 try:
 self.check_toppatch(repo)
 (top, patchfn) = (self.applied[-1].rev, self.applied[-1].name)
-top = revlog.bin(top)
+top = bin(top)
 if repo.changelog.heads(top) != [top]:
 raise util.Abort(_("cannot refresh a revision with children"))
 cparents = repo.changelog.parents(top)
 patchparent = self.qparents(repo, top)
 ph = self.readheaders(patchfn)
 try:
 # might be nice to attempt to roll back strip after this
 patchf.rename()
 n = repo.commit(match.files(), message, user, ph.date,
 match=match, force=1)
-self.applied.append(statusentry(revlog.hex(n), patchfn))
+self.applied.append(statusentry(hex(n), patchfn))
 except:
 ctx = repo[cparents[0]]
 repo.dirstate.rebuild(ctx.node(), ctx.manifest())
 self.save_dirty()
 self.ui.warn(_('refresh interrupted while patch was popped! '
 "\n".join(ar) + '\n' or "")
 n = repo.commit(None, text, user=None, force=1)
 if not n:
 self.ui.warn(_("repo commit failed\n"))
 return 1
-self.applied.append(statusentry(revlog.hex(n),'.hg.patches.save.line'))
+self.applied.append(statusentry(hex(n),'.hg.patches.save.line'))
 self.applied_dirty = 1
 self.removeundo(repo)
 def full_series_end(self):
 if len(self.applied) > 0:
 heads = repo.changelog.heads(repo.changelog.node(rev[-1]))
 if len(heads) > 1:
 raise util.Abort(_('revision %d is the root of more than one '
 'branch') % rev[-1])
 if self.applied:
-base = revlog.hex(repo.changelog.node(rev[0]))
+base = hex(repo.changelog.node(rev[0]))
 if base in [n.rev for n in self.applied]:
 raise util.Abort(_('revision %d is already managed')
 % rev[0])
-if heads != [revlog.bin(self.applied[-1].rev)]:
+if heads != [bin(self.applied[-1].rev)]:
 raise util.Abort(_('revision %d is not the parent of '
 'the queue') % rev[0])
-base = repo.changelog.rev(revlog.bin(self.applied[0].rev))
+base = repo.changelog.rev(bin(self.applied[0].rev))
 lastparent = repo.changelog.parentrevs(base)[0]
 else:
 if heads != [repo.changelog.node(rev[0])]:
 raise util.Abort(_('revision %d has unmanaged children')
 % rev[0])
 self.diffopts().git = True
 for r in rev:
 p1, p2 = repo.changelog.parentrevs(r)
 n = repo.changelog.node(r)
-if p2 != revlog.nullrev:
+if p2 != nullrev:
 raise util.Abort(_('cannot import merge revision %d') % r)
 if lastparent and lastparent != r:
 raise util.Abort(_('revision %d is not the parent of %d')
 % (r, lastparent))
 lastparent = p1
 patchf = self.opener(patchname, "w")
 patch.export(repo, [n], fp=patchf, opts=self.diffopts())
 patchf.close()
-se = statusentry(revlog.hex(n), patchname)
+se = statusentry(hex(n), patchname)
 self.applied.insert(0, se)
 added.append(patchname)
 patchname = None
 self.parse_series()
 raise util.Abort(_('versioned patch repository not found'
 ' (see qinit -c)'))
 qbase, destrev = None, None
 if sr.local():
 if sr.mq.applied:
-qbase = revlog.bin(sr.mq.applied[0].rev)
+qbase = bin(sr.mq.applied[0].rev)
 if not hg.islocal(dest):
 heads = dict.fromkeys(sr.heads())
 for h in sr.heads(qbase):
 del heads[h]
 destrev = heads.keys()
 rev = repo.lookup(rev)
 p = repo.dirstate.parents()
 cl = repo.changelog
 update = True
-if p[0] == revlog.nullid:
+if p[0] == nullid:
 update = False
-elif p[1] == revlog.nullid and rev != cl.ancestor(p[0], rev):
+elif p[1] == nullid and rev != cl.ancestor(p[0], rev):
 update = False
 elif rev not in (cl.ancestor(p[0], rev), cl.ancestor(p[1], rev)):
 update = False
 repo.mq.strip(repo, rev, backup=backup, update=update, force=opts['force'])
 def reposetup(ui, repo):
 class mqrepo(repo.__class__):
 def abort_if_wdir_patched(self, errmsg, force=False):
 if self.mq.applied and not force:
-parent = revlog.hex(self.dirstate.parents()[0])
+parent = hex(self.dirstate.parents()[0])
 if parent in [s.rev for s in self.mq.applied]:
 raise util.Abort(errmsg)
 def commit(self, *args, **opts):
 if len(args) >= 6:
 q = self.mq
 if not q.applied:
 return tagscache
-mqtags = [(revlog.bin(patch.rev), patch.name) for patch in q.applied]
+mqtags = [(bin(patch.rev), patch.name) for patch in q.applied]
 if mqtags[-1][0] not in self.changelog.nodemap:
 self.ui.warn(_('mq status file refers to unknown node %s\n')
-% revlog.short(mqtags[-1][0]))
+% short(mqtags[-1][0]))
 return tagscache
 mqtags.append((mqtags[-1][0], 'qtip'))
 mqtags.append((mqtags[0][0], 'qbase'))
 mqtags.append((self.changelog.parents(mqtags[0][0])[0], 'qparent'))
 q = self.mq
 if not q.applied:
 return super(mqrepo, self)._branchtags(partial, lrev)
 cl = self.changelog
-qbasenode = revlog.bin(q.applied[0].rev)
+qbasenode = bin(q.applied[0].rev)
 if qbasenode not in cl.nodemap:
 self.ui.warn(_('mq status file refers to unknown node %s\n')
-% revlog.short(qbasenode))
+% short(qbasenode))
 return super(mqrepo, self)._branchtags(partial, lrev)
 qbase = cl.rev(qbasenode)
 start = lrev + 1
 if start < qbase:

Mercurial > hg

comparison hgext/mq.py @ 7639:ae7a614a6a57