mercurial: comparison hgext/mq.py

equal deleted inserted replaced

-:64614c7e4bd9
+:aa011d123f71
 def __str__(self):
 return self.rev + ':' + self.name
 class patchheader(object):
-def __init__(self, message, comments, user, date, haspatch):
+def __init__(self, pf):
-self.message = message
-self.comments = comments
-self.user = user
-self.date = date
-self.haspatch = haspatch
-def setuser(self, user):
-if not self.setheader(['From: ', '# User '], user):
-try:
-patchheaderat = self.comments.index('# HG changeset patch')
-self.comments.insert(patchheaderat + 1,'# User ' + user)
-except ValueError:
-self.comments = ['From: ' + user, ''] + self.comments
-self.user = user
-def setdate(self, date):
-if self.setheader(['# Date '], date):
-self.date = date
-def setmessage(self, message):
-if self.comments:
-self._delmsg()
-self.message = [message]
-self.comments += self.message
-def setheader(self, prefixes, new):
-'''Update all references to a field in the patch header.
-If none found, add it email style.'''
-res = False
-for prefix in prefixes:
-for i in xrange(len(self.comments)):
-if self.comments[i].startswith(prefix):
-self.comments[i] = prefix + new
-res = True
-break
-return res
-def __str__(self):
-if not self.comments:
-return ''
-return '\n'.join(self.comments) + '\n\n'
-def _delmsg(self):
-'''Remove existing message, keeping the rest of the comments fields.
-If comments contains 'subject: ', message will prepend
-the field and a blank line.'''
-if self.message:
-subj = 'subject: ' + self.message[0].lower()
-for i in xrange(len(self.comments)):
-if subj == self.comments[i].lower():
-del self.comments[i]
-self.message = self.message[2:]
-break
-ci = 0
-for mi in self.message:
-while mi != self.comments[ci]:
-ci += 1
-del self.comments[ci]
-class queue:
-def __init__(self, ui, path, patchdir=None):
-self.basepath = path
-self.path = patchdir or os.path.join(path, "patches")
-self.opener = util.opener(self.path)
-self.ui = ui
-self.applied_dirty = 0
-self.series_dirty = 0
-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()
-return [statusentry(l) for l in lines]
-return []
-@util.propertycache
-def full_series(self):
-if os.path.exists(self.join(self.series_path)):
-return self.opener(self.series_path).read().splitlines()
-return []
-@util.propertycache
-def series(self):
-self.parse_series()
-return self.series
-@util.propertycache
-def series_guards(self):
-self.parse_series()
-return self.series_guards
-def invalidate(self):
-for a in 'applied full_series series series_guards'.split():
-if a in self.__dict__:
-delattr(self, a)
-self.applied_dirty = 0
-self.series_dirty = 0
-self.guards_dirty = False
-self.active_guards = None
-def diffopts(self):
-if self._diffopts is None:
-self._diffopts = patch.diffopts(self.ui)
-return self._diffopts
-def join(self, *p):
-return os.path.join(self.path, *p)
-def find_series(self, patch):
-pre = re.compile("(\s*)([^#]+)")
-index = 0
-for l in self.full_series:
-m = pre.match(l)
-if m:
-s = m.group(2)
-s = s.rstrip()
-if s == patch:
-return index
-index += 1
-return None
-guard_re = re.compile(r'\s?#([-+][^-+# \t\r\n\f][^# \t\r\n\f]*)')
-def parse_series(self):
-self.series = []
-self.series_guards = []
-for l in self.full_series:
-h = l.find('#')
-if h == -1:
-patch = l
-comment = ''
-elif h == 0:
-continue
-else:
-patch = l[:h]
-comment = l[h:]
-patch = patch.strip()
-if patch:
-if patch in self.series:
-raise util.Abort(_('%s appears more than once in %s') %
-(patch, self.join(self.series_path)))
-self.series.append(patch)
-self.series_guards.append(self.guard_re.findall(comment))
-def check_guard(self, guard):
-if not guard:
-return _('guard cannot be an empty string')
-bad_chars = '# \t\r\n\f'
-first = guard[0]
-if first in '-+':
-return (_('guard %r starts with invalid character: %r') %
-(guard, first))
-for c in bad_chars:
-if c in guard:
-return _('invalid character in guard %r: %r') % (guard, c)
-def set_active(self, guards):
-for guard in guards:
-bad = self.check_guard(guard)
-if bad:
-raise util.Abort(bad)
-guards = sorted(set(guards))
-self.ui.debug(_('active guards: %s\n') % ' '.join(guards))
-self.active_guards = guards
-self.guards_dirty = True
-def active(self):
-if self.active_guards is None:
-self.active_guards = []
-try:
-guards = self.opener(self.guards_path).read().split()
-except IOError, err:
-if err.errno != errno.ENOENT: raise
-guards = []
-for i, guard in enumerate(guards):
-bad = self.check_guard(guard)
-if bad:
-self.ui.warn('%s:%d: %s\n' %
-(self.join(self.guards_path), i + 1, bad))
-else:
-self.active_guards.append(guard)
-return self.active_guards
-def set_guards(self, idx, guards):
-for g in guards:
-if len(g) < 2:
-raise util.Abort(_('guard %r too short') % g)
-if g[0] not in '-+':
-raise util.Abort(_('guard %r starts with invalid char') % g)
-bad = self.check_guard(g[1:])
-if bad:
-raise util.Abort(bad)
-drop = self.guard_re.sub('', self.full_series[idx])
-self.full_series[idx] = drop + ''.join([' #' + g for g in guards])
-self.parse_series()
-self.series_dirty = True
-def pushable(self, idx):
-if isinstance(idx, str):
-idx = self.series.index(idx)
-patchguards = self.series_guards[idx]
-if not patchguards:
-return True, None
-guards = self.active()
-exactneg = [g for g in patchguards if g[0] == '-' and g[1:] in guards]
-if exactneg:
-return False, exactneg[0]
-pos = [g for g in patchguards if g[0] == '+']
-exactpos = [g for g in pos if g[1:] in guards]
-if pos:
-if exactpos:
-return True, exactpos[0]
-return False, pos
-return True, ''
-def explain_pushable(self, idx, all_patches=False):
-write = all_patches and self.ui.write or self.ui.warn
-if all_patches or self.ui.verbose:
-if isinstance(idx, str):
-idx = self.series.index(idx)
-pushable, why = self.pushable(idx)
-if all_patches and pushable:
-if why is None:
-write(_('allowing %s - no guards in effect\n') %
-self.series[idx])
-else:
-if not why:
-write(_('allowing %s - no matching negative guards\n') %
-self.series[idx])
-else:
-write(_('allowing %s - guarded by %r\n') %
-(self.series[idx], why))
-if not pushable:
-if why:
-write(_('skipping %s - guarded by %r\n') %
-(self.series[idx], why))
-else:
-write(_('skipping %s - no matching guards\n') %
-self.series[idx])
-def save_dirty(self):
-def write_list(items, path):
-fp = self.opener(path, 'w')
-for i in items:
-fp.write("%s\n" % i)
-fp.close()
-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)
-if self.guards_dirty: write_list(self.active_guards, self.guards_path)
-def readheaders(self, patch):
 def eatdiff(lines):
 while lines:
 l = lines[-1]
 if (l.startswith("diff -") or
 l.startswith("Index:") or
 if re.match('\s*$', l):
 del lines[-1]
 else:
 break
-pf = self.join(patch)
 message = []
 comments = []
 user = None
 date = None
 format = None
 # make sure message isn't empty
 if format and format.startswith("tag") and subject:
 message.insert(0, "")
 message.insert(0, subject)
-return patchheader(message, comments, user, date, diffstart > 1)
+self.message = message
+self.comments = comments
+self.user = user
+self.date = date
+self.haspatch = diffstart > 1
+def setuser(self, user):
+if not self.setheader(['From: ', '# User '], user):
+try:
+patchheaderat = self.comments.index('# HG changeset patch')
+self.comments.insert(patchheaderat + 1,'# User ' + user)
+except ValueError:
+self.comments = ['From: ' + user, ''] + self.comments
+self.user = user
+def setdate(self, date):
+if self.setheader(['# Date '], date):
+self.date = date
+def setmessage(self, message):
+if self.comments:
+self._delmsg()
+self.message = [message]
+self.comments += self.message
+def setheader(self, prefixes, new):
+'''Update all references to a field in the patch header.
+If none found, add it email style.'''
+res = False
+for prefix in prefixes:
+for i in xrange(len(self.comments)):
+if self.comments[i].startswith(prefix):
+self.comments[i] = prefix + new
+res = True
+break
+return res
+def __str__(self):
+if not self.comments:
+return ''
+return '\n'.join(self.comments) + '\n\n'
+def _delmsg(self):
+'''Remove existing message, keeping the rest of the comments fields.
+If comments contains 'subject: ', message will prepend
+the field and a blank line.'''
+if self.message:
+subj = 'subject: ' + self.message[0].lower()
+for i in xrange(len(self.comments)):
+if subj == self.comments[i].lower():
+del self.comments[i]
+self.message = self.message[2:]
+break
+ci = 0
+for mi in self.message:
+while mi != self.comments[ci]:
+ci += 1
+del self.comments[ci]
+class queue:
+def __init__(self, ui, path, patchdir=None):
+self.basepath = path
+self.path = patchdir or os.path.join(path, "patches")
+self.opener = util.opener(self.path)
+self.ui = ui
+self.applied_dirty = 0
+self.series_dirty = 0
+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()
+return [statusentry(l) for l in lines]
+return []
+@util.propertycache
+def full_series(self):
+if os.path.exists(self.join(self.series_path)):
+return self.opener(self.series_path).read().splitlines()
+return []
+@util.propertycache
+def series(self):
+self.parse_series()
+return self.series
+@util.propertycache
+def series_guards(self):
+self.parse_series()
+return self.series_guards
+def invalidate(self):
+for a in 'applied full_series series series_guards'.split():
+if a in self.__dict__:
+delattr(self, a)
+self.applied_dirty = 0
+self.series_dirty = 0
+self.guards_dirty = False
+self.active_guards = None
+def diffopts(self):
+if self._diffopts is None:
+self._diffopts = patch.diffopts(self.ui)
+return self._diffopts
+def join(self, *p):
+return os.path.join(self.path, *p)
+def find_series(self, patch):
+pre = re.compile("(\s*)([^#]+)")
+index = 0
+for l in self.full_series:
+m = pre.match(l)
+if m:
+s = m.group(2)
+s = s.rstrip()
+if s == patch:
+return index
+index += 1
+return None
+guard_re = re.compile(r'\s?#([-+][^-+# \t\r\n\f][^# \t\r\n\f]*)')
+def parse_series(self):
+self.series = []
+self.series_guards = []
+for l in self.full_series:
+h = l.find('#')
+if h == -1:
+patch = l
+comment = ''
+elif h == 0:
+continue
+else:
+patch = l[:h]
+comment = l[h:]
+patch = patch.strip()
+if patch:
+if patch in self.series:
+raise util.Abort(_('%s appears more than once in %s') %
+(patch, self.join(self.series_path)))
+self.series.append(patch)
+self.series_guards.append(self.guard_re.findall(comment))
+def check_guard(self, guard):
+if not guard:
+return _('guard cannot be an empty string')
+bad_chars = '# \t\r\n\f'
+first = guard[0]
+if first in '-+':
+return (_('guard %r starts with invalid character: %r') %
+(guard, first))
+for c in bad_chars:
+if c in guard:
+return _('invalid character in guard %r: %r') % (guard, c)
+def set_active(self, guards):
+for guard in guards:
+bad = self.check_guard(guard)
+if bad:
+raise util.Abort(bad)
+guards = sorted(set(guards))
+self.ui.debug(_('active guards: %s\n') % ' '.join(guards))
+self.active_guards = guards
+self.guards_dirty = True
+def active(self):
+if self.active_guards is None:
+self.active_guards = []
+try:
+guards = self.opener(self.guards_path).read().split()
+except IOError, err:
+if err.errno != errno.ENOENT: raise
+guards = []
+for i, guard in enumerate(guards):
+bad = self.check_guard(guard)
+if bad:
+self.ui.warn('%s:%d: %s\n' %
+(self.join(self.guards_path), i + 1, bad))
+else:
+self.active_guards.append(guard)
+return self.active_guards
+def set_guards(self, idx, guards):
+for g in guards:
+if len(g) < 2:
+raise util.Abort(_('guard %r too short') % g)
+if g[0] not in '-+':
+raise util.Abort(_('guard %r starts with invalid char') % g)
+bad = self.check_guard(g[1:])
+if bad:
+raise util.Abort(bad)
+drop = self.guard_re.sub('', self.full_series[idx])
+self.full_series[idx] = drop + ''.join([' #' + g for g in guards])
+self.parse_series()
+self.series_dirty = True
+def pushable(self, idx):
+if isinstance(idx, str):
+idx = self.series.index(idx)
+patchguards = self.series_guards[idx]
+if not patchguards:
+return True, None
+guards = self.active()
+exactneg = [g for g in patchguards if g[0] == '-' and g[1:] in guards]
+if exactneg:
+return False, exactneg[0]
+pos = [g for g in patchguards if g[0] == '+']
+exactpos = [g for g in pos if g[1:] in guards]
+if pos:
+if exactpos:
+return True, exactpos[0]
+return False, pos
+return True, ''
+def explain_pushable(self, idx, all_patches=False):
+write = all_patches and self.ui.write or self.ui.warn
+if all_patches or self.ui.verbose:
+if isinstance(idx, str):
+idx = self.series.index(idx)
+pushable, why = self.pushable(idx)
+if all_patches and pushable:
+if why is None:
+write(_('allowing %s - no guards in effect\n') %
+self.series[idx])
+else:
+if not why:
+write(_('allowing %s - no matching negative guards\n') %
+self.series[idx])
+else:
+write(_('allowing %s - guarded by %r\n') %
+(self.series[idx], why))
+if not pushable:
+if why:
+write(_('skipping %s - guarded by %r\n') %
+(self.series[idx], why))
+else:
+write(_('skipping %s - no matching guards\n') %
+self.series[idx])
+def save_dirty(self):
+def write_list(items, path):
+fp = self.opener(path, 'w')
+for i in items:
+fp.write("%s\n" % i)
+fp.close()
+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)
+if self.guards_dirty: write_list(self.active_guards, self.guards_path)
 def removeundo(self, repo):
 undo = repo.sjoin('undo')
 if not os.path.exists(undo):
 return
 raise util.Abort(_("update returned %d") % ret)
 n = repo.commit(None, ctx.description(), ctx.user(), force=1)
 if n is None:
 raise util.Abort(_("repo commit failed"))
 try:
-ph = mergeq.readheaders(patch)
+ph = patchheader(mergeq.join(patch))
 except:
 raise util.Abort(_("unable to read %s") % patch)
 patchf = self.opener(patch, "w")
 comments = str(ph)
 continue
 self.ui.warn(_("applying %s\n") % patchname)
 pf = os.path.join(patchdir, patchname)
 try:
-ph = self.readheaders(patchname)
+ph = patchheader(self.join(patchname))
 except:
 self.ui.warn(_("Unable to read %s\n") % patchname)
 err = 1
 break
 top = bin(top)
 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 = self.readheaders(patchfn)
+ph = patchheader(self.join(patchfn))
 patchf = self.opener(patchfn, 'r')
 # if the patch was a git patch, refresh it as a git patch
 for line in patchf:
 def qseries(self, repo, missing=None, start=0, length=None, status=None,
 summary=False):
 def displayname(patchname):
 if summary:
-ph = self.readheaders(patchname)
+ph = patchheader(self.join(patchname))
 msg = ph.message
 msg = msg and ': ' + msg[0] or ': '
 else:
 msg = ''
 return '%s%s' % (patchname, msg)
 ui.write(_("no patches applied\n"))
 return 1
 if message:
 raise util.Abort(_('option "-e" incompatible with "-m" or "-l"'))
 patch = q.applied[-1].name
-ph = q.readheaders(patch)
+ph = patchheader(q.join(patch))
 message = ui.edit('\n'.join(ph.message), ph.user or ui.username())
 setupheaderopts(ui, opts)
 ret = q.refresh(repo, pats, msg=message, **opts)
 q.save_dirty()
 return ret
 raise util.Abort(_('qfold cannot fold already applied patch %s') % p)
 patches.append(p)
 for p in patches:
 if not message:
-ph = q.readheaders(p)
+ph = patchheader(q.join(p))
 if ph.message:
 messages.append(ph.message)
 pf = q.join(p)
 (patchsuccess, files, fuzz) = q.patch(repo, pf)
 if not patchsuccess:
 raise util.Abort(_('Error folding patch %s') % p)
 patch.updatedir(ui, repo, files)
 if not message:
-ph = q.readheaders(parent)
+ph = patchheader(q.join(parent))
 message, user = ph.message, ph.user
 for msg in messages:
 message.append('* * *')
 message.extend(msg)
 message = '\n'.join(message)
 else:
 if not q.applied:
 ui.write('no patches applied\n')
 return 1
 patch = q.lookup('qtip')
-ph = repo.mq.readheaders(patch)
+ph = patchheader(repo.mq.join(patch))
 ui.write('\n'.join(ph.message) + '\n')
 def lastsavename(path):
 (directory, base) = os.path.split(path)

changeset 8653	aa011d123f71
parent 8632	9e055cfdd620
child 8654	f6cc3638f468