mercurial: comparison hgext/mq.py

equal deleted inserted replaced

-:ef53d200df3d
+:7596611ab3d5
 self.full_series = []
 self.applied_dirty = 0
 self.series_dirty = 0
 self.series_path = os.path.join(self.path, "series")
 self.status_path = os.path.join(self.path, "status")
 s = self.series_path
 if os.path.exists(s):
 self.full_series = self.opener(s).read().splitlines()
 self.read_series(self.full_series)
 s = s.rstrip()
 if len(s) > 0:
 yield s
 self.series = []
 self.series = [ x for x in matcher(list) ]
 def save_dirty(self):
 if self.applied_dirty:
 if len(self.applied) > 0:
 nl = "\n"
 else:
 def readheaders(self, patch):
 def eatdiff(lines):
 while lines:
 l = lines[-1]
-if l.startswith("diff -") or \
+if (l.startswith("diff -") or
-l.startswith("Index:") or \
+l.startswith("Index:") or
-l.startswith("==========="):
+l.startswith("===========")):
 del lines[-1]
 else:
 break
 def eatempty(lines):
 while lines:
 elif not line.startswith("# ") and line:
 message.append(line)
 format = None
 elif line == '# HG changeset patch':
 format = "hgpatch"
-elif format != "tagdone" and \
+elif (format != "tagdone" and (line.startswith("Subject: ") or
-(line.startswith("Subject: ") or \
+line.startswith("subject: "))):
-line.startswith("subject: ")):
 subject = line[9:]
 format = "tag"
-elif format != "tagdone" and \
+elif (format != "tagdone" and (line.startswith("From: ") or
-(line.startswith("From: ") or \
+line.startswith("from: "))):
-line.startswith("from: ")):
 user = line[6:]
 format = "tag"
 elif format == "tag" and line == "":
 # when looking for tags (subject: from: etc) they
 # end once you find a blank line in the source
 message.insert(0, subject)
 return (message, comments, user, diffstart > 1)
 def mergeone(self, repo, mergeq, head, patch, rev, wlock):
 # first try just applying the patch
 (err, n) = self.apply(repo, [ patch ], update_status=False,
 strict=True, merge=rev, wlock=wlock)
 if err == 0:
 return (err, n)
 comments = "\n".join(comments) + '\n\n'
 patchf.write(comments)
 commands.dodiff(patchf, self.ui, repo, head, n)
 patchf.close()
 return (0, n)
 def qparents(self, repo, rev=None):
 if rev is None:
 (p1, p2) = repo.dirstate.parents()
 if p2 == revlog.nullid:
 return p1
 self.applied_dirty = 1
 if err:
 return (err, head)
 return (0, head)
 def apply(self, repo, series, list=False, update_status=True,
 strict=False, patchdir=None, merge=None, wlock=None):
 # TODO unify with commands.py
 if not patchdir:
 patchdir = self.path
 pwd = os.getcwd()
 if list:
 message.append("\nimported patch %s" % patch)
 message = '\n'.join(message)
 try:
-f = os.popen("patch -p1 --no-backup-if-mismatch < '%s'" %
+f = os.popen("patch -p1 --no-backup-if-mismatch < '%s'" % (pf))
-(pf))
 except:
 self.ui.warn("patch failed, unable to continue (try -v)\n")
 err = 1
 break
 files = []
 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:])
 # 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 = True
 self.ui.warn(l + '\n')
 patcherr = f.close()
 if merge and len(files) > 0:
 # Mark as merged and update dirstate parent info
 repo.dirstate.update(repo.dirstate.filterfiles(files), 'm')
 p1, p2 = repo.dirstate.parents()
 repo.dirstate.setparents(p1, merge)
 if len(files) > 0:
 commands.addremove_lock(self.ui, repo, files,
 opts={}, wlock=wlock)
 n = repo.commit(files, message, user, force=1, lock=lock,
 wlock=wlock)
 if n == None:
 sys.exit(1)
 i = self.find_series(patch)
 del self.full_series[i]
 self.read_series(self.full_series)
 self.series_dirty = 1
 def check_toppatch(self, repo):
 if len(self.applied) > 0:
 (top, patch) = self.applied[-1].split(':')
 top = revlog.bin(top)
 pp = repo.dirstate.parents()
 self.check_localchanges(repo)
 self.check_toppatch(repo)
 wlock = repo.wlock()
 insert = self.series_end()
 if msg:
 n = repo.commit([], "[mq]: %s" % msg, force=True, wlock=wlock)
 else:
-n = repo.commit([], "New patch: %s" % patch, force=True, wlock=wlock)
+n = repo.commit([],
+"New patch: %s" % patch, force=True, wlock=wlock)
 if n == None:
 self.ui.warn("repo commit failed\n")
 sys.exit(1)
 self.full_series[insert:insert] = [patch]
 self.applied.append(revlog.hex(n) + ":" + patch)
 if rev not in r:
 saveheads.append(h)
 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":
 backupch = repo.changegroupsubset([rev], chlog.heads(), 'strip')
 bundle(backupch)
 if saveheads:
 if saveheads:
 self.ui.status("adding branch\n")
 commands.unbundle(self.ui, repo, chgrpfile, update=False)
 if backup is not "strip":
 os.unlink(chgrpfile)
 def isapplied(self, patch):
 """returns (index, rev, patch)"""
 for i in xrange(len(self.applied)):
 p = self.applied[i]
 a = p.split(':')
 else:
 self.ui.warn("patch %s not in series\n" % patch)
 sys.exit(1)
 return patch
 def push(self, repo, patch=None, force=False, list=False,
 mergeq=None, wlock=None):
 if not wlock:
 wlock = repo.wlock()
 patch = self.lookup(patch)
 if patch and self.isapplied(patch):
 self.ui.warn("patch %s is already applied\n" % patch)
 sys.exit(1)
 if self.series_end() == len(self.series):
 self.ui.warn("File series fully applied\n")
 sys.exit(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:
 ret = self.mergepatch(repo, mergeq, s, wlock)
 else:
 ret = self.apply(repo, s, list, wlock=wlock)
 top = self.applied[-1].split(':')[1]
 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]
 comments = "\n".join(comments) + '\n\n'
 patchf.write(comments)
 tip = repo.changelog.tip()
 if top == tip:
 # if the top of our patch queue is also the tip, there is an
 # optimization here.  We update the dirstate in place and strip
 # off the tip commit.  Then just commit the current directory
 # tree.  We can also send repo.commit the list of files
 # changed to speed up the diff
 #
 # in short mode, we only diff the files included in the
 # patch already
 #
 # this should really read:
 #(cc, dd, aa, aa2, uu) = repo.changes(tip, patchparent)
 # but we do it backwards to take advantage of manifest/chlog
 # caching against the next repo.changes call
 #
 (cc, aa, dd, aa2, uu) = repo.changes(patchparent, tip)
 if short:
 filelist = cc + aa + dd
 else:
 filelist = None
 c = list(util.unique(cc))
 r = list(util.unique(dd))
 a = list(util.unique(aa))
 filelist = list(util.unique(c + r + a ))
 commands.dodiff(patchf, self.ui, repo, patchparent, None,
 filelist, changes=(c, a, r, [], u))
 patchf.close()
 changes = repo.changelog.read(tip)
 repo.dirstate.setparents(*cparents)
 repo.dirstate.update(a, 'a')
 repo.dirstate.update(r, 'r')
 repo.dirstate.update(c, 'n')
 repo.dirstate.forget(forget)
 if not message:
 message = "patch queue: %s\n" % patch
 else:
 start = self.series_end()
 else:
 start = self.series.index(patch) + 1
 for p in self.series[start:]:
 self.ui.write("%s\n" % p)
 def qseries(self, repo, missing=None):
 start = self.series_end()
 if not missing:
 for p in self.series[:start]:
 if self.ui.verbose:
 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 != "status" and
 fl != "series" and not fl.startswith('.')):
 list.append(fl)
 list.sort()
 if list:
 for x in list:
 if self.ui.verbose:
 self.ui.write("D ")
 self.ui.write("%s\n" % x)
 def issaveline(self, l):
 update = True
 else:
 update = False
 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"
 r = self.qrepo()
 if not r:
 self.ui.warn("save: no patches applied, exiting\n")
 return 1
 if self.issaveline(self.applied[-1]):
 self.ui.warn("status is already saved\n")
 return 1
 ar = [ ':' + x for x in self.full_series ]
 if not msg:
 msg = "hg patches saved state"
 else:
 msg = "hg patches: " + msg.rstrip('\r\n')
 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)
 + '\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')
 def appliedname(self, index):
 p = self.applied[index]
 if not self.ui.verbose:
 p = p.split(':')[1]
 return p
 def top(self, repo):
 if len(self.applied):
 p = self.appliedname(-1)
 self.ui.write(p + '\n')
 else:
 self.ui.warn("-n option not valid when importing multiple files\n")
 sys.exit(1)
 i = 0
 for filename in files:
 if existing:
 if not patch:
 patch = filename
 if not os.path.isfile(os.path.join(self.path, patch)):
 self.ui.warn("patch %s does not exist\n" % patch)
 sys.exit(1)
 else:
 return 0
 def qimport(ui, repo, *filename, **opts):
 """import a patch"""
 q = repomap[repo]
 q.qimport(repo, filename, patch=opts['name'],
 existing=opts['existing'], force=opts['force'])
 q.save_dirty()
 return 0
 def init(ui, repo, **opts):
 """init a new queue repository"""
 max = index
 maxname = f
 if maxname:
 return (os.path.join(dir, maxname), max)
 return (None, None)
 def savename(path):
 (last, index) = lastsavename(path)
 if last is None:
 index = 0
 newpath = path + ".%d" % (index + 1)
 def push(ui, repo, patch=None, **opts):
 """push the next patch onto the stack"""
 q = repomap[repo]
 mergeq = None
 if opts['all']:
 patch = q.series[-1]
 if opts['merge']:
 if opts['name']:
 newpath = opts['name']
 else:
-newpath,i = lastsavename(q.path)
+newpath, i = lastsavename(q.path)
 if not newpath:
 ui.warn("no saved queues found, please use -n\n")
 return 1
 mergeq = queue(ui, repo.join(""), newpath)
 ui.warn("merging with queue at: %s\n" % mergeq.path)
 ret = q.push(repo, patch, force=opts['force'], list=opts['list'],
 mergeq=mergeq)
 q.save_dirty()
 return ret
 def pop(ui, repo, patch=None, **opts):
 def restore(ui, repo, rev, **opts):
 """restore the queue state saved by a rev"""
 rev = repo.lookup(rev)
 q = repomap[repo]
 q.restore(repo, rev, delete=opts['delete'],
 qupdate=opts['update'])
 q.save_dirty()
 return 0
 def save(ui, repo, **opts):
 """save current queue state"""
 if opts['name']:
 newpath = os.path.join(q.basepath, opts['name'])
 if os.path.exists(newpath):
 if not os.path.isdir(newpath):
 ui.warn("destination %s exists and is not a directory\n" %
 newpath)
 sys.exit(1)
 if not opts['force']:
 ui.warn("destination %s exists, use -f to force\n" %
 newpath)
 sys.exit(1)
 else:
 newpath = savename(path)
 ui.warn("copy %s to %s\n" % (path, newpath))
 util.copyfiles(path, newpath)
 try:
 os.unlink(q.status_path)
 except:
 pass
 return 0
 def strip(ui, repo, rev, **opts):
 """strip a revision and all later revs on the same branch"""
 rev = repo.lookup(rev)
 backup = 'all'
 if opts['backup']:
 def reposetup(ui, repo):
 repomap[repo] = queue(ui, repo.join(""))
 cmdtable = {
-"qapplied": (applied, [], "hg qapplied [patch]"),
+"qapplied": (applied, [], 'hg qapplied [patch]'),
-"qcommit|qci": (commit,
+"qcommit|qci":
-[('A', 'addremove', None, _('run addremove during commit')),
+(commit,
-('I', 'include', [], _('include names matching the given patterns')),
+[('A', 'addremove', None, _('run addremove during commit')),
-('X', 'exclude', [], _('exclude names matching the given patterns')),
+('I', 'include', [], _('include names matching the given patterns')),
-('m', 'message', "", _('use <text> as commit message')),
+('X', 'exclude', [], _('exclude names matching the given patterns')),
-('l', 'logfile', "", _('read the commit message from <file>')),
+('m', 'message', '', _('use <text> as commit message')),
-('d', 'date', "", _('record datecode as commit date')),
+('l', 'logfile', '', _('read the commit message from <file>')),
-('u', 'user', "", _('record user as commiter'))],
+('d', 'date', '', _('record datecode as commit date')),
-"hg qcommit [options] [files]"),
+('u', 'user', '', _('record user as commiter'))],
-"^qdiff": (diff, [], "hg qdiff [files]"),
+'hg qcommit [options] [files]'),
-"qdelete": (delete, [], "hg qdelete [patch]"),
+"^qdiff": (diff, [], 'hg qdiff [files]'),
-"^qimport": (qimport, [('e', 'existing', None, 'import file in patch dir'),
+"qdelete": (delete, [], 'hg qdelete [patch]'),
-('n', 'name', "", 'patch file name'),
+"^qimport":
-('f', 'force', None, 'overwrite existing files')],
+(qimport,
-"hg qimport"),
+[('e', 'existing', None, 'import file in patch dir'),
-"^qinit": (init, [('c', 'create-repo', None, 'create patch repository')],
+('n', 'name', '', 'patch file name'),
-"hg [-c] qinit"),
+('f', 'force', None, 'overwrite existing files')],
-"qnew": (new, [('m', 'message', "", 'commit message'),
+'hg qimport'),
-('f', 'force', None, 'force')],
+"^qinit":
-"hg qnew [-m message ] patch"),
+(init,
-"qnext": (next, [], "hg qnext"),
+[('c', 'create-repo', None, 'create patch repository')],
-"qprev": (prev, [], "hg qprev"),
+'hg [-c] qinit'),
-"^qpop": (pop, [('a', 'all', None, 'pop all patches'),
+"qnew":
-('n', 'name', "", 'queue name to pop'),
+(new,
-('f', 'force', None, 'forget any local changes')],
+[('m', 'message', '', 'commit message'),
-'hg qpop [options] [patch/index]'),
+('f', 'force', None, 'force')],
-"^qpush": (push, [('f', 'force', None, 'apply if the patch has rejects'),
+'hg qnew [-m message ] patch'),
-('l', 'list', None, 'list patch name in commit text'),
+"qnext": (next, [], 'hg qnext'),
-('a', 'all', None, 'apply all patches'),
+"qprev": (prev, [], 'hg qprev'),
-('m', 'merge', None, 'merge from another queue'),
+"^qpop":
-('n', 'name', "", 'merge queue name')],
+(pop,
-'hg qpush [options] [patch/index]'),
+[('a', 'all', None, 'pop all patches'),
-"^qrefresh": (refresh, [('s', 'short', None, 'short refresh')],"hg qrefresh"),
+('n', 'name', '', 'queue name to pop'),
-"qrestore": (restore, [('d', 'delete', None, 'delete save entry'),
+('f', 'force', None, 'forget any local changes')],
-('u', 'update', None, 'update queue working dir')],
+'hg qpop [options] [patch/index]'),
-'hg qrestore rev'),
+"^qpush":
-"qsave": (save, [('m', 'message', "", 'commit message'),
+(push,
-('c', 'copy', None, 'copy patch directory'),
+[('f', 'force', None, 'apply if the patch has rejects'),
-('n', 'name', "", 'copy directory name'),
+('l', 'list', None, 'list patch name in commit text'),
-('e', 'empty', None, 'clear queue status file'),
+('a', 'all', None, 'apply all patches'),
-('f', 'force', None, 'force copy')], 'hg qsave'),
+('m', 'merge', None, 'merge from another queue'),
-"qseries": (series, [('m', 'missing', None, 'print patches not in series')],
+('n', 'name', '', 'merge queue name')],
-"hg qseries"),
+'hg qpush [options] [patch/index]'),
-"^strip": (strip, [('f', 'force', None, 'force multi-head removal'),
+"^qrefresh":
-('b', 'backup', None, 'bundle unrelated changesets'),
+(refresh,
-('n', 'nobackup', None, 'no backups')], "hg strip rev"),
+[('s', 'short', None, 'short refresh')],
-"qtop": (top, [], "hg qtop"),
+'hg qrefresh'),
-"qunapplied": (unapplied, [], "hg qunapplied [patch]"),
+"qrestore":
-"qversion": (version, [], "hg qversion")
+(restore,
+[('d', 'delete', None, 'delete save entry'),
+('u', 'update', None, 'update queue working dir')],
+'hg qrestore rev'),
+"qsave":
+(save,
+[('m', 'message', '', 'commit message'),
+('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'),
+"qseries":
+(series,
+[('m', 'missing', None, 'print patches not in series')],
+'hg qseries'),
+"^strip":
+(strip,
+[('f', 'force', None, 'force multi-head removal'),
+('b', 'backup', None, 'bundle unrelated changesets'),
+('n', 'nobackup', None, 'no backups')],
+'hg strip rev'),
+"qtop": (top, [], 'hg qtop'),
+"qunapplied": (unapplied, [], 'hg qunapplied [patch]'),
+"qversion": (version, [], 'hg qversion')
 }

changeset 1810	7596611ab3d5
parent 1808	7036cd7f770d
child 1839	876e4e6ad82b