Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/revset.py @ 22802:1fcd361efaf4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
baseset: use default value instead of [] when possible For pure cleanup purposes, we replace all the occurences of `baseset([])` with `baseset()`.
author Pierre-Yves David <pierre-yves.david@fb.com>
date Mon, 06 Oct 2014 10:41:43 -0700
parents 6af9e9b6af39
children 5385314e0b14
comparison
equal deleted inserted replaced
22801:6af9e9b6af39 22802:1fcd361efaf4
74 74
75 def _revsbetween(repo, roots, heads): 75 def _revsbetween(repo, roots, heads):
76 """Return all paths between roots and heads, inclusive of both endpoint 76 """Return all paths between roots and heads, inclusive of both endpoint
77 sets.""" 77 sets."""
78 if not roots: 78 if not roots:
79 return baseset([]) 79 return baseset()
80 parentrevs = repo.changelog.parentrevs 80 parentrevs = repo.changelog.parentrevs
81 visit = list(heads) 81 visit = list(heads)
82 reachable = set() 82 reachable = set()
83 seen = {} 83 seen = {}
84 minroot = min(roots) 84 minroot = min(roots)
93 seen[rev] = parents 93 seen[rev] = parents
94 for parent in parents: 94 for parent in parents:
95 if parent >= minroot and parent not in seen: 95 if parent >= minroot and parent not in seen:
96 visit.append(parent) 96 visit.append(parent)
97 if not reachable: 97 if not reachable:
98 return baseset([]) 98 return baseset()
99 for rev in sorted(seen): 99 for rev in sorted(seen):
100 for parent in seen[rev]: 100 for parent in seen[rev]:
101 if parent in reachable: 101 if parent in reachable:
102 reachable.add(rev) 102 reachable.add(rev)
103 return baseset(sorted(reachable)) 103 return baseset(sorted(reachable))
255 x = repo[x].rev() 255 x = repo[x].rev()
256 if x == -1 and len(subset) == len(repo): 256 if x == -1 and len(subset) == len(repo):
257 return baseset([-1]) 257 return baseset([-1])
258 if len(subset) == len(repo) or x in subset: 258 if len(subset) == len(repo) or x in subset:
259 return baseset([x]) 259 return baseset([x])
260 return baseset([]) 260 return baseset()
261 261
262 def symbolset(repo, subset, x): 262 def symbolset(repo, subset, x):
263 if x in symbols: 263 if x in symbols:
264 raise error.ParseError(_("can't use %s here") % x) 264 raise error.ParseError(_("can't use %s here") % x)
265 return stringset(repo, subset, x) 265 return stringset(repo, subset, x)
268 cl = baseset(repo.changelog) 268 cl = baseset(repo.changelog)
269 m = getset(repo, cl, x) 269 m = getset(repo, cl, x)
270 n = getset(repo, cl, y) 270 n = getset(repo, cl, y)
271 271
272 if not m or not n: 272 if not m or not n:
273 return baseset([]) 273 return baseset()
274 m, n = m[0], n[-1] 274 m, n = m[0], n[-1]
275 275
276 if m < n: 276 if m < n:
277 r = spanset(repo, m, n + 1) 277 r = spanset(repo, m, n + 1)
278 else: 278 else:
339 else: 339 else:
340 anc = anc.ancestor(repo[r]) 340 anc = anc.ancestor(repo[r])
341 341
342 if anc is not None and anc.rev() in subset: 342 if anc is not None and anc.rev() in subset:
343 return baseset([anc.rev()]) 343 return baseset([anc.rev()])
344 return baseset([]) 344 return baseset()
345 345
346 def _ancestors(repo, subset, x, followfirst=False): 346 def _ancestors(repo, subset, x, followfirst=False):
347 args = getset(repo, spanset(repo), x) 347 args = getset(repo, spanset(repo), x)
348 if not args: 348 if not args:
349 return baseset([]) 349 return baseset()
350 s = _revancestors(repo, args, followfirst) 350 s = _revancestors(repo, args, followfirst)
351 return subset.filter(s.__contains__) 351 return subset.filter(s.__contains__)
352 352
353 def ancestors(repo, subset, x): 353 def ancestors(repo, subset, x):
354 """``ancestors(set)`` 354 """``ancestors(set)``
398 # i18n: "only" is a keyword 398 # i18n: "only" is a keyword
399 args = getargs(x, 1, 2, _('only takes one or two arguments')) 399 args = getargs(x, 1, 2, _('only takes one or two arguments'))
400 include = getset(repo, spanset(repo), args[0]).set() 400 include = getset(repo, spanset(repo), args[0]).set()
401 if len(args) == 1: 401 if len(args) == 1:
402 if len(include) == 0: 402 if len(include) == 0:
403 return baseset([]) 403 return baseset()
404 404
405 descendants = set(_revdescendants(repo, include, False)) 405 descendants = set(_revdescendants(repo, include, False))
406 exclude = [rev for rev in cl.headrevs() 406 exclude = [rev for rev in cl.headrevs()
407 if not rev in descendants and not rev in include] 407 if not rev in descendants and not rev in include]
408 else: 408 else:
657 return subset.filter(matches) 657 return subset.filter(matches)
658 658
659 def _descendants(repo, subset, x, followfirst=False): 659 def _descendants(repo, subset, x, followfirst=False):
660 args = getset(repo, spanset(repo), x) 660 args = getset(repo, spanset(repo), x)
661 if not args: 661 if not args:
662 return baseset([]) 662 return baseset()
663 s = _revdescendants(repo, args, followfirst) 663 s = _revdescendants(repo, args, followfirst)
664 664
665 # Both sets need to be ascending in order to lazily return the union 665 # Both sets need to be ascending in order to lazily return the union
666 # in the correct order. 666 # in the correct order.
667 args.ascending() 667 args.ascending()
828 cx = c[x] 828 cx = c[x]
829 s = set(ctx.rev() for ctx in cx.ancestors(followfirst=followfirst)) 829 s = set(ctx.rev() for ctx in cx.ancestors(followfirst=followfirst))
830 # include the revision responsible for the most recent version 830 # include the revision responsible for the most recent version
831 s.add(cx.linkrev()) 831 s.add(cx.linkrev())
832 else: 832 else:
833 return baseset([]) 833 return baseset()
834 else: 834 else:
835 s = _revancestors(repo, baseset([c.rev()]), followfirst) 835 s = _revancestors(repo, baseset([c.rev()]), followfirst)
836 836
837 return subset & s 837 return subset & s
838 838
1013 except (TypeError, ValueError): 1013 except (TypeError, ValueError):
1014 # i18n: "limit" is a keyword 1014 # i18n: "limit" is a keyword
1015 raise error.ParseError(_("limit expects a number")) 1015 raise error.ParseError(_("limit expects a number"))
1016 ss = subset.set() 1016 ss = subset.set()
1017 os = getset(repo, spanset(repo), l[0]) 1017 os = getset(repo, spanset(repo), l[0])
1018 bs = baseset([]) 1018 bs = baseset()
1019 it = iter(os) 1019 it = iter(os)
1020 for x in xrange(lim): 1020 for x in xrange(lim):
1021 try: 1021 try:
1022 y = it.next() 1022 y = it.next()
1023 if y in ss: 1023 if y in ss:
1041 # i18n: "last" is a keyword 1041 # i18n: "last" is a keyword
1042 raise error.ParseError(_("last expects a number")) 1042 raise error.ParseError(_("last expects a number"))
1043 ss = subset.set() 1043 ss = subset.set()
1044 os = getset(repo, spanset(repo), l[0]) 1044 os = getset(repo, spanset(repo), l[0])
1045 os.reverse() 1045 os.reverse()
1046 bs = baseset([]) 1046 bs = baseset()
1047 it = iter(os) 1047 it = iter(os)
1048 for x in xrange(lim): 1048 for x in xrange(lim):
1049 try: 1049 try:
1050 y = it.next() 1050 y = it.next()
1051 if y in ss: 1051 if y in ss:
1061 os = getset(repo, spanset(repo), x) 1061 os = getset(repo, spanset(repo), x)
1062 if os: 1062 if os:
1063 m = os.max() 1063 m = os.max()
1064 if m in subset: 1064 if m in subset:
1065 return baseset([m]) 1065 return baseset([m])
1066 return baseset([]) 1066 return baseset()
1067 1067
1068 def merge(repo, subset, x): 1068 def merge(repo, subset, x):
1069 """``merge()`` 1069 """``merge()``
1070 Changeset is a merge changeset. 1070 Changeset is a merge changeset.
1071 """ 1071 """
1080 """ 1080 """
1081 # i18n: "branchpoint" is a keyword 1081 # i18n: "branchpoint" is a keyword
1082 getargs(x, 0, 0, _("branchpoint takes no arguments")) 1082 getargs(x, 0, 0, _("branchpoint takes no arguments"))
1083 cl = repo.changelog 1083 cl = repo.changelog
1084 if not subset: 1084 if not subset:
1085 return baseset([]) 1085 return baseset()
1086 baserev = min(subset) 1086 baserev = min(subset)
1087 parentscount = [0]*(len(repo) - baserev) 1087 parentscount = [0]*(len(repo) - baserev)
1088 for r in cl.revs(start=baserev + 1): 1088 for r in cl.revs(start=baserev + 1):
1089 for p in cl.parentrevs(r): 1089 for p in cl.parentrevs(r):
1090 if p >= baserev: 1090 if p >= baserev:
1098 os = getset(repo, spanset(repo), x) 1098 os = getset(repo, spanset(repo), x)
1099 if os: 1099 if os:
1100 m = os.min() 1100 m = os.min()
1101 if m in subset: 1101 if m in subset:
1102 return baseset([m]) 1102 return baseset([m])
1103 return baseset([]) 1103 return baseset()
1104 1104
1105 def modifies(repo, subset, x): 1105 def modifies(repo, subset, x):
1106 """``modifies(pattern)`` 1106 """``modifies(pattern)``
1107 Changesets modifying files matched by pattern. 1107 Changesets modifying files matched by pattern.
1108 1108
1198 """ 1198 """
1199 if x is None: 1199 if x is None:
1200 p = repo[x].p1().rev() 1200 p = repo[x].p1().rev()
1201 if p >= 0: 1201 if p >= 0:
1202 return subset & baseset([p]) 1202 return subset & baseset([p])
1203 return baseset([]) 1203 return baseset()
1204 1204
1205 ps = set() 1205 ps = set()
1206 cl = repo.changelog 1206 cl = repo.changelog
1207 for r in getset(repo, spanset(repo), x): 1207 for r in getset(repo, spanset(repo), x):
1208 ps.add(cl.parentrevs(r)[0]) 1208 ps.add(cl.parentrevs(r)[0])
1217 ps = repo[x].parents() 1217 ps = repo[x].parents()
1218 try: 1218 try:
1219 p = ps[1].rev() 1219 p = ps[1].rev()
1220 if p >= 0: 1220 if p >= 0:
1221 return subset & baseset([p]) 1221 return subset & baseset([p])
1222 return baseset([]) 1222 return baseset()
1223 except IndexError: 1223 except IndexError:
1224 return baseset([]) 1224 return baseset()
1225 1225
1226 ps = set() 1226 ps = set()
1227 cl = repo.changelog 1227 cl = repo.changelog
1228 for r in getset(repo, spanset(repo), x): 1228 for r in getset(repo, spanset(repo), x):
1229 ps.add(cl.parentrevs(r)[1]) 1229 ps.add(cl.parentrevs(r)[1])
1279 to continue even in such cases. 1279 to continue even in such cases.
1280 """ 1280 """
1281 try: 1281 try:
1282 return getset(repo, subset, x) 1282 return getset(repo, subset, x)
1283 except error.RepoLookupError: 1283 except error.RepoLookupError:
1284 return baseset([]) 1284 return baseset()
1285 1285
1286 def public(repo, subset, x): 1286 def public(repo, subset, x):
1287 """``public()`` 1287 """``public()``
1288 Changeset in public phase.""" 1288 Changeset in public phase."""
1289 # i18n: "public" is a keyword 1289 # i18n: "public" is a keyword
1322 n = other.lookup(q) 1322 n = other.lookup(q)
1323 if n in repo: 1323 if n in repo:
1324 r = repo[n].rev() 1324 r = repo[n].rev()
1325 if r in subset: 1325 if r in subset:
1326 return baseset([r]) 1326 return baseset([r])
1327 return baseset([]) 1327 return baseset()
1328 1328
1329 def removes(repo, subset, x): 1329 def removes(repo, subset, x):
1330 """``removes(pattern)`` 1330 """``removes(pattern)``
1331 Changesets which remove files matching pattern. 1331 Changesets which remove files matching pattern.
1332 1332
1650 1650
1651 # for internal use 1651 # for internal use
1652 def _list(repo, subset, x): 1652 def _list(repo, subset, x):
1653 s = getstring(x, "internal error") 1653 s = getstring(x, "internal error")
1654 if not s: 1654 if not s:
1655 return baseset([]) 1655 return baseset()
1656 ls = [repo[r].rev() for r in s.split('\0')] 1656 ls = [repo[r].rev() for r in s.split('\0')]
1657 s = subset.set() 1657 s = subset.set()
1658 return baseset([r for r in ls if r in s]) 1658 return baseset([r for r in ls if r in s])
1659 1659
1660 # for internal use 1660 # for internal use
1661 def _intlist(repo, subset, x): 1661 def _intlist(repo, subset, x):
1662 s = getstring(x, "internal error") 1662 s = getstring(x, "internal error")
1663 if not s: 1663 if not s:
1664 return baseset([]) 1664 return baseset()
1665 ls = [int(r) for r in s.split('\0')] 1665 ls = [int(r) for r in s.split('\0')]
1666 s = subset.set() 1666 s = subset.set()
1667 return baseset([r for r in ls if r in s]) 1667 return baseset([r for r in ls if r in s])
1668 1668
1669 # for internal use 1669 # for internal use
1670 def _hexlist(repo, subset, x): 1670 def _hexlist(repo, subset, x):
1671 s = getstring(x, "internal error") 1671 s = getstring(x, "internal error")
1672 if not s: 1672 if not s:
1673 return baseset([]) 1673 return baseset()
1674 cl = repo.changelog 1674 cl = repo.changelog
1675 ls = [cl.rev(node.bin(r)) for r in s.split('\0')] 1675 ls = [cl.rev(node.bin(r)) for r in s.split('\0')]
1676 s = subset.set() 1676 s = subset.set()
1677 return baseset([r for r in ls if r in s]) 1677 return baseset([r for r in ls if r in s])
1678 1678