mercurial: comparison hgext/mq.py

equal deleted inserted replaced

-:fdc232d8a193
+:987c31e2a08c
 from mercurial import ui, hg, revlog, commands, util
 versionstr = "0.45"
 commands.norepo += " qclone qversion"
+class StatusEntry:
+def __init__(self, rev, name=None):
+if not name:
+self.rev, self.name = rev.split(':')
+else:
+self.rev, self.name = rev, name
+def __str__(self):
+return self.rev + ':' + self.name
 class queue:
 def __init__(self, ui, path, patchdir=None):
 self.basepath = path
 if patchdir:
 if os.path.exists(os.path.join(self.path, self.series_path)):
 self.full_series = self.opener(self.series_path).read().splitlines()
 self.parse_series()
 if os.path.exists(os.path.join(self.path, self.status_path)):
-self.applied = self.opener(self.status_path).read().splitlines()
+self.applied = [StatusEntry(l)
+for l in self.opener(self.status_path).read().splitlines()]
 def find_series(self, patch):
 pre = re.compile("(\s*)([^#]+)")
 index = 0
 for l in self.full_series:
 def write_list(items, path):
 fp = self.opener(path, 'w')
 for i in items:
 print >> fp, i
 fp.close()
-if self.applied_dirty: write_list(self.applied, self.status_path)
+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)
 def readheaders(self, patch):
 def eatdiff(lines):
 while lines:
 (p1, p2) = repo.dirstate.parents()
 if p2 == revlog.nullid:
 return p1
 if len(self.applied) == 0:
 return None
-(top, patch) = self.applied[-1].split(':')
+return revlog.bin(self.applied[-1].rev)
-top = revlog.bin(top)
-return top
 pp = repo.changelog.parents(rev)
 if pp[1] != revlog.nullid:
-arevs = [ x.split(':')[0] for x in self.applied ]
+arevs = [ x.rev for x in self.applied ]
 p0 = revlog.hex(pp[0])
 p1 = revlog.hex(pp[1])
 if p0 in arevs:
 return pp[0]
 if p1 in arevs:
 # 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,
 wlock=wlock)
-self.applied.append(revlog.hex(n) + ":" + pname)
+self.applied.append(StatusEntry(revlog.hex(n), pname))
 self.applied_dirty = 1
 head = self.qparents(repo)
 for patch in series:
 self.ui.warn("patch %s is not applied\n" % patch)
 return (1, None)
 rev = revlog.bin(info[1])
 (err, head) = self.mergeone(repo, mergeq, head, patch, rev, wlock)
 if head:
-self.applied.append(revlog.hex(head) + ":" + patch)
+self.applied.append(StatusEntry(revlog.hex(head), patch))
 self.applied_dirty = 1
 if err:
 return (err, head)
 return (0, head)
 def patch(self, repo, patchfile):
 '''Apply patchfile  to the working directory.
 patchfile: file name of patch'''
 try:
 pp = util.find_in_path('gpatch', os.environ.get('PATH', ''), 'patch')
-f = os.popen("%s -d '%s' -p1 --no-backup-if-mismatch < '%s'" %
+f = os.popen("%s -d %s -p1 --no-backup-if-mismatch < %s" %
-(pp, repo.root, patchfile))
+(pp, util.shellquote(repo.root), util.shellquote(patchfile)))
 except:
 self.ui.warn("patch failed, unable to continue (try -v)\n")
 return (None, [], False)
 files = []
 fuzz = False
 for l in f:
 l = l.rstrip('\r\n');
 if self.ui.verbose:
 self.ui.warn(l + "\n")
 if l[:14] == 'patching file ':
-pf = os.path.normpath(l[14:])
+pf = os.path.normpath(util.parse_patch_output(l))
-# when patch finds a space in the file name, it puts
-# single quotes around the filename.  strip them off
-if pf[0] == "'" and pf[-1] == "'":
-pf = pf[1:-1]
 if pf not in files:
 files.append(pf)
 printed_file = False
 file_str = l
 elif l.find('with fuzz') >= 0:
 if n == None:
 raise util.Abort(_("repo commit failed"))
 if update_status:
-self.applied.append(revlog.hex(n) + ":" + patch)
+self.applied.append(StatusEntry(revlog.hex(n), patch))
 if patcherr:
 if not patchfound:
 self.ui.warn("patch %s is empty\n" % patch)
 err = 0
 self.parse_series()
 self.series_dirty = 1
 def check_toppatch(self, repo):
 if len(self.applied) > 0:
-(top, patch) = self.applied[-1].split(':')
+top = revlog.bin(self.applied[-1].rev)
-top = revlog.bin(top)
 pp = repo.dirstate.parents()
 if top not in pp:
 raise util.Abort(_("queue top not at same revision as working directory"))
 return top
 return None
 n = repo.commit(commitfiles,
 "New patch: %s" % patch, force=True, wlock=wlock)
 if n == None:
 raise util.Abort(_("repo commit failed"))
 self.full_series[insert:insert] = [patch]
-self.applied.append(revlog.hex(n) + ":" + 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 msg:
 filerev = 0
 seen[f] = filerev
 # we go in two steps here so the strip loop happens in a
 # sensible order.  When stripping many files, this helps keep
 # our disk access patterns under control.
-list = seen.keys()
+seen_list = seen.keys()
-list.sort()
+seen_list.sort()
-for f in list:
+for f in seen_list:
 ff = repo.file(f)
 filerev = seen[f]
 if filerev != 0:
 if filerev in ff.nodemap:
 filerev = ff.rev(filerev)
 # that we actually want to keep.  changegroup will be used
 # to preserve them and add them back after the truncate
 saveheads = []
 savebases = {}
-tip = chlog.tip()
 heads = limitheads(chlog, rev)
 seen = {}
 # search through all the heads, finding those where the revision
 # we want to strip away is an ancestor.  Also look for merges
 for x in r:
 if chlog.rev(x) > revnum:
 savebases[x] = 1
 # create a changegroup for all the branches we need to keep
-if backup is "all":
+if backup == "all":
 backupch = repo.changegroupsubset([rev], chlog.heads(), 'strip')
 bundle(backupch)
 if saveheads:
 backupch = repo.changegroupsubset(savebases.keys(), saveheads, 'strip')
 chgrpfile = bundle(backupch)
 repo.manifest.strip(repo.manifest.rev(change[0]), revnum)
 chlog.strip(revnum, revnum)
 if saveheads:
 self.ui.status("adding branch\n")
 commands.unbundle(self.ui, repo, chgrpfile, update=False)
-if backup is not "strip":
+if backup != "strip":
 os.unlink(chgrpfile)
 def isapplied(self, patch):
 """returns (index, rev, patch)"""
 for i in xrange(len(self.applied)):
-p = self.applied[i]
+a = self.applied[i]
-a = p.split(':')
+if a.name == patch:
-if a[1] == patch:
+return (i, a.rev, a.name)
-return (i, a[0], a[1])
 return None
 # if the exact patch name does not exist, we try a few
 # variations.  If strict is passed, we try only #1
 #
 s = self.series[start:end]
 if mergeq:
 ret = self.mergepatch(repo, mergeq, s, wlock)
 else:
 ret = self.apply(repo, s, list, wlock=wlock)
-top = self.applied[-1].split(':')[1]
+top = self.applied[-1].name
 if ret[0]:
 self.ui.write("Errors during apply, please fix and refresh %s\n" %
 top)
 else:
 self.ui.write("Now at: %s\n" % top)
 self.ui.warn(_("no patches applied\n"))
 sys.exit(1)
 if not update:
 parents = repo.dirstate.parents()
-rr = [ revlog.bin(x.split(':')[0]) for x in self.applied ]
+rr = [ revlog.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:
 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(':')
+info = [ popi ] + [self.applied[popi].rev, self.applied[popi].name]
 start = info[0]
 rev = revlog.bin(info[1])
 # we know there are no local changes, so we can make a simplified
 repo.dirstate.forget(a)
 repo.dirstate.setparents(qp, revlog.nullid)
 self.strip(repo, rev, update=False, backup='strip', wlock=wlock)
 del self.applied[start:end]
 if len(self.applied):
-self.ui.write("Now at: %s\n" % self.applied[-1].split(':')[1])
+self.ui.write("Now at: %s\n" % self.applied[-1].name)
 else:
 self.ui.write("Patch queue now empty\n")
 def diff(self, repo, files):
 top = self.check_toppatch(repo)
 if len(self.applied) == 0:
 self.ui.write("No patches applied\n")
 return
 wlock = repo.wlock()
 self.check_toppatch(repo)
-qp = self.qparents(repo)
+(top, patch) = (self.applied[-1].rev, self.applied[-1].name)
-(top, patch) = self.applied[-1].split(':')
 top = revlog.bin(top)
 cparents = repo.changelog.parents(top)
 patchparent = self.qparents(repo, top)
 message, comments, user, date, patchfound = self.readheaders(patch)
 else:
 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[-1] = StatusEntry(revlog.hex(n), patch)
 self.applied_dirty = 1
 else:
 commands.dodiff(patchf, self.ui, repo, patchparent, None)
 patchf.close()
 self.pop(repo, force=True, wlock=wlock)
 raise util.Abort(_("patch %s is not in series file") % patch)
 if not patch:
 start = self.series_end()
 else:
 start = self.series.index(patch) + 1
-for p in self.series[start:]:
+return [(i, self.series[i]) for i in xrange(start, len(self.series))]
-if self.ui.verbose:
-self.ui.write("%d " % self.series.index(p))
-self.ui.write("%s\n" % p)
 def qseries(self, repo, missing=None, summary=False):
 start = self.series_end()
 if not missing:
 for i in range(len(self.series)):
 msg = msg and ': ' + msg[0] or ': '
 else:
 msg = ''
 self.ui.write('%s%s\n' % (patch, msg))
 else:
-list = []
+msng_list = []
 for root, dirs, files in os.walk(self.path):
 d = root[len(self.path) + 1:]
 for f in files:
 fl = os.path.join(d, f)
 if (fl not in self.series and
 fl not in (self.status_path, self.series_path)
 and not fl.startswith('.')):
-list.append(fl)
+msng_list.append(fl)
-list.sort()
+msng_list.sort()
-if list:
+for x in msng_list:
-for x in list:
+if self.ui.verbose:
-if self.ui.verbose:
+self.ui.write("D ")
-self.ui.write("D ")
+self.ui.write("%s\n" % x)
-self.ui.write("%s\n" % x)
 def issaveline(self, l):
 name = l.split(':')[1]
 if name == '.hg.patches.save.line':
 return True
 l = lines[i].rstrip()
 l = l[10:].split(' ')
 qpp = [ hg.bin(x) for x in l ]
 elif datastart != None:
 l = lines[i].rstrip()
-index = l.index(':')
+se = StatusEntry(l)
-id = l[:index]
+file_ = se.name
-file = l[index + 1:]
+if se.rev:
-if id:
+applied.append(se)
-applied.append(l)
+series.append(file_)
-series.append(file)
 if datastart == None:
 self.ui.warn("No saved patch data found\n")
 return 1
 self.ui.warn("restoring status: %s\n" % lines[0])
 self.full_series = series
 r = self.qrepo()
 if r:
 pp = r.dirstate.parents()
 msg += "\nDirstate: %s %s" % (hg.hex(pp[0]), hg.hex(pp[1]))
 msg += "\n\nPatch Data:\n"
-text = msg + "\n".join(self.applied) + '\n' + (ar and "\n".join(ar)
+text = msg + "\n".join(str(self.applied)) + '\n' + (ar and "\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(revlog.hex(n) + ":" + '.hg.patches.save.line')
+self.applied.append(StatusEntry(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(':')
+p = self.applied[-1].name
 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(':')
+p = self.applied[-1].name
 try:
 end = self.series.index(p)
 except ValueError:
 return 0
 return end + 1
 for x in xrange(end):
 p = self.appliedname(x)
 self.ui.write("%s\n" % p)
 def appliedname(self, index):
-p = self.applied[index]
+pname = self.applied[index].name
-pname = p.split(':')[1]
 if not self.ui.verbose:
 p = pname
 else:
 p = str(self.series.index(pname)) + " " + p
 return p
 repo.mq.qapplied(repo, patch)
 return 0
 def unapplied(ui, repo, patch=None, **opts):
 """print the patches not yet applied"""
-repo.mq.unapplied(repo, patch)
+for i, p in repo.mq.unapplied(repo, patch):
-return 0
+if ui.verbose:
+ui.write("%d " % i)
+ui.write("%s\n" % p)
 def qimport(ui, repo, *filename, **opts):
 """import a patch"""
 q = repo.mq
 q.qimport(repo, filename, patch=opts['name'],
 sr = hg.repository(ui, ui.expandpath(source))
 qbase, destrev = None, None
 if sr.local():
 reposetup(ui, sr)
 if sr.mq.applied:
-qbase = revlog.bin(sr.mq.applied[0].split(':')[0])
+qbase = revlog.bin(sr.mq.applied[0].rev)
 if not hg.islocal(dest):
 destrev = sr.parents(qbase)[0]
 ui.note(_('cloning main repo\n'))
 sr, dr = hg.clone(ui, sr, dest,
 pull=opts['pull'],
 -m or -l set the patch header as well as the commit message.
 If neither is specified, the patch header is empty and the
 commit message is 'New patch: PATCH'"""
 q = repo.mq
-message=commands.logmessage(**opts)
+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 = repo.mq
-message=commands.logmessage(**opts)
+message = commands.logmessage(**opts)
 if opts['edit']:
 if message:
 raise util.Abort(_('option "-e" incompatible with "-m" or "-l"'))
-patch = q.applied[-1].split(':')[1]
+patch = q.applied[-1].name
 (message, comment, user, date, hasdiff) = q.readheaders(patch)
 message = ui.edit('\n'.join(message), user or ui.username())
 q.refresh(repo, msg=message, short=opts['short'])
 q.save_dirty()
 return 0
 if not files:
 raise util.Abort(_('qfold requires at least one patch name'))
 if not q.check_toppatch(repo):
 raise util.Abort(_('No patches applied\n'))
-message=commands.logmessage(**opts)
+message = commands.logmessage(**opts)
 if opts['edit']:
 if message:
 raise util.Abort(_('option "-e" incompatible with "-m" or "-l"'))
 parent = q.lookup('qtip')
 patches = []
 messages = []
 for f in files:
 patch = q.lookup(f)
 if patch in patches or patch == parent:
-self.ui.warn(_('Skipping already folded patch %s') % patch)
+ui.warn(_('Skipping already folded patch %s') % patch)
 if q.isapplied(patch):
 raise util.Abort(_('qfold cannot fold already applied patch %s') % patch)
 patches.append(patch)
 for patch in patches:
 message = repo.mq.readheaders(patch)[0]
 ui.write('\n'.join(message) + '\n')
 def lastsavename(path):
-(dir, base) = os.path.split(path)
+(directory, base) = os.path.split(path)
-names = os.listdir(dir)
+names = os.listdir(directory)
 namere = re.compile("%s.([0-9]+)" % base)
-max = None
+maxindex = None
 maxname = None
 for f in names:
 m = namere.match(f)
 if m:
 index = int(m.group(1))
-if max == None or index > max:
+if maxindex == None or index > maxindex:
-max = index
+maxindex = index
 maxname = f
 if maxname:
-return (os.path.join(dir, maxname), max)
+return (os.path.join(directory, maxname), maxindex)
 return (None, None)
 def savename(path):
 (last, index) = lastsavename(path)
 if last is None:
 q.parse_series()
 q.series_dirty = 1
 info = q.isapplied(patch)
 if info:
-q.applied[info[0]] = info[1] + ':' + name
+q.applied[info[0]] = StatusEntry(info[1], name)
 q.applied_dirty = 1
 util.rename(os.path.join(q.path, patch), absdest)
 r = q.qrepo()
 if r:
 return 0
 def save(ui, repo, **opts):
 """save current queue state"""
 q = repo.mq
-message=commands.logmessage(**opts)
+message = commands.logmessage(**opts)
 ret = q.save(repo, msg=message)
 if ret:
 return ret
 q.save_dirty()
 if opts['copy']:
 q = self.mq
 if not q.applied:
 return tagscache
-mqtags = [patch.split(':') for patch in q.applied]
+mqtags = [(patch.rev, patch.name) for patch in q.applied]
 mqtags.append((mqtags[-1][0], 'qtip'))
 mqtags.append((mqtags[0][0], 'qbase'))
 for patch in mqtags:
 if patch[1] in tagscache:
 self.ui.warn('Tag %s overrides mq patch of the same name\n' % patch[1])

changeset 2803	987c31e2a08c
parent 2775	b550cd82f92a
parent 2797	a3c6e7888abf
child 2804	4b20daa25f15