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

equal deleted inserted replaced

-:f94dbc6c7eaf
+:06154aff2b1a
 fns, matchfn, anypats = cmdutil.matchpats(repo, files, opts)
 patch.diff(repo, node1, node2, fns, match=matchfn,
 fp=fp, changes=changes, opts=self.diffopts())
-def mergeone(self, repo, mergeq, head, patch, rev, wlock):
+def mergeone(self, repo, mergeq, head, patch, rev):
 # first try just applying the patch
 (err, n) = self.apply(repo, [ patch ], update_status=False,
-strict=True, merge=rev, wlock=wlock)
+strict=True, merge=rev)
 if err == 0:
 return (err, n)
 if n is None:
 raise util.Abort(_("apply failed for patch %s") % patch)
 self.ui.warn("patch didn't work out, merging %s\n" % patch)
 # apply failed, strip away that rev and merge.
-hg.clean(repo, head, wlock=wlock)
+hg.clean(repo, head)
-self.strip(repo, n, update=False, backup='strip', wlock=wlock)
+self.strip(repo, n, update=False, backup='strip')
 ctx = repo.changectx(rev)
-ret = hg.merge(repo, rev, wlock=wlock)
+ret = hg.merge(repo, rev)
 if ret:
 raise util.Abort(_("update returned %d") % ret)
-n = repo.commit(None, ctx.description(), ctx.user(),
+n = repo.commit(None, ctx.description(), ctx.user(), force=1)
-force=1, wlock=wlock)
 if n == None:
 raise util.Abort(_("repo commit failed"))
 try:
 message, comments, user, date, patchfound = mergeq.readheaders(patch)
 except:
 return pp[0]
 if p1 in arevs:
 return pp[1]
 return pp[0]
-def mergepatch(self, repo, mergeq, series, wlock):
+def mergepatch(self, repo, mergeq, series):
 if len(self.applied) == 0:
 # each of the patches merged in will have two parents.  This
 # can confuse the qrefresh, qdiff, and strip code because it
 # needs to know which parent is actually in the patch queue.
 # so, we insert a merge marker with only one parent.  This way
 # 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,
+n = repo.commit(None, '[mq]: merge marker', user=None, force=1)
-wlock=wlock)
 self.removeundo(repo)
 self.applied.append(statusentry(revlog.hex(n), pname))
 self.applied_dirty = 1
 head = self.qparents(repo)
 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])
-(err, head) = self.mergeone(repo, mergeq, head, patch, rev, wlock)
+(err, head) = self.mergeone(repo, mergeq, head, patch, rev)
 if head:
 self.applied.append(statusentry(revlog.hex(head), patch))
 self.applied_dirty = 1
 if err:
 return (err, head)
 return (False, files, False)
 return (True, files, fuzz)
 def apply(self, repo, series, list=False, update_status=True,
-strict=False, patchdir=None, merge=None, wlock=None,
+strict=False, patchdir=None, merge=None, all_files={}):
-all_files={}):
+wlock = lock = tr = None
-if not wlock:
+try:
 wlock = repo.wlock()
 lock = repo.lock()
 tr = repo.transaction()
-try:
-ret = self._apply(tr, repo, series, list, update_status,
-strict, patchdir, merge, wlock,
-lock=lock, all_files=all_files)
-tr.close()
-self.save_dirty()
-return ret
-except:
 try:
-tr.abort()
+ret = self._apply(repo, series, list, update_status,
-finally:
+strict, patchdir, merge, all_files=all_files)
-repo.invalidate()
+tr.close()
-repo.dirstate.invalidate()
+self.save_dirty()
-raise
+return ret
+except:
-def _apply(self, tr, repo, series, list=False, update_status=True,
+try:
-strict=False, patchdir=None, merge=None, wlock=None,
+tr.abort()
-lock=None, all_files={}):
+finally:
+repo.invalidate()
+repo.dirstate.invalidate()
+raise
+finally:
+del tr, lock, wlock
+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:
 patchdir = self.path
 err = 0
 n = None
 if merge and files:
 # Mark as removed/merged and update dirstate parent info
 removed = []
 merged = []
 for f in files:
-if os.path.exists(repo.dirstate.wjoin(f)):
+if os.path.exists(repo.wjoin(f)):
 merged.append(f)
 else:
 removed.append(f)
-repo.dirstate.update(repo.dirstate.filterfiles(removed), 'r')
+for f in removed:
-repo.dirstate.update(repo.dirstate.filterfiles(merged), 'm')
+repo.dirstate.remove(f)
+for f in merged:
+repo.dirstate.merge(f)
 p1, p2 = repo.dirstate.parents()
 repo.dirstate.setparents(p1, merge)
-files = patch.updatedir(self.ui, repo, files, wlock=wlock)
+files = patch.updatedir(self.ui, repo, files)
-n = repo.commit(files, message, user, date, force=1, lock=lock,
+n = repo.commit(files, message, user, date, force=1)
-wlock=wlock)
 if n == None:
 raise util.Abort(_("repo commit failed"))
 if update_status:
 else:
 m, a, r, d = self.check_localchanges(repo, force)
 commitfiles = m + a + r
 self.check_toppatch(repo)
 wlock = repo.wlock()
-insert = self.full_series_end()
+try:
-if msg:
+insert = self.full_series_end()
-n = repo.commit(commitfiles, msg, force=True, wlock=wlock)
+if msg:
-else:
+n = repo.commit(commitfiles, msg, force=True)
-n = repo.commit(commitfiles,
+else:
-"[mq]: %s" % patch, force=True, wlock=wlock)
+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 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:
-def strip(self, repo, rev, update=True, backup="all", wlock=None):
+del wlock
-if not wlock:
+def strip(self, repo, rev, update=True, backup="all"):
+wlock = lock = None
+try:
 wlock = repo.wlock()
 lock = repo.lock()
 if update:
 self.check_localchanges(repo, refresh=False)
 urev = self.qparents(repo, rev)
-hg.clean(repo, urev, wlock=wlock)
+hg.clean(repo, urev)
 repo.dirstate.write()
 self.removeundo(repo)
 repair.strip(self.ui, repo, rev, backup)
+finally:
+del lock, wlock
 def isapplied(self, patch):
 """returns (index, rev, patch)"""
 for i in xrange(len(self.applied)):
 a = self.applied[i]
 if i + off < len(self.series):
 return self.series[i + off]
 raise util.Abort(_("patch %s not in series") % patch)
 def push(self, repo, patch=None, force=False, list=False,
-mergeq=None, wlock=None):
+mergeq=None):
-if not wlock:
+wlock = repo.wlock()
-wlock = repo.wlock()
+try:
 patch = self.lookup(patch)
-# Suppose our series file is: A B C and the current 'top' patch is B.
+# Suppose our series file is: A B C and the current 'top'
-# qpush C should be performed (moving forward)
+# patch is B. qpush C should be performed (moving forward)
-# qpush B is a NOP (no change)
+# qpush B is a NOP (no change) qpush A is an error (can't
-# qpush A is an error (can't go backwards with qpush)
+# go backwards with qpush)
 if patch:
 info = self.isapplied(patch)
 if info:
 if info[0] < len(self.applied) - 1:
-raise util.Abort(_("cannot push to a previous patch: %s") %
+raise util.Abort(
-patch)
+_("cannot push to a previous patch: %s") % patch)
 if info[0] < len(self.series) - 1:
-self.ui.warn(_('qpush: %s is already at the top\n') % patch)
+self.ui.warn(
+_('qpush: %s is already at the top\n') % patch)
+else:
+self.ui.warn(_('all patches are currently applied\n'))
+return
+# Following the above example, starting at 'top' of B:
+# qpush should be performed (pushes C), but a subsequent
+# qpush without an argument is an error (nothing to
+# apply). This allows a loop of "...while hg qpush..." to
+# work as it detects an error when done
+if self.series_end() == len(self.series):
+self.ui.warn(_('patch series already fully applied\n'))
+return 1
+if not force:
+self.check_localchanges(repo)
+self.applied_dirty = 1;
+start = self.series_end()
+if start > 0:
+self.check_toppatch(repo)
+if not patch:
+patch = self.series[start]
+end = start + 1
+else:
+end = self.series.index(patch, start) + 1
+s = self.series[start:end]
+all_files = {}
+try:
+if mergeq:
+ret = self.mergepatch(repo, mergeq, s)
 else:
-self.ui.warn(_('all patches are currently applied\n'))
+ret = self.apply(repo, s, list, all_files=all_files)
-return
+except:
+self.ui.warn(_('cleaning up working directory...'))
-# Following the above example, starting at 'top' of B:
+node = repo.dirstate.parents()[0]
-#  qpush should be performed (pushes C), but a subsequent qpush without
+hg.revert(repo, node, None)
-#  an argument is an error (nothing to apply). This allows a loop
+unknown = repo.status()[4]
-#  of "...while hg qpush..." to work as it detects an error when done
+# only remove unknown files that we know we touched or
-if self.series_end() == len(self.series):
+# created while patching
-self.ui.warn(_('patch series already fully applied\n'))
+for f in unknown:
-return 1
+if f in all_files:
-if not force:
+util.unlink(repo.wjoin(f))
-self.check_localchanges(repo)
+self.ui.warn(_('done\n'))
+raise
-self.applied_dirty = 1;
+top = self.applied[-1].name
-start = self.series_end()
+if ret[0]:
-if start > 0:
+self.ui.write(
-self.check_toppatch(repo)
+"Errors during apply, please fix and refresh %s\n" % top)
-if not patch:
-patch = self.series[start]
-end = start + 1
-else:
-end = self.series.index(patch, start) + 1
-s = self.series[start:end]
-all_files = {}
-try:
-if mergeq:
-ret = self.mergepatch(repo, mergeq, s, wlock)
 else:
-ret = self.apply(repo, s, list, wlock=wlock,
+self.ui.write("Now at: %s\n" % top)
-all_files=all_files)
+return ret[0]
-except:
+finally:
-self.ui.warn(_('cleaning up working directory...'))
+del wlock
-node = repo.dirstate.parents()[0]
-hg.revert(repo, node, None, wlock)
+def pop(self, repo, patch=None, force=False, update=True, all=False):
-unknown = repo.status(wlock=wlock)[4]
-# only remove unknown files that we know we touched or
-# created while patching
-for f in unknown:
-if f in all_files:
-util.unlink(repo.wjoin(f))
-self.ui.warn(_('done\n'))
-raise
-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)
-return ret[0]
-def pop(self, repo, patch=None, force=False, update=True, all=False,
-wlock=None):
 def getfile(f, rev):
 t = repo.file(f).read(rev)
 repo.wfile(f, "w").write(t)
-if not wlock:
+wlock = repo.wlock()
-wlock = repo.wlock()
+try:
 if patch:
 # index, rev, patch
 info = self.isapplied(patch)
 if not info:
 patch = self.lookup(patch)
 info = self.isapplied(patch)
 if not info:
 raise util.Abort(_("patch %s is not applied") % patch)
 if len(self.applied) == 0:
 # Allow qpop -a to work repeatedly,
 # but not qpop without an argument
 self.ui.warn(_("no patches applied\n"))
 return not all
 if not update:
 parents = repo.dirstate.parents()
 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
 if not force and update:
 self.check_localchanges(repo)
 self.applied_dirty = 1;
 end = len(self.applied)
 if not patch:
 if all:
 popi = 0
+else:
+popi = len(self.applied) - 1
 else:
-popi = len(self.applied) - 1
+popi = info[0] + 1
-else:
+if popi >= end:
-popi = info[0] + 1
+self.ui.warn("qpop: %s is already at the top\n" % patch)
-if popi >= end:
+return
-self.ui.warn("qpop: %s is already at the top\n" % patch)
+info = [ popi ] + [self.applied[popi].rev, self.applied[popi].name]
-return
-info = [ popi ] + [self.applied[popi].rev, self.applied[popi].name]
+start = info[0]
+rev = revlog.bin(info[1])
-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.
-# we know there are no local changes, so we can make a simplified
+if update:
-# form of hg.update.
+top = self.check_toppatch(repo)
-if update:
+qp = self.qparents(repo, rev)
-top = self.check_toppatch(repo)
+changes = repo.changelog.read(qp)
-qp = self.qparents(repo, rev)
+mmap = repo.manifest.read(changes[0])
-changes = repo.changelog.read(qp)
+m, a, r, d, u = repo.status(qp, top)[:5]
-mmap = repo.manifest.read(changes[0])
+if d:
-m, a, r, d, u = repo.status(qp, top)[:5]
+raise util.Abort("deletions found between repo revs")
-if d:
+for f in m:
-raise util.Abort("deletions found between repo revs")
+getfile(f, mmap[f])
-for f in m:
+for f in r:
 getfile(f, mmap[f])
-for f in r:
+util.set_exec(repo.wjoin(f), mmap.execf(f))
-getfile(f, mmap[f])
+for f in m + r:
-util.set_exec(repo.wjoin(f), mmap.execf(f))
+repo.dirstate.normal(f)
-repo.dirstate.update(m + r, 'n')
+for f in a:
-for f in a:
+try:
-try:
+os.unlink(repo.wjoin(f))
-os.unlink(repo.wjoin(f))
+except OSError, e:
-except OSError, e:
+if e.errno != errno.ENOENT:
-if e.errno != errno.ENOENT:
+raise
-raise
+try: os.removedirs(os.path.dirname(repo.wjoin(f)))
-try: os.removedirs(os.path.dirname(repo.wjoin(f)))
+except: pass
-except: pass
+repo.dirstate.forget(f)
-if a:
+repo.dirstate.setparents(qp, revlog.nullid)
-repo.dirstate.forget(a)
+self.strip(repo, rev, update=False, backup='strip')
-repo.dirstate.setparents(qp, revlog.nullid)
+del self.applied[start:end]
-self.strip(repo, rev, update=False, backup='strip', wlock=wlock)
+if len(self.applied):
-del self.applied[start:end]
+self.ui.write("Now at: %s\n" % self.applied[-1].name)
-if len(self.applied):
+else:
-self.ui.write("Now at: %s\n" % self.applied[-1].name)
+self.ui.write("Patch queue now empty\n")
-else:
+finally:
-self.ui.write("Patch queue now empty\n")
+del wlock
 def diff(self, repo, pats, opts):
 top = self.check_toppatch(repo)
 if not top:
 self.ui.write("No patches applied\n")
 def refresh(self, repo, pats=None, **opts):
 if len(self.applied) == 0:
 self.ui.write("No patches applied\n")
 return 1
 wlock = repo.wlock()
-self.check_toppatch(repo)
+try:
-(top, patchfn) = (self.applied[-1].rev, self.applied[-1].name)
+self.check_toppatch(repo)
-top = revlog.bin(top)
+(top, patchfn) = (self.applied[-1].rev, self.applied[-1].name)
-cparents = repo.changelog.parents(top)
+top = revlog.bin(top)
-patchparent = self.qparents(repo, top)
+cparents = repo.changelog.parents(top)
-message, comments, user, date, patchfound = self.readheaders(patchfn)
+patchparent = self.qparents(repo, top)
+message, comments, user, date, patchfound = self.readheaders(patchfn)
-patchf = self.opener(patchfn, 'r+')
+patchf = self.opener(patchfn, 'r+')
-# if the patch was a git patch, refresh it as a git patch
-for line in patchf:
+# if the patch was a git patch, refresh it as a git patch
-if line.startswith('diff --git'):
+for line in patchf:
+if line.startswith('diff --git'):
+self.diffopts().git = True
+break
+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'):
 self.diffopts().git = True
-break
+fns, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
-patchf.seek(0)
+tip = repo.changelog.tip()
-patchf.truncate()
+if top == tip:
+# if the top of our patch queue is also the tip, there is an
-msg = opts.get('msg', '').rstrip()
+# optimization here.  We update the dirstate in place and strip
-if msg:
+# off the tip commit.  Then just commit the current directory
-if comments:
+# tree.  We can also send repo.commit the list of files
-# Remove existing message.
+# changed to speed up the diff
-ci = 0
+#
-subj = None
+# in short mode, we only diff the files included in the
-for mi in xrange(len(message)):
+# patch already
-if comments[ci].lower().startswith('subject: '):
+#
-subj = comments[ci][9:]
+# this should really read:
-while message[mi] != comments[ci] and message[mi] != subj:
+#   mm, dd, aa, aa2, uu = repo.status(tip, patchparent)[:5]
-ci += 1
+# but we do it backwards to take advantage of manifest/chlog
-del comments[ci]
+# caching against the next repo.status call
-comments.append(msg)
+#
-if comments:
+mm, aa, dd, aa2, uu = repo.status(patchparent, tip)[:5]
-comments = "\n".join(comments) + '\n\n'
+changes = repo.changelog.read(tip)
-patchf.write(comments)
+man = repo.manifest.read(changes[0])
+aaa = aa[:]
-if opts.get('git'):
+if opts.get('short'):
-self.diffopts().git = True
+filelist = mm + aa + dd
-fns, matchfn, anypats = cmdutil.matchpats(repo, pats, opts)
+match = dict.fromkeys(filelist).__contains__
-tip = repo.changelog.tip()
+else:
-if top == tip:
+filelist = None
-# if the top of our patch queue is also the tip, there is an
+match = util.always
-# optimization here.  We update the dirstate in place and strip
+m, a, r, d, u = repo.status(files=filelist, match=match)[:5]
-# off the tip commit.  Then just commit the current directory
-# tree.  We can also send repo.commit the list of files
+# we might end up with files that were added between
-# changed to speed up the diff
+# tip and the dirstate parent, but then changed in the
-#
+# local dirstate. in this case, we want them to only
-# in short mode, we only diff the files included in the
+# show up in the added section
-# patch already
+for x in m:
-#
+if x not in aa:
-# this should really read:
+mm.append(x)
-#   mm, dd, aa, aa2, uu = repo.status(tip, patchparent)[:5]
+# we might end up with files added by the local dirstate that
-# but we do it backwards to take advantage of manifest/chlog
+# were deleted by the patch.  In this case, they should only
-# caching against the next repo.status call
+# show up in the changed section.
-#
+for x in a:
-mm, aa, dd, aa2, uu = repo.status(patchparent, tip)[:5]
+if x in dd:
-changes = repo.changelog.read(tip)
+del dd[dd.index(x)]
-man = repo.manifest.read(changes[0])
+mm.append(x)
-aaa = aa[:]
+else:
-if opts.get('short'):
+aa.append(x)
-filelist = mm + aa + dd
+# make sure any files deleted in the local dirstate
-match = dict.fromkeys(filelist).__contains__
+# are not in the add or change column of the patch
+forget = []
+for x in d + r:
+if x in aa:
+del aa[aa.index(x)]
+forget.append(x)
+continue
+elif x in mm:
+del mm[mm.index(x)]
+dd.append(x)
+m = util.unique(mm)
+r = util.unique(dd)
+a = util.unique(aa)
+c = [filter(matchfn, l) for l in (m, a, r, [], u)]
+filelist = util.unique(c[0] + c[1] + c[2])
+patch.diff(repo, patchparent, files=filelist, match=matchfn,
+fp=patchf, changes=c, opts=self.diffopts())
+patchf.close()
+repo.dirstate.setparents(*cparents)
+copies = {}
+for dst in a:
+src = repo.dirstate.copied(dst)
+if src is None:
+continue
+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:
+f = repo.file(dst)
+src = f.renamed(man[dst])
+if src:
+copies[src[0]] = copies.get(dst, [])
+if dst in a:
+copies[src[0]].append(dst)
+# we can't copy a file created by the patch itself
+if dst in copies:
+del copies[dst]
+for src, dsts in copies.iteritems():
+for dst in dsts:
+repo.dirstate.copy(src, dst)
+for f in r:
+repo.dirstate.remove(f)
+# if the patch excludes a modified file, mark that
+# file with mtime=0 so status can see it.
+mm = []
+for i in xrange(len(m)-1, -1, -1):
+if not matchfn(m[i]):
+mm.append(m[i])
+del m[i]
+for f in m:
+repo.dirstate.normal(f)
+for f in mm:
+repo.dirstate.normaldirty(f)
+for f in forget:
+repo.dirstate.forget(f)
+if not msg:
+if not message:
+message = "[mq]: %s\n" % patchfn
+else:
+message = "\n".join(message)
+else:
+message = msg
+self.strip(repo, top, update=False,
+backup='strip')
+n = repo.commit(filelist, message, changes[1], match=matchfn,
+force=1)
+self.applied[-1] = statusentry(revlog.hex(n), patchfn)
+self.applied_dirty = 1
+self.removeundo(repo)
 else:
-filelist = None
+self.printdiff(repo, patchparent, fp=patchf)
-match = util.always
+patchf.close()
-m, a, r, d, u = repo.status(files=filelist, match=match)[:5]
+added = repo.status()[1]
+for a in added:
-# we might end up with files that were added between tip and
+f = repo.wjoin(a)
-# the dirstate parent, but then changed in the local dirstate.
+try:
-# in this case, we want them to only show up in the added section
+os.unlink(f)
-for x in m:
+except OSError, e:
-if x not in aa:
+if e.errno != errno.ENOENT:
-mm.append(x)
+raise
-# we might end up with files added by the local dirstate that
+try: os.removedirs(os.path.dirname(f))
-# were deleted by the patch.  In this case, they should only
+except: pass
-# show up in the changed section.
+# forget the file copies in the dirstate
-for x in a:
+# push should readd the files later on
-if x in dd:
+repo.dirstate.forget(a)
-del dd[dd.index(x)]
+self.pop(repo, force=True)
-mm.append(x)
+self.push(repo, force=True)
-else:
+finally:
-aa.append(x)
+del wlock
-# make sure any files deleted in the local dirstate
-# are not in the add or change column of the patch
-forget = []
-for x in d + r:
-if x in aa:
-del aa[aa.index(x)]
-forget.append(x)
-continue
-elif x in mm:
-del mm[mm.index(x)]
-dd.append(x)
-m = util.unique(mm)
-r = util.unique(dd)
-a = util.unique(aa)
-c = [filter(matchfn, l) for l in (m, a, r, [], u)]
-filelist = util.unique(c[0] + c[1] + c[2])
-patch.diff(repo, patchparent, files=filelist, match=matchfn,
-fp=patchf, changes=c, opts=self.diffopts())
-patchf.close()
-repo.dirstate.setparents(*cparents)
-copies = {}
-for dst in a:
-src = repo.dirstate.copied(dst)
-if src is None:
-continue
-copies.setdefault(src, []).append(dst)
-repo.dirstate.update(a, 'a')
-# 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:
-f = repo.file(dst)
-src = f.renamed(man[dst])
-if src:
-copies[src[0]] = copies.get(dst, [])
-if dst in a:
-copies[src[0]].append(dst)
-# we can't copy a file created by the patch itself
-if dst in copies:
-del copies[dst]
-for src, dsts in copies.iteritems():
-for dst in dsts:
-repo.dirstate.copy(src, dst)
-repo.dirstate.update(r, 'r')
-# if the patch excludes a modified file, mark that file with mtime=0
-# so status can see it.
-mm = []
-for i in xrange(len(m)-1, -1, -1):
-if not matchfn(m[i]):
-mm.append(m[i])
-del m[i]
-repo.dirstate.update(m, 'n')
-repo.dirstate.update(mm, 'n', st_mtime=-1, st_size=-1)
-repo.dirstate.forget(forget)
-if not msg:
-if not message:
-message = "[mq]: %s\n" % patchfn
-else:
-message = "\n".join(message)
-else:
-message = msg
-self.strip(repo, top, update=False, backup='strip', wlock=wlock)
-n = repo.commit(filelist, message, changes[1], match=matchfn,
-force=1, wlock=wlock)
-self.applied[-1] = 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]
-for a in added:
-f = repo.wjoin(a)
-try:
-os.unlink(f)
-except OSError, e:
-if e.errno != errno.ENOENT:
-raise
-try: os.removedirs(os.path.dirname(f))
-except: pass
-# forget the file copies in the dirstate
-# push should readd the files later on
-repo.dirstate.forget(added)
-self.pop(repo, force=True, wlock=wlock)
-self.push(repo, force=True, wlock=wlock)
 def init(self, repo, create=False):
 if not create and os.path.isdir(self.path):
 raise util.Abort(_("patch queue directory already exists"))
 try:
 applied in destination.  If you clone remote repository, be sure
 before that it has no patches applied.
 Source patch repository is looked for in <src>/.hg/patches by
 default.  Use -p <url> to change.
+The patch directory must be a nested mercurial repository, as
+would be created by qinit -c.
 '''
 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')
+try:
+pr = hg.repository(ui, patchdir)
+except hg.RepoError:
+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)
 if not hg.islocal(dest):
 util.rename(q.join(patch), absdest)
 r = q.qrepo()
 if r:
 wlock = r.wlock()
-if r.dirstate.state(name) == 'r':
+try:
-r.undelete([name], wlock)
+if r.dirstate[name] == 'r':
-r.copy(patch, name, wlock)
+r.undelete([name])
-r.remove([patch], False, wlock)
+r.copy(patch, name)
+r.remove([patch], False)
+finally:
+del wlock
 q.save_dirty()
 def restore(ui, repo, rev, **opts):
 """restore the queue state saved by a rev"""
 (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')),
+] + commands.walkopts,
-('X', 'exclude', [], _('exclude names matching the given patterns'))],
 _('hg qdiff [-I] [-X] [-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,
-] + 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,
-('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,

changeset 5124	06154aff2b1a
parent 4911	fc502517d68d
parent 5122	c80af96943aa
child 5140	f6c520fd70cf