Mercurial: hgext/mq.py comparison

comparison hgext/mq.py @ 10187:fcc15ba18c03

Merge with stable

author	Matt Mackall <mpm@selenic.com>
date	Fri, 01 Jan 2010 15:33:51 -0600
parents	926c436964b4 296a0b14a686
children	8161127a638f

comparison

equal deleted inserted replaced

-:572dd10fa308
+:fcc15ba18c03
 self.series_path = "series"
 self.status_path = "status"
 self.guards_path = "guards"
 self.active_guards = None
 self.guards_dirty = False
-self._diffopts = None
 @util.propertycache
 def applied(self):
 if os.path.exists(self.join(self.status_path)):
 lines = self.opener(self.status_path).read().splitlines()
 self.applied_dirty = 0
 self.series_dirty = 0
 self.guards_dirty = False
 self.active_guards = None
-def diffopts(self):
+def diffopts(self, opts={}, patchfn=None):
-if self._diffopts is None:
+diffopts = patch.diffopts(self.ui, opts)
-self._diffopts = patch.diffopts(self.ui)
+if patchfn:
-return self._diffopts
+diffopts = self.patchopts(diffopts, patchfn)
+return diffopts
+def patchopts(self, diffopts, *patches):
+"""Return a copy of input diff options with git set to true if
+referenced patch is a git patch.
+"""
+diffopts = diffopts.copy()
+for patchfn in patches:
+patchf = self.opener(patchfn, 'r')
+# if the patch was a git patch, refresh it as a git patch
+for line in patchf:
+if line.startswith('diff --git'):
+diffopts.git = True
+break
+patchf.close()
+return diffopts
 def join(self, *p):
 return os.path.join(self.path, *p)
 def find_series(self, patch):
 try:
 os.unlink(undo)
 except OSError, inst:
 self.ui.warn(_('error removing undo: %s\n') % str(inst))
-def printdiff(self, repo, node1, node2=None, files=None,
+def printdiff(self, repo, diffopts, node1, node2=None, files=None,
 fp=None, changes=None, opts={}):
 stat = opts.get('stat')
 if stat:
 opts['unified'] = '0'
 m = cmdutil.match(repo, files, opts)
-chunks = patch.diff(repo, node1, node2, m, changes, self.diffopts())
+chunks = patch.diff(repo, node1, node2, m, changes, diffopts)
 write = fp is None and repo.ui.write or fp.write
 if stat:
 width = self.ui.interactive() and util.termwidth() or 80
 write(patch.diffstat(util.iterlines(chunks), width=width,
-git=self.diffopts().git))
+git=diffopts.git))
 else:
 for chunk in chunks:
 write(chunk)
-def mergeone(self, repo, mergeq, head, patch, rev):
+def mergeone(self, repo, mergeq, head, patch, rev, diffopts):
 # first try just applying the patch
 (err, n) = self.apply(repo, [ patch ], update_status=False,
 strict=True, merge=rev)
 if err == 0:
 try:
 ph = patchheader(mergeq.join(patch))
 except:
 raise util.Abort(_("unable to read %s") % patch)
+diffopts = self.patchopts(diffopts, patch)
 patchf = self.opener(patch, "w")
 comments = str(ph)
 if comments:
 patchf.write(comments)
-self.printdiff(repo, head, n, fp=patchf)
+self.printdiff(repo, diffopts, head, n, fp=patchf)
 patchf.close()
 self.removeundo(repo)
 return (0, n)
 def qparents(self, repo, rev=None):
 return pp[0]
 if p1 in arevs:
 return pp[1]
 return pp[0]
-def mergepatch(self, repo, mergeq, series):
+def mergepatch(self, repo, mergeq, series, diffopts):
 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
 info = mergeq.isapplied(patch)
 if not info:
 self.ui.warn(_("patch %s is not applied\n") % patch)
 return (1, None)
 rev = bin(info[1])
-(err, head) = self.mergeone(repo, mergeq, head, patch, rev)
+err, head = self.mergeone(repo, mergeq, head, patch, rev, diffopts)
 if head:
 self.applied.append(statusentry(hex(head), patch))
 self.applied_dirty = 1
 if err:
 return (err, head)
 force = opts.get('force')
 user = opts.get('user')
 date = opts.get('date')
 if date:
 date = util.parsedate(date)
+diffopts = self.diffopts({'git': opts.get('git')})
 self.check_reserved_name(patchfn)
 if os.path.exists(self.join(patchfn)):
 raise util.Abort(_('patch "%s" already exists') % patchfn)
 if opts.get('include') or opts.get('exclude') or pats:
 match = cmdutil.match(repo, pats, opts)
 self.applied_dirty = 1
 if msg:
 msg = msg + "\n\n"
 p.write(msg)
 if commitfiles:
-diffopts = self.diffopts()
-if opts.get('git'): diffopts.git = True
 parent = self.qparents(repo, n)
 chunks = patch.diff(repo, node1=parent, node2=n,
 match=match, opts=diffopts)
 for chunk in chunks:
 p.write(chunk)
 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, all=False):
+diffopts = self.diffopts()
 wlock = repo.wlock()
 try:
 if repo.dirstate.parents()[0] not in repo.heads():
 self.ui.status(_("(working directory not at a head)\n"))
 s = self.series[start:end]
 all_files = {}
 try:
 if mergeq:
-ret = self.mergepatch(repo, mergeq, s)
+ret = self.mergepatch(repo, mergeq, s, diffopts)
 else:
 ret = self.apply(repo, s, list, all_files=all_files)
 except:
 self.ui.warn(_('cleaning up working directory...'))
 node = repo.dirstate.parents()[0]
 qp = self.qparents(repo, top)
 if opts.get('reverse'):
 node1, node2 = None, qp
 else:
 node1, node2 = qp, None
-self._diffopts = patch.diffopts(self.ui, opts)
+diffopts = self.diffopts(opts)
-self.printdiff(repo, node1, node2, files=pats, opts=opts)
+self.printdiff(repo, diffopts, node1, node2, files=pats, opts=opts)
 def refresh(self, repo, pats=None, **opts):
 if len(self.applied) == 0:
 self.ui.write(_("no patches applied\n"))
 return 1
 if repo.changelog.heads(top) != [top]:
 raise util.Abort(_("cannot refresh a revision with children"))
 cparents = repo.changelog.parents(top)
 patchparent = self.qparents(repo, top)
 ph = patchheader(self.join(patchfn))
+diffopts = self.diffopts({'git': opts.get('git')}, patchfn)
 if msg:
 ph.setmessage(msg)
 if newuser:
 ph.setuser(newuser)
 if newdate:
 comments = str(ph)
 if comments:
 patchf.write(comments)
-if opts.get('git'):
-self.diffopts().git = True
 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
 r = list(set(dd))
 a = list(set(aa))
 c = [filter(matchfn, l) for l in (m, a, r)]
 match = cmdutil.matchfiles(repo, set(c[0] + c[1] + c[2]))
 chunks = patch.diff(repo, patchparent, match=match,
-changes=c, opts=self.diffopts())
+changes=c, opts=diffopts)
 for chunk in chunks:
 patchf.write(chunk)
 try:
-if self.diffopts().git:
+if diffopts.git:
 copies = {}
 for dst in a:
 src = repo.dirstate.copied(dst)
 # during qfold, the source file for copies may
 # be removed. Treat this as a simple add.
 self.save_dirty()
 self.ui.warn(_('refresh interrupted while patch was popped! '
 '(revert --all, qpush to recover)\n'))
 raise
 else:
-self.printdiff(repo, patchparent, fp=patchf)
+self.printdiff(repo, diffopts, patchparent, fp=patchf)
 patchf.rename()
 added = repo.status()[1]
 for a in added:
 f = repo.wjoin(a)
 try:
 if heads != [repo.changelog.node(rev[0])]:
 raise util.Abort(_('revision %d has unmanaged children')
 % rev[0])
 lastparent = None
-if git:
+diffopts = self.diffopts({'git': git})
-self.diffopts().git = True
 for r in rev:
 p1, p2 = repo.changelog.parentrevs(r)
 n = repo.changelog.node(r)
 if p2 != nullrev:
 raise util.Abort(_('cannot import merge revision %d') % r)
 checkseries(patchname)
 checkfile(patchname)
 self.full_series.insert(0, patchname)
 patchf = self.opener(patchname, "w")
-patch.export(repo, [n], fp=patchf, opts=self.diffopts())
+patch.export(repo, [n], fp=patchf, opts=diffopts)
 patchf.close()
 se = statusentry(hex(n), patchname)
 self.applied.insert(0, se)
 message = '\n'.join(message)
 if opts['edit']:
 message = ui.edit(message, user or ui.username())
-q.refresh(repo, msg=message)
+diffopts = q.patchopts(q.diffopts(), *patches)
+q.refresh(repo, msg=message, git=diffopts.git)
 q.delete(repo, patches, opts)
 q.save_dirty()
 def goto(ui, repo, patch, **opts):
 '''push or pop patches until named patch is at top of stack'''

Mercurial > hg

comparison hgext/mq.py @ 10187:fcc15ba18c03