Mercurial: hgext/mq.py comparison

comparison hgext/mq.py @ 6042:2da5b19a6460

Merge with crew

author	Bryan O'Sullivan <bos@serpentine.com>
date	Wed, 06 Feb 2008 19:57:52 -0800
parents	dd714452c26e 30d2fecaab76
children	6283316bcfd4

comparison

equal deleted inserted replaced

-:dd714452c26e
+:2da5b19a6460
 from mercurial.i18n import _
 from mercurial import commands, cmdutil, hg, patch, revlog, util
 from mercurial import repair
 import os, sys, re, errno
-commands.norepo += " qclone qversion"
+commands.norepo += " qclone"
 # Patch names looks like unix-file names.
 # They must be joinable with queue directory and result in the patch path.
 normname = util.normpath
 def save_dirty(self):
 def write_list(items, path):
 fp = self.opener(path, 'w')
 for i in items:
-print >> fp, i
+fp.write("%s\n" % i)
 fp.close()
 if self.applied_dirty: write_list(map(str, self.applied), self.status_path)
 if self.series_dirty: write_list(self.full_series, self.series_path)
 if self.guards_dirty: write_list(self.active_guards, self.guards_path)
 finally:
 repo.invalidate()
 repo.dirstate.invalidate()
 raise
 finally:
-del lock, wlock, tr
+del tr, lock, wlock
+self.removeundo(repo)
 def _apply(self, repo, series, list=False, update_status=True,
 strict=False, patchdir=None, merge=None, all_files={}):
 # TODO unify with commands.py
 if not patchdir:
 if fuzz and strict:
 self.ui.warn("fuzz found when applying patch, stopping\n")
 err = 1
 break
-self.removeundo(repo)
 return (err, n)
 def delete(self, repo, patches, opts):
 if not patches and not opts.get('rev'):
 raise util.Abort(_('qdelete requires at least one revision or '
 def check_toppatch(self, repo):
 if len(self.applied) > 0:
 top = revlog.bin(self.applied[-1].rev)
 pp = repo.dirstate.parents()
 if top not in pp:
-raise util.Abort(_("queue top not at same revision as working directory"))
+raise util.Abort(_("working directory revision is not qtip"))
 return top
 return None
 def check_localchanges(self, repo, force=False, refresh=True):
 m, a, r, d = repo.status()[:4]
 if m or a or r or d:
 raise util.Abort(_("local changes found, refresh first"))
 else:
 raise util.Abort(_("local changes found"))
 return m, a, r, d
+_reserved = ('series', 'status', 'guards')
+def check_reserved_name(self, name):
+if (name in self._reserved or name.startswith('.hg')
+or name.startswith('.mq')):
+raise util.Abort(_('"%s" cannot be used as the name of a patch')
+% name)
 def new(self, repo, patch, *pats, **opts):
 msg = opts.get('msg')
 force = opts.get('force')
+user = opts.get('user')
+date = opts.get('date')
+self.check_reserved_name(patch)
 if os.path.exists(self.join(patch)):
 raise util.Abort(_('patch "%s" already exists') % patch)
 if opts.get('include') or opts.get('exclude') or pats:
 fns, match, anypats = cmdutil.matchpats(repo, pats, opts)
 m, a, r, d = repo.status(files=fns, match=match)[:4]
 else:
 m, a, r, d = self.check_localchanges(repo, force)
+fns, match, anypats = cmdutil.matchpats(repo, m + a + r)
 commitfiles = m + a + r
 self.check_toppatch(repo)
 wlock = repo.wlock()
 try:
 insert = self.full_series_end()
-if msg:
+commitmsg = msg and msg or ("[mq]: %s" % patch)
-n = repo.commit(commitfiles, msg, force=True)
+n = repo.commit(commitfiles, commitmsg, user, date, match=match, force=True)
-else:
-n = repo.commit(commitfiles, "[mq]: %s" % patch, force=True)
 if n == None:
 raise util.Abort(_("repo commit failed"))
 self.full_series[insert:insert] = [patch]
 self.applied.append(statusentry(revlog.hex(n), patch))
 self.parse_series()
 self.series_dirty = 1
 self.applied_dirty = 1
 p = self.opener(patch, "w")
+if date:
+p.write("# HG changeset patch\n")
+if user:
+p.write("# User " + user + "\n")
+p.write("# Date " + date + "\n")
+p.write("\n")
+elif user:
+p.write("From: " + user + "\n")
+p.write("\n")
 if msg:
 msg = msg + "\n"
 p.write(msg)
 p.close()
 wlock = None
 r = self.qrepo()
 if r: r.add([patch])
 if commitfiles:
-self.refresh(repo, short=True)
+self.refresh(repo, short=True, git=opts.get('git'))
 self.removeundo(repo)
 finally:
 del wlock
 def strip(self, repo, rev, update=True, backup="all"):
 hg.clean(repo, urev)
 repo.dirstate.write()
 self.removeundo(repo)
 repair.strip(self.ui, repo, rev, backup)
+# strip may have unbundled a set of backed up revisions after
+# the actual strip
+self.removeundo(repo)
 finally:
 del lock, wlock
 def isapplied(self, patch):
 """returns (index, rev, patch)"""
 return ret[0]
 finally:
 del wlock
 def pop(self, repo, patch=None, force=False, update=True, all=False):
-def getfile(f, rev):
+def getfile(f, rev, flags):
 t = repo.file(f).read(rev)
-repo.wfile(f, "w").write(t)
+repo.wwrite(f, t, flags)
 wlock = repo.wlock()
 try:
 if patch:
 # index, rev, patch
 info = [ popi ] + [self.applied[popi].rev, self.applied[popi].name]
 start = info[0]
 rev = revlog.bin(info[1])
+if update:
+top = self.check_toppatch(repo)
+if repo.changelog.heads(rev) != [revlog.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 update:
-top = self.check_toppatch(repo)
 qp = self.qparents(repo, rev)
 changes = repo.changelog.read(qp)
 mmap = repo.manifest.read(changes[0])
 m, a, r, d, u = repo.status(qp, top)[:5]
 if d:
 raise util.Abort("deletions found between repo revs")
 for f in m:
-getfile(f, mmap[f])
+getfile(f, mmap[f], mmap.flags(f))
 for f in r:
-getfile(f, mmap[f])
+getfile(f, mmap[f], mmap.flags(f))
-util.set_exec(repo.wjoin(f), mmap.execf(f))
 for f in m + r:
 repo.dirstate.normal(f)
 for f in a:
 try:
 os.unlink(repo.wjoin(f))
 raise
 try: os.removedirs(os.path.dirname(repo.wjoin(f)))
 except: pass
 repo.dirstate.forget(f)
 repo.dirstate.setparents(qp, revlog.nullid)
+del self.applied[start:end]
 self.strip(repo, rev, update=False, backup='strip')
-del self.applied[start:end]
 if len(self.applied):
 self.ui.write("Now at: %s\n" % self.applied[-1].name)
 else:
 self.ui.write("Patch queue now empty\n")
 finally:
 wlock = repo.wlock()
 try:
 self.check_toppatch(repo)
 (top, patchfn) = (self.applied[-1].rev, self.applied[-1].name)
 top = revlog.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)
 message, comments, user, date, patchfound = self.readheaders(patchfn)
 patchf = self.opener(patchfn, 'r+')
 # if the patch was a git patch, refresh it as a git patch
 for line in patchf:
 if line.startswith('diff --git'):
 self.diffopts().git = True
 break
+msg = opts.get('msg', '').rstrip()
+if msg and comments:
+# Remove existing message, keeping the rest of the comments
+# fields.
+# If comments contains 'subject: ', message will prepend
+# the field and a blank line.
+if message:
+subj = 'subject: ' + message[0].lower()
+for i in xrange(len(comments)):
+if subj == comments[i].lower():
+del comments[i]
+message = message[2:]
+break
+ci = 0
+for mi in xrange(len(message)):
+while message[mi] != comments[ci]:
+ci += 1
+del comments[ci]
+def setheaderfield(comments, prefixes, new):
+# Update all references to a field in the patch header.
+# If none found, add it email style.
+res = False
+for prefix in prefixes:
+for i in xrange(len(comments)):
+if comments[i].startswith(prefix):
+comments[i] = prefix + new
+res = True
+break
+return res
+newuser = opts.get('user')
+if newuser:
+if not setheaderfield(comments, ['From: ', '# User '], newuser):
+try:
+patchheaderat = comments.index('# HG changeset patch')
+comments.insert(patchheaderat + 1,'# User ' + newuser)
+except ValueError:
+comments = ['From: ' + newuser, ''] + comments
+user = newuser
+newdate = opts.get('date')
+if newdate:
+if setheaderfield(comments, ['# Date '], newdate):
+date = newdate
+if msg:
+comments.append(msg)
 patchf.seek(0)
 patchf.truncate()
-msg = opts.get('msg', '').rstrip()
-if msg:
-if comments:
-# Remove existing message.
-ci = 0
-subj = None
-for mi in xrange(len(message)):
-if comments[ci].lower().startswith('subject: '):
-subj = comments[ci][9:]
-while message[mi] != comments[ci] and message[mi] != subj:
-ci += 1
-del comments[ci]
-comments.append(msg)
 if comments:
 comments = "\n".join(comments) + '\n\n'
 patchf.write(comments)
 if opts.get('git'):
 repo.dirstate.setparents(*cparents)
 copies = {}
 for dst in a:
 src = repo.dirstate.copied(dst)
-if src is None:
+if src is not None:
-continue
+copies.setdefault(src, []).append(dst)
-copies.setdefault(src, []).append(dst)
 repo.dirstate.add(dst)
 # remember the copies between patchparent and tip
 # this may be slow, so don't do it if we're not tracking copies
 if self.diffopts().git:
 for dst in aaa:
 mm.append(m[i])
 del m[i]
 for f in m:
 repo.dirstate.normal(f)
 for f in mm:
-repo.dirstate.normaldirty(f)
+repo.dirstate.normallookup(f)
 for f in forget:
 repo.dirstate.forget(f)
 if not msg:
 if not message:
 else:
 message = "\n".join(message)
 else:
 message = msg
+if not user:
+user = changes[1]
+self.applied.pop()
+self.applied_dirty = 1
 self.strip(repo, top, update=False,
 backup='strip')
-n = repo.commit(filelist, message, changes[1], match=matchfn,
+n = repo.commit(filelist, message, user, date, match=matchfn,
 force=1)
-self.applied[-1] = statusentry(revlog.hex(n), patchfn)
+self.applied.append(statusentry(revlog.hex(n), patchfn))
-self.applied_dirty = 1
 self.removeundo(repo)
 else:
 self.printdiff(repo, patchparent, fp=patchf)
 patchf.close()
 added = repo.status()[1]
 self.strip(repo, rev, update=update, backup='strip')
 if qpp:
 self.ui.warn("saved queue repository parents: %s %s\n" %
 (hg.short(qpp[0]), hg.short(qpp[1])))
 if qupdate:
-print "queue directory updating"
+self.ui.status(_("queue directory updating\n"))
 r = self.qrepo()
 if not r:
 self.ui.warn("Unable to load queue repository\n")
 return 1
 hg.clean(r, qpp[0])
 % (r, lastparent))
 lastparent = p1
 if not patchname:
 patchname = normname('%d.diff' % r)
+self.check_reserved_name(patchname)
 checkseries(patchname)
 checkfile(patchname)
 self.full_series.insert(0, patchname)
 patchf = self.opener(patchname, "w")
 if existing:
 if filename == '-':
 raise util.Abort(_('-e is incompatible with import from -'))
 if not patchname:
 patchname = normname(filename)
+self.check_reserved_name(patchname)
 if not os.path.isfile(self.join(patchname)):
 raise util.Abort(_("patch %s does not exist") % patchname)
 else:
 try:
 if filename == '-':
 text = file(filename).read()
 except IOError:
 raise util.Abort(_("unable to read %s") % patchname)
 if not patchname:
 patchname = normname(os.path.basename(filename))
+self.check_reserved_name(patchname)
 checkfile(patchname)
 patchf = self.opener(patchname, "w")
 patchf.write(text)
 checkseries(patchname)
 index = self.full_series_end() + i
 default.  Use -p <url> to change.
 The patch directory must be a nested mercurial repository, as
 would be created by qinit -c.
 '''
+def patchdir(repo):
+url = repo.url()
+if url.endswith('/'):
+url = url[:-1]
+return url + '/.hg/patches'
 cmdutil.setremoteconfig(ui, opts)
 if dest is None:
 dest = hg.defaultdest(source)
 sr = hg.repository(ui, ui.expandpath(source))
-patchdir = opts['patches'] or (sr.url() + '/.hg/patches')
+patchespath = opts['patches'] or patchdir(sr)
 try:
-pr = hg.repository(ui, patchdir)
+pr = hg.repository(ui, patchespath)
 except hg.RepoError:
 raise util.Abort(_('versioned patch repository not found'
 ' (see qinit -c)'))
 qbase, destrev = None, None
 if sr.local():
 pull=opts['pull'],
 rev=destrev,
 update=False,
 stream=opts['uncompressed'])
 ui.note(_('cloning patch repo\n'))
-spr, dpr = hg.clone(ui, opts['patches'] or (sr.url() + '/.hg/patches'),
+spr, dpr = hg.clone(ui, opts['patches'] or patchdir(sr), patchdir(dr),
-dr.url() + '/.hg/patches',
+pull=opts['pull'], update=not opts['noupdate'],
-pull=opts['pull'],
-update=not opts['noupdate'],
 stream=opts['uncompressed'])
 if dr.local():
 if qbase:
 ui.note(_('stripping applied patches from destination repo\n'))
 dr.mq.strip(dr, qbase, update=False, backup=None)
 ui.write("No patches applied\n")
 return 1
 return q.qseries(repo, start=l-2, length=1, status='A',
 summary=opts.get('summary'))
+def setupheaderopts(ui, opts):
+def do(opt,val):
+if not opts[opt] and opts['current' + opt]:
+opts[opt] = val
+do('user', ui.username())
+do('date', "%d %d" % util.makedate())
 def new(ui, repo, patch, *args, **opts):
 """create a new patch
 qnew creates a new patch on top of the currently-applied patch
 (if any). It will refuse to run if there are any outstanding
 q = repo.mq
 message = cmdutil.logmessage(opts)
 if opts['edit']:
 message = ui.edit(message, ui.username())
 opts['msg'] = message
+setupheaderopts(ui, opts)
 q.new(repo, patch, *args, **opts)
 q.save_dirty()
 return 0
 def refresh(ui, repo, *pats, **opts):
 git-style patches (--git or [diff] git=1) to track copies and renames.
 """
 q = repo.mq
 message = cmdutil.logmessage(opts)
 if opts['edit']:
+if not q.applied:
+ui.write(_("No patches applied\n"))
+return 1
 if message:
 raise util.Abort(_('option "-e" incompatible with "-m" or "-l"'))
 patch = q.applied[-1].name
 (message, comment, user, date, hasdiff) = q.readheaders(patch)
 message = ui.edit('\n'.join(message), user or ui.username())
+setupheaderopts(ui, opts)
 ret = q.refresh(repo, pats, msg=message, **opts)
 q.save_dirty()
 return ret
 def diff(ui, repo, *pats, **opts):
 q = self.mq
 if not q.applied:
 return tagscache
 mqtags = [(revlog.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]))
+return tagscache
 mqtags.append((mqtags[-1][0], 'qtip'))
 mqtags.append((mqtags[0][0], 'qbase'))
 mqtags.append((self.changelog.parents(mqtags[0][0])[0], 'qparent'))
 for patch in mqtags:
 if patch[1] in tagscache:
 def _branchtags(self):
 q = self.mq
 if not q.applied:
 return super(mqrepo, self)._branchtags()
+cl = self.changelog
+qbasenode = revlog.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))
+return super(mqrepo, self)._branchtags()
 self.branchcache = {} # avoid recursion in changectx
-cl = self.changelog
 partial, last, lrev = self._readbranchcache()
-qbase = cl.rev(revlog.bin(q.applied[0].rev))
+qbase = cl.rev(qbasenode)
 start = lrev + 1
 if start < qbase:
 # update the cache (excluding the patches) and save it
 self._updatebranchcache(partial, lrev+1, qbase)
 self._writebranchcache(partial, cl.node(qbase-1), qbase-1)
 repo.__class__ = mqrepo
 repo.mq = queue(ui, repo.join(""))
 seriesopts = [('s', 'summary', None, _('print first line of patch header'))]
+headeropts = [
+('U', 'currentuser', None, _('add "From: <current user>" to patch')),
+('u', 'user', '', _('add "From: <given user>" to patch')),
+('D', 'currentdate', None, _('add "Date: <current date>" to patch')),
+('d', 'date', '', _('add "Date: <given date>" to patch'))]
 cmdtable = {
 "qapplied": (applied, [] + seriesopts, _('hg qapplied [-s] [PATCH]')),
 "qclone":
 (clone,
 [('', 'pull', None, _('use pull protocol to copy metadata')),
 ('U', 'noupdate', None, _('do not update the new working directories')),
 ('', 'uncompressed', None,
 _('use uncompressed transfer (fast over LAN)')),
-('e', 'ssh', '', _('specify ssh command to use')),
 ('p', 'patches', '', _('location of source patch repo')),
-('', 'remotecmd', '',
+] + commands.remoteopts,
-_('specify hg command to run on the remote side'))],
 _('hg qclone [OPTION]... SOURCE [DEST]')),
 "qcommit|qci":
 (commit,
 commands.table["^commit|ci"][1],
 _('hg qcommit [OPTION]... [FILE]...')),
 "^qdiff":
 (diff,
 [('g', 'git', None, _('use git extended diff format')),
-('I', 'include', [], _('include names matching the given patterns')),
+('U', 'unified', 3, _('number of lines of context to show')),
-('X', 'exclude', [], _('exclude names matching the given patterns')),
+] + commands.walkopts,
-('U', 'unified', 3, _('number of lines of context to show'))],
 _('hg qdiff [-I] [-X] [-U NUM] [-g] [FILE]...')),
 "qdelete|qremove|qrm":
 (delete,
 [('k', 'keep', None, _('keep patch file')),
 ('r', 'rev', [], _('stop managing a revision'))],
 _('hg qinit [-c]')),
 "qnew":
 (new,
 [('e', 'edit', None, _('edit commit message')),
 ('f', 'force', None, _('import uncommitted changes into patch')),
-('I', 'include', [], _('include names matching the given patterns')),
+('g', 'git', None, _('use git extended diff format')),
-('X', 'exclude', [], _('exclude names matching the given patterns')),
+] + commands.walkopts + commands.commitopts + headeropts,
-] + commands.commitopts,
 _('hg qnew [-e] [-m TEXT] [-l FILE] [-f] PATCH [FILE]...')),
 "qnext": (next, [] + seriesopts, _('hg qnext [-s]')),
 "qprev": (prev, [] + seriesopts, _('hg qprev [-s]')),
 "^qpop":
 (pop,
 "^qrefresh":
 (refresh,
 [('e', 'edit', None, _('edit commit message')),
 ('g', 'git', None, _('use git extended diff format')),
 ('s', 'short', None, _('refresh only files already in the patch')),
-('I', 'include', [], _('include names matching the given patterns')),
+] + commands.walkopts + commands.commitopts + headeropts,
-('X', 'exclude', [], _('exclude names matching the given patterns')),
-] + commands.commitopts,
 _('hg qrefresh [-I] [-X] [-e] [-m TEXT] [-l FILE] [-s] [FILE]...')),
 'qrename|qmv':
 (rename, [], _('hg qrename PATCH1 [PATCH2]')),
 "qrestore":
 (restore,

Mercurial > hg

comparison hgext/mq.py @ 6042:2da5b19a6460