mercurial: comparison mercurial/revset.py

equal deleted inserted replaced

-:d6afa9c149c3
+:59fa3890d40a
 import re
 from .i18n import _
 from .pycompat import getattr
+from .node import (
+bin,
+nullrev,
+wdirrev,
+)
 from . import (
 dagop,
 destutil,
 diffutil,
 encoding,
 error,
 grep as grepmod,
 hbisect,
 match as matchmod,
-node,
 obsolete as obsmod,
 obsutil,
 pathutil,
 phases,
 pycompat,
 generatorset = smartset.generatorset
 spanset = smartset.spanset
 fullreposet = smartset.fullreposet
 # revisions not included in all(), but populated if specified
-_virtualrevs = (node.nullrev, node.wdirrev)
+_virtualrevs = (nullrev, wdirrev)
 # Constants for ordering requirement, used in getset():
 #
 # If 'define', any nested functions and operations MAY change the ordering of
 # the entries in the set (but if changes the ordering, it MUST ALWAYS change
 def _makerangeset(repo, subset, m, n, order):
 if m == n:
 r = baseset([m])
-elif n == node.wdirrev:
+elif n == wdirrev:
 r = spanset(repo, m, len(repo)) + baseset([n])
-elif m == node.wdirrev:
+elif m == wdirrev:
 r = baseset([m]) + spanset(repo, repo.changelog.tiprev(), n - 1)
 elif m < n:
 r = spanset(repo, m, n + 1)
 else:
 r = spanset(repo, m, n - 1)
 matchrevs.add(bmrev)
 for bmrev in matchrevs:
 bms.add(repo[bmrev].rev())
 else:
 bms = {repo[r].rev() for r in repo._bookmarks.values()}
-bms -= {node.nullrev}
+bms -= {nullrev}
 return subset & bms
 @predicate(b'branch(string or set)', safe=True, weight=10)
 def branch(repo, subset, x):
 if not parentset:
 return baseset()
 cs = set()
 pr = repo.changelog.parentrevs
 minrev = parentset.min()
-nullrev = node.nullrev
 for r in subset:
 if r <= minrev:
 continue
 p1, p2 = pr(r)
 if p1 in parentset:
 if rev is not None:
 raise error.ParseError(
 b'_matchfiles expected at most one revision'
 )
 if value == b'':  # empty means working directory
-rev = node.wdirrev
+rev = wdirrev
 else:
 rev = value
 elif prefix == b'd:':
 if default is not None:
 raise error.ParseError(
 mcache = [None]
 # This directly read the changelog data as creating changectx for all
 # revisions is quite expensive.
 getfiles = repo.changelog.readfiles
-wdirrev = node.wdirrev
 def matches(x):
 if x == wdirrev:
 files = repo[x].files()
 else:
 # argument set should never define order
 if order == defineorder:
 order = followorder
 inputset = getset(repo, fullreposet(repo), x, order=order)
 wdirparents = None
-if node.wdirrev in inputset:
+if wdirrev in inputset:
 # a bit slower, but not common so good enough for now
 wdirparents = [p.rev() for p in repo[None].parents()]
 inputset = set(inputset)
-inputset.discard(node.wdirrev)
+inputset.discard(wdirrev)
 heads = repo.changelog.headrevs(inputset)
 if wdirparents is not None:
 heads.difference_update(wdirparents)
-heads.add(node.wdirrev)
+heads.add(wdirrev)
 heads = baseset(heads)
 return subset & heads
 @predicate(b'hidden()', safe=True)
 def merge(repo, subset, x):
 """Changeset is a merge changeset."""
 # i18n: "merge" is a keyword
 getargs(x, 0, 0, _(b"merge takes no arguments"))
 cl = repo.changelog
-nullrev = node.nullrev
 def ismerge(r):
 try:
 return cl.parentrevs(r)[1] != nullrev
 except error.WdirUnsupported:
 for ns in namespaces:
 for name in ns.listnames(repo):
 if name not in ns.deprecated:
 names.update(repo[n].rev() for n in ns.nodes(repo, name))
-names -= {node.nullrev}
+names -= {nullrev}
 return subset & names
 @predicate(b'id(string)', safe=True)
 def node_(repo, subset, x):
 l = getargs(x, 1, 1, _(b"id requires one argument"))
 # i18n: "id" is a keyword
 n = getstring(l[0], _(b"id requires a string"))
 if len(n) == 40:
 try:
-rn = repo.changelog.rev(node.bin(n))
+rn = repo.changelog.rev(bin(n))
 except error.WdirUnsupported:
-rn = node.wdirrev
+rn = wdirrev
 except (LookupError, TypeError):
 rn = None
 else:
 rn = None
 try:
 if pm is not None:
 rn = repo.changelog.rev(pm)
 except LookupError:
 pass
 except error.WdirUnsupported:
-rn = node.wdirrev
+rn = wdirrev
 if rn is None:
 return baseset()
 result = baseset([rn])
 return result & subset
 for r in getset(repo, fullreposet(repo), x):
 try:
 ps.add(cl.parentrevs(r)[0])
 except error.WdirUnsupported:
 ps.add(repo[r].p1().rev())
-ps -= {node.nullrev}
+ps -= {nullrev}
 # XXX we should turn this into a baseset instead of a set, smartset may do
 # some optimizations from the fact this is a baseset.
 return subset & ps
 ps.add(cl.parentrevs(r)[1])
 except error.WdirUnsupported:
 parents = repo[r].parents()
 if len(parents) == 2:
 ps.add(parents[1])
-ps -= {node.nullrev}
+ps -= {nullrev}
 # XXX we should turn this into a baseset instead of a set, smartset may do
 # some optimizations from the fact this is a baseset.
 return subset & ps
 for r in getset(repo, fullreposet(repo), x):
 try:
 up(parentrevs(r))
 except error.WdirUnsupported:
 up(p.rev() for p in repo[r].parents())
-ps -= {node.nullrev}
+ps -= {nullrev}
 return subset & ps
 def _phase(repo, subset, *targets):
 """helper to select all rev in <targets> phases"""
 except error.WdirUnsupported:
 ps.add(repo[r].p1().rev())
 else:
 try:
 parents = cl.parentrevs(r)
-if parents[1] != node.nullrev:
+if parents[1] != nullrev:
 ps.add(parents[1])
 except error.WdirUnsupported:
 parents = repo[r].parents()
 if len(parents) == 2:
 ps.add(parents[1].rev())
 @predicate(b'wdir()', safe=True, weight=0)
 def wdir(repo, subset, x):
 """Working directory. (EXPERIMENTAL)"""
 # i18n: "wdir" is a keyword
 getargs(x, 0, 0, _(b"wdir takes no arguments"))
-if node.wdirrev in subset or isinstance(subset, fullreposet):
+if wdirrev in subset or isinstance(subset, fullreposet):
-return baseset([node.wdirrev])
+return baseset([wdirrev])
 return baseset()
 def _orderedlist(repo, subset, x):
 s = getstring(x, b"internal error")
 def _orderedhexlist(repo, subset, x):
 s = getstring(x, b"internal error")
 if not s:
 return baseset()
 cl = repo.changelog
-ls = [cl.rev(node.bin(r)) for r in s.split(b'\0')]
+ls = [cl.rev(bin(r)) for r in s.split(b'\0')]
 s = subset
 return baseset([r for r in ls if r in s])
 # for internal use

changeset 46113	59fa3890d40a
parent 45942	89a2afe31e82
child 46115	be3d8178251e