Show More
@@ -76,7 +76,7 b' 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() | |
@@ -95,7 +95,7 b' def _revsbetween(repo, roots, heads):' | |||||
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: | |
@@ -257,7 +257,7 b' def stringset(repo, subset, x):' | |||||
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: | |
@@ -270,7 +270,7 b' def rangeset(repo, subset, x, y):' | |||||
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: | |
@@ -341,12 +341,12 b' def ancestor(repo, subset, x):' | |||||
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 | |||
@@ -400,7 +400,7 b' def only(repo, subset, x):' | |||||
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() | |
@@ -659,7 +659,7 b' def desc(repo, subset, x):' | |||||
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 | |
@@ -830,7 +830,7 b' def _follow(repo, subset, x, name, follo' | |||||
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 | |||
@@ -1015,7 +1015,7 b' def limit(repo, subset, x):' | |||||
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: | |
@@ -1043,7 +1043,7 b' def last(repo, subset, x):' | |||||
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: | |
@@ -1063,7 +1063,7 b' def maxrev(repo, subset, x):' | |||||
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()`` | |
@@ -1082,7 +1082,7 b' def branchpoint(repo, subset, x):' | |||||
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): | |
@@ -1100,7 +1100,7 b' def minrev(repo, subset, x):' | |||||
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)`` | |
@@ -1200,7 +1200,7 b' def p1(repo, subset, x):' | |||||
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 | |
@@ -1219,9 +1219,9 b' def p2(repo, subset, x):' | |||||
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 | |
@@ -1281,7 +1281,7 b' def present(repo, subset, x):' | |||||
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()`` | |
@@ -1324,7 +1324,7 b' def remote(repo, subset, x):' | |||||
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)`` | |
@@ -1652,7 +1652,7 b' def user(repo, subset, x):' | |||||
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]) | |
@@ -1661,7 +1661,7 b' def _list(repo, subset, x):' | |||||
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]) | |
@@ -1670,7 +1670,7 b' def _intlist(repo, subset, x):' | |||||
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() |
General Comments 0
You need to be logged in to leave comments.
Login now