mercurial: comparison hgext/mq.py

equal deleted inserted replaced

-:5c5d23d93447
+:126f527b3ba3
 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
-lock = tr = None
 try:
-if not wlock:
+wlock = repo.wlock()
-wlock = repo.wlock()
 lock = repo.lock()
 tr = repo.transaction()
 try:
 ret = self._apply(tr, repo, series, list, update_status,
-strict, patchdir, merge, wlock,
+strict, patchdir, merge, all_files=all_files)
-lock=lock, all_files=all_files)
 tr.close()
 self.save_dirty()
 return ret
 except:
 try:
 raise
 finally:
 del lock, wlock, tr
 def _apply(self, tr, repo, series, list=False, update_status=True,
-strict=False, patchdir=None, merge=None, wlock=None,
+strict=False, patchdir=None, merge=None, all_files={}):
-lock=None, all_files={}):
 # TODO unify with commands.py
 if not patchdir:
 patchdir = self.path
 err = 0
 n = None
 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:
 self.check_toppatch(repo)
 wlock = repo.wlock()
 try:
 insert = self.full_series_end()
 if msg:
-n = repo.commit(commitfiles, msg, force=True, wlock=wlock)
+n = repo.commit(commitfiles, msg, force=True)
 else:
-n = repo.commit(commitfiles,
+n = repo.commit(commitfiles, "[mq]: %s" % patch, force=True)
-"[mq]: %s" % patch, force=True, wlock=wlock)
 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.refresh(repo, short=True)
 self.removeundo(repo)
 finally:
 del wlock
-def strip(self, repo, rev, update=True, backup="all", wlock=None):
+def strip(self, repo, rev, update=True, backup="all"):
-lock = None
+wlock = lock = None
 try:
-if not wlock:
+wlock = repo.wlock()
-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:
 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. qpush C should be performed (moving forward)
 # qpush B is a NOP (no change) qpush A is an error (can't
 end = self.series.index(patch, start) + 1
 s = self.series[start:end]
 all_files = {}
 try:
 if mergeq:
-ret = self.mergepatch(repo, mergeq, s, wlock)
+ret = self.mergepatch(repo, mergeq, s)
 else:
-ret = self.apply(repo, s, list, wlock=wlock,
+ret = self.apply(repo, s, list, all_files=all_files)
-all_files=all_files)
 except:
 self.ui.warn(_('cleaning up working directory...'))
 node = repo.dirstate.parents()[0]
-hg.revert(repo, node, None, wlock)
+hg.revert(repo, node, None)
-unknown = repo.status(wlock=wlock)[4]
+unknown = repo.status()[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.write("Now at: %s\n" % top)
 return ret[0]
 finally:
 del wlock
-def pop(self, repo, patch=None, force=False, update=True, all=False,
+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:
 raise
 try: os.removedirs(os.path.dirname(repo.wjoin(f)))
 except: pass
 repo.dirstate.forget(f)
 repo.dirstate.setparents(qp, revlog.nullid)
-self.strip(repo, rev, update=False, backup='strip', wlock=wlock)
+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")
 message = "\n".join(message)
 else:
 message = msg
 self.strip(repo, top, update=False,
-backup='strip', wlock=wlock)
+backup='strip')
 n = repo.commit(filelist, message, changes[1], match=matchfn,
-force=1, wlock=wlock)
+force=1)
 self.applied[-1] = statusentry(revlog.hex(n), patchfn)
 self.applied_dirty = 1
 self.removeundo(repo)
 else:
 self.printdiff(repo, patchparent, fp=patchf)
 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(a)
-self.pop(repo, force=True, wlock=wlock)
+self.pop(repo, force=True)
-self.push(repo, force=True, wlock=wlock)
+self.push(repo, force=True)
 finally:
 del wlock
 def init(self, repo, create=False):
 if not create and os.path.isdir(self.path):
 r = q.qrepo()
 if r:
 wlock = r.wlock()
 try:
 if r.dirstate[name] == 'r':
-r.undelete([name], wlock)
+r.undelete([name])
-r.copy(patch, name, wlock)
+r.copy(patch, name)
-r.remove([patch], False, wlock)
+r.remove([patch], False)
 finally:
 del wlock
 q.save_dirty()

changeset 4917	126f527b3ba3
parent 4915	97b734fb9c6f
child 4970	30d4d8985dd8