Mercurial: comparison hgext/mq.py

equal deleted inserted replaced

-:17c0cb1045e5
+:8ff2957c1d82
 lines = self.opener.read(self.status_path).splitlines()
 return list(parselines(lines))
 return []
 @util.propertycache
-def full_series(self):
+def fullseries(self):
 if os.path.exists(self.join(self.series_path)):
 return self.opener.read(self.series_path).splitlines()
 return []
 @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():
+for a in 'applied fullseries series series_guards'.split():
 if a in self.__dict__:
 delattr(self, a)
 self.applied_dirty = 0
 self.series_dirty = 0
 self.guards_dirty = False
 def find_series(self, patch):
 def matchpatch(l):
 l = l.split('#', 1)[0]
 return l.strip() == patch
-for index, l in enumerate(self.full_series):
+for index, l in enumerate(self.fullseries):
 if matchpatch(l):
 return index
 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:
+for l in self.fullseries:
 h = l.find('#')
 if h == -1:
 patch = l
 comment = ''
 elif h == 0:
 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])
+drop = self.guard_re.sub('', self.fullseries[idx])
-self.full_series[idx] = drop + ''.join([' #' + g for g in guards])
+self.fullseries[idx] = drop + ''.join([' #' + g for g in guards])
 self.parse_series()
 self.series_dirty = True
 def pushable(self, idx):
 if isinstance(idx, str):
 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)
+write_list(self.fullseries, self.series_path)
 if self.guards_dirty:
 write_list(self.active_guards, self.guards_path)
 if self.added:
 qrepo = self.qrepo()
 if qrepo:
 unknown = []
 for (i, p) in sorted([(self.find_series(p), p) for p in patches],
 reverse=True):
 if i is not None:
-del self.full_series[i]
+del self.fullseries[i]
 else:
 unknown.append(p)
 if unknown:
 if numrevs:
 commitmsg = msg and msg or ("[mq]: %s" % patchfn)
 n = repo.commit(commitmsg, user, date, match=match, force=True)
 if n is None:
 raise util.Abort(_("repo commit failed"))
 try:
-self.full_series[insert:insert] = [patchfn]
+self.fullseries[insert:insert] = [patchfn]
 self.applied.append(statusentry(n, patchfn))
 self.parse_series()
 self.series_dirty = 1
 self.applied_dirty = 1
 if msg:
 hg.update(repo, target)
 if move:
 if not patch:
 raise util.Abort(_("please specify the patch to move"))
-for i, rpn in enumerate(self.full_series[start:]):
+for i, rpn in enumerate(self.fullseries[start:]):
 # strip markers for patch guards
 if self.guard_re.split(rpn, 1)[0] == patch:
 break
 index = start + i
-assert index < len(self.full_series)
+assert index < len(self.fullseries)
-fullpatch = self.full_series[index]
+fullpatch = self.fullseries[index]
-del self.full_series[index]
+del self.fullseries[index]
-self.full_series.insert(start, fullpatch)
+self.fullseries.insert(start, fullpatch)
 self.parse_series()
 self.series_dirty = 1
 self.applied_dirty = 1
 if start > 0:
 series.append(l)
 if datastart is None:
 self.ui.warn(_("No saved patch data found\n"))
 return 1
 self.ui.warn(_("restoring status: %s\n") % lines[0])
-self.full_series = series
+self.fullseries = series
 self.applied = applied
 self.parse_series()
 self.series_dirty = 1
 self.applied_dirty = 1
 heads = repo.changelog.heads()
 if r:
 pp = r.dirstate.parents()
 msg += "\nDirstate: %s %s" % (hex(pp[0]), hex(pp[1]))
 msg += "\n\nPatch Data:\n"
 msg += ''.join('%s\n' % x for x in self.applied)
-msg += ''.join(':%s\n' % x for x in self.full_series)
+msg += ''.join(':%s\n' % x for x in self.fullseries)
 n = repo.commit(msg, force=True)
 if not n:
 self.ui.warn(_("repo commit failed\n"))
 return 1
 self.applied.append(statusentry(n, '.hg.patches.save.line'))
 def full_series_end(self):
 if self.applied:
 p = self.applied[-1].name
 end = self.find_series(p)
 if end is None:
-return len(self.full_series)
+return len(self.fullseries)
 return end + 1
 return 0
 def series_end(self, all_patches=False):
 """If all_patches is False, return the index of the next pushable patch
 if not patchname:
 patchname = normname('%d.diff' % r)
 checkseries(patchname)
 self.checkpatchname(patchname, force)
-self.full_series.insert(0, patchname)
+self.fullseries.insert(0, patchname)
 patchf = self.opener(patchname, "w")
 cmdutil.export(repo, [n], fp=patchf, opts=diffopts)
 patchf.close()
 patchf.close()
 if not force:
 checkseries(patchname)
 if patchname not in self.series:
 index = self.full_series_end() + i
-self.full_series[index:index] = [patchname]
+self.fullseries[index:index] = [patchname]
 self.parse_series()
 self.series_dirty = True
 self.ui.warn(_("adding %s to series file\n") % patchname)
 self.added.append(patchname)
 patchname = None
 absdest = q.join(name)
 q.checkpatchname(name)
 ui.note(_('renaming %s to %s\n') % (patch, name))
 i = q.find_series(patch)
-guards = q.guard_re.findall(q.full_series[i])
+guards = q.guard_re.findall(q.fullseries[i])
-q.full_series[i] = name + ''.join([' #' + g for g in guards])
+q.fullseries[i] = name + ''.join([' #' + g for g in guards])
 q.parse_series()
 q.series_dirty = 1
 info = q.isapplied(patch)
 if info:

changeset 14572	8ff2957c1d82
parent 14564	65f4512e40e4
child 14573	d590ff1f22b2