mercurial-crew-with-dirclash: comparison hgext/mq.py

equal deleted inserted replaced

-:99e7cf6bd2f7
+:030d0abdf91b
 self.applied_dirty = 1
 head = self.qparents(repo)
 for patch in series:
-patch = mergeq.lookup(patch)
+patch = mergeq.lookup(patch, strict=True)
 if not patch:
 self.ui.warn("patch %s does not exist\n" % patch)
 return (1, None)
 info = mergeq.isapplied(patch)
 tr.close()
 os.chdir(pwd)
 return (err, n)
 def delete(self, repo, patch):
-patch = self.lookup(patch)
+patch = self.lookup(patch, strict=True)
 info = self.isapplied(patch)
 if info:
 self.ui.warn("cannot delete applied patch %s\n" % patch)
 sys.exit(1)
 if patch not in self.series:
 raise util.Abort(_("Local changes found, refresh first"))
 else:
 commitfiles = c + a + r
 self.check_toppatch(repo)
 wlock = repo.wlock()
-insert = self.series_end()
+insert = self.full_series_end()
 if msg:
 n = repo.commit(commitfiles, "[mq]: %s" % msg, force=True,
 wlock=wlock)
 else:
 n = repo.commit(commitfiles,
 p.close()
 wlock = None
 r = self.qrepo()
 if r: r.add([patch])
 if commitfiles:
-self.refresh(repo, short=True)
+self.refresh(repo, msg=None, short=True)
 def strip(self, repo, rev, update=True, backup="all", wlock=None):
 def limitheads(chlog, stop):
 """return the list of all nodes that have no children"""
 p = {}
 # TODO delete the undo files, and handle undo of merge sets
 pp = chlog.parents(rev)
 revnum = chlog.rev(rev)
 if update:
+(c, a, r, d, u) = repo.changes(None, None)
+if c or a or d or r:
+raise util.Abort(_("Local changes found"))
 urev = self.qparents(repo, rev)
 repo.update(urev, allow=False, force=True, wlock=wlock)
 repo.dirstate.write()
 # save is a list of all the branches we are truncating away
 a = p.split(':')
 if a[1] == patch:
 return (i, a[0], a[1])
 return None
-def lookup(self, patch):
+# if the exact patch name does not exist, we try a few
+# variations.  If strict is passed, we try only #1
+#
+# 1) a number to indicate an offset in the series file
+# 2) a unique substring of the patch name was given
+# 3) patchname[-+]num to indicate an offset in the series file
+def lookup(self, patch, strict=False):
+def partial_name(s):
+count = 0
+if s in self.series:
+return s
+for x in self.series:
+if s in x:
+count += 1
+last = x
+if count > 1:
+return None
+if count:
+return last
+if len(self.series) > 0 and len(self.applied) > 0:
+if s == 'qtip':
+return self.series[self.series_end()-1]
+if s == 'qbase':
+return self.series[0]
+return None
 if patch == None:
 return None
-if patch in self.series:
-return patch
+# we don't want to return a partial match until we make
+# sure the file name passed in does not exist (checked below)
+res = partial_name(patch)
+if res and res == patch:
+return res
 if not os.path.isfile(os.path.join(self.path, patch)):
 try:
 sno = int(patch)
 except(ValueError, OverflowError):
-self.ui.warn("patch %s not in series\n" % patch)
+pass
-sys.exit(1)
+else:
-if sno >= len(self.series):
+if sno < len(self.series):
-self.ui.warn("patch number %d is out of range\n" % sno)
+patch = self.series[sno]
-sys.exit(1)
+return patch
-patch = self.series[sno]
+if not strict:
-else:
+# return any partial match made above
-self.ui.warn("patch %s not in series\n" % patch)
+if res:
-sys.exit(1)
+return res
-return patch
+minus = patch.rsplit('-', 1)
+if len(minus) > 1:
+res = partial_name(minus[0])
+if res:
+i = self.series.index(res)
+try:
+off = int(minus[1] or 1)
+except(ValueError, OverflowError):
+pass
+else:
+if i - off >= 0:
+return self.series[i - off]
+plus = patch.rsplit('+', 1)
+if len(plus) > 1:
+res = partial_name(plus[0])
+if res:
+i = self.series.index(res)
+try:
+off = int(plus[1] or 1)
+except(ValueError, OverflowError):
+pass
+else:
+if i + off < len(self.series):
+return self.series[i + off]
+self.ui.warn("patch %s not in series\n" % patch)
+sys.exit(1)
 def push(self, repo, patch=None, force=False, list=False,
 mergeq=None, wlock=None):
 if not wlock:
 wlock = repo.wlock()
 top)
 else:
 self.ui.write("Now at: %s\n" % top)
 return ret[0]
-def pop(self, repo, patch=None, force=False, update=True, wlock=None):
+def pop(self, repo, patch=None, force=False, update=True, all=False,
+wlock=None):
 def getfile(f, rev):
 t = repo.file(f).read(rev)
 try:
 repo.wfile(f, "w").write(t)
 except IOError:
 self.check_localchanges(repo)
 self.applied_dirty = 1;
 end = len(self.applied)
 if not patch:
-info = [len(self.applied) - 1] + self.applied[-1].split(':')
+if all:
+popi = 0
+else:
+popi = len(self.applied) - 1
+else:
+popi = info[0] + 1
+if popi >= end:
+self.ui.warn("qpop: %s is already at the top\n" % patch)
+return
+info = [ popi ] + self.applied[popi].split(':')
 start = info[0]
 rev = revlog.bin(info[1])
 # we know there are no local changes, so we can make a simplified
 # form of hg.update.
 self.ui.write("No patches applied\n")
 return
 qp = self.qparents(repo, top)
 commands.dodiff(sys.stdout, self.ui, repo, qp, None, files)
-def refresh(self, repo, short=False):
+def refresh(self, repo, msg=None, short=False):
 if len(self.applied) == 0:
 self.ui.write("No patches applied\n")
 return
 wlock = repo.wlock()
 self.check_toppatch(repo)
 repo.dirstate.update(a, 'a')
 repo.dirstate.update(r, 'r')
 repo.dirstate.update(c, 'n')
 repo.dirstate.forget(forget)
-if not message:
+if not msg:
-message = "patch queue: %s\n" % patch
+if not message:
+message = "patch queue: %s\n" % patch
+else:
+message = "\n".join(message)
 else:
-message = "\n".join(message)
+message = msg
 self.strip(repo, top, update=False, backup='strip', wlock=wlock)
 n = repo.commit(filelist, message, changes[1], force=1, wlock=wlock)
 self.applied[-1] = revlog.hex(n) + ':' + patch
 self.applied_dirty = 1
 else:
 if not patch:
 start = self.series_end()
 else:
 start = self.series.index(patch) + 1
 for p in self.series[start:]:
+if self.ui.verbose:
+self.ui.write("%d " % self.series.index(p))
 self.ui.write("%s\n" % p)
 def qseries(self, repo, missing=None):
 start = self.series_end()
 if not missing:
 self.ui.warn("repo commit failed\n")
 return 1
 self.applied.append(revlog.hex(n) + ":" + '.hg.patches.save.line')
 self.applied_dirty = 1
+def full_series_end(self):
+if len(self.applied) > 0:
+(top, p) = self.applied[-1].split(':')
+end = self.find_series(p)
+if end == None:
+return len(self.full_series)
+return end + 1
+return 0
 def series_end(self):
 end = 0
 if len(self.applied) > 0:
 (top, p) = self.applied[-1].split(':')
 try:
 p = self.appliedname(x)
 self.ui.write("%s\n" % p)
 def appliedname(self, index):
 p = self.applied[index]
+pname = p.split(':')[1]
 if not self.ui.verbose:
-p = p.split(':')[1]
+p = pname
+else:
+p = str(self.series.index(pname)) + " " + p
 return p
 def top(self, repo):
 if len(self.applied):
 p = self.appliedname(-1)
 def next(self, repo):
 end = self.series_end()
 if end == len(self.series):
 self.ui.write("All patches applied\n")
 else:
-self.ui.write(self.series[end] + '\n')
+p = self.series[end]
+if self.ui.verbose:
+self.ui.write("%d " % self.series.index(p))
+self.ui.write(p + '\n')
 def prev(self, repo):
 if len(self.applied) > 1:
 p = self.appliedname(-2)
 self.ui.write(p + '\n')
 patchf = self.opener(patch, "w")
 patchf.write(text)
 if patch in self.series:
 self.ui.warn("patch %s is already in the series file\n" % patch)
 sys.exit(1)
-index = self.series_end() + i
+index = self.full_series_end() + i
 self.full_series[index:index] = [patch]
 self.read_series(self.full_series)
 self.ui.warn("adding %s to series file\n" % patch)
 i += 1
 added.append(patch)
 return 0
 def new(ui, repo, patch, **opts):
 """create a new patch"""
 q = repomap[repo]
-q.new(repo, patch, msg=opts['message'], force=opts['force'])
+message=commands.logmessage(**opts)
+q.new(repo, patch, msg=message, force=opts['force'])
 q.save_dirty()
 return 0
 def refresh(ui, repo, **opts):
 """update the current patch"""
 q = repomap[repo]
-q.refresh(repo, short=opts['short'])
+message=commands.logmessage(**opts)
+q.refresh(repo, msg=message, short=opts['short'])
 q.save_dirty()
 return 0
 def diff(ui, repo, *files, **opts):
 """diff of the current patch"""
 q = queue(ui, repo.join(""), repo.join(opts['name']))
 ui.warn('using patch queue: %s\n' % q.path)
 localupdate = False
 else:
 q = repomap[repo]
-if opts['all'] and len(q.applied) > 0:
+q.pop(repo, patch, force=opts['force'], update=localupdate, all=opts['all'])
-patch = q.applied[0].split(':')[1]
-q.pop(repo, patch, force=opts['force'], update=localupdate)
 q.save_dirty()
 return 0
 def restore(ui, repo, rev, **opts):
 """restore the queue state saved by a rev"""
 return 0
 def save(ui, repo, **opts):
 """save current queue state"""
 q = repomap[repo]
-ret = q.save(repo, msg=opts['message'])
+message=commands.logmessage(**opts)
+ret = q.save(repo, msg=message)
 if ret:
 return ret
 q.save_dirty()
 if opts['copy']:
 path = q.path
 ui.write("mq version %s\n" % versionstr)
 return 0
 def reposetup(ui, repo):
 repomap[repo] = queue(ui, repo.join(""))
-oldlookup = repo.lookup
+oldtags = repo.tags
-def qlookup(key):
+def qtags():
-try:
+if repo.tagscache:
-return oldlookup(key)
+return repo.tagscache
-except hg.RepoError:
-q = repomap[repo]
+tagscache = oldtags()
-qpatchnames = { 'qtip': -1, 'qbase': 0 }
+q = repomap[repo]
-if key in qpatchnames:
+if len(q.applied) == 0:
-if len(q.applied) == 0:
+return tagscache
-self.ui.warn('No patches applied\n')
-raise
+mqtags = [patch.split(':') for patch in q.applied]
-patch = q.applied[qpatchnames[key]].split(':')[0]
+mqtags.append((mqtags[-1][0], 'qtip'))
-return revlog.bin(patch)
+mqtags.append((mqtags[0][0], 'qbase'))
+for patch in mqtags:
-patch = q.isapplied(key)
+if patch[1] in tagscache:
-if not patch:
+repo.ui.warn('Tag %s overrides mq patch of the same name\n' % patch[1])
-raise
+else:
-return revlog.bin(patch[1])
+tagscache[patch[1]] = revlog.bin(patch[0])
-repo.lookup = qlookup
+return tagscache
+repo.tags = qtags
 cmdtable = {
 "qapplied": (applied, [], 'hg qapplied [PATCH]'),
 "qcommit|qci":
 (commit,
 (init,
 [('c', 'create-repo', None, 'create queue repository')],
 'hg qinit [-c]'),
 "qnew":
 (new,
-[('m', 'message', '', 'commit message'),
+[('m', 'message', '', _('use <text> as commit message')),
+('l', 'logfile', '', _('read the commit message from <file>')),
 ('f', 'force', None, 'force')],
-'hg qnew [-m TEXT] [-f] PATCH'),
+'hg qnew [-m TEXT] [-l FILE] [-f] PATCH'),
 "qnext": (next, [], 'hg qnext'),
 "qprev": (prev, [], 'hg qprev'),
 "^qpop":
 (pop,
 [('a', 'all', None, 'pop all patches'),
 ('m', 'merge', None, 'merge from another queue'),
 ('n', 'name', '', 'merge queue name')],
 'hg qpush [-f] [-l] [-a] [-m] [-n NAME] [PATCH | INDEX]'),
 "^qrefresh":
 (refresh,
-[('s', 'short', None, 'short refresh')],
+[('m', 'message', '', _('change commit message with <text>')),
-'hg qrefresh [-s]'),
+('l', 'logfile', '', _('change commit message with <file> content')),
+('s', 'short', None, 'short refresh')],
+'hg qrefresh [-m TEXT] [-l FILE] [-s]'),
 "qrestore":
 (restore,
 [('d', 'delete', None, 'delete save entry'),
 ('u', 'update', None, 'update queue working dir')],
 'hg qrestore [-d] [-u] REV'),
 "qsave":
 (save,
-[('m', 'message', '', 'commit message'),
+[('m', 'message', '', _('use <text> as commit message')),
+('l', 'logfile', '', _('read the commit message from <file>')),
 ('c', 'copy', None, 'copy patch directory'),
 ('n', 'name', '', 'copy directory name'),
 ('e', 'empty', None, 'clear queue status file'),
 ('f', 'force', None, 'force copy')],
-'hg qsave [-m TEXT] [-c] [-n NAME] [-e] [-f]'),
+'hg qsave [-m TEXT] [-l FILE] [-c] [-n NAME] [-e] [-f]'),
 "qseries":
 (series,
 [('m', 'missing', None, 'print patches not in series')],
 'hg qseries [-m]'),
 "^strip":

changeset 2705	030d0abdf91b
parent 2699	f8bcaf5696d5
child 2710	ca97be5babf8