mercurial-scm/hg: mercurial/revset.py comparison

comparison mercurial/revset.py @ 16409:2cbd7dd0cc1f

graphlog: fix --follow-first --rev combinations This solves a similar problem than the previous --follow/--rev patch. This time we need changelog.ancestors()/descendants() filtering on first parent. Duplicating the code looked better than introducing keyword arguments. Besides, the ancestors() version was already implemented in follow() revset.

author	Patrick Mezard <patrick@mezard.eu>
date	Wed, 11 Apr 2012 11:25:34 +0200
parents	1fb2f1400ea8
children	4c2edcd84175

comparison

equal deleted inserted replaced

-:d74099ac2ac1
+:2cbd7dd0cc1f
 import node as nodemod
 import bookmarks as bookmarksmod
 import match as matchmod
 from i18n import _
 import encoding
+def _revancestors(repo, revs, followfirst):
+"""Like revlog.ancestors(), but supports followfirst."""
+cut = followfirst and 1 or None
+cl = repo.changelog
+visit = list(revs)
+seen = set([nodemod.nullrev])
+while visit:
+for parent in cl.parentrevs(visit.pop(0))[:cut]:
+if parent not in seen:
+visit.append(parent)
+seen.add(parent)
+yield parent
+def _revdescendants(repo, revs, followfirst):
+"""Like revlog.descendants() but supports followfirst."""
+cut = followfirst and 1 or None
+cl = repo.changelog
+first = min(revs)
+if first == nodemod.nullrev:
+# Are there nodes with a null first parent and a non-null
+# second one? Maybe. Do we care? Probably not.
+for i in cl:
+yield i
+return
+seen = set(revs)
+for i in xrange(first + 1, len(cl)):
+for x in cl.parentrevs(i)[:cut]:
+if x != nodemod.nullrev and x in seen:
+seen.add(i)
+yield i
+break
 elements = {
 "(": (20, ("group", 1, ")"), ("func", 1, ")")),
 "~": (18, None, ("ancestor", 18)),
 "^": (18, None, ("parent", 18), ("parentpost", 18)),
 raise error.ParseError(_("ancestor arguments must be single revisions"))
 an = [repo[a[0]].ancestor(repo[b[0]]).rev()]
 return [r for r in an if r in subset]
+def _ancestors(repo, subset, x, followfirst=False):
+args = getset(repo, range(len(repo)), x)
+if not args:
+return []
+s = set(_revancestors(repo, args, followfirst)) | set(args)
+return [r for r in subset if r in s]
 def ancestors(repo, subset, x):
 """``ancestors(set)``
 Changesets that are ancestors of a changeset in set.
 """
-args = getset(repo, range(len(repo)), x)
+return _ancestors(repo, subset, x)
-if not args:
-return []
+def _firstancestors(repo, subset, x):
-s = set(repo.changelog.ancestors(*args)) | set(args)
+# ``_firstancestors(set)``
-return [r for r in subset if r in s]
+# Like ``ancestors(set)`` but follows only the first parents.
+return _ancestors(repo, subset, x, followfirst=True)
 def ancestorspec(repo, subset, x, n):
 """``set~n``
 Changesets that are the Nth ancestor (first parents only) of a changeset in set.
 """
 c = repo[r]
 if ds in encoding.lower(c.description()):
 l.append(r)
 return l
+def _descendants(repo, subset, x, followfirst=False):
+args = getset(repo, range(len(repo)), x)
+if not args:
+return []
+s = set(_revdescendants(repo, args, followfirst)) | set(args)
+return [r for r in subset if r in s]
 def descendants(repo, subset, x):
 """``descendants(set)``
 Changesets which are descendants of changesets in set.
 """
-args = getset(repo, range(len(repo)), x)
+return _descendants(repo, subset, x)
-if not args:
-return []
+def _firstdescendants(repo, subset, x):
-s = set(repo.changelog.descendants(*args)) | set(args)
+# ``_firstdescendants(set)``
-return [r for r in subset if r in s]
+# Like ``descendants(set)`` but follows only the first parents.
+return _descendants(repo, subset, x, followfirst=True)
 def draft(repo, subset, x):
 """``draft()``
 Changeset in draft phase."""
 getargs(x, 0, 0, _("draft takes no arguments"))
 # include the revision responsible for the most recent version
 s.add(cx.linkrev())
 else:
 return []
 else:
-cut = followfirst and 1 or None
+s = set(_revancestors(repo, [c.rev()], followfirst)) | set([c.rev()])
-cl = repo.changelog
-s = set()
-visit = [c.rev()]
-while visit:
-for prev in cl.parentrevs(visit.pop(0))[:cut]:
-if prev not in s and prev != nodemod.nullrev:
-visit.append(prev)
-s.add(prev)
-s.add(c.rev())
 return [r for r in subset if r in s]
 def follow(repo, subset, x):
 """``follow([file])``
 symbols = {
 "adds": adds,
 "all": getall,
 "ancestor": ancestor,
 "ancestors": ancestors,
+"_firstancestors": _firstancestors,
 "author": author,
 "bisect": bisect,
 "bisected": bisected,
 "bookmark": bookmark,
 "branch": branch,
 "closed": closed,
 "contains": contains,
 "date": date,
 "desc": desc,
 "descendants": descendants,
+"_firstdescendants": _firstdescendants,
 "draft": draft,
 "file": hasfile,
 "filelog": filelog,
 "first": first,
 "follow": follow,

Mercurial > public > mercurial-scm > hg

comparison mercurial/revset.py @ 16409:2cbd7dd0cc1f