mercurial-scm/hg-stable: mercurial/revset.py annotate

annotate mercurial/revset.py @ 30782:db38cfc7c29d

revset: stop lowercasing the regex pattern for 'author' It was probably unintentional for regex, as the meaning of some sequences like \S and \s is actually inverted by changing the case. For backward compatibility however, the matching is forced to case insensitive.

author	Matt Harbison <matt_harbison@yahoo.com>
date	Wed, 11 Jan 2017 22:42:10 -0500
parents	b1012cb1bec3
children	931a60880df4

rev	line source
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1 # revset.py - revision set queries for mercurial
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2 #
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	3 # Copyright 2010 Matt Mackall <mpm@selenic.com>
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	4 #
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	5 # This software may be used and distributed according to the terms of the
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	6 # GNU General Public License version 2 or any later version.
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	7
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	8 from __future__ import absolute_import
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	9
20690 13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	10 import heapq
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	11 import re
30071 2def3d55b1b9 revset: build _syminitletters from a saner source: the string module Augie Fackler <augie@google.com> parents: 30056 diff changeset	12 import string
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	13
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	14 from .i18n import _
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	15 from . import (
26713 a271925699d6 revset: reintroduce and experimental revset for update destination Pierre-Yves David <pierre-yves.david@fb.com> parents: 26638 diff changeset	16 destutil,
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	17 encoding,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	18 error,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	19 hbisect,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	20 match as matchmod,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	21 node,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	22 obsolete as obsmod,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	23 parser,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	24 pathutil,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	25 phases,
30071 2def3d55b1b9 revset: build _syminitletters from a saner source: the string module Augie Fackler <augie@google.com> parents: 30056 diff changeset	26 pycompat,
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	27 registrar,
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	28 repoview,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	29 util,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	30 )
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	31
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	32 def _revancestors(repo, revs, followfirst):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	33 """Like revlog.ancestors(), but supports followfirst."""
24306 6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	34 if followfirst:
6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	35 cut = 1
6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	36 else:
6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	37 cut = None
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	38 cl = repo.changelog
20690 13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	39
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	40 def iterate():
22832 2f1d2a42f040 revancestors: replace `descending` with `sort(reverse=False)` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22831 diff changeset	41 revs.sort(reverse=True)
24939 85544a52ee84 revset: use an iterator instead of a dequeue in ancestors() Pierre-Yves David <pierre-yves.david@fb.com> parents: 24938 diff changeset	42 irevs = iter(revs)
20691 c1f666e27345 revset: optimized _revancestors method based on order of revisions Lucas Moscovicz <lmoscovicz@fb.com> parents: 20690 diff changeset	43 h = []
c1f666e27345 revset: optimized _revancestors method based on order of revisions Lucas Moscovicz <lmoscovicz@fb.com> parents: 20690 diff changeset	44
25143 91c49621b2b8 _revancestors: use 'next' to remove the verbose try except clauses Pierre-Yves David <pierre-yves.david@fb.com> parents: 25131 diff changeset	45 inputrev = next(irevs, None)
91c49621b2b8 _revancestors: use 'next' to remove the verbose try except clauses Pierre-Yves David <pierre-yves.david@fb.com> parents: 25131 diff changeset	46 if inputrev is not None:
24939 85544a52ee84 revset: use an iterator instead of a dequeue in ancestors() Pierre-Yves David <pierre-yves.david@fb.com> parents: 24938 diff changeset	47 heapq.heappush(h, -inputrev)
20691 c1f666e27345 revset: optimized _revancestors method based on order of revisions Lucas Moscovicz <lmoscovicz@fb.com> parents: 20690 diff changeset	48
23956 b1e026c25552 revset: fix ancestors(null) to include null revision (issue4512) Yuya Nishihara <yuya@tcha.org> parents: 23954 diff changeset	49 seen = set()
20690 13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	50 while h:
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	51 current = -heapq.heappop(h)
24940 6b54f749659b revset: avoid returning duplicates when returning ancestors Pierre-Yves David <pierre-yves.david@fb.com> parents: 24939 diff changeset	52 if current == inputrev:
25143 91c49621b2b8 _revancestors: use 'next' to remove the verbose try except clauses Pierre-Yves David <pierre-yves.david@fb.com> parents: 25131 diff changeset	53 inputrev = next(irevs, None)
91c49621b2b8 _revancestors: use 'next' to remove the verbose try except clauses Pierre-Yves David <pierre-yves.david@fb.com> parents: 25131 diff changeset	54 if inputrev is not None:
24940 6b54f749659b revset: avoid returning duplicates when returning ancestors Pierre-Yves David <pierre-yves.david@fb.com> parents: 24939 diff changeset	55 heapq.heappush(h, -inputrev)
20690 13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	56 if current not in seen:
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	57 seen.add(current)
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	58 yield current
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	59 for parent in cl.parentrevs(current)[:cut]:
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	60 if parent != node.nullrev:
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	61 heapq.heappush(h, -parent)
13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	62
22795 c21342159fad generatorset: drop the leading underscore in the class name Pierre-Yves David <pierre-yves.david@fb.com> parents: 22794 diff changeset	63 return generatorset(iterate(), iterasc=False)
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	64
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	65 def _revdescendants(repo, revs, followfirst):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	66 """Like revlog.descendants() but supports followfirst."""
24306 6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	67 if followfirst:
6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	68 cut = 1
6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	69 else:
6ddc86eedc3b style: kill ersatz if-else ternary operators Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24219 diff changeset	70 cut = None
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	71
20692 7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	72 def iterate():
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	73 cl = repo.changelog
25549 f93ff3ab8d14 revset: mark spots that should use 'smartset.min()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25548 diff changeset	74 # XXX this should be 'parentset.min()' assuming 'parentset' is a
f93ff3ab8d14 revset: mark spots that should use 'smartset.min()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25548 diff changeset	75 # smartset (and if it is not, it should.)
20692 7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	76 first = min(revs)
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	77 nullrev = node.nullrev
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	78 if first == nullrev:
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	79 # Are there nodes with a null first parent and a non-null
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	80 # second one? Maybe. Do we care? Probably not.
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	81 for i in cl:
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	82 yield i
20692 7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	83 else:
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	84 seen = set(revs)
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	85 for i in cl.revs(first + 1):
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	86 for x in cl.parentrevs(i)[:cut]:
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	87 if x != nullrev and x in seen:
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	88 seen.add(i)
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	89 yield i
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	90 break
7af341082b76 revset: changed descendants revset to use lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20691 diff changeset	91
22795 c21342159fad generatorset: drop the leading underscore in the class name Pierre-Yves David <pierre-yves.david@fb.com> parents: 22794 diff changeset	92 return generatorset(iterate(), iterasc=True)
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	93
26095 6eed95ca4c03 revset: mark reachablerootspure as private Yuya Nishihara <yuya@tcha.org> parents: 26094 diff changeset	94 def _reachablerootspure(repo, minroot, roots, heads, includepath):
26002 fd92bfbbe02d revset: rename revsbetween to reachableroots and add an argument Laurent Charignon <lcharignon@fb.com> parents: 26001 diff changeset	95 """return (heads(::<roots> and ::<heads>))
fd92bfbbe02d revset: rename revsbetween to reachableroots and add an argument Laurent Charignon <lcharignon@fb.com> parents: 26001 diff changeset	96
fd92bfbbe02d revset: rename revsbetween to reachableroots and add an argument Laurent Charignon <lcharignon@fb.com> parents: 26001 diff changeset	97 If includepath is True, return (<roots>::<heads>)."""
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	98 if not roots:
26094 df41c7be16d6 reachableroots: construct and sort baseset in revset module Yuya Nishihara <yuya@tcha.org> parents: 26093 diff changeset	99 return []
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	100 parentrevs = repo.changelog.parentrevs
26053 b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26006 diff changeset	101 roots = set(roots)
22487 e40bb83d0989 revset: stop using a baseset instead of a plain list in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 22483 diff changeset	102 visit = list(heads)
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	103 reachable = set()
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	104 seen = {}
25566 15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	105 # prefetch all the things! (because python is slow)
15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	106 reached = reachable.add
15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	107 dovisit = visit.append
15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	108 nextvisit = visit.pop
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	109 # open-code the post-order traversal due to the tiny size of
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	110 # sys.getrecursionlimit()
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	111 while visit:
25566 15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	112 rev = nextvisit()
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	113 if rev in roots:
25566 15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	114 reached(rev)
26002 fd92bfbbe02d revset: rename revsbetween to reachableroots and add an argument Laurent Charignon <lcharignon@fb.com> parents: 26001 diff changeset	115 if not includepath:
fd92bfbbe02d revset: rename revsbetween to reachableroots and add an argument Laurent Charignon <lcharignon@fb.com> parents: 26001 diff changeset	116 continue
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	117 parents = parentrevs(rev)
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	118 seen[rev] = parents
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	119 for parent in parents:
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	120 if parent >= minroot and parent not in seen:
25566 15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	121 dovisit(parent)
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	122 if not reachable:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	123 return baseset()
26002 fd92bfbbe02d revset: rename revsbetween to reachableroots and add an argument Laurent Charignon <lcharignon@fb.com> parents: 26001 diff changeset	124 if not includepath:
fd92bfbbe02d revset: rename revsbetween to reachableroots and add an argument Laurent Charignon <lcharignon@fb.com> parents: 26001 diff changeset	125 return reachable
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	126 for rev in sorted(seen):
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	127 for parent in seen[rev]:
b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	128 if parent in reachable:
25566 15412bba5a68 revset: prefetch all attributes before loop in _revsbetween Pierre-Yves David <pierre-yves.david@fb.com> parents: 25554 diff changeset	129 reached(rev)
26091 60bbd4f9abd1 reachableroots: sort the smartset in the pure version too Pierre-Yves David <pierre-yves.david@fb.com> parents: 26060 diff changeset	130 return reachable
16862 b6efeb27e733 revset: introduce and use _revsbetween Bryan O'Sullivan <bryano@fb.com> parents: 16861 diff changeset	131
26006 1ffd97cbf9a2 reachableroots: default to the C implementation Laurent Charignon <lcharignon@fb.com> parents: 26002 diff changeset	132 def reachableroots(repo, roots, heads, includepath=False):
1ffd97cbf9a2 reachableroots: default to the C implementation Laurent Charignon <lcharignon@fb.com> parents: 26002 diff changeset	133 """return (heads(::<roots> and ::<heads>))
1ffd97cbf9a2 reachableroots: default to the C implementation Laurent Charignon <lcharignon@fb.com> parents: 26002 diff changeset	134
1ffd97cbf9a2 reachableroots: default to the C implementation Laurent Charignon <lcharignon@fb.com> parents: 26002 diff changeset	135 If includepath is True, return (<roots>::<heads>)."""
1ffd97cbf9a2 reachableroots: default to the C implementation Laurent Charignon <lcharignon@fb.com> parents: 26002 diff changeset	136 if not roots:
1ffd97cbf9a2 reachableroots: default to the C implementation Laurent Charignon <lcharignon@fb.com> parents: 26002 diff changeset	137 return baseset()
26093 204131131766 reachableroots: use smartset min Pierre-Yves David <pierre-yves.david@fb.com> parents: 26091 diff changeset	138 minroot = roots.min()
26053 b68c9d232db6 reachableroots: use internal "revstates" array to test if rev is a root Yuya Nishihara <yuya@tcha.org> parents: 26006 diff changeset	139 roots = list(roots)
26006 1ffd97cbf9a2 reachableroots: default to the C implementation Laurent Charignon <lcharignon@fb.com> parents: 26002 diff changeset	140 heads = list(heads)
1ffd97cbf9a2 reachableroots: default to the C implementation Laurent Charignon <lcharignon@fb.com> parents: 26002 diff changeset	141 try:
26094 df41c7be16d6 reachableroots: construct and sort baseset in revset module Yuya Nishihara <yuya@tcha.org> parents: 26093 diff changeset	142 revs = repo.changelog.reachableroots(minroot, heads, roots, includepath)
26006 1ffd97cbf9a2 reachableroots: default to the C implementation Laurent Charignon <lcharignon@fb.com> parents: 26002 diff changeset	143 except AttributeError:
26095 6eed95ca4c03 revset: mark reachablerootspure as private Yuya Nishihara <yuya@tcha.org> parents: 26094 diff changeset	144 revs = _reachablerootspure(repo, minroot, roots, heads, includepath)
26094 df41c7be16d6 reachableroots: construct and sort baseset in revset module Yuya Nishihara <yuya@tcha.org> parents: 26093 diff changeset	145 revs = baseset(revs)
df41c7be16d6 reachableroots: construct and sort baseset in revset module Yuya Nishihara <yuya@tcha.org> parents: 26093 diff changeset	146 revs.sort()
df41c7be16d6 reachableroots: construct and sort baseset in revset module Yuya Nishihara <yuya@tcha.org> parents: 26093 diff changeset	147 return revs
26006 1ffd97cbf9a2 reachableroots: default to the C implementation Laurent Charignon <lcharignon@fb.com> parents: 26002 diff changeset	148
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	149 elements = {
25815 e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	150 # token-type: binding-strength, primary, prefix, infix, suffix
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	151 "(": (21, None, ("group", 1, ")"), ("func", 1, ")"), None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	152 "##": (20, None, None, ("_concat", 20), None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	153 "~": (18, None, None, ("ancestor", 18), None),
29778 e5b794063fd4 parser: remove unused binding parameter from suffix action Yuya Nishihara <yuya@tcha.org> parents: 29646 diff changeset	154 "^": (18, None, None, ("parent", 18), "parentpost"),
25815 e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	155 "-": (5, None, ("negate", 19), ("minus", 5), None),
29778 e5b794063fd4 parser: remove unused binding parameter from suffix action Yuya Nishihara <yuya@tcha.org> parents: 29646 diff changeset	156 "::": (17, None, ("dagrangepre", 17), ("dagrange", 17), "dagrangepost"),
e5b794063fd4 parser: remove unused binding parameter from suffix action Yuya Nishihara <yuya@tcha.org> parents: 29646 diff changeset	157 "..": (17, None, ("dagrangepre", 17), ("dagrange", 17), "dagrangepost"),
e5b794063fd4 parser: remove unused binding parameter from suffix action Yuya Nishihara <yuya@tcha.org> parents: 29646 diff changeset	158 ":": (15, "rangeall", ("rangepre", 15), ("range", 15), "rangepost"),
25815 e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	159 "not": (10, None, ("not", 10), None, None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	160 "!": (10, None, ("not", 10), None, None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	161 "and": (5, None, None, ("and", 5), None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	162 "&": (5, None, None, ("and", 5), None),
29778 e5b794063fd4 parser: remove unused binding parameter from suffix action Yuya Nishihara <yuya@tcha.org> parents: 29646 diff changeset	163 "%": (5, None, None, ("only", 5), "onlypost"),
25815 e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	164 "or": (4, None, None, ("or", 4), None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	165 "\|": (4, None, None, ("or", 4), None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	166 "+": (4, None, None, ("or", 4), None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	167 "=": (3, None, None, ("keyvalue", 3), None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	168 ",": (2, None, None, ("list", 2), None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	169 ")": (0, None, None, None, None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	170 "symbol": (0, "symbol", None, None, None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	171 "string": (0, "string", None, None, None),
e71e5629e006 parser: separate actions for primary expression and prefix operator Yuya Nishihara <yuya@tcha.org> parents: 25801 diff changeset	172 "end": (0, None, None, None, None),
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	173 }
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	174
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	175 keywords = set(['and', 'or', 'not'])
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	176
23842 91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	177 # default set of valid characters for the initial letter of symbols
30071 2def3d55b1b9 revset: build _syminitletters from a saner source: the string module Augie Fackler <augie@google.com> parents: 30056 diff changeset	178 _syminitletters = set(
2def3d55b1b9 revset: build _syminitletters from a saner source: the string module Augie Fackler <augie@google.com> parents: 30056 diff changeset	179 string.ascii_letters +
2def3d55b1b9 revset: build _syminitletters from a saner source: the string module Augie Fackler <augie@google.com> parents: 30056 diff changeset	180 string.digits + pycompat.sysstr('._@')) \| set(map(chr, xrange(128, 256)))
23842 91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	181
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	182 # default set of valid characters for non-initial letters of symbols
30071 2def3d55b1b9 revset: build _syminitletters from a saner source: the string module Augie Fackler <augie@google.com> parents: 30056 diff changeset	183 _symletters = _syminitletters \| set(pycompat.sysstr('-/'))
23842 91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	184
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	185 def tokenize(program, lookup=None, syminitletters=None, symletters=None):
17886 d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	186 '''
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	187 Parse a revset statement into a stream of tokens
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	188
23842 91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	189 ``syminitletters`` is the set of valid characters for the initial
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	190 letter of symbols.
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	191
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	192 By default, character ``c`` is recognized as valid for initial
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	193 letter of symbols, if ``c.isalnum() or c in '._@' or ord(c) > 127``.
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	194
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	195 ``symletters`` is the set of valid characters for non-initial
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	196 letters of symbols.
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	197
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	198 By default, character ``c`` is recognized as valid for non-initial
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	199 letters of symbols, if ``c.isalnum() or c in '-._/@' or ord(c) > 127``.
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	200
17886 d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	201 Check that @ is a valid unquoted token character (issue3686):
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	202 >>> list(tokenize("@::"))
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	203 [('symbol', '@', 0), ('::', None, 1), ('end', None, 3)]
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	204
d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	205 '''
23842 91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	206 if syminitletters is None:
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	207 syminitletters = _syminitletters
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	208 if symletters is None:
91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	209 symletters = _symletters
17886 d8905e2c1301 revset: accept @ in unquoted symbols (issue3686) Matt Mackall <mpm@selenic.com> parents: 17829 diff changeset	210
25902 5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	211 if program and lookup:
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	212 # attempt to parse old-style ranges first to deal with
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	213 # things like old-tag which contain query metacharacters
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	214 parts = program.split(':', 1)
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	215 if all(lookup(sym) for sym in parts if sym):
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	216 if parts[0]:
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	217 yield ('symbol', parts[0], 0)
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	218 if len(parts) > 1:
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	219 s = len(parts[0])
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	220 yield (':', None, s)
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	221 if parts[1]:
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	222 yield ('symbol', parts[1], s + 1)
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	223 yield ('end', None, len(program))
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	224 return
5214cbdc37e5 revset: port parsing rule of old-style ranges from scmutil.revrange() Yuya Nishihara <yuya@tcha.org> parents: 25819 diff changeset	225
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	226 pos, l = 0, len(program)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	227 while pos < l:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	228 c = program[pos]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	229 if c.isspace(): # skip inter-token whitespace
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	230 pass
11278 7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	231 elif c == ':' and program[pos:pos + 2] == '::': # look ahead carefully
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	232 yield ('::', None, pos)
11278 7df88cdf47fd revset: add support for prefix and suffix versions of : and :: Matt Mackall <mpm@selenic.com> parents: 11275 diff changeset	233 pos += 1 # skip ahead
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	234 elif c == '.' and program[pos:pos + 2] == '..': # look ahead carefully
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	235 yield ('..', None, pos)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	236 pos += 1 # skip ahead
23742 3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	237 elif c == '#' and program[pos:pos + 2] == '##': # look ahead carefully
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	238 yield ('##', None, pos)
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	239 pos += 1 # skip ahead
25704 70a2082f855a revset: add parsing rule for key=value pair Yuya Nishihara <yuya@tcha.org> parents: 25689 diff changeset	240 elif c in "():=,-\|&+!~^%": # handle simple operators
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	241 yield (c, None, pos)
12408 78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	242 elif (c in '"\'' or c == 'r' and
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	243 program[pos:pos + 2] in ("r'", 'r"')): # handle quoted strings
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	244 if c == 'r':
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	245 pos += 1
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	246 c = program[pos]
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	247 decode = lambda x: x
78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	248 else:
26232 43f9976346e9 revset: handle error of string unescaping Yuya Nishihara <yuya@tcha.org> parents: 26212 diff changeset	249 decode = parser.unescapestr
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	250 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	251 s = pos
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	252 while pos < l: # find closing quote
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	253 d = program[pos]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	254 if d == '\\': # skip over escaped characters
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	255 pos += 2
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	256 continue
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	257 if d == c:
12408 78a97859b90d revset: support raw string literals Brodie Rao <brodie@bitheap.org> parents: 12401 diff changeset	258 yield ('string', decode(program[s:pos]), s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	259 break
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	260 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	261 else:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	262 raise error.ParseError(_("unterminated string"), s)
16683 525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	263 # gather up a symbol/keyword
23842 91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	264 elif c in syminitletters:
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	265 s = pos
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	266 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	267 while pos < l: # find end of symbol
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	268 d = program[pos]
23842 91dbb98b3513 revset: make tokenize extensible to parse alias declarations and definitions FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23836 diff changeset	269 if d not in symletters:
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	270 break
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	271 if d == '.' and program[pos - 1] == '.': # special case for ..
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	272 pos -= 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	273 break
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	274 pos += 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	275 sym = program[s:pos]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	276 if sym in keywords: # operator keywords
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	277 yield (sym, None, s)
20780 403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	278 elif '-' in sym:
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	279 # some jerk gave us foo-bar-baz, try to check if it's a symbol
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	280 if lookup and lookup(sym):
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	281 # looks like a real symbol
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	282 yield ('symbol', sym, s)
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	283 else:
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	284 # looks like an expression
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	285 parts = sym.split('-')
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	286 for p in parts[:-1]:
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	287 if p: # possible consecutive -
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	288 yield ('symbol', p, s)
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	289 s += len(p)
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	290 yield ('-', None, pos)
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	291 s += 1
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	292 if parts[-1]: # possible trailing -
403f1f73d30f revset: try to handle hyphenated symbols if lookup callback is available Matt Mackall <mpm@selenic.com> parents: 20779 diff changeset	293 yield ('symbol', parts[-1], s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	294 else:
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	295 yield ('symbol', sym, s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	296 pos -= 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	297 else:
24708 fb47816e1a9c revsets: more informative syntax error message Ryan McElroy <rmcelroy@fb.com> parents: 24518 diff changeset	298 raise error.ParseError(_("syntax error in revset '%s'") %
fb47816e1a9c revsets: more informative syntax error message Ryan McElroy <rmcelroy@fb.com> parents: 24518 diff changeset	299 program, pos)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	300 pos += 1
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	301 yield ('end', None, pos)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	302
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	303 # helpers
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	304
29441 9e8d258708bb revset: check invalid function syntax "func-name"() explicitly Yuya Nishihara <yuya@tcha.org> parents: 29425 diff changeset	305 def getsymbol(x):
9e8d258708bb revset: check invalid function syntax "func-name"() explicitly Yuya Nishihara <yuya@tcha.org> parents: 29425 diff changeset	306 if x and x[0] == 'symbol':
9e8d258708bb revset: check invalid function syntax "func-name"() explicitly Yuya Nishihara <yuya@tcha.org> parents: 29425 diff changeset	307 return x[1]
9e8d258708bb revset: check invalid function syntax "func-name"() explicitly Yuya Nishihara <yuya@tcha.org> parents: 29425 diff changeset	308 raise error.ParseError(_('not a symbol'))
9e8d258708bb revset: check invalid function syntax "func-name"() explicitly Yuya Nishihara <yuya@tcha.org> parents: 29425 diff changeset	309
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	310 def getstring(x, err):
11406 42408cd43f55 revset: fix up contains/getstring when no args passed Matt Mackall <mpm@selenic.com> parents: 11404 diff changeset	311 if x and (x[0] == 'string' or x[0] == 'symbol'):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	312 return x[1]
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	313 raise error.ParseError(err)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	314
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	315 def getlist(x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	316 if not x:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	317 return []
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	318 if x[0] == 'list':
27987 b19d8d5d6b51 revset: flatten chained 'list' operations (aka function args) (issue5072) Yuya Nishihara <yuya@tcha.org> parents: 27945 diff changeset	319 return list(x[1:])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	320 return [x]
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	321
11339 744d5b73f776 revset: improve filter argument handling Matt Mackall <mpm@selenic.com> parents: 11304 diff changeset	322 def getargs(x, min, max, err):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	323 l = getlist(x)
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	324 if len(l) < min or (max >= 0 and len(l) > max):
11289 4215ce511134 revset: raise ParseError exceptions Matt Mackall <mpm@selenic.com> parents: 11284 diff changeset	325 raise error.ParseError(err)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	326 return l
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	327
25767 026105c442d7 revset: rename getkwargs() to getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 25766 diff changeset	328 def getargsdict(x, funcname, keys):
30753 c3a3896a9fa8 parser: extend buildargsdict() to support variable-length positional args Yuya Nishihara <yuya@tcha.org> parents: 30719 diff changeset	329 return parser.buildargsdict(getlist(x), funcname, parser.splitargspec(keys),
25705 48919d246a47 revset: add function to build dict of positional and keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25704 diff changeset	330 keyvaluenode='keyvalue', keynode='symbol')
48919d246a47 revset: add function to build dict of positional and keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25704 diff changeset	331
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	332 def getset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	333 if not x:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	334 raise error.ParseError(_("missing argument"))
20527 bde426f18e0a revset: changed mfunc and getset to work with old style revset methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20526 diff changeset	335 s = methods[x[0]](repo, subset, *x[1:])
22884 4584eec9aead getset: check if an object is a baseset using `isascending` instead of `set` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22883 diff changeset	336 if util.safehasattr(s, 'isascending'):
20527 bde426f18e0a revset: changed mfunc and getset to work with old style revset methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20526 diff changeset	337 return s
29098 2822e9a5263b devel: use the new 'config' argument for the revset develwarn Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29074 diff changeset	338 # else case should not happen, because all non-func are internal,
2822e9a5263b devel: use the new 'config' argument for the revset develwarn Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29074 diff changeset	339 # ignoring for now.
2822e9a5263b devel: use the new 'config' argument for the revset develwarn Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29074 diff changeset	340 if x[0] == 'func' and x[1][0] == 'symbol' and x[1][1] in symbols:
29147 ff07da10de4c devel: fix a typo in a deprecation warning Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29146 diff changeset	341 repo.ui.deprecwarn('revset "%s" uses list instead of smartset'
29146 b175d9cc3ee8 devel: officially deprecate old style revset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29139 diff changeset	342 % x[1][1],
b175d9cc3ee8 devel: officially deprecate old style revset Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 29139 diff changeset	343 '3.9')
20527 bde426f18e0a revset: changed mfunc and getset to work with old style revset methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20526 diff changeset	344 return baseset(s)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	345
17003 42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	346 def _getrevsource(repo, r):
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	347 extra = repo[r].extra()
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	348 for label in ('source', 'transplant_source', 'rebase_source'):
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	349 if label in extra:
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	350 try:
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	351 return repo[extra[label]].rev()
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	352 except error.RepoLookupError:
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	353 pass
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	354 return None
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	355
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	356 # operator methods
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	357
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	358 def stringset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	359 x = repo[x].rev()
25265 e16456831516 revset: drop magic of fullreposet membership test (issue4682) Yuya Nishihara <yuya@tcha.org> parents: 25094 diff changeset	360 if (x in subset
e16456831516 revset: drop magic of fullreposet membership test (issue4682) Yuya Nishihara <yuya@tcha.org> parents: 25094 diff changeset	361 or x == node.nullrev and isinstance(subset, fullreposet)):
20364 a6cf48b2880d revset: added baseset class (still empty) to improve revset performance Lucas Moscovicz <lmoscovicz@fb.com> parents: 20289 diff changeset	362 return baseset([x])
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	363 return baseset()
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	364
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	365 def rangeset(repo, subset, x, y, order):
23162 69524a05a7fa revset-rangeset: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23139 diff changeset	366 m = getset(repo, fullreposet(repo), x)
69524a05a7fa revset-rangeset: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23139 diff changeset	367 n = getset(repo, fullreposet(repo), y)
11456 88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	368
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	369 if not m or not n:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	370 return baseset()
30043 49d5434d68fb revset: extract function that creates range set from computed revisions Yuya Nishihara <yuya@tcha.org> parents: 29959 diff changeset	371 return _makerangeset(repo, subset, m.first(), n.last(), order)
49d5434d68fb revset: extract function that creates range set from computed revisions Yuya Nishihara <yuya@tcha.org> parents: 29959 diff changeset	372
30044 69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	373 def rangepre(repo, subset, y, order):
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	374 # ':y' can't be rewritten to '0:y' since '0' may be hidden
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	375 n = getset(repo, fullreposet(repo), y)
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	376 if not n:
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	377 return baseset()
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	378 return _makerangeset(repo, subset, 0, n.last(), order)
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	379
30043 49d5434d68fb revset: extract function that creates range set from computed revisions Yuya Nishihara <yuya@tcha.org> parents: 29959 diff changeset	380 def _makerangeset(repo, subset, m, n, order):
25766 d51dac68ec98 revset: work around x:y range where x or y is wdir() Yuya Nishihara <yuya@tcha.org> parents: 25765 diff changeset	381 if m == n:
d51dac68ec98 revset: work around x:y range where x or y is wdir() Yuya Nishihara <yuya@tcha.org> parents: 25765 diff changeset	382 r = baseset([m])
d51dac68ec98 revset: work around x:y range where x or y is wdir() Yuya Nishihara <yuya@tcha.org> parents: 25765 diff changeset	383 elif n == node.wdirrev:
d51dac68ec98 revset: work around x:y range where x or y is wdir() Yuya Nishihara <yuya@tcha.org> parents: 25765 diff changeset	384 r = spanset(repo, m, len(repo)) + baseset([n])
d51dac68ec98 revset: work around x:y range where x or y is wdir() Yuya Nishihara <yuya@tcha.org> parents: 25765 diff changeset	385 elif m == node.wdirrev:
d51dac68ec98 revset: work around x:y range where x or y is wdir() Yuya Nishihara <yuya@tcha.org> parents: 25765 diff changeset	386 r = baseset([m]) + spanset(repo, len(repo) - 1, n - 1)
d51dac68ec98 revset: work around x:y range where x or y is wdir() Yuya Nishihara <yuya@tcha.org> parents: 25765 diff changeset	387 elif m < n:
20526 9ad6dae67845 revset: changed revsets to use spanset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20525 diff changeset	388 r = spanset(repo, m, n + 1)
11456 88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	389 else:
20526 9ad6dae67845 revset: changed revsets to use spanset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20525 diff changeset	390 r = spanset(repo, m, n - 1)
29948 5f56a3b9675e revset: fix order of nested 'range' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29947 diff changeset	391
5f56a3b9675e revset: fix order of nested 'range' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29947 diff changeset	392 if order == defineorder:
5f56a3b9675e revset: fix order of nested 'range' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29947 diff changeset	393 return r & subset
5f56a3b9675e revset: fix order of nested 'range' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29947 diff changeset	394 else:
5f56a3b9675e revset: fix order of nested 'range' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29947 diff changeset	395 # carrying the sorting over when possible would be more efficient
5f56a3b9675e revset: fix order of nested 'range' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29947 diff changeset	396 return subset & r
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	397
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	398 def dagrange(repo, subset, x, y, order):
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	399 r = fullreposet(repo)
26002 fd92bfbbe02d revset: rename revsbetween to reachableroots and add an argument Laurent Charignon <lcharignon@fb.com> parents: 26001 diff changeset	400 xs = reachableroots(repo, getset(repo, r, x), getset(repo, r, y),
fd92bfbbe02d revset: rename revsbetween to reachableroots and add an argument Laurent Charignon <lcharignon@fb.com> parents: 26001 diff changeset	401 includepath=True)
29139 64c1955a0461 revset: make dagrange preserve order of input set Yuya Nishihara <yuya@tcha.org> parents: 29119 diff changeset	402 return subset & xs
16860 e1aa1ed30030 revset: turn dagrange into a function Bryan O'Sullivan <bryano@fb.com> parents: 16859 diff changeset	403
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	404 def andset(repo, subset, x, y, order):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	405 return getset(repo, getset(repo, subset, x), y)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	406
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	407 def differenceset(repo, subset, x, y, order):
28217 d2ac8b57a75d revset: use smartset minus operator Durham Goode <durham@fb.com> parents: 28139 diff changeset	408 return getset(repo, subset, x) - getset(repo, subset, y)
d2ac8b57a75d revset: use smartset minus operator Durham Goode <durham@fb.com> parents: 28139 diff changeset	409
29933 b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	410 def _orsetlist(repo, subset, xs):
25929 289149111d46 revset: make balanced addsets by orset() without using _combinesets() Yuya Nishihara <yuya@tcha.org> parents: 25927 diff changeset	411 assert xs
289149111d46 revset: make balanced addsets by orset() without using _combinesets() Yuya Nishihara <yuya@tcha.org> parents: 25927 diff changeset	412 if len(xs) == 1:
289149111d46 revset: make balanced addsets by orset() without using _combinesets() Yuya Nishihara <yuya@tcha.org> parents: 25927 diff changeset	413 return getset(repo, subset, xs[0])
289149111d46 revset: make balanced addsets by orset() without using _combinesets() Yuya Nishihara <yuya@tcha.org> parents: 25927 diff changeset	414 p = len(xs) // 2
29933 b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	415 a = _orsetlist(repo, subset, xs[:p])
b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	416 b = _orsetlist(repo, subset, xs[p:])
25929 289149111d46 revset: make balanced addsets by orset() without using _combinesets() Yuya Nishihara <yuya@tcha.org> parents: 25927 diff changeset	417 return a + b
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	418
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	419 def orset(repo, subset, x, order):
29938 2c6a05b938d8 revset: fix order of nested 'or' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29937 diff changeset	420 xs = getlist(x)
2c6a05b938d8 revset: fix order of nested 'or' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29937 diff changeset	421 if order == followorder:
2c6a05b938d8 revset: fix order of nested 'or' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29937 diff changeset	422 # slow path to take the subset order
2c6a05b938d8 revset: fix order of nested 'or' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29937 diff changeset	423 return subset & _orsetlist(repo, fullreposet(repo), xs)
2c6a05b938d8 revset: fix order of nested 'or' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29937 diff changeset	424 else:
2c6a05b938d8 revset: fix order of nested 'or' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29937 diff changeset	425 return _orsetlist(repo, subset, xs)
29933 b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	426
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	427 def notset(repo, subset, x, order):
20366 5ec6321f49a9 revset: added substraction to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20365 diff changeset	428 return subset - getset(repo, subset, x)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	429
27987 b19d8d5d6b51 revset: flatten chained 'list' operations (aka function args) (issue5072) Yuya Nishihara <yuya@tcha.org> parents: 27945 diff changeset	430 def listset(repo, subset, *xs):
27517 c60a9c16ae25 revset: add hint for list error to use or timeless <timeless@mozdev.org> parents: 27440 diff changeset	431 raise error.ParseError(_("can't use a list in this context"),
c60a9c16ae25 revset: add hint for list error to use or timeless <timeless@mozdev.org> parents: 27440 diff changeset	432 hint=_('see hg help "revsets.x or y"'))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	433
25704 70a2082f855a revset: add parsing rule for key=value pair Yuya Nishihara <yuya@tcha.org> parents: 25689 diff changeset	434 def keyvaluepair(repo, subset, k, v):
70a2082f855a revset: add parsing rule for key=value pair Yuya Nishihara <yuya@tcha.org> parents: 25689 diff changeset	435 raise error.ParseError(_("can't use a key-value pair in this context"))
70a2082f855a revset: add parsing rule for key=value pair Yuya Nishihara <yuya@tcha.org> parents: 25689 diff changeset	436
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	437 def func(repo, subset, a, b, order):
29441 9e8d258708bb revset: check invalid function syntax "func-name"() explicitly Yuya Nishihara <yuya@tcha.org> parents: 29425 diff changeset	438 f = getsymbol(a)
9e8d258708bb revset: check invalid function syntax "func-name"() explicitly Yuya Nishihara <yuya@tcha.org> parents: 29425 diff changeset	439 if f in symbols:
30402 155d7ea98085 revset: avoid shadowing a variable with a list comprehension Augie Fackler <augie@google.com> parents: 30342 diff changeset	440 func = symbols[f]
155d7ea98085 revset: avoid shadowing a variable with a list comprehension Augie Fackler <augie@google.com> parents: 30342 diff changeset	441 if getattr(func, '_takeorder', False):
155d7ea98085 revset: avoid shadowing a variable with a list comprehension Augie Fackler <augie@google.com> parents: 30342 diff changeset	442 return func(repo, subset, b, order)
155d7ea98085 revset: avoid shadowing a variable with a list comprehension Augie Fackler <augie@google.com> parents: 30342 diff changeset	443 return func(repo, subset, b)
25632 015c0d1087a3 revset: don't suggest private or undocumented queries Matt Harbison <matt_harbison@yahoo.com> parents: 25630 diff changeset	444
015c0d1087a3 revset: don't suggest private or undocumented queries Matt Harbison <matt_harbison@yahoo.com> parents: 25630 diff changeset	445 keep = lambda fn: getattr(fn, '__doc__', None) is not None
015c0d1087a3 revset: don't suggest private or undocumented queries Matt Harbison <matt_harbison@yahoo.com> parents: 25630 diff changeset	446
015c0d1087a3 revset: don't suggest private or undocumented queries Matt Harbison <matt_harbison@yahoo.com> parents: 25630 diff changeset	447 syms = [s for (s, fn) in symbols.items() if keep(fn)]
29441 9e8d258708bb revset: check invalid function syntax "func-name"() explicitly Yuya Nishihara <yuya@tcha.org> parents: 29425 diff changeset	448 raise error.UnknownIdentifier(f, syms)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	449
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	450 # functions
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	451
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	452 # symbols are callables like:
fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	453 # fn(repo, subset, x)
fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	454 # with:
fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	455 # repo - current repository instance
fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	456 # subset - of revisions to be examined
fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	457 # x - argument in tree form
fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	458 symbols = {}
fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	459
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	460 # symbols which can't be used for a DoS attack for any given input
c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	461 # (e.g. those which accept regexes as plain strings shouldn't be included)
c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	462 # functions that just return a lot of changesets (like all) don't count here
c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	463 safesymbols = set()
c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	464
28395 0383f7a5e86c revset: replace predicate by revsetpredicate of registrar FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28393 diff changeset	465 predicate = registrar.revsetpredicate()
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	466
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	467 @predicate('_destupdate')
26713 a271925699d6 revset: reintroduce and experimental revset for update destination Pierre-Yves David <pierre-yves.david@fb.com> parents: 26638 diff changeset	468 def _destupdate(repo, subset, x):
a271925699d6 revset: reintroduce and experimental revset for update destination Pierre-Yves David <pierre-yves.david@fb.com> parents: 26638 diff changeset	469 # experimental revset for update destination
a271925699d6 revset: reintroduce and experimental revset for update destination Pierre-Yves David <pierre-yves.david@fb.com> parents: 26638 diff changeset	470 args = getargsdict(x, 'limit', 'clean check')
a271925699d6 revset: reintroduce and experimental revset for update destination Pierre-Yves David <pierre-yves.david@fb.com> parents: 26638 diff changeset	471 return subset & baseset([destutil.destupdate(repo, **args)[0]])
a271925699d6 revset: reintroduce and experimental revset for update destination Pierre-Yves David <pierre-yves.david@fb.com> parents: 26638 diff changeset	472
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	473 @predicate('_destmerge')
26716 c027641f8a83 revset: rename and test '_destmerge' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26714 diff changeset	474 def _destmerge(repo, subset, x):
c027641f8a83 revset: rename and test '_destmerge' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26714 diff changeset	475 # experimental revset for merge destination
28139 5476a7a039c0 destutil: allow to specify an explicit source for the merge Pierre-Yves David <pierre-yves.david@fb.com> parents: 28015 diff changeset	476 sourceset = None
5476a7a039c0 destutil: allow to specify an explicit source for the merge Pierre-Yves David <pierre-yves.david@fb.com> parents: 28015 diff changeset	477 if x is not None:
5476a7a039c0 destutil: allow to specify an explicit source for the merge Pierre-Yves David <pierre-yves.david@fb.com> parents: 28015 diff changeset	478 sourceset = getset(repo, fullreposet(repo), x)
5476a7a039c0 destutil: allow to specify an explicit source for the merge Pierre-Yves David <pierre-yves.david@fb.com> parents: 28015 diff changeset	479 return subset & baseset([destutil.destmerge(repo, sourceset=sourceset)])
26303 c99b4d6efdd8 merge: move default destination computation in a revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 26232 diff changeset	480
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	481 @predicate('adds(pattern)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	482 def adds(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	483 """Changesets that add a file matching pattern.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	484
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	485 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	486 relative to the current directory and match against a file or a
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	487 directory.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	488 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	489 # i18n: "adds" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	490 pat = getstring(x, _("adds requires a pattern"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	491 return checkstatus(repo, subset, pat, 1)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	492
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	493 @predicate('ancestor(*changeset)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	494 def ancestor(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	495 """A greatest common ancestor of the changesets.
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	496
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	497 Accepts 0 or more changesets.
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	498 Will return empty list when passed no args.
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	499 Greatest common ancestor of a single changeset is that changeset.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	500 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	501 # i18n: "ancestor" is a keyword
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	502 l = getlist(x)
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	503 rl = fullreposet(repo)
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	504 anc = None
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	505
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	506 # (getset(repo, rl, i) for i in l) generates a list of lists
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	507 for revs in (getset(repo, rl, i) for i in l):
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	508 for r in revs:
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	509 if anc is None:
20991 a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	510 anc = repo[r]
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	511 else:
20991 a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	512 anc = anc.ancestor(repo[r])
a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	513
a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	514 if anc is not None and anc.rev() in subset:
a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	515 return baseset([anc.rev()])
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	516 return baseset()
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	517
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	518 def _ancestors(repo, subset, x, followfirst=False):
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	519 heads = getset(repo, fullreposet(repo), x)
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	520 if not heads:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	521 return baseset()
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	522 s = _revancestors(repo, heads, followfirst)
23003 62d19ce9d7b6 revset-_ancestor: use & instead of filter Pierre-Yves David <pierre-yves.david@fb.com> parents: 22999 diff changeset	523 return subset & s
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	524
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	525 @predicate('ancestors(set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	526 def ancestors(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	527 """Changesets that are ancestors of a changeset in set.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	528 """
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	529 return _ancestors(repo, subset, x)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	530
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	531 @predicate('_firstancestors', safe=True)
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	532 def _firstancestors(repo, subset, x):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	533 # ``_firstancestors(set)``
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	534 # Like ``ancestors(set)`` but follows only the first parents.
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	535 return _ancestors(repo, subset, x, followfirst=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	536
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	537 def ancestorspec(repo, subset, x, n, order):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	538 """``set~n``
16683 525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	539 Changesets that are the Nth ancestor (first parents only) of a changeset
525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	540 in set.
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	541 """
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	542 try:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	543 n = int(n[1])
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	544 except (TypeError, ValueError):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	545 raise error.ParseError(_("~ expects a number"))
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	546 ps = set()
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	547 cl = repo.changelog
23163 6f1b8b3f12fd revset-ancestorspec: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23162 diff changeset	548 for r in getset(repo, fullreposet(repo), x):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	549 for i in range(n):
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	550 r = cl.parentrevs(r)[0]
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	551 ps.add(r)
22531 22ba2c0825da revset: use `subset &` in `ancestorspec` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22530 diff changeset	552 return subset & ps
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	553
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	554 @predicate('author(string)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	555 def author(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	556 """Alias for ``user(string)``.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	557 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	558 # i18n: "author" is a keyword
30782 db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	559 n = getstring(x, _("author requires a string"))
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	560 kind, pattern, matcher = _substringmatcher(n, casesensitive=False)
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	561 return subset.filter(lambda x: matcher(repo[x].user()),
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	562 condrepr=('<user %r>', n))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	563
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	564 @predicate('bisect(string)', safe=True)
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	565 def bisect(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	566 """Changesets marked in the specified bisect status:
15136 18219c0789ae revset.bisect: add new 'range' set to the bisect keyword "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15135 diff changeset	567
15153 fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	568 - ``good``, ``bad``, ``skip``: csets explicitly marked as good/bad/skip
17424 e7cfe3587ea4 fix trivial spelling errors Mads Kiilerich <mads@kiilerich.com> parents: 17390 diff changeset	569 - ``goods``, ``bads`` : csets topologically good/bad
15153 fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	570 - ``range`` : csets taking part in the bisection
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	571 - ``pruned`` : csets that are goods, bads or skipped
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	572 - ``untested`` : csets whose fate is yet unknown
fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	573 - ``ignored`` : csets ignored due to DAG topology
16647 14913fcb30c6 bisect: track the current changeset (issue3382) Bryan O'Sullivan <bryano@fb.com> parents: 16640 diff changeset	574 - ``current`` : the cset currently being bisected
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	575 """
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	576 # i18n: "bisect" is a keyword
15135 f19de58af225 revset.bisect: move bisect() code to hbisect.py "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15134 diff changeset	577 status = getstring(x, _("bisect requires a string")).lower()
16467 7f59900e3f8b revset: fix O(n*2) behaviour of bisect() (issue3381) Bryan O'Sullivan <bryano@fb.com>* parents: 16453 diff changeset	578 state = set(hbisect.get(repo, status))
22532 0cf46b8298fe revset: use `subset &` in `bisect` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22531 diff changeset	579 return subset & state
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	580
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	581 # Backward-compatibility
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	582 # - no help entry so that we do not advertise it any more
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	583 @predicate('bisected', safe=True)
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	584 def bisected(repo, subset, x):
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	585 return bisect(repo, subset, x)
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	586
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	587 @predicate('bookmark([name])', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	588 def bookmark(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	589 """The named bookmark or all bookmarks.
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	590
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	591 If `name` starts with `re:`, the remainder of the name is treated as
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	592 a regular expression. To match a bookmark that actually starts with `re:`,
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	593 use the prefix `literal:`.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	594 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	595 # i18n: "bookmark" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	596 args = getargs(x, 0, 1, _('bookmark takes one or no arguments'))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	597 if args:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	598 bm = getstring(args[0],
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	599 # i18n: "bookmark" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	600 _('the argument to bookmark must be a string'))
26481 7d132557e44a util: extract stringmatcher() from revset Matt Harbison <matt_harbison@yahoo.com> parents: 26307 diff changeset	601 kind, pattern, matcher = util.stringmatcher(bm)
22499 8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	602 bms = set()
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	603 if kind == 'literal':
22105 3efe3c2609e0 revset: bookmark revset interprets 'literal:' prefix correctly (issue4329) Michael O'Connor <mkoconnor@gmail.com> parents: 21939 diff changeset	604 bmrev = repo._bookmarks.get(pattern, None)
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	605 if not bmrev:
23978 eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	606 raise error.RepoLookupError(_("bookmark '%s' does not exist")
26538 5c9ec1cc671a revset: strip off "literal:" prefix from bookmark not found error Yuya Nishihara <yuya@tcha.org> parents: 26537 diff changeset	607 % pattern)
22499 8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	608 bms.add(repo[bmrev].rev())
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	609 else:
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	610 matchrevs = set()
18495 8260fa9f30b9 bookmarks: don't use bookmarks.listbookmarks in local computations Kevin Bullock <kbullock@ringworld.org> parents: 18473 diff changeset	611 for name, bmrev in repo._bookmarks.iteritems():
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	612 if matcher(name):
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	613 matchrevs.add(bmrev)
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	614 if not matchrevs:
23978 eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	615 raise error.RepoLookupError(_("no bookmarks exist"
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	616 " that match '%s'") % pattern)
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	617 for bmrev in matchrevs:
22499 8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	618 bms.add(repo[bmrev].rev())
8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	619 else:
8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	620 bms = set([repo[r].rev()
8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	621 for r in repo._bookmarks.values()])
22500 171015d3b30c revset: remove nullrev from the bookmark computation Pierre-Yves David <pierre-yves.david@fb.com> parents: 22499 diff changeset	622 bms -= set([node.nullrev])
22530 faf4f63533ff revset: use `subset &` in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22529 diff changeset	623 return subset & bms
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	624
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	625 @predicate('branch(string or set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	626 def branch(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	627 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	628 All changesets belonging to the given branch or the branches of the given
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	629 changesets.
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	630
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	631 If `string` starts with `re:`, the remainder of the name is treated as
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	632 a regular expression. To match a branch that actually starts with `re:`,
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	633 use the prefix `literal:`.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	634 """
24374 77fd1fb538cd revbranchcache: store repo on the object Durham Goode <durham@fb.com> parents: 24366 diff changeset	635 getbi = repo.revbranchcache().branchinfo
23787 678f53865c68 revset: use localrepo revbranchcache for branch name filtering Mads Kiilerich <madski@unity3d.com> parents: 23765 diff changeset	636
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	637 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	638 b = getstring(x, '')
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	639 except error.ParseError:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	640 # not a string, but another revspec, e.g. tip()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	641 pass
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	642 else:
26481 7d132557e44a util: extract stringmatcher() from revset Matt Harbison <matt_harbison@yahoo.com> parents: 26307 diff changeset	643 kind, pattern, matcher = util.stringmatcher(b)
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	644 if kind == 'literal':
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	645 # note: falls through to the revspec case if no branch with
26537 832feae7c986 revset: do not fall through to revspec for literal: branch (issue4838) Yuya Nishihara <yuya@tcha.org> parents: 26481 diff changeset	646 # this name exists and pattern kind is not specified explicitly
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	647 if pattern in repo.branchmap():
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	648 return subset.filter(lambda r: matcher(getbi(r)[0]),
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	649 condrepr=('<branch %r>', b))
26537 832feae7c986 revset: do not fall through to revspec for literal: branch (issue4838) Yuya Nishihara <yuya@tcha.org> parents: 26481 diff changeset	650 if b.startswith('literal:'):
832feae7c986 revset: do not fall through to revspec for literal: branch (issue4838) Yuya Nishihara <yuya@tcha.org> parents: 26481 diff changeset	651 raise error.RepoLookupError(_("branch '%s' does not exist")
832feae7c986 revset: do not fall through to revspec for literal: branch (issue4838) Yuya Nishihara <yuya@tcha.org> parents: 26481 diff changeset	652 % pattern)
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	653 else:
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	654 return subset.filter(lambda r: matcher(getbi(r)[0]),
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	655 condrepr=('<branch %r>', b))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	656
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	657 s = getset(repo, fullreposet(repo), x)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	658 b = set()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	659 for r in s:
24374 77fd1fb538cd revbranchcache: store repo on the object Durham Goode <durham@fb.com> parents: 24366 diff changeset	660 b.add(getbi(r)[0])
22867 5ee9b78ce805 revset-branch: remove usage of `set()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22866 diff changeset	661 c = s.__contains__
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	662 return subset.filter(lambda r: c(r) or getbi(r)[0] in b,
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	663 condrepr=lambda: '<branch %r>' % sorted(b))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	664
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	665 @predicate('bumped()', safe=True)
17829 c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	666 def bumped(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	667 """Mutable changesets marked as successors of public changesets.
17829 c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	668
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	669 Only non-public and non-obsolete changesets can be `bumped`.
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	670 """
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	671 # i18n: "bumped" is a keyword
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	672 getargs(x, 0, 0, _("bumped takes no arguments"))
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	673 bumped = obsmod.getrevs(repo, 'bumped')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	674 return subset & bumped
17829 c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	675
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	676 @predicate('bundle()', safe=True)
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	677 def bundle(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	678 """Changesets in the bundle.
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	679
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	680 Bundle must be specified by the -R option."""
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	681
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	682 try:
18411 8b0f0dd56cec bundlerepo: improve performance for bundle() revset expression Mads Kiilerich <madski@unity3d.com> parents: 18382 diff changeset	683 bundlerevs = repo.changelog.bundlerevs
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	684 except AttributeError:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26571 diff changeset	685 raise error.Abort(_("no bundle provided - specify with -R"))
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	686 return subset & bundlerevs
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	687
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	688 def checkstatus(repo, subset, pat, field):
16521 592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	689 hasset = matchmod.patkind(pat) == 'set'
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	690
23115 c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	691 mcache = [None]
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	692 def matches(x):
ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	693 c = repo[x]
23115 c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	694 if not mcache[0] or hasset:
c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	695 mcache[0] = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	696 m = mcache[0]
c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	697 fname = None
c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	698 if not m.anypats() and len(m.files()) == 1:
c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	699 fname = m.files()[0]
16521 592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	700 if fname is not None:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	701 if fname not in c.files():
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	702 return False
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	703 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	704 for f in c.files():
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	705 if m(f):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	706 break
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	707 else:
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	708 return False
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	709 files = repo.status(c.p1().node(), c.node())[field]
16521 592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	710 if fname is not None:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	711 if fname in files:
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	712 return True
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	713 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	714 for f in files:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	715 if m(f):
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	716 return True
ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	717
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	718 return subset.filter(matches, condrepr=('<status[%r] %r>', field, pat))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	719
29406 c2193e59ef9f revsets: passing a set to baseset() is not wrong Martin von Zweigbergk <martinvonz@google.com> parents: 29389 diff changeset	720 def _children(repo, subset, parentset):
25550 3e9049876ace revset: gratuitous code move in '_children' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25549 diff changeset	721 if not parentset:
3e9049876ace revset: gratuitous code move in '_children' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25549 diff changeset	722 return baseset()
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	723 cs = set()
476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	724 pr = repo.changelog.parentrevs
25567 f140d6207cca revset: use parentsets.min in _children Pierre-Yves David <pierre-yves.david@fb.com> parents: 25566 diff changeset	725 minrev = parentset.min()
30699 5bda147c3139 revset: make children() not look at p2 if null (issue5439) Yuya Nishihara <yuya@tcha.org> parents: 30402 diff changeset	726 nullrev = node.nullrev
29406 c2193e59ef9f revsets: passing a set to baseset() is not wrong Martin von Zweigbergk <martinvonz@google.com> parents: 29389 diff changeset	727 for r in subset:
18063 34a1a639d835 revset.children: ignore rev numbers that are too low Siddharth Agarwal <sid0@fb.com> parents: 17980 diff changeset	728 if r <= minrev:
34a1a639d835 revset.children: ignore rev numbers that are too low Siddharth Agarwal <sid0@fb.com> parents: 17980 diff changeset	729 continue
30699 5bda147c3139 revset: make children() not look at p2 if null (issue5439) Yuya Nishihara <yuya@tcha.org> parents: 30402 diff changeset	730 p1, p2 = pr(r)
5bda147c3139 revset: make children() not look at p2 if null (issue5439) Yuya Nishihara <yuya@tcha.org> parents: 30402 diff changeset	731 if p1 in parentset:
5bda147c3139 revset: make children() not look at p2 if null (issue5439) Yuya Nishihara <yuya@tcha.org> parents: 30402 diff changeset	732 cs.add(r)
5bda147c3139 revset: make children() not look at p2 if null (issue5439) Yuya Nishihara <yuya@tcha.org> parents: 30402 diff changeset	733 if p2 != nullrev and p2 in parentset:
5bda147c3139 revset: make children() not look at p2 if null (issue5439) Yuya Nishihara <yuya@tcha.org> parents: 30402 diff changeset	734 cs.add(r)
20709 71df845d86cf revsets: backout d04aac468bf4 due to performance regressions Matt Mackall <mpm@selenic.com> parents: 20708 diff changeset	735 return baseset(cs)
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	736
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	737 @predicate('children(set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	738 def children(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	739 """Child changesets of changesets in set.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	740 """
23164 7a42e5d4c418 revset-children: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23163 diff changeset	741 s = getset(repo, fullreposet(repo), x)
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	742 cs = _children(repo, subset, s)
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	743 return subset & cs
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	744
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	745 @predicate('closed()', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	746 def closed(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	747 """Changeset is closed.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	748 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	749 # i18n: "closed" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	750 getargs(x, 0, 0, _("closed takes no arguments"))
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	751 return subset.filter(lambda r: repo[r].closesbranch(),
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	752 condrepr='<branch closed>')
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	753
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	754 @predicate('contains(pattern)')
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	755 def contains(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	756 """The revision's manifest contains a file matching pattern (but might not
21199 e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog` Greg Hurrell <glh@fb.com> parents: 21173 diff changeset	757 modify it). See :hg:`help patterns` for information about file patterns.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	758
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	759 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	760 relative to the current directory and match against a file exactly
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	761 for efficiency.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	762 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	763 # i18n: "contains" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	764 pat = getstring(x, _("contains requires a pattern"))
20461 abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	765
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	766 def matches(x):
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	767 if not matchmod.patkind(pat):
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	768 pats = pathutil.canonpath(repo.root, repo.getcwd(), pat)
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	769 if pats in repo[x]:
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	770 return True
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	771 else:
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	772 c = repo[x]
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	773 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=c)
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	774 for f in c.manifest():
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	775 if m(f):
20461 abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	776 return True
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	777 return False
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	778
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	779 return subset.filter(matches, condrepr=('<contains %r>', pat))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	780
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	781 @predicate('converted([id])', safe=True)
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	782 def converted(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	783 """Changesets converted from the given identifier in the old repository if
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	784 present, or all converted changesets if no identifier is specified.
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	785 """
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	786
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	787 # There is exactly no chance of resolving the revision, so do a simple
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	788 # string compare and hope for the best
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	789
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	790 rev = None
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	791 # i18n: "converted" is a keyword
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	792 l = getargs(x, 0, 1, _('converted takes one or no arguments'))
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	793 if l:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	794 # i18n: "converted" is a keyword
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	795 rev = getstring(l[0], _('converted requires a revision'))
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	796
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	797 def _matchvalue(r):
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	798 source = repo[r].extra().get('convert_revision', None)
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	799 return source is not None and (rev is None or source.startswith(rev))
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	800
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	801 return subset.filter(lambda r: _matchvalue(r),
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	802 condrepr=('<converted %r>', rev))
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	803
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	804 @predicate('date(interval)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	805 def date(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	806 """Changesets within the interval, see :hg:`help dates`.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	807 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	808 # i18n: "date" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	809 ds = getstring(x, _("date requires a string"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	810 dm = util.matchdate(ds)
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	811 return subset.filter(lambda x: dm(repo[x].date()[0]),
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	812 condrepr=('<date %r>', ds))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	813
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	814 @predicate('desc(string)', safe=True)
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	815 def desc(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	816 """Search commit message for string. The match is case-insensitive.
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	817 """
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	818 # i18n: "desc" is a keyword
15726 9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	819 ds = encoding.lower(getstring(x, _("desc requires a string")))
20452 a685d9870eb5 revset: added lazyset implementation to desc revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20451 diff changeset	820
a685d9870eb5 revset: added lazyset implementation to desc revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20451 diff changeset	821 def matches(x):
a685d9870eb5 revset: added lazyset implementation to desc revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20451 diff changeset	822 c = repo[x]
a685d9870eb5 revset: added lazyset implementation to desc revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20451 diff changeset	823 return ds in encoding.lower(c.description())
a685d9870eb5 revset: added lazyset implementation to desc revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20451 diff changeset	824
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	825 return subset.filter(matches, condrepr=('<desc %r>', ds))
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	826
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	827 def _descendants(repo, subset, x, followfirst=False):
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	828 roots = getset(repo, fullreposet(repo), x)
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	829 if not roots:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	830 return baseset()
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	831 s = _revdescendants(repo, roots, followfirst)
20894 04e1596d5dbd revset: improve _descendants performance Durham Goode <durham@fb.com> parents: 20863 diff changeset	832
04e1596d5dbd revset: improve _descendants performance Durham Goode <durham@fb.com> parents: 20863 diff changeset	833 # Both sets need to be ascending in order to lazily return the union
04e1596d5dbd revset: improve _descendants performance Durham Goode <durham@fb.com> parents: 20863 diff changeset	834 # in the correct order.
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	835 base = subset & roots
22860 1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	836 desc = subset & s
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	837 result = base + desc
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	838 if subset.isascending():
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	839 result.sort()
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	840 elif subset.isdescending():
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	841 result.sort(reverse=True)
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	842 else:
1dd178277cf5 revset-_descendant: rework the whole sorting and combining logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22859 diff changeset	843 result = subset & result
22830 1d1da8abe130 _descendants: directly use smartset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22829 diff changeset	844 return result
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	845
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	846 @predicate('descendants(set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	847 def descendants(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	848 """Changesets which are descendants of changesets in set.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	849 """
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	850 return _descendants(repo, subset, x)
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	851
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	852 @predicate('_firstdescendants', safe=True)
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	853 def _firstdescendants(repo, subset, x):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	854 # ``_firstdescendants(set)``
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	855 # Like ``descendants(set)`` but follows only the first parents.
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	856 return _descendants(repo, subset, x, followfirst=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	857
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	858 @predicate('destination([set])', safe=True)
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	859 def destination(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	860 """Changesets that were created by a graft, transplant or rebase operation,
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	861 with the given revisions specified as the source. Omitting the optional set
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	862 is the same as passing all().
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	863 """
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	864 if x is not None:
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	865 sources = getset(repo, fullreposet(repo), x)
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	866 else:
24201 77ef059b3317 revset: drop unnecessary calls of getall() with empty argument Yuya Nishihara <yuya@tcha.org> parents: 24163 diff changeset	867 sources = fullreposet(repo)
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	868
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	869 dests = set()
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	870
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	871 # subset contains all of the possible destinations that can be returned, so
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	872 # iterate over them and see if their source(s) were provided in the arg set.
5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	873 # Even if the immediate src of r is not in the arg set, src's source (or
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	874 # further back) may be. Scanning back further than the immediate src allows
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	875 # transitive transplants and rebases to yield the same results as transitive
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	876 # grafts.
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	877 for r in subset:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	878 src = _getrevsource(repo, r)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	879 lineage = None
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	880
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	881 while src is not None:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	882 if lineage is None:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	883 lineage = list()
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	884
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	885 lineage.append(r)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	886
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	887 # The visited lineage is a match if the current source is in the arg
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	888 # set. Since every candidate dest is visited by way of iterating
17494 74801685aaa2 spelling: further timeless@mozdev.org parents: 17291 diff changeset	889 # subset, any dests further back in the lineage will be tested by a
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	890 # different iteration over subset. Likewise, if the src was already
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	891 # selected, the current lineage can be selected without going back
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	892 # further.
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	893 if src in sources or src in dests:
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	894 dests.update(lineage)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	895 break
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	896
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	897 r = src
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	898 src = _getrevsource(repo, r)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	899
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	900 return subset.filter(dests.__contains__,
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	901 condrepr=lambda: '<destination %r>' % sorted(dests))
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	902
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	903 @predicate('divergent()', safe=True)
18071 bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	904 def divergent(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	905 """
18071 bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	906 Final successors of changesets with an alternative set of final successors.
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	907 """
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	908 # i18n: "divergent" is a keyword
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	909 getargs(x, 0, 0, _("divergent takes no arguments"))
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	910 divergent = obsmod.getrevs(repo, 'divergent')
22533 5b65429721d5 revset: use `subset &` in `divergent` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22532 diff changeset	911 return subset & divergent
18071 bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	912
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	913 @predicate('extinct()', safe=True)
17173 c621f84dbb35 obsolete: compute extinct changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17171 diff changeset	914 def extinct(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	915 """Obsolete changesets with obsolete descendants only.
17291 2d6bbf87f7b4 revset: minor doc fixes on obsolete related revsets Patrick Mezard <patrick@mezard.eu> parents: 17272 diff changeset	916 """
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	917 # i18n: "extinct" is a keyword
17258 5822345e9e46 revset: use appropriate predicate name in error messages FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17244 diff changeset	918 getargs(x, 0, 0, _("extinct takes no arguments"))
17825 3cc06457f15e obsolete: rename `getobscache` into `getrevs` Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17804 diff changeset	919 extincts = obsmod.getrevs(repo, 'extinct')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	920 return subset & extincts
17173 c621f84dbb35 obsolete: compute extinct changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17171 diff changeset	921
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	922 @predicate('extra(label, [value])', safe=True)
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	923 def extra(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	924 """Changesets with the given label in the extra metadata, with the given
16824 f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	925 optional value.
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	926
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	927 If `value` starts with `re:`, the remainder of the value is treated as
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	928 a regular expression. To match a value that actually starts with `re:`,
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	929 use the prefix `literal:`.
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	930 """
25767 026105c442d7 revset: rename getkwargs() to getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 25766 diff changeset	931 args = getargsdict(x, 'extra', 'label value')
25706 b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	932 if 'label' not in args:
b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	933 # i18n: "extra" is a keyword
b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	934 raise error.ParseError(_('extra takes at least 1 argument'))
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	935 # i18n: "extra" is a keyword
25706 b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	936 label = getstring(args['label'], _('first argument to extra must be '
b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	937 'a string'))
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	938 value = None
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	939
25706 b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	940 if 'value' in args:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	941 # i18n: "extra" is a keyword
25706 b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	942 value = getstring(args['value'], _('second argument to extra must be '
b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	943 'a string'))
26481 7d132557e44a util: extract stringmatcher() from revset Matt Harbison <matt_harbison@yahoo.com> parents: 26307 diff changeset	944 kind, value, matcher = util.stringmatcher(value)
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	945
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	946 def _matchvalue(r):
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	947 extra = repo[r].extra()
16824 f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	948 return label in extra and (value is None or matcher(extra[label]))
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	949
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	950 return subset.filter(lambda r: _matchvalue(r),
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	951 condrepr=('<extra[%r] %r>', label, value))
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	952
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	953 @predicate('filelog(pattern)', safe=True)
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	954 def filelog(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	955 """Changesets connected to the specified filelog.
17244 483aa765f6c4 revset: add explanation about difference between 'filelog()' and 'file()' FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17186 diff changeset	956
21199 e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog` Greg Hurrell <glh@fb.com> parents: 21173 diff changeset	957 For performance reasons, visits only revisions mentioned in the file-level
e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog` Greg Hurrell <glh@fb.com> parents: 21173 diff changeset	958 filelog, rather than filtering through all changesets (much faster, but
e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog` Greg Hurrell <glh@fb.com> parents: 21173 diff changeset	959 doesn't include deletes or duplicate changes). For a slower, more accurate
e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog` Greg Hurrell <glh@fb.com> parents: 21173 diff changeset	960 result, use ``file()``.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	961
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	962 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	963 relative to the current directory and match against a file exactly
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	964 for efficiency.
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	965
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	966 If some linkrev points to revisions filtered by the current repoview, we'll
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	967 work around it to return a non-filtered value.
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	968 """
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	969
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	970 # i18n: "filelog" is a keyword
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	971 pat = getstring(x, _("filelog requires a pattern"))
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	972 s = set()
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	973 cl = repo.changelog
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	974
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	975 if not matchmod.patkind(pat):
20288 b61ad01c4e73 revset: use "canonpath()" for "filelog()" pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20287 diff changeset	976 f = pathutil.canonpath(repo.root, repo.getcwd(), pat)
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	977 files = [f]
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	978 else:
20288 b61ad01c4e73 revset: use "canonpath()" for "filelog()" pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20287 diff changeset	979 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=repo[None])
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	980 files = (f for f in repo[None] if m(f))
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	981
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	982 for f in files:
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	983 fl = repo.file(f)
27945 4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	984 known = {}
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	985 scanpos = 0
23719 34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	986 for fr in list(fl):
27945 4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	987 fn = fl.node(fr)
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	988 if fn in known:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	989 s.add(known[fn])
23821 7a7f437ab63d filelog: remove trailing "form feed" character Martin von Zweigbergk <martinvonz@google.com> parents: 23820 diff changeset	990 continue
27945 4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	991
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	992 lr = fl.linkrev(fr)
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	993 if lr in cl:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	994 s.add(lr)
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	995 elif scanpos is not None:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	996 # lowest matching changeset is filtered, scan further
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	997 # ahead in changelog
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	998 start = max(lr, scanpos) + 1
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	999 scanpos = None
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1000 for r in cl.revs(start):
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1001 # minimize parsing of non-matching entries
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1002 if f in cl.revision(r) and f in cl.readfiles(r):
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1003 try:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1004 # try to use manifest delta fastpath
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1005 n = repo[r].filenode(f)
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1006 if n not in known:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1007 if n == fn:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1008 s.add(r)
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1009 scanpos = r
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1010 break
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1011 else:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1012 known[n] = r
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1013 except error.ManifestLookupError:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1014 # deletion in changelog
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	1015 continue
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	1016
22534 6261b9c549a2 revset: use `subset &` in `filelog` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22533 diff changeset	1017 return subset & s
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	1018
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1019 @predicate('first(set, [n])', safe=True)
15117 0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	1020 def first(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1021 """An alias for limit().
15117 0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	1022 """
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	1023 return limit(repo, subset, x)
0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	1024
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	1025 def _follow(repo, subset, x, name, followfirst=False):
29825 cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	1026 l = getargs(x, 0, 2, _("%s takes no arguments or a pattern "
cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	1027 "and an optional revset") % name)
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	1028 c = repo['.']
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	1029 if l:
26102 5618858dce26 revsets: makes follow() supports file patterns (issue4757) (BC) liscju <piotr.listkiewicz@gmail.com> parents: 26099 diff changeset	1030 x = getstring(l[0], _("%s expected a pattern") % name)
29825 cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	1031 rev = None
cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	1032 if len(l) >= 2:
30178 d61c42c1a35c revset: make follow() reject more than one start revisions Yuya Nishihara <yuya@tcha.org> parents: 30071 diff changeset	1033 revs = getset(repo, fullreposet(repo), l[1])
d61c42c1a35c revset: make follow() reject more than one start revisions Yuya Nishihara <yuya@tcha.org> parents: 30071 diff changeset	1034 if len(revs) != 1:
29825 cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	1035 raise error.RepoLookupError(
30178 d61c42c1a35c revset: make follow() reject more than one start revisions Yuya Nishihara <yuya@tcha.org> parents: 30071 diff changeset	1036 _("%s expected one starting revision") % name)
d61c42c1a35c revset: make follow() reject more than one start revisions Yuya Nishihara <yuya@tcha.org> parents: 30071 diff changeset	1037 rev = revs.last()
29825 cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	1038 c = repo[rev]
26102 5618858dce26 revsets: makes follow() supports file patterns (issue4757) (BC) liscju <piotr.listkiewicz@gmail.com> parents: 26099 diff changeset	1039 matcher = matchmod.match(repo.root, repo.getcwd(), [x],
29825 cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	1040 ctx=repo[rev], default='path')
26102 5618858dce26 revsets: makes follow() supports file patterns (issue4757) (BC) liscju <piotr.listkiewicz@gmail.com> parents: 26099 diff changeset	1041
28008 86c4cbdaffee revset: use manifest.matches in _follow revset Durham Goode <durham@fb.com> parents: 27945 diff changeset	1042 files = c.manifest().walk(matcher)
86c4cbdaffee revset: use manifest.matches in _follow revset Durham Goode <durham@fb.com> parents: 27945 diff changeset	1043
26102 5618858dce26 revsets: makes follow() supports file patterns (issue4757) (BC) liscju <piotr.listkiewicz@gmail.com> parents: 26099 diff changeset	1044 s = set()
28008 86c4cbdaffee revset: use manifest.matches in _follow revset Durham Goode <durham@fb.com> parents: 27945 diff changeset	1045 for fname in files:
86c4cbdaffee revset: use manifest.matches in _follow revset Durham Goode <durham@fb.com> parents: 27945 diff changeset	1046 fctx = c[fname]
86c4cbdaffee revset: use manifest.matches in _follow revset Durham Goode <durham@fb.com> parents: 27945 diff changeset	1047 s = s.union(set(c.rev() for c in fctx.ancestors(followfirst)))
86c4cbdaffee revset: use manifest.matches in _follow revset Durham Goode <durham@fb.com> parents: 27945 diff changeset	1048 # include the revision responsible for the most recent version
86c4cbdaffee revset: use manifest.matches in _follow revset Durham Goode <durham@fb.com> parents: 27945 diff changeset	1049 s.add(fctx.introrev())
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	1050 else:
20690 13c0327eeb6f revset: changed ancestors revset to return lazy generators Lucas Moscovicz <lmoscovicz@fb.com> parents: 20659 diff changeset	1051 s = _revancestors(repo, baseset([c.rev()]), followfirst)
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	1052
22535 44f471102f3a revset: use `subset &` in `follow` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22534 diff changeset	1053 return subset & s
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	1054
29825 cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	1055 @predicate('follow([pattern[, startrev]])', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1056 def follow(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1057 """
24366 e8ea31131705 revset: replace "working copy" with "working directory" in function help Yuya Nishihara <yuya@tcha.org> parents: 24306 diff changeset	1058 An alias for ``::.`` (ancestors of the working directory's first parent).
26102 5618858dce26 revsets: makes follow() supports file patterns (issue4757) (BC) liscju <piotr.listkiewicz@gmail.com> parents: 26099 diff changeset	1059 If pattern is specified, the histories of files matching given
29825 cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	1060 pattern in the revision given by startrev are followed, including copies.
14343 9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	1061 """
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	1062 return _follow(repo, subset, x, 'follow')
14343 9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	1063
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1064 @predicate('_followfirst', safe=True)
16174 0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	1065 def _followfirst(repo, subset, x):
29825 cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	1066 # ``followfirst([pattern[, startrev]])``
cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	1067 # Like ``follow([pattern[, startrev]])`` but follows only the first parent
cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	1068 # of every revisions or files revisions.
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	1069 return _follow(repo, subset, x, '_followfirst', followfirst=True)
14343 9ed227f79e47 revset: add follow(filename) to follow a filename's history across copies Matt Mackall <mpm@selenic.com> parents: 14342 diff changeset	1070
30719 42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1071 @predicate('followlines(file, fromline, toline[, rev=.])', safe=True)
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1072 def followlines(repo, subset, x):
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1073 """Changesets modifying `file` in line range ('fromline', 'toline').
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1074
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1075 Line range corresponds to 'file' content at 'rev' and should hence be
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1076 consistent with file size. If rev is not specified, working directory's
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1077 parent is used.
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1078 """
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1079 from . import context # avoid circular import issues
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1080
30754 26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	1081 args = getargsdict(x, 'followlines', 'file *lines rev')
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	1082 if len(args['lines']) != 2:
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	1083 raise error.ParseError(_("followlines takes at least three arguments"))
30719 42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1084
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1085 rev = '.'
30754 26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	1086 if 'rev' in args:
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	1087 revs = getset(repo, fullreposet(repo), args['rev'])
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	1088 if len(revs) != 1:
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	1089 raise error.ParseError(
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	1090 _("followlines expects exactly one revision"))
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	1091 rev = revs.last()
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	1092
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	1093 pat = getstring(args['file'], _("followlines requires a pattern"))
30719 42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1094 if not matchmod.patkind(pat):
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1095 fname = pathutil.canonpath(repo.root, repo.getcwd(), pat)
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1096 else:
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1097 m = matchmod.match(repo.root, repo.getcwd(), [pat], ctx=repo[rev])
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1098 files = [f for f in repo[rev] if m(f)]
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1099 if len(files) != 1:
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1100 raise error.ParseError(_("followlines expects exactly one file"))
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1101 fname = files[0]
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1102
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1103 try:
30754 26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	1104 fromline, toline = [int(getsymbol(a)) for a in args['lines']]
30719 42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1105 except ValueError:
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1106 raise error.ParseError(_("line range bounds must be integers"))
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1107 if toline - fromline < 0:
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1108 raise error.ParseError(_("line range must be positive"))
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1109 if fromline < 1:
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1110 raise error.ParseError(_("fromline must be strictly positive"))
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1111 fromline -= 1
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1112
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1113 fctx = repo[rev].filectx(fname)
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1114 revs = (c.rev() for c in context.blockancestors(fctx, fromline, toline))
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1115 return subset & generatorset(revs, iterasc=False)
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	1116
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1117 @predicate('all()', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1118 def getall(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1119 """All changesets, the same as ``0:tip``.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1120 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1121 # i18n: "all" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1122 getargs(x, 0, 0, _("all takes no arguments"))
24202 2de9ee016425 revset: have all() filter out null revision Yuya Nishihara <yuya@tcha.org> parents: 24201 diff changeset	1123 return subset & spanset(repo) # drop "null" if any
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1124
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1125 @predicate('grep(regex)')
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1126 def grep(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1127 """Like ``keyword(string)`` but accepts a regex. Use ``grep(r'...')``
14357 cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	1128 to ensure special escape characters are handled correctly. Unlike
cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	1129 ``keyword(string)``, the match is case-sensitive.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1130 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1131 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1132 # i18n: "grep" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1133 gr = re.compile(getstring(x, _("grep requires a string")))
25660 328739ea70c3 global: mass rewrite to use modern exception syntax Gregory Szorc <gregory.szorc@gmail.com> parents: 25654 diff changeset	1134 except re.error as e:
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1135 raise error.ParseError(_('invalid match pattern: %s') % e)
20453 6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	1136
6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	1137 def matches(x):
6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	1138 c = repo[x]
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1139 for e in c.files() + [c.user(), c.description()]:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1140 if gr.search(e):
20453 6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	1141 return True
6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	1142 return False
6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	1143
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1144 return subset.filter(matches, condrepr=('<grep %r>', gr.pattern))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1145
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1146 @predicate('_matchfiles', safe=True)
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1147 def _matchfiles(repo, subset, x):
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1148 # _matchfiles takes a revset list of prefixed arguments:
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1149 #
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1150 # [p:foo, i:bar, x:baz]
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1151 #
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1152 # builds a match object from them and filters subset. Allowed
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1153 # prefixes are 'p:' for regular patterns, 'i:' for include
16181 1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	1154 # patterns and 'x:' for exclude patterns. Use 'r:' prefix to pass
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	1155 # a revision identifier, or the empty string to reference the
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	1156 # working directory, from which the match object is
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1157 # initialized. Use 'd:' to set the default matching mode, default
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1158 # to 'glob'. At most one 'r:' and 'd:' argument can be passed.
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1159
28271 5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles Yuya Nishihara <yuya@tcha.org> parents: 28217 diff changeset	1160 l = getargs(x, 1, -1, "_matchfiles requires at least one argument")
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1161 pats, inc, exc = [], [], []
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1162 rev, default = None, None
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1163 for arg in l:
28271 5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles Yuya Nishihara <yuya@tcha.org> parents: 28217 diff changeset	1164 s = getstring(arg, "_matchfiles requires string arguments")
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1165 prefix, value = s[:2], s[2:]
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1166 if prefix == 'p:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1167 pats.append(value)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1168 elif prefix == 'i:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1169 inc.append(value)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1170 elif prefix == 'x:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1171 exc.append(value)
16181 1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	1172 elif prefix == 'r:':
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	1173 if rev is not None:
28271 5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles Yuya Nishihara <yuya@tcha.org> parents: 28217 diff changeset	1174 raise error.ParseError('_matchfiles expected at most one '
5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles Yuya Nishihara <yuya@tcha.org> parents: 28217 diff changeset	1175 'revision')
23950 caff3675cba5 log: evaluate filesets on working copy, not its parent Martin von Zweigbergk <martinvonz@google.com> parents: 23847 diff changeset	1176 if value != '': # empty means working directory; leave rev as None
caff3675cba5 log: evaluate filesets on working copy, not its parent Martin von Zweigbergk <martinvonz@google.com> parents: 23847 diff changeset	1177 rev = value
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1178 elif prefix == 'd:':
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1179 if default is not None:
28271 5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles Yuya Nishihara <yuya@tcha.org> parents: 28217 diff changeset	1180 raise error.ParseError('_matchfiles expected at most one '
5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles Yuya Nishihara <yuya@tcha.org> parents: 28217 diff changeset	1181 'default mode')
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1182 default = value
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1183 else:
28271 5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles Yuya Nishihara <yuya@tcha.org> parents: 28217 diff changeset	1184 raise error.ParseError('invalid _matchfiles prefix: %s' % prefix)
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1185 if not default:
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	1186 default = 'glob'
20458 8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1187
23061 f2aeff8a87b6 revset: avoid recalculating filesets Matt Mackall <mpm@selenic.com> parents: 23019 diff changeset	1188 m = matchmod.match(repo.root, repo.getcwd(), pats, include=inc,
f2aeff8a87b6 revset: avoid recalculating filesets Matt Mackall <mpm@selenic.com> parents: 23019 diff changeset	1189 exclude=exc, ctx=repo[rev], default=default)
f2aeff8a87b6 revset: avoid recalculating filesets Matt Mackall <mpm@selenic.com> parents: 23019 diff changeset	1190
27028 f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	1191 # This directly read the changelog data as creating changectx for all
f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	1192 # revisions is quite expensive.
27440 ff305ab2e0d7 log: speed up hg log <file\|folder> Laurent Charignon <lcharignon@fb.com> parents: 27293 diff changeset	1193 getfiles = repo.changelog.readfiles
27028 f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	1194 wdirrev = node.wdirrev
20458 8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1195 def matches(x):
27028 f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	1196 if x == wdirrev:
f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	1197 files = repo[x].files()
f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	1198 else:
27440 ff305ab2e0d7 log: speed up hg log <file\|folder> Laurent Charignon <lcharignon@fb.com> parents: 27293 diff changeset	1199 files = getfiles(x)
27028 f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	1200 for f in files:
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1201 if m(f):
20458 8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1202 return True
8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1203 return False
8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1204
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1205 return subset.filter(matches,
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1206 condrepr=('<matchfiles patterns=%r, include=%r '
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1207 'exclude=%r, default=%r, rev=%r>',
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1208 pats, inc, exc, default, rev))
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1209
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1210 @predicate('file(pattern)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1211 def hasfile(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1212 """Changesets affecting files matched by pattern.
17244 483aa765f6c4 revset: add explanation about difference between 'filelog()' and 'file()' FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17186 diff changeset	1213
17265 c30307eeec4b revset: polish explanation of the difference between file() and filelog() Greg Ward <greg@gerg.ca> parents: 17259 diff changeset	1214 For a faster but less accurate result, consider using ``filelog()``
c30307eeec4b revset: polish explanation of the difference between file() and filelog() Greg Ward <greg@gerg.ca> parents: 17259 diff changeset	1215 instead.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1216
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1217 This predicate uses ``glob:`` as the default kind of pattern.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1218 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1219 # i18n: "file" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1220 pat = getstring(x, _("file requires a pattern"))
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1221 return _matchfiles(repo, subset, ('string', 'p:' + pat))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1222
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1223 @predicate('head()', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1224 def head(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1225 """Changeset is a named branch head.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1226 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1227 # i18n: "head" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1228 getargs(x, 0, 0, _("head takes no arguments"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1229 hs = set()
25620 5f87f2305ad0 revset: translate node directly with changelog in 'head' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25619 diff changeset	1230 cl = repo.changelog
29407 20fabe814f89 revsets: use itervalues() where only values are needed Martin von Zweigbergk <martinvonz@google.com> parents: 29406 diff changeset	1231 for ls in repo.branchmap().itervalues():
25620 5f87f2305ad0 revset: translate node directly with changelog in 'head' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25619 diff changeset	1232 hs.update(cl.rev(h) for h in ls)
29408 785cadec2091 revset: make head() honor order of subset Martin von Zweigbergk <martinvonz@google.com> parents: 29407 diff changeset	1233 return subset & baseset(hs)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1234
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1235 @predicate('heads(set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1236 def heads(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1237 """Members of set with no children in set.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1238 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1239 s = getset(repo, subset, x)
20366 5ec6321f49a9 revset: added substraction to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20365 diff changeset	1240 ps = parents(repo, subset, x)
5ec6321f49a9 revset: added substraction to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20365 diff changeset	1241 return s - ps
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1242
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1243 @predicate('hidden()', safe=True)
17390 74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1244 def hidden(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1245 """Hidden changesets.
17390 74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1246 """
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1247 # i18n: "hidden" is a keyword
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1248 getargs(x, 0, 0, _("hidden takes no arguments"))
18382 f3b21beb9802 filtering: rename filters to their antonyms Kevin Bullock <kbullock@ringworld.org> parents: 18251 diff changeset	1249 hiddenrevs = repoview.filterrevs(repo, 'visible')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1250 return subset & hiddenrevs
17390 74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1251
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1252 @predicate('keyword(string)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1253 def keyword(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1254 """Search commit message, user name, and names of changed files for
14357 cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	1255 string. The match is case-insensitive.
30772 b1012cb1bec3 revset: point to 'grep' in the 'keyword' help for regex searches Matt Harbison <matt_harbison@yahoo.com> parents: 30754 diff changeset	1256
b1012cb1bec3 revset: point to 'grep' in the 'keyword' help for regex searches Matt Harbison <matt_harbison@yahoo.com> parents: 30754 diff changeset	1257 For a regular expression or case sensitive search of these fields, use
b1012cb1bec3 revset: point to 'grep' in the 'keyword' help for regex searches Matt Harbison <matt_harbison@yahoo.com> parents: 30754 diff changeset	1258 ``grep(regex)``.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1259 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1260 # i18n: "keyword" is a keyword
15726 9b822edecb4c i18n: use "encoding.lower()" to normalize specified string for revset FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15596 diff changeset	1261 kw = encoding.lower(getstring(x, _("keyword requires a string")))
20447 abb91b74f758 revset: added lazyset implementation to keyword revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20446 diff changeset	1262
abb91b74f758 revset: added lazyset implementation to keyword revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20446 diff changeset	1263 def matches(r):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1264 c = repo[r]
25551 c1d163ce7394 revset: gratuitous formating fix in keyword Pierre-Yves David <pierre-yves.david@fb.com> parents: 25550 diff changeset	1265 return any(kw in encoding.lower(t)
c1d163ce7394 revset: gratuitous formating fix in keyword Pierre-Yves David <pierre-yves.david@fb.com> parents: 25550 diff changeset	1266 for t in c.files() + [c.user(), c.description()])
20447 abb91b74f758 revset: added lazyset implementation to keyword revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20446 diff changeset	1267
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1268 return subset.filter(matches, condrepr=('<keyword %r>', kw))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1269
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1270 @predicate('limit(set[, n[, offset]])', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1271 def limit(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1272 """First n members of set, defaulting to 1, starting from offset.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1273 """
26638 7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1274 args = getargsdict(x, 'limit', 'set n offset')
26637 179764469754 revset: port limit() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 26636 diff changeset	1275 if 'set' not in args:
179764469754 revset: port limit() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 26636 diff changeset	1276 # i18n: "limit" is a keyword
26638 7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1277 raise error.ParseError(_("limit requires one to three arguments"))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1278 try:
26638 7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1279 lim, ofs = 1, 0
26637 179764469754 revset: port limit() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 26636 diff changeset	1280 if 'n' in args:
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1281 # i18n: "limit" is a keyword
26637 179764469754 revset: port limit() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 26636 diff changeset	1282 lim = int(getstring(args['n'], _("limit requires a number")))
26638 7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1283 if 'offset' in args:
7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1284 # i18n: "limit" is a keyword
7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1285 ofs = int(getstring(args['offset'], _("limit requires a number")))
7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1286 if ofs < 0:
7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1287 raise error.ParseError(_("negative offset"))
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	1288 except (TypeError, ValueError):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1289 # i18n: "limit" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1290 raise error.ParseError(_("limit expects a number"))
26637 179764469754 revset: port limit() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 26636 diff changeset	1291 os = getset(repo, fullreposet(repo), args['set'])
22804 5385314e0b14 revset-limit: remove user of baseset.append Pierre-Yves David <pierre-yves.david@fb.com> parents: 22802 diff changeset	1292 result = []
20446 d258486604f4 revset: changed limit revset implementation to work with lazy revsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20445 diff changeset	1293 it = iter(os)
26638 7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1294 for x in xrange(ofs):
7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1295 y = next(it, None)
7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1296 if y is None:
7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1297 break
20446 d258486604f4 revset: changed limit revset implementation to work with lazy revsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20445 diff changeset	1298 for x in xrange(lim):
25144 81a395447b34 revset: use 'next()' to detect end of iteration in 'limit' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25143 diff changeset	1299 y = next(it, None)
81a395447b34 revset: use 'next()' to detect end of iteration in 'limit' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25143 diff changeset	1300 if y is None:
20446 d258486604f4 revset: changed limit revset implementation to work with lazy revsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20445 diff changeset	1301 break
26636 ff6baf32b3ba revset: eliminate temporary reference to subset in limit() and last() Yuya Nishihara <yuya@tcha.org> parents: 26587 diff changeset	1302 elif y in subset:
25144 81a395447b34 revset: use 'next()' to detect end of iteration in 'limit' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25143 diff changeset	1303 result.append(y)
28426 3d39ac06af9a revset: add inspection data to limit() and last() functions Yuya Nishihara <yuya@tcha.org> parents: 28425 diff changeset	1304 return baseset(result, datarepr=('<limit n=%d, offset=%d, %r, %r>',
3d39ac06af9a revset: add inspection data to limit() and last() functions Yuya Nishihara <yuya@tcha.org> parents: 28425 diff changeset	1305 lim, ofs, subset, os))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1306
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1307 @predicate('last(set, [n])', safe=True)
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1308 def last(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1309 """Last n members of set, defaulting to 1.
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1310 """
611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1311 # i18n: "last" is a keyword
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1312 l = getargs(x, 1, 2, _("last requires one or two arguments"))
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1313 try:
15116 d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1314 lim = 1
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1315 if len(l) == 2:
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1316 # i18n: "last" is a keyword
d8501bcbb221 revset: add default of 1 to limit and last functions Matt Mackall <mpm@selenic.com> parents: 14901 diff changeset	1317 lim = int(getstring(l[1], _("last requires a number")))
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	1318 except (TypeError, ValueError):
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1319 # i18n: "last" is a keyword
611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1320 raise error.ParseError(_("last expects a number"))
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1321 os = getset(repo, fullreposet(repo), l[0])
20534 4849f574aa24 revset: changed last implementation to use lazy classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20527 diff changeset	1322 os.reverse()
22805 e74245b79901 revset-last: remove user of baseset.append Pierre-Yves David <pierre-yves.david@fb.com> parents: 22804 diff changeset	1323 result = []
20534 4849f574aa24 revset: changed last implementation to use lazy classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20527 diff changeset	1324 it = iter(os)
4849f574aa24 revset: changed last implementation to use lazy classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20527 diff changeset	1325 for x in xrange(lim):
25145 3553163bb736 revset: use 'next()' to detect end of iteration in 'last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25144 diff changeset	1326 y = next(it, None)
3553163bb736 revset: use 'next()' to detect end of iteration in 'last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25144 diff changeset	1327 if y is None:
20534 4849f574aa24 revset: changed last implementation to use lazy classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20527 diff changeset	1328 break
26636 ff6baf32b3ba revset: eliminate temporary reference to subset in limit() and last() Yuya Nishihara <yuya@tcha.org> parents: 26587 diff changeset	1329 elif y in subset:
25145 3553163bb736 revset: use 'next()' to detect end of iteration in 'last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25144 diff changeset	1330 result.append(y)
28426 3d39ac06af9a revset: add inspection data to limit() and last() functions Yuya Nishihara <yuya@tcha.org> parents: 28425 diff changeset	1331 return baseset(result, datarepr=('<last n=%d, %r, %r>', lim, subset, os))
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1332
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1333 @predicate('max(set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1334 def maxrev(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1335 """Changeset with highest revision number in set.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1336 """
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1337 os = getset(repo, fullreposet(repo), x)
26305 ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1338 try:
20754 f15ff553b762 revset: changed minrev and maxrev implementations to use ordered sets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20753 diff changeset	1339 m = os.max()
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1340 if m in subset:
28427 969a4615c4c4 revset: add inspection data to max() and min() functions Yuya Nishihara <yuya@tcha.org> parents: 28426 diff changeset	1341 return baseset([m], datarepr=('<max %r, %r>', subset, os))
26305 ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1342 except ValueError:
ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1343 # os.max() throws a ValueError when the collection is empty.
ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1344 # Same as python's max().
ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1345 pass
28427 969a4615c4c4 revset: add inspection data to max() and min() functions Yuya Nishihara <yuya@tcha.org> parents: 28426 diff changeset	1346 return baseset(datarepr=('<max %r, %r>', subset, os))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1347
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1348 @predicate('merge()', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1349 def merge(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1350 """Changeset is a merge changeset.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1351 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1352 # i18n: "merge" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1353 getargs(x, 0, 0, _("merge takes no arguments"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1354 cl = repo.changelog
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1355 return subset.filter(lambda r: cl.parentrevs(r)[1] != -1,
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1356 condrepr='<merge>')
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1357
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1358 @predicate('branchpoint()', safe=True)
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1359 def branchpoint(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1360 """Changesets with more than one child.
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1361 """
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1362 # i18n: "branchpoint" is a keyword
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1363 getargs(x, 0, 0, _("branchpoint takes no arguments"))
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1364 cl = repo.changelog
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1365 if not subset:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1366 return baseset()
25549 f93ff3ab8d14 revset: mark spots that should use 'smartset.min()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25548 diff changeset	1367 # XXX this should be 'parentset.min()' assuming 'parentset' is a smartset
f93ff3ab8d14 revset: mark spots that should use 'smartset.min()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25548 diff changeset	1368 # (and if it is not, it should.)
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1369 baserev = min(subset)
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1370 parentscount = [0]*(len(repo) - baserev)
17785 ac5c9c8046f7 clfilter: use changelog to iterate over the repo in branchpoint Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17753 diff changeset	1371 for r in cl.revs(start=baserev + 1):
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1372 for p in cl.parentrevs(r):
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1373 if p >= baserev:
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1374 parentscount[p - baserev] += 1
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1375 return subset.filter(lambda r: parentscount[r - baserev] > 1,
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1376 condrepr='<branchpoint>')
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1377
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1378 @predicate('min(set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1379 def minrev(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1380 """Changeset with lowest revision number in set.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1381 """
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1382 os = getset(repo, fullreposet(repo), x)
26305 ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1383 try:
20754 f15ff553b762 revset: changed minrev and maxrev implementations to use ordered sets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20753 diff changeset	1384 m = os.min()
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1385 if m in subset:
28427 969a4615c4c4 revset: add inspection data to max() and min() functions Yuya Nishihara <yuya@tcha.org> parents: 28426 diff changeset	1386 return baseset([m], datarepr=('<min %r, %r>', subset, os))
26305 ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1387 except ValueError:
ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1388 # os.min() throws a ValueError when the collection is empty.
ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1389 # Same as python's min().
ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1390 pass
28427 969a4615c4c4 revset: add inspection data to max() and min() functions Yuya Nishihara <yuya@tcha.org> parents: 28426 diff changeset	1391 return baseset(datarepr=('<min %r, %r>', subset, os))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1392
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1393 @predicate('modifies(pattern)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1394 def modifies(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1395 """Changesets modifying files matched by pattern.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1396
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1397 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1398 relative to the current directory and match against a file or a
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1399 directory.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1400 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1401 # i18n: "modifies" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1402 pat = getstring(x, _("modifies requires a pattern"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1403 return checkstatus(repo, subset, pat, 0)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1404
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1405 @predicate('named(namespace)')
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1406 def named(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1407 """The changesets in a given namespace.
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1408
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1409 If `namespace` starts with `re:`, the remainder of the string is treated as
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1410 a regular expression. To match a namespace that actually starts with `re:`,
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1411 use the prefix `literal:`.
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1412 """
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1413 # i18n: "named" is a keyword
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1414 args = getargs(x, 1, 1, _('named requires a namespace argument'))
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1415
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1416 ns = getstring(args[0],
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1417 # i18n: "named" is a keyword
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1418 _('the argument to named must be a string'))
26481 7d132557e44a util: extract stringmatcher() from revset Matt Harbison <matt_harbison@yahoo.com> parents: 26307 diff changeset	1419 kind, pattern, matcher = util.stringmatcher(ns)
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1420 namespaces = set()
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1421 if kind == 'literal':
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1422 if pattern not in repo.names:
23978 eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	1423 raise error.RepoLookupError(_("namespace '%s' does not exist")
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	1424 % ns)
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1425 namespaces.add(repo.names[pattern])
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1426 else:
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1427 for name, ns in repo.names.iteritems():
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1428 if matcher(name):
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1429 namespaces.add(ns)
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1430 if not namespaces:
23978 eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	1431 raise error.RepoLookupError(_("no namespace exists"
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	1432 " that match '%s'") % pattern)
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1433
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1434 names = set()
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1435 for ns in namespaces:
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1436 for name in ns.listnames(repo):
24151 38824c53c2f1 revset: mask specific names for named() predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24008 diff changeset	1437 if name not in ns.deprecated:
38824c53c2f1 revset: mask specific names for named() predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 24008 diff changeset	1438 names.update(repo[n].rev() for n in ns.nodes(repo, name))
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1439
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1440 names -= set([node.nullrev])
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1441 return subset & names
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1442
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1443 @predicate('id(string)', safe=True)
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	1444 def node_(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1445 """Revision non-ambiguously specified by the given hex string prefix.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1446 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1447 # i18n: "id" is a keyword
12736 7e14e67e6622 revset: use 'requires' instead of 'wants' in error message Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12733 diff changeset	1448 l = getargs(x, 1, 1, _("id requires one argument"))
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1449 # i18n: "id" is a keyword
12736 7e14e67e6622 revset: use 'requires' instead of 'wants' in error message Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12733 diff changeset	1450 n = getstring(l[0], _("id requires a string"))
12716 c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1451 if len(n) == 40:
24904 b5c227f3e461 revset: id() called with 40-byte strings should give the same results as for short strings Alexander Drozdov <al.drozdov@gmail.com> parents: 24777 diff changeset	1452 try:
b5c227f3e461 revset: id() called with 40-byte strings should give the same results as for short strings Alexander Drozdov <al.drozdov@gmail.com> parents: 24777 diff changeset	1453 rn = repo.changelog.rev(node.bin(n))
b5c227f3e461 revset: id() called with 40-byte strings should give the same results as for short strings Alexander Drozdov <al.drozdov@gmail.com> parents: 24777 diff changeset	1454 except (LookupError, TypeError):
b5c227f3e461 revset: id() called with 40-byte strings should give the same results as for short strings Alexander Drozdov <al.drozdov@gmail.com> parents: 24777 diff changeset	1455 rn = None
12716 c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1456 else:
16735 47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1457 rn = None
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1458 pm = repo.changelog._partialmatch(n)
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1459 if pm is not None:
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1460 rn = repo.changelog.rev(pm)
47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1461
23005 9bfe68357c01 revset-node: speedup by a few hundred fold Pierre-Yves David <pierre-yves.david@fb.com> parents: 23004 diff changeset	1462 if rn is None:
9bfe68357c01 revset-node: speedup by a few hundred fold Pierre-Yves David <pierre-yves.david@fb.com> parents: 23004 diff changeset	1463 return baseset()
9bfe68357c01 revset-node: speedup by a few hundred fold Pierre-Yves David <pierre-yves.david@fb.com> parents: 23004 diff changeset	1464 result = baseset([rn])
9bfe68357c01 revset-node: speedup by a few hundred fold Pierre-Yves David <pierre-yves.david@fb.com> parents: 23004 diff changeset	1465 return result & subset
12716 c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1466
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1467 @predicate('obsolete()', safe=True)
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1468 def obsolete(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1469 """Mutable changeset with a newer version."""
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1470 # i18n: "obsolete" is a keyword
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1471 getargs(x, 0, 0, _("obsolete takes no arguments"))
17825 3cc06457f15e obsolete: rename `getobscache` into `getrevs` Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17804 diff changeset	1472 obsoletes = obsmod.getrevs(repo, 'obsolete')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1473 return subset & obsoletes
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1474
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1475 @predicate('only(set, [set])', safe=True)
23466 d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1476 def only(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1477 """Changesets that are ancestors of the first set that are not ancestors
23466 d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1478 of any other head in the repo. If a second set is specified, the result
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1479 is ancestors of the first set that are not ancestors of the second set
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1480 (i.e. ::<set1> - ::<set2>).
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1481 """
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1482 cl = repo.changelog
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1483 # i18n: "only" is a keyword
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1484 args = getargs(x, 1, 2, _('only takes one or two arguments'))
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1485 include = getset(repo, fullreposet(repo), args[0])
23466 d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1486 if len(args) == 1:
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1487 if not include:
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1488 return baseset()
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1489
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1490 descendants = set(_revdescendants(repo, include, False))
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1491 exclude = [rev for rev in cl.headrevs()
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1492 if not rev in descendants and not rev in include]
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1493 else:
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1494 exclude = getset(repo, fullreposet(repo), args[1])
23466 d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1495
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1496 results = set(cl.findmissingrevs(common=exclude, heads=include))
25554 94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1497 # XXX we should turn this into a baseset instead of a set, smartset may do
30342 318a24b52eeb spelling: fixes of non-dictionary words Mads Kiilerich <madski@unity3d.com> parents: 30227 diff changeset	1498 # some optimizations from the fact this is a baseset.
23466 d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1499 return subset & results
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1500
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1501 @predicate('origin([set])', safe=True)
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1502 def origin(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1503 """
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1504 Changesets that were specified as a source for the grafts, transplants or
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1505 rebases that created the given revisions. Omitting the optional set is the
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1506 same as passing all(). If a changeset created by these operations is itself
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1507 specified as a source for one of these operations, only the source changeset
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1508 for the first operation is selected.
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1509 """
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1510 if x is not None:
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1511 dests = getset(repo, fullreposet(repo), x)
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1512 else:
24201 77ef059b3317 revset: drop unnecessary calls of getall() with empty argument Yuya Nishihara <yuya@tcha.org> parents: 24163 diff changeset	1513 dests = fullreposet(repo)
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1514
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1515 def _firstsrc(rev):
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1516 src = _getrevsource(repo, rev)
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1517 if src is None:
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1518 return None
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1519
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1520 while True:
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1521 prev = _getrevsource(repo, src)
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1522
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1523 if prev is None:
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1524 return src
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1525 src = prev
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1526
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	1527 o = set([_firstsrc(r) for r in dests])
22498 64673dc48931 revset: remove invalid value in the origin set Pierre-Yves David <pierre-yves.david@fb.com> parents: 22497 diff changeset	1528 o -= set([None])
25554 94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1529 # XXX we should turn this into a baseset instead of a set, smartset may do
30342 318a24b52eeb spelling: fixes of non-dictionary words Mads Kiilerich <madski@unity3d.com> parents: 30227 diff changeset	1530 # some optimizations from the fact this is a baseset.
22536 8040a44aab1c revset: use `subset &` in `origin` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22535 diff changeset	1531 return subset & o
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1532
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1533 @predicate('outgoing([path])', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1534 def outgoing(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1535 """Changesets not found in the specified destination repository, or the
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1536 default push location.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1537 """
24722 02a5618e2fbf revset: don't import discovery at module level Gregory Szorc <gregory.szorc@gmail.com> parents: 24708 diff changeset	1538 # Avoid cycles.
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	1539 from . import (
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	1540 discovery,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	1541 hg,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	1542 )
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1543 # i18n: "outgoing" is a keyword
14717 c8ee2729e89f revset and fileset: fix typos in parser error messages Mads Kiilerich <mads@kiilerich.com> parents: 14715 diff changeset	1544 l = getargs(x, 0, 1, _("outgoing takes one or no arguments"))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1545 # i18n: "outgoing" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1546 dest = l and getstring(l[0], _("outgoing requires a repository path")) or ''
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1547 dest = repo.ui.expandpath(dest or 'default-push', dest or 'default')
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1548 dest, branches = hg.parseurl(dest)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1549 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1550 if revs:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1551 revs = [repo.lookup(rev) for rev in revs]
14556 517e1d88bf7e hg: change various repository() users to use peer() where appropriate Matt Mackall <mpm@selenic.com> parents: 14509 diff changeset	1552 other = hg.peer(repo, {}, dest)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1553 repo.ui.pushbuffer()
15837 cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15819 diff changeset	1554 outgoing = discovery.findcommonoutgoing(repo, other, onlyheads=revs)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1555 repo.ui.popbuffer()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1556 cl = repo.changelog
15837 cd956049fc14 discovery: introduce outgoing object for result of findcommonoutgoing Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15819 diff changeset	1557 o = set([cl.rev(r) for r in outgoing.missing])
22529 5c53d7888aef revset: use `subset &` in `outgoing` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22528 diff changeset	1558 return subset & o
12716 c7e619e30ba3 revset: add id() and rev() to allow explicitly referring to changes by hash or rev Augie Fackler <durin42@gmail.com> parents: 12715 diff changeset	1559
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1560 @predicate('p1([set])', safe=True)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1561 def p1(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1562 """First parent of changesets in set, or the working directory.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1563 """
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1564 if x is None:
13878 a8d13ee0ce68 misc: replace .parents()[0] with p1() Matt Mackall <mpm@selenic.com> parents: 13873 diff changeset	1565 p = repo[x].p1().rev()
22538 a428db9ab61d revset: use `subset &` in bare `p1()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22537 diff changeset	1566 if p >= 0:
a428db9ab61d revset: use `subset &` in bare `p1()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22537 diff changeset	1567 return subset & baseset([p])
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1568 return baseset()
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1569
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1570 ps = set()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1571 cl = repo.changelog
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1572 for r in getset(repo, fullreposet(repo), x):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1573 ps.add(cl.parentrevs(r)[0])
22495 668b26d32bf6 revset: remove nullrev from set computed in p1() and p2() Pierre-Yves David <pierre-yves.david@fb.com> parents: 22494 diff changeset	1574 ps -= set([node.nullrev])
25554 94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1575 # XXX we should turn this into a baseset instead of a set, smartset may do
30342 318a24b52eeb spelling: fixes of non-dictionary words Mads Kiilerich <madski@unity3d.com> parents: 30227 diff changeset	1576 # some optimizations from the fact this is a baseset.
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1577 return subset & ps
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1578
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1579 @predicate('p2([set])', safe=True)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1580 def p2(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1581 """Second parent of changesets in set, or the working directory.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1582 """
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1583 if x is None:
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1584 ps = repo[x].parents()
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1585 try:
12935 98b79c892768 revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e) Patrick Mezard <pmezard@gmail.com> parents: 12929 diff changeset	1586 p = ps[1].rev()
22539 6f434ef54222 revset: use `subset &` in bare `p2()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22538 diff changeset	1587 if p >= 0:
6f434ef54222 revset: use `subset &` in bare `p2()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22538 diff changeset	1588 return subset & baseset([p])
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1589 return baseset()
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1590 except IndexError:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1591 return baseset()
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1592
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1593 ps = set()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1594 cl = repo.changelog
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1595 for r in getset(repo, fullreposet(repo), x):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1596 ps.add(cl.parentrevs(r)[1])
22495 668b26d32bf6 revset: remove nullrev from set computed in p1() and p2() Pierre-Yves David <pierre-yves.david@fb.com> parents: 22494 diff changeset	1597 ps -= set([node.nullrev])
25554 94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1598 # XXX we should turn this into a baseset instead of a set, smartset may do
30342 318a24b52eeb spelling: fixes of non-dictionary words Mads Kiilerich <madski@unity3d.com> parents: 30227 diff changeset	1599 # some optimizations from the fact this is a baseset.
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1600 return subset & ps
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1601
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	1602 def parentpost(repo, subset, x, order):
29935 d2d1be3009ca revset: add stub to handle parentpost operation Yuya Nishihara <yuya@tcha.org> parents: 29934 diff changeset	1603 return p1(repo, subset, x)
d2d1be3009ca revset: add stub to handle parentpost operation Yuya Nishihara <yuya@tcha.org> parents: 29934 diff changeset	1604
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1605 @predicate('parents([set])', safe=True)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1606 def parents(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1607 """
12929 515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	1608 The set of all parents for all changesets in set, or the working directory.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1609 """
12929 515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	1610 if x is None:
22496 35af9361a049 revset: refactor parents() into a single return point Pierre-Yves David <pierre-yves.david@fb.com> parents: 22495 diff changeset	1611 ps = set(p.rev() for p in repo[x].parents())
35af9361a049 revset: refactor parents() into a single return point Pierre-Yves David <pierre-yves.david@fb.com> parents: 22495 diff changeset	1612 else:
35af9361a049 revset: refactor parents() into a single return point Pierre-Yves David <pierre-yves.david@fb.com> parents: 22495 diff changeset	1613 ps = set()
35af9361a049 revset: refactor parents() into a single return point Pierre-Yves David <pierre-yves.david@fb.com> parents: 22495 diff changeset	1614 cl = repo.changelog
25716 d50677c3bf44 revset: prefetch method in "parents" Pierre-Yves David <pierre-yves.david@fb.com> parents: 25706 diff changeset	1615 up = ps.update
d50677c3bf44 revset: prefetch method in "parents" Pierre-Yves David <pierre-yves.david@fb.com> parents: 25706 diff changeset	1616 parentrevs = cl.parentrevs
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1617 for r in getset(repo, fullreposet(repo), x):
25765 5e1b0739611c revset: use integer representation of wdir() in revset Yuya Nishihara <yuya@tcha.org> parents: 25716 diff changeset	1618 if r == node.wdirrev:
25716 d50677c3bf44 revset: prefetch method in "parents" Pierre-Yves David <pierre-yves.david@fb.com> parents: 25706 diff changeset	1619 up(p.rev() for p in repo[r].parents())
25689 1cce81121472 revset: fix a crash in parents() when 'wdir()' is in the set Matt Harbison <matt_harbison@yahoo.com> parents: 25660 diff changeset	1620 else:
25716 d50677c3bf44 revset: prefetch method in "parents" Pierre-Yves David <pierre-yves.david@fb.com> parents: 25706 diff changeset	1621 up(parentrevs(r))
22497 8ea3f47bcaff revset: remove nullrev from set computed in parents() Pierre-Yves David <pierre-yves.david@fb.com> parents: 22496 diff changeset	1622 ps -= set([node.nullrev])
22712 093df3b77f27 revert: bring back usage of `subset & ps` in `parents` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22692 diff changeset	1623 return subset & ps
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1624
25621 21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1625 def _phase(repo, subset, target):
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1626 """helper to select all rev in phase <target>"""
25622 85294076adce revset: make use of natively-computed set for 'draft()' and 'secret()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25621 diff changeset	1627 repo._phasecache.loadphaserevs(repo) # ensure phase's sets are loaded
85294076adce revset: make use of natively-computed set for 'draft()' and 'secret()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25621 diff changeset	1628 if repo._phasecache._phasesets:
85294076adce revset: make use of natively-computed set for 'draft()' and 'secret()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25621 diff changeset	1629 s = repo._phasecache._phasesets[target] - repo.changelog.filteredrevs
85294076adce revset: make use of natively-computed set for 'draft()' and 'secret()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25621 diff changeset	1630 s = baseset(s)
85294076adce revset: make use of natively-computed set for 'draft()' and 'secret()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25621 diff changeset	1631 s.sort() # set are non ordered, so we enforce ascending
85294076adce revset: make use of natively-computed set for 'draft()' and 'secret()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25621 diff changeset	1632 return subset & s
85294076adce revset: make use of natively-computed set for 'draft()' and 'secret()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25621 diff changeset	1633 else:
85294076adce revset: make use of natively-computed set for 'draft()' and 'secret()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25621 diff changeset	1634 phase = repo._phasecache.phase
85294076adce revset: make use of natively-computed set for 'draft()' and 'secret()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25621 diff changeset	1635 condition = lambda r: phase(repo, r) == target
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1636 return subset.filter(condition, condrepr=('<phase %r>', target),
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1637 cache=False)
25621 21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1638
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1639 @predicate('draft()', safe=True)
25621 21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1640 def draft(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1641 """Changeset in draft phase."""
25621 21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1642 # i18n: "draft" is a keyword
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1643 getargs(x, 0, 0, _("draft takes no arguments"))
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1644 target = phases.draft
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1645 return _phase(repo, subset, target)
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1646
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1647 @predicate('secret()', safe=True)
25621 21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1648 def secret(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1649 """Changeset in secret phase."""
25621 21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1650 # i18n: "secret" is a keyword
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1651 getargs(x, 0, 0, _("secret takes no arguments"))
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1652 target = phases.secret
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1653 return _phase(repo, subset, target)
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1654
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	1655 def parentspec(repo, subset, x, n, order):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1656 """``set^0``
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1657 The set.
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1658 ``set^1`` (or ``set^``), ``set^2``
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1659 First or second parent, respectively, of all changesets in set.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1660 """
12320 40c40c6f20b8 revset: handle re.compile() errors in grep() Brodie Rao <brodie@bitheap.org> parents: 11882 diff changeset	1661 try:
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1662 n = int(n[1])
14072 2e4d79dcc0a0 revset: add missing whitespace Kevin Gessner <kevin@kevingessner.com> parents: 14070 diff changeset	1663 if n not in (0, 1, 2):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1664 raise ValueError
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	1665 except (TypeError, ValueError):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1666 raise error.ParseError(_("^ expects a number 0, 1, or 2"))
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1667 ps = set()
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1668 cl = repo.changelog
23165 7e8737e6ab08 revset-parentspec: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23164 diff changeset	1669 for r in getset(repo, fullreposet(repo), x):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1670 if n == 0:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1671 ps.add(r)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1672 elif n == 1:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1673 ps.add(cl.parentrevs(r)[0])
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1674 elif n == 2:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1675 parents = cl.parentrevs(r)
30179 cdef35b38026 revset: for x^2, do not take null as a valid p2 revision Yuya Nishihara <yuya@tcha.org> parents: 30178 diff changeset	1676 if parents[1] != node.nullrev:
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1677 ps.add(parents[1])
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1678 return subset & ps
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1679
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1680 @predicate('present(set)', safe=True)
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1681 def present(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1682 """An empty set, if any revision in set isn't found; otherwise,
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1683 all revisions in set.
16748 0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1684
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1685 If any of specified revisions is not present in the local repository,
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1686 the query is normally aborted. But this predicate allows the query
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1687 to continue even in such cases.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1688 """
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1689 try:
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1690 return getset(repo, subset, x)
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1691 except error.RepoLookupError:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1692 return baseset()
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1693
25224 d032f57936f5 revset: drop docstring from internal _notpublic() function Yuya Nishihara <yuya@tcha.org> parents: 25191 diff changeset	1694 # for internal use
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1695 @predicate('_notpublic', safe=True)
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1696 def _notpublic(repo, subset, x):
25225 57fae767c52b revset: drop translation marker from error message of _notpublic() Yuya Nishihara <yuya@tcha.org> parents: 25224 diff changeset	1697 getargs(x, 0, 0, "_notpublic takes no arguments")
25612 97528adbf74b revset: ensure we have loaded phases data in '_notpublic()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25567 diff changeset	1698 repo._phasecache.loadphaserevs(repo) # ensure phase's sets are loaded
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1699 if repo._phasecache._phasesets:
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1700 s = set()
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1701 for u in repo._phasecache._phasesets[1:]:
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1702 s.update(u)
25619 833fa28cd949 revset: use a baseset in _notpublic() Pierre-Yves David <pierre-yves.david@fb.com> parents: 25612 diff changeset	1703 s = baseset(s - repo.changelog.filteredrevs)
833fa28cd949 revset: use a baseset in _notpublic() Pierre-Yves David <pierre-yves.david@fb.com> parents: 25612 diff changeset	1704 s.sort()
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1705 return subset & s
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1706 else:
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1707 phase = repo._phasecache.phase
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1708 target = phases.public
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1709 condition = lambda r: phase(repo, r) != target
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1710 return subset.filter(condition, condrepr=('<phase %r>', target),
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1711 cache=False)
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1712
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1713 @predicate('public()', safe=True)
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1714 def public(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1715 """Changeset in public phase."""
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1716 # i18n: "public" is a keyword
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1717 getargs(x, 0, 0, _("public takes no arguments"))
23019 c8f32accd00a revset-phases: prefetch attributes in phasesrelated revsets Pierre-Yves David <pierre-yves.david@fb.com> parents: 23018 diff changeset	1718 phase = repo._phasecache.phase
c8f32accd00a revset-phases: prefetch attributes in phasesrelated revsets Pierre-Yves David <pierre-yves.david@fb.com> parents: 23018 diff changeset	1719 target = phases.public
c8f32accd00a revset-phases: prefetch attributes in phasesrelated revsets Pierre-Yves David <pierre-yves.david@fb.com> parents: 23018 diff changeset	1720 condition = lambda r: phase(repo, r) == target
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1721 return subset.filter(condition, condrepr=('<phase %r>', target),
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1722 cache=False)
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1723
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1724 @predicate('remote([id [,path]])', safe=True)
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1725 def remote(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1726 """Local revision that corresponds to the given identifier in a
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1727 remote repository, if present. Here, the '.' identifier is a
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1728 synonym for the current local branch.
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1729 """
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1730
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	1731 from . import hg # avoid start-up nasties
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1732 # i18n: "remote" is a keyword
27293 9e06e7fb037d grammar: favor zero, one, two over ... or no timeless <timeless@mozdev.org> parents: 27028 diff changeset	1733 l = getargs(x, 0, 2, _("remote takes zero, one, or two arguments"))
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1734
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1735 q = '.'
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1736 if len(l) > 0:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1737 # i18n: "remote" is a keyword
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1738 q = getstring(l[0], _("remote requires a string id"))
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1739 if q == '.':
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1740 q = repo['.'].branch()
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1741
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1742 dest = ''
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1743 if len(l) > 1:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1744 # i18n: "remote" is a keyword
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1745 dest = getstring(l[1], _("remote requires a repository path"))
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1746 dest = repo.ui.expandpath(dest or 'default')
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1747 dest, branches = hg.parseurl(dest)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1748 revs, checkout = hg.addbranchrevs(repo, repo, branches, [])
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1749 if revs:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1750 revs = [repo.lookup(rev) for rev in revs]
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1751 other = hg.peer(repo, {}, dest)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1752 n = other.lookup(q)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1753 if n in repo:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1754 r = repo[n].rev()
16006 39e60576ac98 revset: fix 'remote()' failure when remote repo has more revs than local FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 15966 diff changeset	1755 if r in subset:
20364 a6cf48b2880d revset: added baseset class (still empty) to improve revset performance Lucas Moscovicz <lmoscovicz@fb.com> parents: 20289 diff changeset	1756 return baseset([r])
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1757 return baseset()
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1758
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1759 @predicate('removes(pattern)', safe=True)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1760 def removes(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1761 """Changesets which remove files matching pattern.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1762
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1763 The pattern without explicit kind like ``glob:`` is expected to be
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1764 relative to the current directory and match against a file or a
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1765 directory.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1766 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1767 # i18n: "removes" is a keyword
12736 7e14e67e6622 revset: use 'requires' instead of 'wants' in error message Benoit Boissinot <benoit.boissinot@ens-lyon.org> parents: 12733 diff changeset	1768 pat = getstring(x, _("removes requires a pattern"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1769 return checkstatus(repo, subset, pat, 2)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1770
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1771 @predicate('rev(number)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1772 def rev(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1773 """Revision with the given numeric identifier.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1774 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1775 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1776 l = getargs(x, 1, 1, _("rev requires one argument"))
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1777 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1778 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1779 l = int(getstring(l[0], _("rev requires a number")))
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	1780 except (TypeError, ValueError):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1781 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1782 raise error.ParseError(_("rev expects a number"))
24031 fe1abb5d92f6 revset: have rev() validate input by repo.changelog.__contains__() Yuya Nishihara <yuya@tcha.org> parents: 24012 diff changeset	1783 if l not in repo.changelog and l != node.nullrev:
23062 ba89f7b542c9 revset: have rev() drop out-of-range or filtered rev explicitly (issue4396) Yuya Nishihara <yuya@tcha.org> parents: 23061 diff changeset	1784 return baseset()
22537 bbf4f3dfd700 revset: use `subset &` in `rev` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22536 diff changeset	1785 return subset & baseset([l])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1786
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1787 @predicate('matching(revision [, field])', safe=True)
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1788 def matching(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1789 """Changesets in which a given set of fields match the set of fields in the
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1790 selected revision or set.
16528 5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1791
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1792 To match more than one field pass the list of fields to match separated
16528 5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1793 by spaces (e.g. ``author description``).
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1794
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1795 Valid fields are most regular revision fields and some special fields.
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1796
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1797 Regular revision fields are ``description``, ``author``, ``branch``,
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1798 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user``
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1799 and ``diff``.
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1800 Note that ``author`` and ``user`` are synonyms. ``diff`` refers to the
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1801 contents of the revision. Two revisions matching their ``diff`` will
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1802 also match their ``files``.
16528 5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1803
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1804 Special fields are ``summary`` and ``metadata``:
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1805 ``summary`` matches the first line of the description.
16639 00290bd359fe revset: documentation typo "metatadata" Jesse Glick <jesse.glick@oracle.com> parents: 16528 diff changeset	1806 ``metadata`` is equivalent to matching ``description user date``
16528 5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1807 (i.e. it matches the main metadata fields).
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1808
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1809 ``metadata`` is the default field which is used when no fields are
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1810 specified. You can match more than one field at a time.
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1811 """
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1812 # i18n: "matching" is a keyword
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1813 l = getargs(x, 1, 2, _("matching takes 1 or 2 arguments"))
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1814
23166 30e0dcd7c5ff revset-matching: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23165 diff changeset	1815 revs = getset(repo, fullreposet(repo), l[0])
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1816
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1817 fieldlist = ['metadata']
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1818 if len(l) > 1:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1819 fieldlist = getstring(l[1],
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1820 # i18n: "matching" is a keyword
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1821 _("matching requires a string "
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1822 "as its second argument")).split()
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1823
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1824 # Make sure that there are no repeated fields,
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1825 # expand the 'special' 'metadata' field type
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1826 # and check the 'files' whenever we check the 'diff'
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1827 fields = []
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1828 for field in fieldlist:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1829 if field == 'metadata':
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1830 fields += ['user', 'description', 'date']
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1831 elif field == 'diff':
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1832 # a revision matching the diff must also match the files
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1833 # since matching the diff is very costly, make sure to
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1834 # also match the files first
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1835 fields += ['files', 'diff']
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1836 else:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1837 if field == 'author':
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1838 field = 'user'
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1839 fields.append(field)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1840 fields = set(fields)
16444 432f198600c6 revset: make matching keyword not match summary when matching for description Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16417 diff changeset	1841 if 'summary' in fields and 'description' in fields:
432f198600c6 revset: make matching keyword not match summary when matching for description Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16417 diff changeset	1842 # If a revision matches its description it also matches its summary
432f198600c6 revset: make matching keyword not match summary when matching for description Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16417 diff changeset	1843 fields.discard('summary')
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1844
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1845 # We may want to match more than one field
16446 984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1846 # Not all fields take the same amount of time to be matched
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1847 # Sort the selected fields in order of increasing matching cost
16453 d2a865d4b963 revset: make matching() work on python 2.4 Patrick Mezard <patrick@mezard.eu> parents: 16452 diff changeset	1848 fieldorder = ['phase', 'parents', 'user', 'date', 'branch', 'summary',
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1849 'files', 'description', 'substate', 'diff']
16446 984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1850 def fieldkeyfunc(f):
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1851 try:
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1852 return fieldorder.index(f)
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1853 except ValueError:
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1854 # assume an unknown field is very costly
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1855 return len(fieldorder)
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1856 fields = list(fields)
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1857 fields.sort(key=fieldkeyfunc)
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1858
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1859 # Each field will be matched with its own "getfield" function
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1860 # which will be added to the getfieldfuncs array of functions
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1861 getfieldfuncs = []
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1862 _funcs = {
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1863 'user': lambda r: repo[r].user(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1864 'branch': lambda r: repo[r].branch(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1865 'date': lambda r: repo[r].date(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1866 'description': lambda r: repo[r].description(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1867 'files': lambda r: repo[r].files(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1868 'parents': lambda r: repo[r].parents(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1869 'phase': lambda r: repo[r].phase(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1870 'substate': lambda r: repo[r].substate,
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1871 'summary': lambda r: repo[r].description().splitlines()[0],
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1872 'diff': lambda r: list(repo[r].diff(git=True),)
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1873 }
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1874 for info in fields:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1875 getfield = _funcs.get(info, None)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1876 if getfield is None:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1877 raise error.ParseError(
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1878 # i18n: "matching" is a keyword
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1879 _("unexpected field name passed to matching: %s") % info)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1880 getfieldfuncs.append(getfield)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1881 # convert the getfield array of functions into a "getinfo" function
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1882 # which returns an array of field values (or a single value if there
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1883 # is only one field to match)
16445 453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1884 getinfo = lambda r: [f(r) for f in getfieldfuncs]
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1885
20459 51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1886 def matches(x):
51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1887 for rev in revs:
51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1888 target = getinfo(rev)
16445 453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1889 match = True
453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1890 for n, f in enumerate(getfieldfuncs):
20459 51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1891 if target[n] != f(x):
16445 453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1892 match = False
453c8670566c revset: speedup matching() by stopping the match early if a field does not match Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16444 diff changeset	1893 if match:
20459 51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1894 return True
51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1895 return False
51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1896
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1897 return subset.filter(matches, condrepr=('<matching%r %r>', fields, revs))
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1898
29949 89dbae952ec1 revset: make reverse() noop depending on ordering requirement (BC) Yuya Nishihara <yuya@tcha.org> parents: 29948 diff changeset	1899 @predicate('reverse(set)', safe=True, takeorder=True)
89dbae952ec1 revset: make reverse() noop depending on ordering requirement (BC) Yuya Nishihara <yuya@tcha.org> parents: 29948 diff changeset	1900 def reverse(repo, subset, x, order):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1901 """Reverse order of set.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1902 """
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1903 l = getset(repo, subset, x)
29949 89dbae952ec1 revset: make reverse() noop depending on ordering requirement (BC) Yuya Nishihara <yuya@tcha.org> parents: 29948 diff changeset	1904 if order == defineorder:
89dbae952ec1 revset: make reverse() noop depending on ordering requirement (BC) Yuya Nishihara <yuya@tcha.org> parents: 29948 diff changeset	1905 l.reverse()
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1906 return l
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1907
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1908 @predicate('roots(set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1909 def roots(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1910 """Changesets in set with no parent changeset in set.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1911 """
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1912 s = getset(repo, fullreposet(repo), x)
25647 46a96dd4d976 revset: improves time complexity of 'roots(xxx)' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25634 diff changeset	1913 parents = repo.changelog.parentrevs
46a96dd4d976 revset: improves time complexity of 'roots(xxx)' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25634 diff changeset	1914 def filter(r):
46a96dd4d976 revset: improves time complexity of 'roots(xxx)' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25634 diff changeset	1915 for p in parents(r):
46a96dd4d976 revset: improves time complexity of 'roots(xxx)' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25634 diff changeset	1916 if 0 <= p and p in s:
46a96dd4d976 revset: improves time complexity of 'roots(xxx)' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25634 diff changeset	1917 return False
46a96dd4d976 revset: improves time complexity of 'roots(xxx)' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25634 diff changeset	1918 return True
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1919 return subset & s.filter(filter, condrepr='<roots>')
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1920
29265 3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1921 _sortkeyfuncs = {
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1922 'rev': lambda c: c.rev(),
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1923 'branch': lambda c: c.branch(),
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1924 'desc': lambda c: c.description(),
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1925 'user': lambda c: c.user(),
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1926 'author': lambda c: c.user(),
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1927 'date': lambda c: c.date()[0],
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1928 }
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1929
29365 f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1930 def _getsortargs(x):
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1931 """Parse sort options into (set, [(key, reverse)], opts)"""
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1932 args = getargsdict(x, 'sort', 'set keys topo.firstbranch')
29238 e150c1d5f262 revset: use getargsdict for sort() Martijn Pieters <mjpieters@fb.com> parents: 29216 diff changeset	1933 if 'set' not in args:
e150c1d5f262 revset: use getargsdict for sort() Martijn Pieters <mjpieters@fb.com> parents: 29216 diff changeset	1934 # i18n: "sort" is a keyword
e150c1d5f262 revset: use getargsdict for sort() Martijn Pieters <mjpieters@fb.com> parents: 29216 diff changeset	1935 raise error.ParseError(_('sort requires one or two arguments'))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1936 keys = "rev"
29238 e150c1d5f262 revset: use getargsdict for sort() Martijn Pieters <mjpieters@fb.com> parents: 29216 diff changeset	1937 if 'keys' in args:
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	1938 # i18n: "sort" is a keyword
29238 e150c1d5f262 revset: use getargsdict for sort() Martijn Pieters <mjpieters@fb.com> parents: 29216 diff changeset	1939 keys = getstring(args['keys'], _("sort spec must be a string"))
e150c1d5f262 revset: use getargsdict for sort() Martijn Pieters <mjpieters@fb.com> parents: 29216 diff changeset	1940
29363 2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1941 keyflags = []
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1942 for k in keys.split():
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1943 fk = k
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1944 reverse = (k[0] == '-')
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1945 if reverse:
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1946 k = k[1:]
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1947 if k not in _sortkeyfuncs and k != 'topo':
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1948 raise error.ParseError(_("unknown sort key %r") % fk)
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1949 keyflags.append((k, reverse))
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1950
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1951 if len(keyflags) > 1 and any(k == 'topo' for k, reverse in keyflags):
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1952 # i18n: "topo" is a keyword
29646 a8a5dd8986f0 revset: refactor to make xgettext put i18n comments into hg.pot file FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29441 diff changeset	1953 raise error.ParseError(_('topo sort order cannot be combined '
a8a5dd8986f0 revset: refactor to make xgettext put i18n comments into hg.pot file FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29441 diff changeset	1954 'with other sort keys'))
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1955
29364 76a1a703e23d revset: build dict of extra sort options before evaluating set Yuya Nishihara <yuya@tcha.org> parents: 29363 diff changeset	1956 opts = {}
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1957 if 'topo.firstbranch' in args:
29363 2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1958 if any(k == 'topo' for k, reverse in keyflags):
29364 76a1a703e23d revset: build dict of extra sort options before evaluating set Yuya Nishihara <yuya@tcha.org> parents: 29363 diff changeset	1959 opts['topo.firstbranch'] = args['topo.firstbranch']
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1960 else:
2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1961 # i18n: "topo" and "topo.firstbranch" are keywords
29646 a8a5dd8986f0 revset: refactor to make xgettext put i18n comments into hg.pot file FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29441 diff changeset	1962 raise error.ParseError(_('topo.firstbranch can only be used '
a8a5dd8986f0 revset: refactor to make xgettext put i18n comments into hg.pot file FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 29441 diff changeset	1963 'when using the topo sort key'))
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1964
29365 f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1965 return args['set'], keyflags, opts
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1966
29950 285a8c3e53f2 revset: make sort() noop depending on ordering requirement (BC) Yuya Nishihara <yuya@tcha.org> parents: 29949 diff changeset	1967 @predicate('sort(set[, [-]key... [, ...]])', safe=True, takeorder=True)
285a8c3e53f2 revset: make sort() noop depending on ordering requirement (BC) Yuya Nishihara <yuya@tcha.org> parents: 29949 diff changeset	1968 def sort(repo, subset, x, order):
29365 f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1969 """Sort set by keys. The default sort order is ascending, specify a key
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1970 as ``-key`` to sort in descending order.
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1971
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1972 The keys can be:
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1973
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1974 - ``rev`` for the revision number,
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1975 - ``branch`` for the branch name,
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1976 - ``desc`` for the commit message (description),
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1977 - ``user`` for user name (``author`` can be used as an alias),
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1978 - ``date`` for the commit date
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1979 - ``topo`` for a reverse topographical sort
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1980
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1981 The ``topo`` sort order cannot be combined with other sort keys. This sort
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1982 takes one optional argument, ``topo.firstbranch``, which takes a revset that
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1983 specifies what topographical branches to prioritize in the sort.
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1984
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1985 """
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1986 s, keyflags, opts = _getsortargs(x)
29364 76a1a703e23d revset: build dict of extra sort options before evaluating set Yuya Nishihara <yuya@tcha.org> parents: 29363 diff changeset	1987 revs = getset(repo, subset, s)
76a1a703e23d revset: build dict of extra sort options before evaluating set Yuya Nishihara <yuya@tcha.org> parents: 29363 diff changeset	1988
29950 285a8c3e53f2 revset: make sort() noop depending on ordering requirement (BC) Yuya Nishihara <yuya@tcha.org> parents: 29949 diff changeset	1989 if not keyflags or order != defineorder:
20719 cce8fbedc82a revset: changed sort method to use native sort implementation of smartsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20718 diff changeset	1990 return revs
29363 2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1991 if len(keyflags) == 1 and keyflags[0][0] == "rev":
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1992 revs.sort(reverse=keyflags[0][1])
20719 cce8fbedc82a revset: changed sort method to use native sort implementation of smartsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20718 diff changeset	1993 return revs
29363 2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1994 elif keyflags[0][0] == "topo":
29364 76a1a703e23d revset: build dict of extra sort options before evaluating set Yuya Nishihara <yuya@tcha.org> parents: 29363 diff changeset	1995 firstbranch = ()
76a1a703e23d revset: build dict of extra sort options before evaluating set Yuya Nishihara <yuya@tcha.org> parents: 29363 diff changeset	1996 if 'topo.firstbranch' in opts:
76a1a703e23d revset: build dict of extra sort options before evaluating set Yuya Nishihara <yuya@tcha.org> parents: 29363 diff changeset	1997 firstbranch = getset(repo, subset, opts['topo.firstbranch'])
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1998 revs = baseset(_toposort(revs, repo.changelog.parentrevs, firstbranch),
2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1999 istopo=True)
29363 2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	2000 if keyflags[0][1]:
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	2001 revs.reverse()
2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	2002 return revs
2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	2003
29001 923fa9e06ea0 revset: make sort() do dumb multi-pass sorting for multiple keys (issue5218) Yuya Nishihara <yuya@tcha.org> parents: 28910 diff changeset	2004 # sort() is guaranteed to be stable
923fa9e06ea0 revset: make sort() do dumb multi-pass sorting for multiple keys (issue5218) Yuya Nishihara <yuya@tcha.org> parents: 28910 diff changeset	2005 ctxs = [repo[r] for r in revs]
29363 2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	2006 for k, reverse in reversed(keyflags):
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	2007 ctxs.sort(key=_sortkeyfuncs[k], reverse=reverse)
29001 923fa9e06ea0 revset: make sort() do dumb multi-pass sorting for multiple keys (issue5218) Yuya Nishihara <yuya@tcha.org> parents: 28910 diff changeset	2008 return baseset([c.rev() for c in ctxs])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2009
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	2010 def _toposort(revs, parentsfunc, firstbranch=()):
29347 98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2011 """Yield revisions from heads to roots one (topo) branch at a time.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2012
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2013 This function aims to be used by a graph generator that wishes to minimize
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2014 the number of parallel branches and their interleaving.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2015
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2016 Example iteration order (numbers show the "true" order in a changelog):
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2017
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2018 o 4
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2019 \|
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2020 o 1
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2021 \|
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2022 \| o 3
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2023 \| \|
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2024 \| o 2
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2025 \|/
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2026 o 0
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2027
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2028 Note that the ancestors of merges are understood by the current
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2029 algorithm to be on the same branch. This means no reordering will
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2030 occur behind a merge.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2031 """
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2032
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2033 ### Quick summary of the algorithm
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2034 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2035 # This function is based around a "retention" principle. We keep revisions
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2036 # in memory until we are ready to emit a whole branch that immediately
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2037 # "merges" into an existing one. This reduces the number of parallel
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2038 # branches with interleaved revisions.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2039 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2040 # During iteration revs are split into two groups:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2041 # A) revision already emitted
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2042 # B) revision in "retention". They are stored as different subgroups.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2043 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2044 # for each REV, we do the following logic:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2045 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2046 # 1) if REV is a parent of (A), we will emit it. If there is a
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2047 # retention group ((B) above) that is blocked on REV being
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2048 # available, we emit all the revisions out of that retention
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2049 # group first.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2050 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2051 # 2) else, we'll search for a subgroup in (B) awaiting for REV to be
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2052 # available, if such subgroup exist, we add REV to it and the subgroup is
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2053 # now awaiting for REV.parents() to be available.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2054 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2055 # 3) finally if no such group existed in (B), we create a new subgroup.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2056 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2057 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2058 # To bootstrap the algorithm, we emit the tipmost revision (which
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2059 # puts it in group (A) from above).
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2060
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2061 revs.sort(reverse=True)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2062
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2063 # Set of parents of revision that have been emitted. They can be considered
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2064 # unblocked as the graph generator is already aware of them so there is no
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2065 # need to delay the revisions that reference them.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2066 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2067 # If someone wants to prioritize a branch over the others, pre-filling this
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2068 # set will force all other branches to wait until this branch is ready to be
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2069 # emitted.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2070 unblocked = set(firstbranch)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2071
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2072 # list of groups waiting to be displayed, each group is defined by:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2073 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2074 # (revs: lists of revs waiting to be displayed,
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2075 # blocked: set of that cannot be displayed before those in 'revs')
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2076 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2077 # The second value ('blocked') correspond to parents of any revision in the
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2078 # group ('revs') that is not itself contained in the group. The main idea
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2079 # of this algorithm is to delay as much as possible the emission of any
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2080 # revision. This means waiting for the moment we are about to display
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2081 # these parents to display the revs in a group.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2082 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2083 # This first implementation is smart until it encounters a merge: it will
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2084 # emit revs as soon as any parent is about to be emitted and can grow an
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2085 # arbitrary number of revs in 'blocked'. In practice this mean we properly
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2086 # retains new branches but gives up on any special ordering for ancestors
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2087 # of merges. The implementation can be improved to handle this better.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2088 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2089 # The first subgroup is special. It corresponds to all the revision that
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2090 # were already emitted. The 'revs' lists is expected to be empty and the
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2091 # 'blocked' set contains the parents revisions of already emitted revision.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2092 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2093 # You could pre-seed the <parents> set of groups[0] to a specific
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2094 # changesets to select what the first emitted branch should be.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2095 groups = [([], unblocked)]
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2096 pendingheap = []
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2097 pendingset = set()
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2098
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2099 heapq.heapify(pendingheap)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2100 heappop = heapq.heappop
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2101 heappush = heapq.heappush
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2102 for currentrev in revs:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2103 # Heap works with smallest element, we want highest so we invert
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2104 if currentrev not in pendingset:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2105 heappush(pendingheap, -currentrev)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2106 pendingset.add(currentrev)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2107 # iterates on pending rev until after the current rev have been
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2108 # processed.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2109 rev = None
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2110 while rev != currentrev:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2111 rev = -heappop(pendingheap)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2112 pendingset.remove(rev)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2113
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2114 # Seek for a subgroup blocked, waiting for the current revision.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2115 matching = [i for i, g in enumerate(groups) if rev in g[1]]
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2116
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2117 if matching:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2118 # The main idea is to gather together all sets that are blocked
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2119 # on the same revision.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2120 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2121 # Groups are merged when a common blocking ancestor is
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2122 # observed. For example, given two groups:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2123 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2124 # revs [5, 4] waiting for 1
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2125 # revs [3, 2] waiting for 1
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2126 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2127 # These two groups will be merged when we process
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2128 # 1. In theory, we could have merged the groups when
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2129 # we added 2 to the group it is now in (we could have
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2130 # noticed the groups were both blocked on 1 then), but
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2131 # the way it works now makes the algorithm simpler.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2132 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2133 # We also always keep the oldest subgroup first. We can
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2134 # probably improve the behavior by having the longest set
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2135 # first. That way, graph algorithms could minimise the length
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2136 # of parallel lines their drawing. This is currently not done.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2137 targetidx = matching.pop(0)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2138 trevs, tparents = groups[targetidx]
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2139 for i in matching:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2140 gr = groups[i]
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2141 trevs.extend(gr[0])
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2142 tparents \|= gr[1]
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2143 # delete all merged subgroups (except the one we kept)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2144 # (starting from the last subgroup for performance and
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2145 # sanity reasons)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2146 for i in reversed(matching):
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2147 del groups[i]
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2148 else:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2149 # This is a new head. We create a new subgroup for it.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2150 targetidx = len(groups)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2151 groups.append(([], set([rev])))
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2152
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2153 gr = groups[targetidx]
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2154
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2155 # We now add the current nodes to this subgroups. This is done
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2156 # after the subgroup merging because all elements from a subgroup
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2157 # that relied on this rev must precede it.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2158 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2159 # we also update the <parents> set to include the parents of the
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2160 # new nodes.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2161 if rev == currentrev: # only display stuff in rev
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2162 gr[0].append(rev)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2163 gr[1].remove(rev)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2164 parents = [p for p in parentsfunc(rev) if p > node.nullrev]
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2165 gr[1].update(parents)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2166 for p in parents:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2167 if p not in pendingset:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2168 pendingset.add(p)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2169 heappush(pendingheap, -p)
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2170
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2171 # Look for a subgroup to display
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2172 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2173 # When unblocked is empty (if clause), we were not waiting for any
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2174 # revisions during the first iteration (if no priority was given) or
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2175 # if we emitted a whole disconnected set of the graph (reached a
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2176 # root). In that case we arbitrarily take the oldest known
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2177 # subgroup. The heuristic could probably be better.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2178 #
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2179 # Otherwise (elif clause) if the subgroup is blocked on
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2180 # a revision we just emitted, we can safely emit it as
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2181 # well.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2182 if not unblocked:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2183 if len(groups) > 1: # display other subset
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2184 targetidx = 1
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2185 gr = groups[1]
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2186 elif not gr[1] & unblocked:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2187 gr = None
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2188
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2189 if gr is not None:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2190 # update the set of awaited revisions with the one from the
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2191 # subgroup
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2192 unblocked \|= gr[1]
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2193 # output all revisions in the subgroup
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2194 for r in gr[0]:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2195 yield r
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2196 # delete the subgroup that you just output
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2197 # unless it is groups[0] in which case you just empty it.
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2198 if targetidx:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2199 del groups[targetidx]
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2200 else:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2201 gr[0][:] = []
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2202 # Check if we have some subgroup waiting for revisions we are not going to
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2203 # iterate over
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2204 for g in groups:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2205 for r in g[0]:
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2206 yield r
98535ad46fc0 revset: move groupbranchiter over from graphmod Martijn Pieters <mjpieters@fb.com> parents: 29346 diff changeset	2207
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	2208 @predicate('subrepo([pattern])')
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2209 def subrepo(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	2210 """Changesets that add, modify or remove the given subrepo. If no subrepo
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2211 pattern is named, any subrepo changes are returned.
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2212 """
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2213 # i18n: "subrepo" is a keyword
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2214 args = getargs(x, 0, 1, _('subrepo takes at most one argument'))
28272 760f9d04842a revset: define "pat" variable unconditionally in subrepo() Yuya Nishihara <yuya@tcha.org> parents: 28271 diff changeset	2215 pat = None
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2216 if len(args) != 0:
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2217 pat = getstring(args[0], _("subrepo requires a pattern"))
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2218
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2219 m = matchmod.exact(repo.root, repo.root, ['.hgsubstate'])
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2220
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2221 def submatches(names):
26481 7d132557e44a util: extract stringmatcher() from revset Matt Harbison <matt_harbison@yahoo.com> parents: 26307 diff changeset	2222 k, p, m = util.stringmatcher(pat)
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2223 for name in names:
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2224 if m(name):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2225 yield name
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2226
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2227 def matches(x):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2228 c = repo[x]
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2229 s = repo.status(c.p1().node(), c.node(), match=m)
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2230
28272 760f9d04842a revset: define "pat" variable unconditionally in subrepo() Yuya Nishihara <yuya@tcha.org> parents: 28271 diff changeset	2231 if pat is None:
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2232 return s.added or s.modified or s.removed
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2233
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2234 if s.added:
25149 3f0744eeaeaf cleanup: use __builtins__.any instead of util.any Augie Fackler <augie@google.com> parents: 25146 diff changeset	2235 return any(submatches(c.substate.keys()))
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2236
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2237 if s.modified:
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2238 subs = set(c.p1().substate.keys())
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2239 subs.update(c.substate.keys())
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2240
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2241 for path in submatches(subs):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2242 if c.p1().substate.get(path) != c.substate.get(path):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2243 return True
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2244
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2245 if s.removed:
25149 3f0744eeaeaf cleanup: use __builtins__.any instead of util.any Augie Fackler <augie@google.com> parents: 25146 diff changeset	2246 return any(submatches(c.p1().substate.keys()))
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2247
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2248 return False
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2249
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	2250 return subset.filter(matches, condrepr=('<subrepo %r>', pat))
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	2251
30782 db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	2252 def _substringmatcher(pattern, casesensitive=True):
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	2253 kind, pattern, matcher = util.stringmatcher(pattern,
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	2254 casesensitive=casesensitive)
16823 b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	2255 if kind == 'literal':
30782 db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	2256 if not casesensitive:
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	2257 pattern = encoding.lower(pattern)
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	2258 matcher = lambda s: pattern in encoding.lower(s)
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	2259 else:
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	2260 matcher = lambda s: pattern in s
16823 b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	2261 return kind, pattern, matcher
16819 5260a9e93113 revset: add helper function for matching strings to patterns Simon King <simon@simonking.org.uk> parents: 16803 diff changeset	2262
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	2263 @predicate('tag([name])', safe=True)
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	2264 def tag(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	2265 """The specified tag by name, or all tagged revisions if no name is given.
20824 c57c9cece645 revset: document the regular expression support for tag(name) Matt Harbison <matt_harbison@yahoo.com> parents: 20289 diff changeset	2266
c57c9cece645 revset: document the regular expression support for tag(name) Matt Harbison <matt_harbison@yahoo.com> parents: 20289 diff changeset	2267 If `name` starts with `re:`, the remainder of the name is treated as
c57c9cece645 revset: document the regular expression support for tag(name) Matt Harbison <matt_harbison@yahoo.com> parents: 20289 diff changeset	2268 a regular expression. To match a tag that actually starts with `re:`,
c57c9cece645 revset: document the regular expression support for tag(name) Matt Harbison <matt_harbison@yahoo.com> parents: 20289 diff changeset	2269 use the prefix `literal:`.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	2270 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	2271 # i18n: "tag" is a keyword
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	2272 args = getargs(x, 0, 1, _("tag takes one or no arguments"))
11280 a5eb0bf7e158 revset: add tagged predicate Matt Mackall <mpm@selenic.com> parents: 11279 diff changeset	2273 cl = repo.changelog
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	2274 if args:
16820 20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	2275 pattern = getstring(args[0],
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	2276 # i18n: "tag" is a keyword
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	2277 _('the argument to tag must be a string'))
26481 7d132557e44a util: extract stringmatcher() from revset Matt Harbison <matt_harbison@yahoo.com> parents: 26307 diff changeset	2278 kind, pattern, matcher = util.stringmatcher(pattern)
16820 20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	2279 if kind == 'literal':
16825 b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	2280 # avoid resolving all tags
b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	2281 tn = repo._tagscache.tags.get(pattern, None)
b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	2282 if tn is None:
23978 eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	2283 raise error.RepoLookupError(_("tag '%s' does not exist")
eeb5d5ab14a6 revset: raise RepoLookupError to make present() predicate continue the query FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23956 diff changeset	2284 % pattern)
16825 b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	2285 s = set([repo[tn].rev()])
16820 20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	2286 else:
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	2287 s = set([cl.rev(n) for t, n in repo.tagslist() if matcher(t)])
12715 33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	2288 else:
33820dccbea4 revset: rename tagged() to tag() and allow it to take an optional tag name Augie Fackler <durin42@gmail.com> parents: 12616 diff changeset	2289 s = set([cl.rev(n) for t, n in repo.tagslist() if t != 'tip'])
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	2290 return subset & s
11280 a5eb0bf7e158 revset: add tagged predicate Matt Mackall <mpm@selenic.com> parents: 11279 diff changeset	2291
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	2292 @predicate('tagged', safe=True)
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	2293 def tagged(repo, subset, x):
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	2294 return tag(repo, subset, x)
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	2295
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	2296 @predicate('unstable()', safe=True)
17171 9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	2297 def unstable(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	2298 """Non-obsolete changesets with obsolete ancestors.
17291 2d6bbf87f7b4 revset: minor doc fixes on obsolete related revsets Patrick Mezard <patrick@mezard.eu> parents: 17272 diff changeset	2299 """
17259 e96ad092fb18 i18n: add/relocate "i18n keyword" comments for i18n messages in revset.py FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17258 diff changeset	2300 # i18n: "unstable" is a keyword
17258 5822345e9e46 revset: use appropriate predicate name in error messages FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 17244 diff changeset	2301 getargs(x, 0, 0, _("unstable takes no arguments"))
17825 3cc06457f15e obsolete: rename `getobscache` into `getrevs` Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17804 diff changeset	2302 unstables = obsmod.getrevs(repo, 'unstable')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	2303 return subset & unstables
17171 9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	2304
9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	2305
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	2306 @predicate('user(string)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	2307 def user(repo, subset, x):
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	2308 """User name contains string. The match is case-insensitive.
16823 b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	2309
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	2310 If `string` starts with `re:`, the remainder of the string is treated as
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	2311 a regular expression. To match a user that actually contains `re:`, use
b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	2312 the prefix `literal:`.
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	2313 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	2314 return author(repo, subset, x)
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	2315
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	2316 @predicate('wdir', safe=True)
24419 0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	2317 def wdir(repo, subset, x):
30701 8b1d87243710 revset: document wdir() as an experimental function Yuya Nishihara <yuya@tcha.org> parents: 30700 diff changeset	2318 """Working directory. (EXPERIMENTAL)"""
24419 0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	2319 # i18n: "wdir" is a keyword
0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	2320 getargs(x, 0, 0, _("wdir takes no arguments"))
25765 5e1b0739611c revset: use integer representation of wdir() in revset Yuya Nishihara <yuya@tcha.org> parents: 25716 diff changeset	2321 if node.wdirrev in subset or isinstance(subset, fullreposet):
5e1b0739611c revset: use integer representation of wdir() in revset Yuya Nishihara <yuya@tcha.org> parents: 25716 diff changeset	2322 return baseset([node.wdirrev])
24419 0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	2323 return baseset()
0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	2324
29939 e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2325 def _orderedlist(repo, subset, x):
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2326 s = getstring(x, "internal error")
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2327 if not s:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	2328 return baseset()
25341 9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	2329 # remove duplicates here. it's difficult for caller to deduplicate sets
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	2330 # because different symbols can point to the same rev.
25344 ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	2331 cl = repo.changelog
25341 9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	2332 ls = []
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	2333 seen = set()
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	2334 for t in s.split('\0'):
25344 ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	2335 try:
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	2336 # fast path for integer revision
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	2337 r = int(t)
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	2338 if str(r) != t or r not in cl:
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	2339 raise ValueError
26143 42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	2340 revs = [r]
25344 ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	2341 except ValueError:
26143 42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	2342 revs = stringset(repo, subset, t)
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	2343
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	2344 for r in revs:
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	2345 if r in seen:
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	2346 continue
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	2347 if (r in subset
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	2348 or r == node.nullrev and isinstance(subset, fullreposet)):
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	2349 ls.append(r)
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	2350 seen.add(r)
25341 9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	2351 return baseset(ls)
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2352
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	2353 # for internal use
29939 e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2354 @predicate('_list', safe=True, takeorder=True)
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2355 def _list(repo, subset, x, order):
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2356 if order == followorder:
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2357 # slow path to take the subset order
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2358 return subset & _orderedlist(repo, fullreposet(repo), x)
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2359 else:
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2360 return _orderedlist(repo, subset, x)
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2361
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2362 def _orderedintlist(repo, subset, x):
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	2363 s = getstring(x, "internal error")
98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	2364 if not s:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	2365 return baseset()
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	2366 ls = [int(r) for r in s.split('\0')]
22876 d52ca940c665 revset-_intlist: remove usage of `set()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22875 diff changeset	2367 s = subset
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	2368 return baseset([r for r in ls if r in s])
98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	2369
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	2370 # for internal use
29939 e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2371 @predicate('_intlist', safe=True, takeorder=True)
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2372 def _intlist(repo, subset, x, order):
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2373 if order == followorder:
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2374 # slow path to take the subset order
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2375 return subset & _orderedintlist(repo, fullreposet(repo), x)
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2376 else:
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2377 return _orderedintlist(repo, subset, x)
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2378
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2379 def _orderedhexlist(repo, subset, x):
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	2380 s = getstring(x, "internal error")
0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	2381 if not s:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	2382 return baseset()
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	2383 cl = repo.changelog
0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	2384 ls = [cl.rev(node.bin(r)) for r in s.split('\0')]
22877 489d2f3688c9 revset-_hexlist: remove usage of `set()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22876 diff changeset	2385 s = subset
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	2386 return baseset([r for r in ls if r in s])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2387
29939 e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2388 # for internal use
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2389 @predicate('_hexlist', safe=True, takeorder=True)
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2390 def _hexlist(repo, subset, x, order):
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2391 if order == followorder:
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2392 # slow path to take the subset order
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2393 return subset & _orderedhexlist(repo, fullreposet(repo), x)
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2394 else:
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2395 return _orderedhexlist(repo, subset, x)
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2396
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2397 methods = {
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2398 "range": rangeset,
30044 69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	2399 "rangepre": rangepre,
16860 e1aa1ed30030 revset: turn dagrange into a function Bryan O'Sullivan <bryano@fb.com> parents: 16859 diff changeset	2400 "dagrange": dagrange,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2401 "string": stringset,
24932 022282152632 revset: don't error out if tokens parse as existing symbols Jordi Guti?rrez Hermoso <jordigh@octave.org> parents: 24923 diff changeset	2402 "symbol": stringset,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2403 "and": andset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2404 "or": orset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2405 "not": notset,
28217 d2ac8b57a75d revset: use smartset minus operator Durham Goode <durham@fb.com> parents: 28139 diff changeset	2406 "difference": differenceset,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2407 "list": listset,
25704 70a2082f855a revset: add parsing rule for key=value pair Yuya Nishihara <yuya@tcha.org> parents: 25689 diff changeset	2408 "keyvalue": keyvaluepair,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2409 "func": func,
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	2410 "ancestor": ancestorspec,
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	2411 "parent": parentspec,
29935 d2d1be3009ca revset: add stub to handle parentpost operation Yuya Nishihara <yuya@tcha.org> parents: 29934 diff changeset	2412 "parentpost": parentpost,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2413 }
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2414
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2415 # Constants for ordering requirement, used in _analyze():
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2416 #
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2417 # If 'define', any nested functions and operations can change the ordering of
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2418 # the entries in the set. If 'follow', any nested functions and operations
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2419 # should take the ordering specified by the first operand to the '&' operator.
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2420 #
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2421 # For instance,
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2422 #
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2423 # X & (Y \| Z)
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2424 # ^ ^^^^^^^
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2425 # \| follow
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2426 # define
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2427 #
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2428 # will be evaluated as 'or(y(x()), z(x()))', where 'x()' can change the order
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2429 # of the entries in the set, but 'y()', 'z()' and 'or()' shouldn't.
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2430 #
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2431 # 'any' means the order doesn't matter. For instance,
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2432 #
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2433 # X & !Y
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2434 # ^
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2435 # any
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2436 #
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2437 # 'y()' can either enforce its ordering requirement or take the ordering
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2438 # specified by 'x()' because 'not()' doesn't care the order.
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2439 #
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2440 # Transition of ordering requirement:
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2441 #
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2442 # 1. starts with 'define'
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2443 # 2. shifts to 'follow' by 'x & y'
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2444 # 3. changes back to 'define' on function call 'f(x)' or function-like
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2445 # operation 'x (f) y' because 'f' may have its own ordering requirement
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2446 # for 'x' and 'y' (e.g. 'first(x)')
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2447 #
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2448 anyorder = 'any' # don't care the order
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2449 defineorder = 'define' # should define the order
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2450 followorder = 'follow' # must follow the current order
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2451
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2452 # transition table for 'x & y', from the current expression 'x' to 'y'
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2453 _tofolloworder = {
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2454 anyorder: anyorder,
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2455 defineorder: followorder,
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2456 followorder: followorder,
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2457 }
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2458
29117 7828cadd2873 revset: construct arguments of only() against matched tree Yuya Nishihara <yuya@tcha.org> parents: 29116 diff changeset	2459 def _matchonly(revs, bases):
7828cadd2873 revset: construct arguments of only() against matched tree Yuya Nishihara <yuya@tcha.org> parents: 29116 diff changeset	2460 """
7828cadd2873 revset: construct arguments of only() against matched tree Yuya Nishihara <yuya@tcha.org> parents: 29116 diff changeset	2461 >>> f = lambda args: _matchonly(map(parse, args))
7828cadd2873 revset: construct arguments of only() against matched tree Yuya Nishihara <yuya@tcha.org> parents: 29116 diff changeset	2462 >>> f('ancestors(A)', 'not ancestors(B)')
7828cadd2873 revset: construct arguments of only() against matched tree Yuya Nishihara <yuya@tcha.org> parents: 29116 diff changeset	2463 ('list', ('symbol', 'A'), ('symbol', 'B'))
7828cadd2873 revset: construct arguments of only() against matched tree Yuya Nishihara <yuya@tcha.org> parents: 29116 diff changeset	2464 """
7828cadd2873 revset: construct arguments of only() against matched tree Yuya Nishihara <yuya@tcha.org> parents: 29116 diff changeset	2465 if (revs is not None
29116 0c9b05dae010 revset: unnest isonly() closure from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29098 diff changeset	2466 and revs[0] == 'func'
29441 9e8d258708bb revset: check invalid function syntax "func-name"() explicitly Yuya Nishihara <yuya@tcha.org> parents: 29425 diff changeset	2467 and getsymbol(revs[1]) == 'ancestors'
29116 0c9b05dae010 revset: unnest isonly() closure from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29098 diff changeset	2468 and bases is not None
0c9b05dae010 revset: unnest isonly() closure from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29098 diff changeset	2469 and bases[0] == 'not'
0c9b05dae010 revset: unnest isonly() closure from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29098 diff changeset	2470 and bases[1][0] == 'func'
29441 9e8d258708bb revset: check invalid function syntax "func-name"() explicitly Yuya Nishihara <yuya@tcha.org> parents: 29425 diff changeset	2471 and getsymbol(bases[1][1]) == 'ancestors'):
29117 7828cadd2873 revset: construct arguments of only() against matched tree Yuya Nishihara <yuya@tcha.org> parents: 29116 diff changeset	2472 return ('list', revs[2], bases[1][2])
29116 0c9b05dae010 revset: unnest isonly() closure from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29098 diff changeset	2473
29780 abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2474 def _fixops(x):
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2475 """Rewrite raw parsed tree to resolve ambiguous syntax which cannot be
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2476 handled well by our simple top-down parser"""
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2477 if not isinstance(x, tuple):
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2478 return x
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2479
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2480 op = x[0]
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2481 if op == 'parent':
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2482 # x^:y means (x^) : y, not x ^ (:y)
29781 9c51a5de76db revset: also parse x^: as (x^): Yuya Nishihara <yuya@tcha.org> parents: 29780 diff changeset	2483 # x^: means (x^) :, not x ^ (:)
29780 abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2484 post = ('parentpost', x[1])
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2485 if x[2][0] == 'dagrangepre':
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2486 return _fixops(('dagrange', post, x[2][1]))
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2487 elif x[2][0] == 'rangepre':
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2488 return _fixops(('range', post, x[2][1]))
29781 9c51a5de76db revset: also parse x^: as (x^): Yuya Nishihara <yuya@tcha.org> parents: 29780 diff changeset	2489 elif x[2][0] == 'rangeall':
9c51a5de76db revset: also parse x^: as (x^): Yuya Nishihara <yuya@tcha.org> parents: 29780 diff changeset	2490 return _fixops(('rangepost', post))
29933 b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	2491 elif op == 'or':
b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	2492 # make number of arguments deterministic:
b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	2493 # x + y + z -> (or x y z) -> (or (list x y z))
b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	2494 return (op, _fixops(('list',) + x[1:]))
29780 abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2495
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2496 return (op,) + tuple(_fixops(y) for y in x[1:])
abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2497
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2498 def _analyze(x, order):
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2499 if x is None:
e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2500 return x
e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2501
e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2502 op = x[0]
e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2503 if op == 'minus':
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2504 return _analyze(('and', x[1], ('not', x[2])), order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2505 elif op == 'only':
e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2506 t = ('func', ('symbol', 'only'), ('list', x[1], x[2]))
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2507 return _analyze(t, order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2508 elif op == 'onlypost':
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2509 return _analyze(('func', ('symbol', 'only'), x[1]), order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2510 elif op == 'dagrangepre':
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2511 return _analyze(('func', ('symbol', 'ancestors'), x[1]), order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2512 elif op == 'dagrangepost':
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2513 return _analyze(('func', ('symbol', 'descendants'), x[1]), order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2514 elif op == 'rangeall':
30044 69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	2515 return _analyze(('rangepre', ('string', 'tip')), order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2516 elif op == 'rangepost':
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2517 return _analyze(('range', x[1], ('string', 'tip')), order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2518 elif op == 'negate':
e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2519 s = getstring(x[1], _("can't negate that"))
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2520 return _analyze(('string', '-' + s), order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2521 elif op in ('string', 'symbol'):
e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2522 return x
e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2523 elif op == 'and':
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2524 ta = _analyze(x[1], order)
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2525 tb = _analyze(x[2], _tofolloworder[order])
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2526 return (op, ta, tb, order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2527 elif op == 'or':
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2528 return (op, _analyze(x[1], order), order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2529 elif op == 'not':
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2530 return (op, _analyze(x[1], anyorder), order)
30044 69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	2531 elif op in ('rangepre', 'parentpost'):
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2532 return (op, _analyze(x[1], defineorder), order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2533 elif op == 'group':
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2534 return _analyze(x[1], order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2535 elif op in ('dagrange', 'range', 'parent', 'ancestor'):
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2536 ta = _analyze(x[1], defineorder)
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2537 tb = _analyze(x[2], defineorder)
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2538 return (op, ta, tb, order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2539 elif op == 'list':
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2540 return (op,) + tuple(_analyze(y, order) for y in x[1:])
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2541 elif op == 'keyvalue':
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2542 return (op, x[1], _analyze(x[2], order))
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2543 elif op == 'func':
29947 80c86b9bb40b revset: forward ordering requirement to argument of present() Yuya Nishihara <yuya@tcha.org> parents: 29939 diff changeset	2544 f = getsymbol(x[1])
80c86b9bb40b revset: forward ordering requirement to argument of present() Yuya Nishihara <yuya@tcha.org> parents: 29939 diff changeset	2545 d = defineorder
80c86b9bb40b revset: forward ordering requirement to argument of present() Yuya Nishihara <yuya@tcha.org> parents: 29939 diff changeset	2546 if f == 'present':
80c86b9bb40b revset: forward ordering requirement to argument of present() Yuya Nishihara <yuya@tcha.org> parents: 29939 diff changeset	2547 # 'present(set)' is known to return the argument set with no
80c86b9bb40b revset: forward ordering requirement to argument of present() Yuya Nishihara <yuya@tcha.org> parents: 29939 diff changeset	2548 # modification, so forward the current order to its argument
80c86b9bb40b revset: forward ordering requirement to argument of present() Yuya Nishihara <yuya@tcha.org> parents: 29939 diff changeset	2549 d = order
80c86b9bb40b revset: forward ordering requirement to argument of present() Yuya Nishihara <yuya@tcha.org> parents: 29939 diff changeset	2550 return (op, x[1], _analyze(x[2], d), order)
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2551 raise ValueError('invalid operator %r' % op)
e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2552
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2553 def analyze(x, order=defineorder):
29909 371c2a39eead revset: make analyze() a separate step from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29908 diff changeset	2554 """Transform raw parsed tree to evaluatable tree which can be fed to
371c2a39eead revset: make analyze() a separate step from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29908 diff changeset	2555 optimize() or getset()
371c2a39eead revset: make analyze() a separate step from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29908 diff changeset	2556
371c2a39eead revset: make analyze() a separate step from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29908 diff changeset	2557 All pseudo operations should be mapped to real operations or functions
371c2a39eead revset: make analyze() a separate step from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29908 diff changeset	2558 defined in methods or symbols table respectively.
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2559
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2560 'order' specifies how the current expression 'x' is ordered (see the
90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2561 constants defined above.)
29909 371c2a39eead revset: make analyze() a separate step from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29908 diff changeset	2562 """
29934 90455e7bf543 revset: infer ordering flag to teach if operation should define/follow order Yuya Nishihara <yuya@tcha.org> parents: 29933 diff changeset	2563 return _analyze(x, order)
29909 371c2a39eead revset: make analyze() a separate step from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29908 diff changeset	2564
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2565 def _optimize(x, small):
13031 3da456d0c885 code style: prefer 'is' and 'is not' tests with singletons Martin Geisler <mg@aragost.com> parents: 12936 diff changeset	2566 if x is None:
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2567 return 0, x
62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2568
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2569 smallbonus = 1
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2570 if small:
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2571 smallbonus = .5
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2572
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2573 op = x[0]
29908 e4b4168a4f1c revset: extract tree transformation from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29902 diff changeset	2574 if op in ('string', 'symbol'):
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2575 return smallbonus, x # single revisions are small
16859 eeb464ed7275 revset: drop unreachable code Bryan O'Sullivan <bryano@fb.com> parents: 16838 diff changeset	2576 elif op == 'and':
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2577 wa, ta = _optimize(x[1], True)
a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2578 wb, tb = _optimize(x[2], True)
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2579 order = x[3]
29116 0c9b05dae010 revset: unnest isonly() closure from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29098 diff changeset	2580 w = min(wa, wb)
20499 2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2581
2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2582 # (::x and not ::y)/(not ::y and ::x) have a fast path
29117 7828cadd2873 revset: construct arguments of only() against matched tree Yuya Nishihara <yuya@tcha.org> parents: 29116 diff changeset	2583 tm = _matchonly(ta, tb) or _matchonly(tb, ta)
7828cadd2873 revset: construct arguments of only() against matched tree Yuya Nishihara <yuya@tcha.org> parents: 29116 diff changeset	2584 if tm:
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2585 return w, ('func', ('symbol', 'only'), tm, order)
20499 2efd608473fb revset: optimize missing ancestor expressions Siddharth Agarwal <sid0@fb.com> parents: 20498 diff changeset	2586
28217 d2ac8b57a75d revset: use smartset minus operator Durham Goode <durham@fb.com> parents: 28139 diff changeset	2587 if tb is not None and tb[0] == 'not':
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2588 return wa, ('difference', ta, tb[1], order)
28217 d2ac8b57a75d revset: use smartset minus operator Durham Goode <durham@fb.com> parents: 28139 diff changeset	2589
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2590 if wa > wb:
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2591 return w, (op, tb, ta, order)
09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2592 return w, (op, ta, tb, order)
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2593 elif op == 'or':
25343 7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2594 # fast path for machine-generated expression, that is likely to have
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2595 # lots of trivial revisions: 'a + b + c()' to '_list(a b) + c()'
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2596 order = x[2]
25343 7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2597 ws, ts, ss = [], [], []
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2598 def flushss():
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2599 if not ss:
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2600 return
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2601 if len(ss) == 1:
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2602 w, t = ss[0]
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2603 else:
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2604 s = '\0'.join(t[1] for w, t in ss)
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2605 y = ('func', ('symbol', '_list'), ('string', s), order)
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2606 w, t = _optimize(y, False)
25343 7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2607 ws.append(w)
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2608 ts.append(t)
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2609 del ss[:]
29933 b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	2610 for y in getlist(x[1]):
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2611 w, t = _optimize(y, False)
25996 b12e00a05d57 revset: prevent crash caused by empty group expression while optimizing "or" Yuya Nishihara <yuya@tcha.org> parents: 25995 diff changeset	2612 if t is not None and (t[0] == 'string' or t[0] == 'symbol'):
25343 7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2613 ss.append((w, t))
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2614 continue
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2615 flushss()
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2616 ws.append(w)
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2617 ts.append(t)
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2618 flushss()
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2619 if len(ts) == 1:
7fbef7932af9 revset: optimize 'or' operation of trivial revisions to a list Yuya Nishihara <yuya@tcha.org> parents: 25342 diff changeset	2620 return ws[0], ts[0] # 'or' operation is fully optimized out
25307 4d1e56b29a91 revset: comment that we can't swap 'or' operands by weight Yuya Nishihara <yuya@tcha.org> parents: 25270 diff changeset	2621 # we can't reorder trees by weight because it would change the order.
4d1e56b29a91 revset: comment that we can't swap 'or' operands by weight Yuya Nishihara <yuya@tcha.org> parents: 25270 diff changeset	2622 # ("sort(a + b)" == "sort(b + a)", but "a + b" != "b + a")
25309 b333ca94403d revset: reduce nesting of chained 'or' operations (issue4624) Yuya Nishihara <yuya@tcha.org> parents: 25308 diff changeset	2623 # ts = tuple(t for w, t in sorted(zip(ws, ts), key=lambda wt: wt[0]))
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2624 return max(ws), (op, ('list',) + tuple(ts), order)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2625 elif op == 'not':
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2626 # Optimize not public() to _notpublic() because we have a fast version
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2627 if x[1][:3] == ('func', ('symbol', 'public'), None):
09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2628 order = x[1][3]
09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2629 newsym = ('func', ('symbol', '_notpublic'), None, order)
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2630 o = _optimize(newsym, not small)
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2631 return o[0], o[1]
08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	2632 else:
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2633 o = _optimize(x[1], not small)
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2634 order = x[2]
09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2635 return o[0], (op, o[1], order)
30044 69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	2636 elif op in ('rangepre', 'parentpost'):
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2637 o = _optimize(x[1], small)
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2638 order = x[2]
09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2639 return o[0], (op, o[1], order)
29902 7203400f91b0 revset: do not partial-match operator and function names in optimize() Yuya Nishihara <yuya@tcha.org> parents: 29901 diff changeset	2640 elif op in ('dagrange', 'range', 'parent', 'ancestor'):
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2641 wa, ta = _optimize(x[1], small)
a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2642 wb, tb = _optimize(x[2], small)
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2643 order = x[3]
09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2644 return wa + wb, (op, ta, tb, order)
27987 b19d8d5d6b51 revset: flatten chained 'list' operations (aka function args) (issue5072) Yuya Nishihara <yuya@tcha.org> parents: 27945 diff changeset	2645 elif op == 'list':
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2646 ws, ts = zip(*(_optimize(y, small) for y in x[1:]))
27987 b19d8d5d6b51 revset: flatten chained 'list' operations (aka function args) (issue5072) Yuya Nishihara <yuya@tcha.org> parents: 27945 diff changeset	2647 return sum(ws), (op,) + ts
29661 5004ef47f437 revset: fix keyword arguments to go through optimization process Yuya Nishihara <yuya@tcha.org> parents: 29646 diff changeset	2648 elif op == 'keyvalue':
5004ef47f437 revset: fix keyword arguments to go through optimization process Yuya Nishihara <yuya@tcha.org> parents: 29646 diff changeset	2649 w, t = _optimize(x[2], small)
5004ef47f437 revset: fix keyword arguments to go through optimization process Yuya Nishihara <yuya@tcha.org> parents: 29646 diff changeset	2650 return w, (op, x[1], t)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2651 elif op == 'func':
29441 9e8d258708bb revset: check invalid function syntax "func-name"() explicitly Yuya Nishihara <yuya@tcha.org> parents: 29425 diff changeset	2652 f = getsymbol(x[1])
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2653 wa, ta = _optimize(x[2], small)
29902 7203400f91b0 revset: do not partial-match operator and function names in optimize() Yuya Nishihara <yuya@tcha.org> parents: 29901 diff changeset	2654 if f in ('author', 'branch', 'closed', 'date', 'desc', 'file', 'grep',
30205 b4074417b661 revset: optimize for destination() being "inefficient" Mads Kiilerich <madski@unity3d.com> parents: 30179 diff changeset	2655 'keyword', 'outgoing', 'user', 'destination'):
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2656 w = 10 # slow
29902 7203400f91b0 revset: do not partial-match operator and function names in optimize() Yuya Nishihara <yuya@tcha.org> parents: 29901 diff changeset	2657 elif f in ('modifies', 'adds', 'removes'):
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2658 w = 30 # slower
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2659 elif f == "contains":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2660 w = 100 # very slow
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2661 elif f == "ancestor":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2662 w = 1 * smallbonus
30700 323f0c4b43f4 revset: categorize wdir() as very fast function Yuya Nishihara <yuya@tcha.org> parents: 30699 diff changeset	2663 elif f in ('reverse', 'limit', 'first', 'wdir', '_intlist'):
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2664 w = 0
29902 7203400f91b0 revset: do not partial-match operator and function names in optimize() Yuya Nishihara <yuya@tcha.org> parents: 29901 diff changeset	2665 elif f == "sort":
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2666 w = 10 # assume most sorts look at changelog
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2667 else:
11279 62ccf4cd6e7f revset: optimize the parse tree directly Matt Mackall <mpm@selenic.com> parents: 11278 diff changeset	2668 w = 1
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2669 order = x[3]
09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	2670 return w + wa, (op, x[1], ta, order)
29900 104914b03b83 revset: make optimize() reject unknown operators Yuya Nishihara <yuya@tcha.org> parents: 29825 diff changeset	2671 raise ValueError('invalid operator %r' % op)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2672
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2673 def optimize(tree):
29909 371c2a39eead revset: make analyze() a separate step from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29908 diff changeset	2674 """Optimize evaluatable tree
371c2a39eead revset: make analyze() a separate step from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29908 diff changeset	2675
371c2a39eead revset: make analyze() a separate step from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29908 diff changeset	2676 All pseudo operations should be transformed beforehand.
371c2a39eead revset: make analyze() a separate step from optimize() Yuya Nishihara <yuya@tcha.org> parents: 29908 diff changeset	2677 """
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2678 _weight, newtree = _optimize(tree, small=True)
a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2679 return newtree
a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2680
23845 0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2681 # the set of valid characters for the initial letter of symbols in
0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2682 # alias declarations and definitions
30071 2def3d55b1b9 revset: build _syminitletters from a saner source: the string module Augie Fackler <augie@google.com> parents: 30056 diff changeset	2683 _aliassyminitletters = _syminitletters \| set(pycompat.sysstr('$'))
23845 0a7fd54d4e60 revset: introduce "_parsealiasdecl" to parse alias declarations strictly FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23844 diff changeset	2684
29073 81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2685 def _parsewith(spec, lookup=None, syminitletters=None):
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2686 """Generate a parse tree of given spec with given tokenizing options
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2687
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2688 >>> _parsewith('foo($1)', syminitletters=_aliassyminitletters)
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2689 ('func', ('symbol', 'foo'), ('symbol', '$1'))
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2690 >>> _parsewith('$1')
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2691 Traceback (most recent call last):
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2692 ...
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2693 ParseError: ("syntax error in revset '$1'", 0)
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2694 >>> _parsewith('foo bar')
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2695 Traceback (most recent call last):
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2696 ...
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2697 ParseError: ('invalid token', 4)
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2698 """
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2699 p = parser.parser(elements)
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2700 tree, pos = p.parse(tokenize(spec, lookup=lookup,
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2701 syminitletters=syminitletters))
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2702 if pos != len(spec):
81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2703 raise error.ParseError(_('invalid token'), pos)
29780 abe4eecc3253 revset: resolve ambiguity of x^:y before alias expansion Yuya Nishihara <yuya@tcha.org> parents: 29778 diff changeset	2704 return _fixops(parser.simplifyinfixops(tree, ('list', 'or')))
29073 81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2705
28870 475dad3432fd parser: add stub class that will host alias parsing and expansion Yuya Nishihara <yuya@tcha.org> parents: 28869 diff changeset	2706 class _aliasrules(parser.basealiasrules):
475dad3432fd parser: add stub class that will host alias parsing and expansion Yuya Nishihara <yuya@tcha.org> parents: 28869 diff changeset	2707 """Parsing and expansion rule set of revset aliases"""
475dad3432fd parser: add stub class that will host alias parsing and expansion Yuya Nishihara <yuya@tcha.org> parents: 28869 diff changeset	2708 _section = _('revset alias')
29074 e7c679738503 revset: define _parsealias() in _aliasrules class Yuya Nishihara <yuya@tcha.org> parents: 29073 diff changeset	2709
e7c679738503 revset: define _parsealias() in _aliasrules class Yuya Nishihara <yuya@tcha.org> parents: 29073 diff changeset	2710 @staticmethod
e7c679738503 revset: define _parsealias() in _aliasrules class Yuya Nishihara <yuya@tcha.org> parents: 29073 diff changeset	2711 def _parse(spec):
e7c679738503 revset: define _parsealias() in _aliasrules class Yuya Nishihara <yuya@tcha.org> parents: 29073 diff changeset	2712 """Parse alias declaration/definition ``spec``
e7c679738503 revset: define _parsealias() in _aliasrules class Yuya Nishihara <yuya@tcha.org> parents: 29073 diff changeset	2713
e7c679738503 revset: define _parsealias() in _aliasrules class Yuya Nishihara <yuya@tcha.org> parents: 29073 diff changeset	2714 This allows symbol names to use also ``$`` as an initial letter
e7c679738503 revset: define _parsealias() in _aliasrules class Yuya Nishihara <yuya@tcha.org> parents: 29073 diff changeset	2715 (for backward compatibility), and callers of this function should
e7c679738503 revset: define _parsealias() in _aliasrules class Yuya Nishihara <yuya@tcha.org> parents: 29073 diff changeset	2716 examine whether ``$`` is used also for unexpected symbols or not.
e7c679738503 revset: define _parsealias() in _aliasrules class Yuya Nishihara <yuya@tcha.org> parents: 29073 diff changeset	2717 """
e7c679738503 revset: define _parsealias() in _aliasrules class Yuya Nishihara <yuya@tcha.org> parents: 29073 diff changeset	2718 return _parsewith(spec, syminitletters=_aliassyminitletters)
28910 1203159c8928 parser: factor out _trygetfunc() that extracts function name and arguments Yuya Nishihara <yuya@tcha.org> parents: 28898 diff changeset	2719
1203159c8928 parser: factor out _trygetfunc() that extracts function name and arguments Yuya Nishihara <yuya@tcha.org> parents: 28898 diff changeset	2720 @staticmethod
1203159c8928 parser: factor out _trygetfunc() that extracts function name and arguments Yuya Nishihara <yuya@tcha.org> parents: 28898 diff changeset	2721 def _trygetfunc(tree):
1203159c8928 parser: factor out _trygetfunc() that extracts function name and arguments Yuya Nishihara <yuya@tcha.org> parents: 28898 diff changeset	2722 if tree[0] == 'func' and tree[1][0] == 'symbol':
1203159c8928 parser: factor out _trygetfunc() that extracts function name and arguments Yuya Nishihara <yuya@tcha.org> parents: 28898 diff changeset	2723 return tree[1][1], getlist(tree[2])
28870 475dad3432fd parser: add stub class that will host alias parsing and expansion Yuya Nishihara <yuya@tcha.org> parents: 28869 diff changeset	2724
29926 ae933e3e2226 revset: remove showwarning option from expandaliases() Yuya Nishihara <yuya@tcha.org> parents: 29910 diff changeset	2725 def expandaliases(ui, tree):
28893 ee11167fe1da parser: extract helper that creates a dict of aliases Yuya Nishihara <yuya@tcha.org> parents: 28892 diff changeset	2726 aliases = _aliasrules.buildmap(ui.configitems('revsetalias'))
28895 4bf9ed7a260e parser: move functions that process alias expansion to rule-set class Yuya Nishihara <yuya@tcha.org> parents: 28894 diff changeset	2727 tree = _aliasrules.expand(aliases, tree)
29926 ae933e3e2226 revset: remove showwarning option from expandaliases() Yuya Nishihara <yuya@tcha.org> parents: 29910 diff changeset	2728 # warn about problematic (but not referred) aliases
ae933e3e2226 revset: remove showwarning option from expandaliases() Yuya Nishihara <yuya@tcha.org> parents: 29910 diff changeset	2729 for name, alias in sorted(aliases.iteritems()):
ae933e3e2226 revset: remove showwarning option from expandaliases() Yuya Nishihara <yuya@tcha.org> parents: 29910 diff changeset	2730 if alias.error and not alias.warned:
ae933e3e2226 revset: remove showwarning option from expandaliases() Yuya Nishihara <yuya@tcha.org> parents: 29910 diff changeset	2731 ui.warn(_('warning: %s\n') % (alias.error))
ae933e3e2226 revset: remove showwarning option from expandaliases() Yuya Nishihara <yuya@tcha.org> parents: 29910 diff changeset	2732 alias.warned = True
23725 6a81f88758aa revset: delay showing parse error for the revset alias until it is referred FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23720 diff changeset	2733 return tree
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2734
23742 3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2735 def foldconcat(tree):
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2736 """Fold elements to be concatenated by `##`
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2737 """
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2738 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2739 return tree
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2740 if tree[0] == '_concat':
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2741 pending = [tree]
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2742 l = []
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2743 while pending:
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2744 e = pending.pop()
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2745 if e[0] == '_concat':
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2746 pending.extend(reversed(e[1:]))
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2747 elif e[0] in ('string', 'symbol'):
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2748 l.append(e[1])
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2749 else:
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2750 msg = _("\"##\" can't concatenate \"%s\" element") % (e[0])
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2751 raise error.ParseError(msg)
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2752 return ('string', ''.join(l))
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2753 else:
3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2754 return tuple(foldconcat(t) for t in tree)
14098 9f5a0acb0056 revset aliases Alexander Solovyov <alexander@solovyov.net> parents: 14073 diff changeset	2755
20779 ffc2295c6b80 revset: pass a lookup function to the tokenizer Matt Mackall <mpm@selenic.com> parents: 20754 diff changeset	2756 def parse(spec, lookup=None):
29073 81bac118f9e2 revset: factor out common parsing function Yuya Nishihara <yuya@tcha.org> parents: 29072 diff changeset	2757 return _parsewith(spec, lookup=lookup)
20779 ffc2295c6b80 revset: pass a lookup function to the tokenizer Matt Mackall <mpm@selenic.com> parents: 20754 diff changeset	2758
24518 dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2759 def posttreebuilthook(tree, repo):
dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2760 # hook for extensions to execute code on the optimized tree
dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2761 pass
dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2762
29959 1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2763 def match(ui, spec, repo=None, order=defineorder):
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2764 """Create a matcher for a single revision spec
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2765
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2766 If order=followorder, a matcher takes the ordering specified by the input
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2767 set.
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2768 """
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2769 return matchany(ui, [spec], repo=repo, order=order)
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2770
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2771 def matchany(ui, specs, repo=None, order=defineorder):
25927 44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2772 """Create a matcher that will include any revisions matching one of the
29959 1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2773 given specs
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2774
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2775 If order=followorder, a matcher takes the ordering specified by the input
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2776 set.
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2777 """
25927 44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2778 if not specs:
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2779 def mfunc(repo, subset=None):
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2780 return baseset()
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2781 return mfunc
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2782 if not all(specs):
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2783 raise error.ParseError(_("empty query"))
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2784 lookup = None
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2785 if repo:
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2786 lookup = repo.__contains__
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2787 if len(specs) == 1:
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2788 tree = parse(specs[0], lookup)
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2789 else:
29933 b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	2790 tree = ('or', ('list',) + tuple(parse(s, lookup) for s in specs))
29910 41491cf936f2 revset: add public function to create matcher from evaluatable tree Yuya Nishihara <yuya@tcha.org> parents: 29909 diff changeset	2791
14900 fc3d6f300d7d revset: allow bypassing alias expansion Matt Mackall <mpm@selenic.com> parents: 14851 diff changeset	2792 if ui:
29926 ae933e3e2226 revset: remove showwarning option from expandaliases() Yuya Nishihara <yuya@tcha.org> parents: 29910 diff changeset	2793 tree = expandaliases(ui, tree)
23742 3a4d8a6ce432 revset: introduce new operator "##" to concatenate strings/symbols at runtime FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 23729 diff changeset	2794 tree = foldconcat(tree)
29959 1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2795 tree = analyze(tree, order)
29119 a032ebea4e97 revset: factor out public optimize() function from recursion Yuya Nishihara <yuya@tcha.org> parents: 29118 diff changeset	2796 tree = optimize(tree)
24518 dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2797 posttreebuilthook(tree, repo)
29910 41491cf936f2 revset: add public function to create matcher from evaluatable tree Yuya Nishihara <yuya@tcha.org> parents: 29909 diff changeset	2798 return makematcher(tree)
41491cf936f2 revset: add public function to create matcher from evaluatable tree Yuya Nishihara <yuya@tcha.org> parents: 29909 diff changeset	2799
41491cf936f2 revset: add public function to create matcher from evaluatable tree Yuya Nishihara <yuya@tcha.org> parents: 29909 diff changeset	2800 def makematcher(tree):
41491cf936f2 revset: add public function to create matcher from evaluatable tree Yuya Nishihara <yuya@tcha.org> parents: 29909 diff changeset	2801 """Create a matcher from an evaluatable tree"""
24114 fafd9a1284cf revset: make match function initiate query from full set by default Yuya Nishihara <yuya@tcha.org> parents: 24031 diff changeset	2802 def mfunc(repo, subset=None):
fafd9a1284cf revset: make match function initiate query from full set by default Yuya Nishihara <yuya@tcha.org> parents: 24031 diff changeset	2803 if subset is None:
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	2804 subset = fullreposet(repo)
22885 e02b16f496f2 match: check if an object is a baseset using `isascending` instead of `set` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22884 diff changeset	2805 if util.safehasattr(subset, 'isascending'):
22686 2717dcff7be1 revset: use a single return statement in matcher function Pierre-Yves David <pierre-yves.david@fb.com> parents: 22670 diff changeset	2806 result = getset(repo, subset, tree)
2717dcff7be1 revset: use a single return statement in matcher function Pierre-Yves David <pierre-yves.david@fb.com> parents: 22670 diff changeset	2807 else:
2717dcff7be1 revset: use a single return statement in matcher function Pierre-Yves David <pierre-yves.david@fb.com> parents: 22670 diff changeset	2808 result = getset(repo, baseset(subset), tree)
2717dcff7be1 revset: use a single return statement in matcher function Pierre-Yves David <pierre-yves.david@fb.com> parents: 22670 diff changeset	2809 return result
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2810 return mfunc
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	2811
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2812 def formatspec(expr, *args):
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2813 '''
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2814 This is a convenience function for using revsets internally, and
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2815 escapes arguments appropriately. Aliases are intentionally ignored
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2816 so that intended expression behavior isn't accidentally subverted.
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2817
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2818 Supported arguments:
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2819
15266 8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	2820 %r = revset expression, parenthesized
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2821 %d = int(arg), no quoting
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2822 %s = string(arg), escaped and single-quoted
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2823 %b = arg.branch(), escaped and single-quoted
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2824 %n = hex(arg), single-quoted
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2825 %% = a literal '%'
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2826
15266 8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	2827 Prefixing the type with 'l' specifies a parenthesized list of that type.
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2828
15268 bd5103819c2e revset: fix %r handling in formatspec Matt Mackall <mpm@selenic.com> parents: 15266 diff changeset	2829 >>> formatspec('%r:: and %lr', '10 or 11', ("this()", "that()"))
bd5103819c2e revset: fix %r handling in formatspec Matt Mackall <mpm@selenic.com> parents: 15266 diff changeset	2830 '(10 or 11):: and ((this()) or (that()))'
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2831 >>> formatspec('%d:: and not %d::', 10, 20)
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2832 '10:: and not 20::'
15325 cdf1daa3b83f revset: deal with empty lists in formatspec Matt Mackall <mpm@selenic.com> parents: 15268 diff changeset	2833 >>> formatspec('%ld or %ld', [], [1])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2834 "_list('') or 1"
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2835 >>> formatspec('keyword(%s)', 'foo\\xe9')
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2836 "keyword('foo\\\\xe9')"
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2837 >>> b = lambda: 'default'
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2838 >>> b.branch = b
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2839 >>> formatspec('branch(%b)', b)
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2840 "branch('default')"
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2841 >>> formatspec('root(%ls)', ['a', 'b', 'c', 'd'])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2842 "root(_list('a\\x00b\\x00c\\x00d'))"
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2843 '''
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2844
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2845 def quote(s):
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2846 return repr(str(s))
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2847
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2848 def argtype(c, arg):
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2849 if c == 'd':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2850 return str(int(arg))
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2851 elif c == 's':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2852 return quote(arg)
15266 8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	2853 elif c == 'r':
8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	2854 parse(arg) # make sure syntax errors are confined
8bea39ca9acb revset: add %r for embedded revset support to formatspec Matt Mackall <mpm@selenic.com> parents: 15153 diff changeset	2855 return '(%s)' % arg
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2856 elif c == 'n':
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	2857 return quote(node.hex(arg))
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2858 elif c == 'b':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2859 return quote(arg.branch())
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2860
15595 a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	2861 def listexp(s, t):
a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	2862 l = len(s)
a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	2863 if l == 0:
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2864 return "_list('')"
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2865 elif l == 1:
15595 a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	2866 return argtype(t, s[0])
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2867 elif t == 'd':
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	2868 return "_intlist('%s')" % "\0".join(str(int(a)) for a in s)
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2869 elif t == 's':
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2870 return "_list('%s')" % "\0".join(s)
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2871 elif t == 'n':
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	2872 return "_hexlist('%s')" % "\0".join(node.hex(a) for a in s)
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2873 elif t == 'b':
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2874 return "_list('%s')" % "\0".join(a.branch() for a in s)
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	2875
15791 a814f8fcc65a Use explicit integer division Martin Geisler <mg@aragost.com> parents: 15726 diff changeset	2876 m = l // 2
15595 a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	2877 return '(%s or %s)' % (listexp(s[:m], t), listexp(s[m:], t))
a585d78e7b2f revset: balance %l or-expressions (issue3129) Matt Mackall <mpm@selenic.com> parents: 15532 diff changeset	2878
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2879 ret = ''
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2880 pos = 0
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2881 arg = 0
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2882 while pos < len(expr):
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2883 c = expr[pos]
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2884 if c == '%':
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2885 pos += 1
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2886 d = expr[pos]
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2887 if d == '%':
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2888 ret += d
15268 bd5103819c2e revset: fix %r handling in formatspec Matt Mackall <mpm@selenic.com> parents: 15266 diff changeset	2889 elif d in 'dsnbr':
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2890 ret += argtype(d, args[arg])
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2891 arg += 1
15140 353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2892 elif d == 'l':
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2893 # a list of some type
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2894 pos += 1
353a1ba928f6 revset: add 'l' flag to formatspec for args Matt Mackall <mpm@selenic.com> parents: 15138 diff changeset	2895 d = expr[pos]
15596 2555f441a32f merge with stable Matt Mackall <mpm@selenic.com> parents: 15595 diff changeset	2896 ret += listexp(list(args[arg]), d)
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2897 arg += 1
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2898 else:
29389 98e8313dcd9e i18n: translate abort messages liscju <piotr.listkiewicz@gmail.com> parents: 29365 diff changeset	2899 raise error.Abort(_('unexpected revspec format character %s')
98e8313dcd9e i18n: translate abort messages liscju <piotr.listkiewicz@gmail.com> parents: 29365 diff changeset	2900 % d)
14901 a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2901 else:
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2902 ret += c
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2903 pos += 1
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2904
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2905 return ret
a773119f30ba revset: add formatspec convenience query builder Matt Mackall <mpm@selenic.com> parents: 14900 diff changeset	2906
16218 81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2907 def prettyformat(tree):
25253 3f1a9b44b8c2 parser: move prettyformat() function from revset module Yuya Nishihara <yuya@tcha.org> parents: 25251 diff changeset	2908 return parser.prettyformat(tree, ('string', 'symbol'))
16218 81a1a00f5738 debugrevspec: pretty print output Patrick Mezard <patrick@mezard.eu> parents: 16185 diff changeset	2909
19719 2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2910 def depth(tree):
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2911 if isinstance(tree, tuple):
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2912 return max(map(depth, tree)) + 1
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2913 else:
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2914 return 0
2f9d5c5256ea revset: add helper function to get revset parse tree depth Alexander Plavin <alexander@plav.in> parents: 19706 diff changeset	2915
19720 f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2916 def funcsused(tree):
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2917 if not isinstance(tree, tuple) or tree[0] in ('string', 'symbol'):
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2918 return set()
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2919 else:
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2920 funcs = set()
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2921 for s in tree[1:]:
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2922 funcs \|= funcsused(s)
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2923 if tree[0] == 'func':
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2924 funcs.add(tree[1][1])
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2925 return funcs
f0b992a9be9c revset: add helper function to get functions used in a revset parse tree Alexander Plavin <alexander@plav.in> parents: 19719 diff changeset	2926
28423 0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2927 def _formatsetrepr(r):
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2928 """Format an optional printable representation of a set
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2929
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2930 ======== =================================
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2931 type(r) example
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2932 ======== =================================
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2933 tuple ('<not %r>', other)
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2934 str '<branch closed>'
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2935 callable lambda: '<branch %r>' % sorted(b)
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2936 object other
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2937 ======== =================================
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2938 """
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2939 if r is None:
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2940 return ''
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2941 elif isinstance(r, tuple):
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2942 return r[0] % r[1:]
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2943 elif isinstance(r, str):
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2944 return r
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2945 elif callable(r):
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2946 return r()
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2947 else:
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2948 return repr(r)
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	2949
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2950 class abstractsmartset(object):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2951
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2952 def __nonzero__(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2953 """True if the smartset is not empty"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2954 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2955
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2956 def __contains__(self, rev):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2957 """provide fast membership testing"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2958 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2959
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2960 def __iter__(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2961 """iterate the set in the order it is supposed to be iterated"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2962 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2963
22716 6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2964 # Attributes containing a function to perform a fast iteration in a given
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2965 # direction. A smartset can have none, one, or both defined.
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2966 #
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2967 # Default value is None instead of a function returning None to avoid
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2968 # initializing an iterator just for testing if a fast method exists.
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2969 fastasc = None
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2970 fastdesc = None
6877ba8d85ff abstractsmartset: document the `fastasc` and `fastdesc` attributes/methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22715 diff changeset	2971
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2972 def isascending(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2973 """True if the set will iterate in ascending order"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2974 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2975
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2976 def isdescending(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2977 """True if the set will iterate in descending order"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2978 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2979
29346 38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	2980 def istopo(self):
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	2981 """True if the set will iterate in topographical order"""
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	2982 raise NotImplementedError()
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	2983
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2984 def min(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2985 """return the minimum element in the set"""
30227 5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	2986 if self.fastasc is None:
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	2987 v = min(self)
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	2988 else:
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	2989 for v in self.fastasc():
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	2990 break
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	2991 else:
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	2992 raise ValueError('arg is an empty sequence')
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	2993 self.min = lambda: v
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	2994 return v
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	2995
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2996 def max(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	2997 """return the maximum element in the set"""
30227 5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	2998 if self.fastdesc is None:
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	2999 return max(self)
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	3000 else:
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	3001 for v in self.fastdesc():
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	3002 break
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	3003 else:
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	3004 raise ValueError('arg is an empty sequence')
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	3005 self.max = lambda: v
5ee944b9c750 revset: don't cache abstractsmartset min/max invocations infinitely Mads Kiilerich <madski@unity3d.com> parents: 30205 diff changeset	3006 return v
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3007
22808 228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	3008 def first(self):
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	3009 """return the first element in the set (user iteration perspective)
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	3010
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	3011 Return None if the set is empty"""
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	3012 raise NotImplementedError()
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	3013
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	3014 def last(self):
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	3015 """return the last element in the set (user iteration perspective)
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	3016
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	3017 Return None if the set is empty"""
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	3018 raise NotImplementedError()
228b0aafb1ce smartset: add first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22805 diff changeset	3019
22995 2587631c5f8a revset: make __len__ part of the offical API Pierre-Yves David <pierre-yves.david@fb.com> parents: 22944 diff changeset	3020 def __len__(self):
2587631c5f8a revset: make __len__ part of the offical API Pierre-Yves David <pierre-yves.david@fb.com> parents: 22944 diff changeset	3021 """return the length of the smartsets
2587631c5f8a revset: make __len__ part of the offical API Pierre-Yves David <pierre-yves.david@fb.com> parents: 22944 diff changeset	3022
2587631c5f8a revset: make __len__ part of the offical API Pierre-Yves David <pierre-yves.david@fb.com> parents: 22944 diff changeset	3023 This can be expensive on smartset that could be lazy otherwise."""
2587631c5f8a revset: make __len__ part of the offical API Pierre-Yves David <pierre-yves.david@fb.com> parents: 22944 diff changeset	3024 raise NotImplementedError()
2587631c5f8a revset: make __len__ part of the offical API Pierre-Yves David <pierre-yves.david@fb.com> parents: 22944 diff changeset	3025
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3026 def reverse(self):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3027 """reverse the expected iteration order"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3028 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3029
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3030 def sort(self, reverse=True):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3031 """get the set to iterate in an ascending or descending order"""
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3032 raise NotImplementedError()
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3033
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3034 def __and__(self, other):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3035 """Returns a new object with the intersection of the two collections.
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3036
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3037 This is part of the mandatory API for smartset."""
24459 7d369fae098e revset: optimize "x & fullreposet" case Yuya Nishihara <yuya@tcha.org> parents: 24458 diff changeset	3038 if isinstance(other, fullreposet):
7d369fae098e revset: optimize "x & fullreposet" case Yuya Nishihara <yuya@tcha.org> parents: 24458 diff changeset	3039 return self
28423 0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3040 return self.filter(other.__contains__, condrepr=other, cache=False)
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3041
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3042 def __add__(self, other):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3043 """Returns a new object with the union of the two collections.
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3044
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3045 This is part of the mandatory API for smartset."""
22861 546fa6576815 revset: restore order of `or` operation as in Mercurial 2.9 Pierre-Yves David <pierre-yves.david@fb.com> parents: 22860 diff changeset	3046 return addset(self, other)
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3047
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3048 def __sub__(self, other):
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3049 """Returns a new object with the substraction of the two collections.
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3050
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3051 This is part of the mandatory API for smartset."""
22730 aeacc2055f0d abstractsmartset: add default implementation for __sub__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22729 diff changeset	3052 c = other.__contains__
28423 0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3053 return self.filter(lambda r: not c(r), condrepr=('<not %r>', other),
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3054 cache=False)
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3055
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3056 def filter(self, condition, condrepr=None, cache=True):
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3057 """Returns this smartset filtered by condition as a new smartset.
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3058
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3059 `condition` is a callable which takes a revision number and returns a
28423 0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3060 boolean. Optional `condrepr` provides a printable representation of
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3061 the given `condition`.
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3062
78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3063 This is part of the mandatory API for smartset."""
22864 96b6b3d78697 revset: cache most conditions used in `filter` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22863 diff changeset	3064 # builtin cannot be cached. but do not needs to
96b6b3d78697 revset: cache most conditions used in `filter` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22863 diff changeset	3065 if cache and util.safehasattr(condition, 'func_code'):
96b6b3d78697 revset: cache most conditions used in `filter` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22863 diff changeset	3066 condition = util.cachefunc(condition)
28423 0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3067 return filteredset(self, condition, condrepr)
22692 78c916f24dd9 revset: introduce an abstractsmartset class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22691 diff changeset	3068
22825 0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	3069 class baseset(abstractsmartset):
20416 e72bcc245ecb revset: added docstring to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20393 diff changeset	3070 """Basic data structure that represents a revset and contains the basic
e72bcc245ecb revset: added docstring to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20393 diff changeset	3071 operation that it should be able to perform.
20727 1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	3072
1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	3073 Every method in this class should be implemented by any smartset class.
20416 e72bcc245ecb revset: added docstring to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20393 diff changeset	3074 """
29346 38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3075 def __init__(self, data=(), datarepr=None, istopo=False):
28425 02d7faaf455c revset: stub to add extra data to baseset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28424 diff changeset	3076 """
02d7faaf455c revset: stub to add extra data to baseset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28424 diff changeset	3077 datarepr: a tuple of (format, obj, ...), a function or an object that
02d7faaf455c revset: stub to add extra data to baseset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28424 diff changeset	3078 provides a printable representation of the given data.
02d7faaf455c revset: stub to add extra data to baseset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28424 diff changeset	3079 """
28786 69c6e9623bdc revset: force ascending order for baseset initialized from a set Pierre-Yves David <pierre-yves.david@fb.com> parents: 28785 diff changeset	3080 self._ascending = None
29346 38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3081 self._istopo = istopo
22825 0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	3082 if not isinstance(data, list):
26060 4ee2af2194d4 baseset: keep the input set around Pierre-Yves David <pierre-yves.david@fb.com> parents: 26053 diff changeset	3083 if isinstance(data, set):
4ee2af2194d4 baseset: keep the input set around Pierre-Yves David <pierre-yves.david@fb.com> parents: 26053 diff changeset	3084 self._set = data
28786 69c6e9623bdc revset: force ascending order for baseset initialized from a set Pierre-Yves David <pierre-yves.david@fb.com> parents: 28785 diff changeset	3085 # set has no order we pick one for stability purpose
69c6e9623bdc revset: force ascending order for baseset initialized from a set Pierre-Yves David <pierre-yves.david@fb.com> parents: 28785 diff changeset	3086 self._ascending = True
22825 0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	3087 data = list(data)
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	3088 self._list = data
28425 02d7faaf455c revset: stub to add extra data to baseset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28424 diff changeset	3089 self._datarepr = datarepr
20365 bc770ee6a351 revset: implemented set caching for revset evaluation Lucas Moscovicz <lmoscovicz@fb.com> parents: 20364 diff changeset	3090
22826 4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	3091 @util.propertycache
22879 efe5062145c1 baseset: make `_set` a property cache Pierre-Yves David <pierre-yves.david@fb.com> parents: 22877 diff changeset	3092 def _set(self):
efe5062145c1 baseset: make `_set` a property cache Pierre-Yves David <pierre-yves.david@fb.com> parents: 22877 diff changeset	3093 return set(self._list)
efe5062145c1 baseset: make `_set` a property cache Pierre-Yves David <pierre-yves.david@fb.com> parents: 22877 diff changeset	3094
efe5062145c1 baseset: make `_set` a property cache Pierre-Yves David <pierre-yves.david@fb.com> parents: 22877 diff changeset	3095 @util.propertycache
22826 4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	3096 def _asclist(self):
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	3097 asclist = self._list[:]
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	3098 asclist.sort()
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	3099 return asclist
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	3100
22827 c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	3101 def __iter__(self):
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	3102 if self._ascending is None:
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	3103 return iter(self._list)
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	3104 elif self._ascending:
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	3105 return iter(self._asclist)
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	3106 else:
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	3107 return reversed(self._asclist)
c1107cb21df2 baseset: prepare lazy ordering in __iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22826 diff changeset	3108
22826 4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	3109 def fastasc(self):
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	3110 return iter(self._asclist)
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	3111
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	3112 def fastdesc(self):
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	3113 return reversed(self._asclist)
4ffb327e4719 baseset: implement a fastasc and fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22825 diff changeset	3114
22503 300e07582e9b revset: add an optimised baseset.__contains__ (issue4371) Pierre-Yves David <pierre-yves.david@fb.com> parents: 22105 diff changeset	3115 @util.propertycache
300e07582e9b revset: add an optimised baseset.__contains__ (issue4371) Pierre-Yves David <pierre-yves.david@fb.com> parents: 22105 diff changeset	3116 def __contains__(self):
22880 5b635b44af14 baseset: access `_set` directly for containment check Pierre-Yves David <pierre-yves.david@fb.com> parents: 22879 diff changeset	3117 return self._set.__contains__
22503 300e07582e9b revset: add an optimised baseset.__contains__ (issue4371) Pierre-Yves David <pierre-yves.david@fb.com> parents: 22105 diff changeset	3118
22691 d8a08b68f754 revset: add a `__nonzero__` to baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22690 diff changeset	3119 def __nonzero__(self):
22825 0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	3120 return bool(self._list)
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	3121
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	3122 def sort(self, reverse=False):
22829 36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3123 self._ascending = not bool(reverse)
29346 38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3124 self._istopo = False
22825 0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	3125
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	3126 def reverse(self):
22829 36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3127 if self._ascending is None:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3128 self._list.reverse()
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3129 else:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3130 self._ascending = not self._ascending
29346 38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3131 self._istopo = False
22825 0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	3132
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	3133 def __len__(self):
0e8bb81b58b9 baseset: stop inheriting from built-in list class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22817 diff changeset	3134 return len(self._list)
22691 d8a08b68f754 revset: add a `__nonzero__` to baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22690 diff changeset	3135
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3136 def isascending(self):
20727 1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	3137 """Returns True if the collection is ascending order, False if not.
1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	3138
1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	3139 This is part of the mandatory API for smartset."""
22863 a1a02b516cca baseset: empty or one-element sets are ascending and descending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22862 diff changeset	3140 if len(self) <= 1:
a1a02b516cca baseset: empty or one-element sets are ascending and descending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22862 diff changeset	3141 return True
22828 966860f7a1a8 baseset: fix isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22827 diff changeset	3142 return self._ascending is not None and self._ascending
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3143
cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3144 def isdescending(self):
20727 1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	3145 """Returns True if the collection is descending order, False if not.
1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	3146
1e59f760d850 revset: added comments to all methods needed to duck-type from baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20726 diff changeset	3147 This is part of the mandatory API for smartset."""
22863 a1a02b516cca baseset: empty or one-element sets are ascending and descending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22862 diff changeset	3148 if len(self) <= 1:
a1a02b516cca baseset: empty or one-element sets are ascending and descending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22862 diff changeset	3149 return True
22828 966860f7a1a8 baseset: fix isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22827 diff changeset	3150 return self._ascending is not None and not self._ascending
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3151
29346 38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3152 def istopo(self):
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3153 """Is the collection is in topographical order or not.
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3154
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3155 This is part of the mandatory API for smartset."""
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3156 if len(self) <= 1:
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3157 return True
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3158 return self._istopo
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3159
22812 fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	3160 def first(self):
fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	3161 if self:
22829 36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3162 if self._ascending is None:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3163 return self._list[0]
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3164 elif self._ascending:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3165 return self._asclist[0]
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3166 else:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3167 return self._asclist[-1]
22812 fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	3168 return None
fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	3169
fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	3170 def last(self):
fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	3171 if self:
22829 36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3172 if self._ascending is None:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3173 return self._list[-1]
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3174 elif self._ascending:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3175 return self._asclist[-1]
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3176 else:
36e09c25f870 baseset: explicitly track order of the baseset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22828 diff changeset	3177 return self._asclist[0]
22812 fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	3178 return None
fcd12b310148 baseset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22811 diff changeset	3179
24457 c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3180 def __repr__(self):
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3181 d = {None: '', False: '-', True: '+'}[self._ascending]
28425 02d7faaf455c revset: stub to add extra data to baseset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28424 diff changeset	3182 s = _formatsetrepr(self._datarepr)
02d7faaf455c revset: stub to add extra data to baseset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28424 diff changeset	3183 if not s:
28785 87b89dca669d revset: stabilize repr of baseset initialized with a set Pierre-Yves David <pierre-yves.david@fb.com> parents: 28720 diff changeset	3184 l = self._list
87b89dca669d revset: stabilize repr of baseset initialized with a set Pierre-Yves David <pierre-yves.david@fb.com> parents: 28720 diff changeset	3185 # if _list has been built from a set, it might have a different
87b89dca669d revset: stabilize repr of baseset initialized with a set Pierre-Yves David <pierre-yves.david@fb.com> parents: 28720 diff changeset	3186 # order from one python implementation to another.
87b89dca669d revset: stabilize repr of baseset initialized with a set Pierre-Yves David <pierre-yves.david@fb.com> parents: 28720 diff changeset	3187 # We fallback to the sorted version for a stable output.
87b89dca669d revset: stabilize repr of baseset initialized with a set Pierre-Yves David <pierre-yves.david@fb.com> parents: 28720 diff changeset	3188 if self._ascending is not None:
87b89dca669d revset: stabilize repr of baseset initialized with a set Pierre-Yves David <pierre-yves.david@fb.com> parents: 28720 diff changeset	3189 l = self._asclist
87b89dca669d revset: stabilize repr of baseset initialized with a set Pierre-Yves David <pierre-yves.david@fb.com> parents: 28720 diff changeset	3190 s = repr(l)
28425 02d7faaf455c revset: stub to add extra data to baseset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28424 diff changeset	3191 return '<%s%s %s>' % (type(self).__name__, d, s)
24457 c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3192
22726 169aa5e74b52 lazyset: rename the class to filteredset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22725 diff changeset	3193 class filteredset(abstractsmartset):
20427 4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3194 """Duck type for baseset class which iterates lazily over the revisions in
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3195 the subset and contains a function which tests for membership in the
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3196 revset
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3197 """
28423 0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3198 def __init__(self, subset, condition=lambda x: True, condrepr=None):
20738 33943add5d65 revset: add some documentation for lazyset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20737 diff changeset	3199 """
33943add5d65 revset: add some documentation for lazyset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20737 diff changeset	3200 condition: a function that decide whether a revision in the subset
33943add5d65 revset: add some documentation for lazyset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20737 diff changeset	3201 belongs to the revset or not.
28423 0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3202 condrepr: a tuple of (format, obj, ...), a function or an object that
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3203 provides a printable representation of the given condition.
20738 33943add5d65 revset: add some documentation for lazyset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20737 diff changeset	3204 """
20427 4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3205 self._subset = subset
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3206 self._condition = condition
28423 0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3207 self._condrepr = condrepr
20427 4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3208
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3209 def __contains__(self, x):
26212 0d8df1f510c6 revset: uncache filteredset.__contains__ Yuya Nishihara <yuya@tcha.org> parents: 26143 diff changeset	3210 return x in self._subset and self._condition(x)
20427 4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3211
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3212 def __iter__(self):
22719 21fda9dcd4e8 lazyset: split the iteration logic from the condition filtering logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22718 diff changeset	3213 return self._iterfilter(self._subset)
21fda9dcd4e8 lazyset: split the iteration logic from the condition filtering logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22718 diff changeset	3214
21fda9dcd4e8 lazyset: split the iteration logic from the condition filtering logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22718 diff changeset	3215 def _iterfilter(self, it):
20427 4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3216 cond = self._condition
22719 21fda9dcd4e8 lazyset: split the iteration logic from the condition filtering logic Pierre-Yves David <pierre-yves.david@fb.com> parents: 22718 diff changeset	3217 for x in it:
20427 4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3218 if cond(x):
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3219 yield x
4a9191ca848e revset: added lazyset class with basic operations Lucas Moscovicz <lmoscovicz@fb.com> parents: 20424 diff changeset	3220
22720 4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3221 @property
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3222 def fastasc(self):
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3223 it = self._subset.fastasc
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3224 if it is None:
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3225 return None
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3226 return lambda: self._iterfilter(it())
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3227
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3228 @property
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3229 def fastdesc(self):
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3230 it = self._subset.fastdesc
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3231 if it is None:
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3232 return None
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3233 return lambda: self._iterfilter(it())
4388f99c5512 lazyset: inherit the fastasc and fastdesc method from subset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22719 diff changeset	3234
20552 0e99a66eb7bc revset: added __nonzero__ method to lazyset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20540 diff changeset	3235 def __nonzero__(self):
29304 5e32852fa4bd revset: make filteredset.__nonzero__ respect the order of the filteredset Kostia Balytskyi <ikostia@fb.com> parents: 29265 diff changeset	3236 fast = None
5e32852fa4bd revset: make filteredset.__nonzero__ respect the order of the filteredset Kostia Balytskyi <ikostia@fb.com> parents: 29265 diff changeset	3237 candidates = [self.fastasc if self.isascending() else None,
5e32852fa4bd revset: make filteredset.__nonzero__ respect the order of the filteredset Kostia Balytskyi <ikostia@fb.com> parents: 29265 diff changeset	3238 self.fastdesc if self.isdescending() else None,
5e32852fa4bd revset: make filteredset.__nonzero__ respect the order of the filteredset Kostia Balytskyi <ikostia@fb.com> parents: 29265 diff changeset	3239 self.fastasc,
5e32852fa4bd revset: make filteredset.__nonzero__ respect the order of the filteredset Kostia Balytskyi <ikostia@fb.com> parents: 29265 diff changeset	3240 self.fastdesc]
5e32852fa4bd revset: make filteredset.__nonzero__ respect the order of the filteredset Kostia Balytskyi <ikostia@fb.com> parents: 29265 diff changeset	3241 for candidate in candidates:
5e32852fa4bd revset: make filteredset.__nonzero__ respect the order of the filteredset Kostia Balytskyi <ikostia@fb.com> parents: 29265 diff changeset	3242 if candidate is not None:
5e32852fa4bd revset: make filteredset.__nonzero__ respect the order of the filteredset Kostia Balytskyi <ikostia@fb.com> parents: 29265 diff changeset	3243 fast = candidate
5e32852fa4bd revset: make filteredset.__nonzero__ respect the order of the filteredset Kostia Balytskyi <ikostia@fb.com> parents: 29265 diff changeset	3244 break
5e32852fa4bd revset: make filteredset.__nonzero__ respect the order of the filteredset Kostia Balytskyi <ikostia@fb.com> parents: 29265 diff changeset	3245
26307 428a8747f4ee revset: avoid implicit None testing in revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 26306 diff changeset	3246 if fast is not None:
26306 d157e1f18e3f revset: speed up existence checks for ordered filtered sets Durham Goode <durham@fb.com> parents: 26305 diff changeset	3247 it = fast()
26307 428a8747f4ee revset: avoid implicit None testing in revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 26306 diff changeset	3248 else:
428a8747f4ee revset: avoid implicit None testing in revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 26306 diff changeset	3249 it = self
26306 d157e1f18e3f revset: speed up existence checks for ordered filtered sets Durham Goode <durham@fb.com> parents: 26305 diff changeset	3250
d157e1f18e3f revset: speed up existence checks for ordered filtered sets Durham Goode <durham@fb.com> parents: 26305 diff changeset	3251 for r in it:
20552 0e99a66eb7bc revset: added __nonzero__ method to lazyset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20540 diff changeset	3252 return True
0e99a66eb7bc revset: added __nonzero__ method to lazyset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20540 diff changeset	3253 return False
0e99a66eb7bc revset: added __nonzero__ method to lazyset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20540 diff changeset	3254
20429 f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	3255 def __len__(self):
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	3256 # Basic implementation to be changed in future patches.
28718 f103f985ac00 revset: prevent infinite recursion on pypy Maciej Fijalkowski <fijall@gmail.com> parents: 28717 diff changeset	3257 # until this gets improved, we use generator expression
30342 318a24b52eeb spelling: fixes of non-dictionary words Mads Kiilerich <madski@unity3d.com> parents: 30227 diff changeset	3258 # here, since list comprehensions are free to call __len__ again
28718 f103f985ac00 revset: prevent infinite recursion on pypy Maciej Fijalkowski <fijall@gmail.com> parents: 28717 diff changeset	3259 # causing infinite recursion
f103f985ac00 revset: prevent infinite recursion on pypy Maciej Fijalkowski <fijall@gmail.com> parents: 28717 diff changeset	3260 l = baseset(r for r in self)
20429 f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	3261 return len(l)
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	3262
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	3263 def sort(self, reverse=False):
22862 9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	3264 self._subset.sort(reverse=reverse)
20429 f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	3265
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	3266 def reverse(self):
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	3267 self._subset.reverse()
f5b560c60bcd revset: added operations to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20428 diff changeset	3268
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3269 def isascending(self):
22862 9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	3270 return self._subset.isascending()
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3271
cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3272 def isdescending(self):
22862 9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	3273 return self._subset.isdescending()
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3274
29346 38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3275 def istopo(self):
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3276 return self._subset.istopo()
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3277
22813 5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3278 def first(self):
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3279 for x in self:
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3280 return x
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3281 return None
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3282
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3283 def last(self):
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3284 it = None
25648 9b9877d2b229 revset: rework 'filteredset.last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25647 diff changeset	3285 if self.isascending():
22862 9e5576f822cc filteredset: drop explicit order management Pierre-Yves David <pierre-yves.david@fb.com> parents: 22861 diff changeset	3286 it = self.fastdesc
25648 9b9877d2b229 revset: rework 'filteredset.last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25647 diff changeset	3287 elif self.isdescending():
9b9877d2b229 revset: rework 'filteredset.last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25647 diff changeset	3288 it = self.fastasc
9b9877d2b229 revset: rework 'filteredset.last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25647 diff changeset	3289 if it is not None:
9b9877d2b229 revset: rework 'filteredset.last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25647 diff changeset	3290 for x in it():
9b9877d2b229 revset: rework 'filteredset.last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25647 diff changeset	3291 return x
9b9877d2b229 revset: rework 'filteredset.last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25647 diff changeset	3292 return None #empty case
9b9877d2b229 revset: rework 'filteredset.last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25647 diff changeset	3293 else:
9b9877d2b229 revset: rework 'filteredset.last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25647 diff changeset	3294 x = None
9b9877d2b229 revset: rework 'filteredset.last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25647 diff changeset	3295 for x in self:
9b9877d2b229 revset: rework 'filteredset.last' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25647 diff changeset	3296 pass
22813 5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3297 return x
5a96df266b2b filteredset: implement `first` and `last` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22812 diff changeset	3298
24457 c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3299 def __repr__(self):
28423 0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3300 xs = [repr(self._subset)]
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3301 s = _formatsetrepr(self._condrepr)
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3302 if s:
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3303 xs.append(s)
0d79d91ba7e3 revset: add extra data to filteredset for better inspection Yuya Nishihara <yuya@tcha.org> parents: 28395 diff changeset	3304 return '<%s %s>' % (type(self).__name__, ', '.join(xs))
24457 c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3305
25131 adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3306 def _iterordered(ascending, iter1, iter2):
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3307 """produce an ordered iteration from two iterators with the same order
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3308
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3309 The ascending is used to indicated the iteration direction.
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3310 """
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3311 choice = max
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3312 if ascending:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3313 choice = min
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3314
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3315 val1 = None
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3316 val2 = None
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3317 try:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3318 # Consume both iterators in an ordered way until one is empty
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3319 while True:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3320 if val1 is None:
29216 ead25aa27a43 py3: convert to next() function timeless <timeless@mozdev.org> parents: 29215 diff changeset	3321 val1 = next(iter1)
25131 adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3322 if val2 is None:
29216 ead25aa27a43 py3: convert to next() function timeless <timeless@mozdev.org> parents: 29215 diff changeset	3323 val2 = next(iter2)
29215 f5983805574e revset: rename variable to avoid shadowing with builtin next() function timeless <timeless@mozdev.org> parents: 29147 diff changeset	3324 n = choice(val1, val2)
f5983805574e revset: rename variable to avoid shadowing with builtin next() function timeless <timeless@mozdev.org> parents: 29147 diff changeset	3325 yield n
f5983805574e revset: rename variable to avoid shadowing with builtin next() function timeless <timeless@mozdev.org> parents: 29147 diff changeset	3326 if val1 == n:
25131 adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3327 val1 = None
29215 f5983805574e revset: rename variable to avoid shadowing with builtin next() function timeless <timeless@mozdev.org> parents: 29147 diff changeset	3328 if val2 == n:
25131 adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3329 val2 = None
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3330 except StopIteration:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3331 # Flush any remaining values and consume the other one
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3332 it = iter2
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3333 if val1 is not None:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3334 yield val1
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3335 it = iter1
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3336 elif val2 is not None:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3337 # might have been equality and both are empty
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3338 yield val2
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3339 for val in it:
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3340 yield val
adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3341
22793 ff6689b47e48 addset: drop the leading underscore from the class name Pierre-Yves David <pierre-yves.david@fb.com> parents: 22792 diff changeset	3342 class addset(abstractsmartset):
20708 17c89e5a5627 revset: made addset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20707 diff changeset	3343 """Represent the addition of two sets
17c89e5a5627 revset: made addset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20707 diff changeset	3344
17c89e5a5627 revset: made addset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20707 diff changeset	3345 Wrapper structure for lazily adding two structures without losing much
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3346 performance on the __contains__ method
20708 17c89e5a5627 revset: made addset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20707 diff changeset	3347
20712 c152e538b85b revset: added ascending attribute to addset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20711 diff changeset	3348 If the ascending attribute is set, that means the two structures are
c152e538b85b revset: added ascending attribute to addset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20711 diff changeset	3349 ordered in either an ascending or descending way. Therefore, we can add
21024 7731a2281cf0 spelling: fixes from spell checker Mads Kiilerich <madski@unity3d.com> parents: 20991 diff changeset	3350 them maintaining the order by iterating over both at the same time
25024 263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3351
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3352 >>> xs = baseset([0, 3, 2])
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3353 >>> ys = baseset([5, 2, 4])
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3354
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3355 >>> rs = addset(xs, ys)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3356 >>> bool(rs), 0 in rs, 1 in rs, 5 in rs, rs.first(), rs.last()
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3357 (True, True, False, True, 0, 4)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3358 >>> rs = addset(xs, baseset([]))
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3359 >>> bool(rs), 0 in rs, 1 in rs, rs.first(), rs.last()
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3360 (True, True, False, 0, 2)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3361 >>> rs = addset(baseset([]), baseset([]))
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3362 >>> bool(rs), 0 in rs, rs.first(), rs.last()
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3363 (False, False, None, None)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3364
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3365 iterate unsorted:
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3366 >>> rs = addset(xs, ys)
28717 c5f212c8ad78 pypy: fix doctests for pypy optimizations Maciej Fijalkowski <fijall@gmail.com> parents: 28708 diff changeset	3367 >>> # (use generator because pypy could call len())
c5f212c8ad78 pypy: fix doctests for pypy optimizations Maciej Fijalkowski <fijall@gmail.com> parents: 28708 diff changeset	3368 >>> list(x for x in rs) # without _genlist
25024 263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3369 [0, 3, 2, 5, 4]
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3370 >>> assert not rs._genlist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3371 >>> len(rs)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3372 5
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3373 >>> [x for x in rs] # with _genlist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3374 [0, 3, 2, 5, 4]
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3375 >>> assert rs._genlist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3376
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3377 iterate ascending:
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3378 >>> rs = addset(xs, ys, ascending=True)
28717 c5f212c8ad78 pypy: fix doctests for pypy optimizations Maciej Fijalkowski <fijall@gmail.com> parents: 28708 diff changeset	3379 >>> # (use generator because pypy could call len())
c5f212c8ad78 pypy: fix doctests for pypy optimizations Maciej Fijalkowski <fijall@gmail.com> parents: 28708 diff changeset	3380 >>> list(x for x in rs), list(x for x in rs.fastasc()) # without _asclist
25024 263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3381 ([0, 2, 3, 4, 5], [0, 2, 3, 4, 5])
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3382 >>> assert not rs._asclist
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3383 >>> len(rs)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3384 5
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3385 >>> [x for x in rs], [x for x in rs.fastasc()]
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3386 ([0, 2, 3, 4, 5], [0, 2, 3, 4, 5])
25024 263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3387 >>> assert rs._asclist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3388
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3389 iterate descending:
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3390 >>> rs = addset(xs, ys, ascending=False)
28717 c5f212c8ad78 pypy: fix doctests for pypy optimizations Maciej Fijalkowski <fijall@gmail.com> parents: 28708 diff changeset	3391 >>> # (use generator because pypy could call len())
c5f212c8ad78 pypy: fix doctests for pypy optimizations Maciej Fijalkowski <fijall@gmail.com> parents: 28708 diff changeset	3392 >>> list(x for x in rs), list(x for x in rs.fastdesc()) # without _asclist
25024 263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3393 ([5, 4, 3, 2, 0], [5, 4, 3, 2, 0])
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3394 >>> assert not rs._asclist
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3395 >>> len(rs)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3396 5
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3397 >>> [x for x in rs], [x for x in rs.fastdesc()]
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3398 ([5, 4, 3, 2, 0], [5, 4, 3, 2, 0])
25024 263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3399 >>> assert rs._asclist
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3400
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3401 iterate ascending without fastasc:
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3402 >>> rs = addset(xs, generatorset(ys), ascending=True)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3403 >>> assert rs.fastasc is None
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3404 >>> [x for x in rs]
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3405 [0, 2, 3, 4, 5]
25024 263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3406
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3407 iterate descending without fastdesc:
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3408 >>> rs = addset(generatorset(xs), ys, ascending=False)
263bbed1833c revset: test current behavior of addset class Yuya Nishihara <yuya@tcha.org> parents: 25023 diff changeset	3409 >>> assert rs.fastdesc is None
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3410 >>> [x for x in rs]
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3411 [5, 4, 3, 2, 0]
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3412 """
20712 c152e538b85b revset: added ascending attribute to addset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20711 diff changeset	3413 def __init__(self, revs1, revs2, ascending=None):
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3414 self._r1 = revs1
621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3415 self._r2 = revs2
621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3416 self._iter = None
20712 c152e538b85b revset: added ascending attribute to addset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20711 diff changeset	3417 self._ascending = ascending
20720 5f8400efca0b revset: added cached generated list to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20719 diff changeset	3418 self._genlist = None
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3419 self._asclist = None
20720 5f8400efca0b revset: added cached generated list to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20719 diff changeset	3420
20845 bc95143446e8 _addset: add a __len__ method Pierre-Yves David <pierre-yves.david@fb.com> parents: 20833 diff changeset	3421 def __len__(self):
bc95143446e8 _addset: add a __len__ method Pierre-Yves David <pierre-yves.david@fb.com> parents: 20833 diff changeset	3422 return len(self._list)
bc95143446e8 _addset: add a __len__ method Pierre-Yves David <pierre-yves.david@fb.com> parents: 20833 diff changeset	3423
22743 eccf9907b844 addset: add a __nonzero__ method Pierre-Yves David <pierre-yves.david@fb.com> parents: 22742 diff changeset	3424 def __nonzero__(self):
23100 ac494b087feb revset: fix O(2^n) perf regression in addset Durham Goode <durham@fb.com> parents: 23078 diff changeset	3425 return bool(self._r1) or bool(self._r2)
22743 eccf9907b844 addset: add a __nonzero__ method Pierre-Yves David <pierre-yves.david@fb.com> parents: 22742 diff changeset	3426
20720 5f8400efca0b revset: added cached generated list to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20719 diff changeset	3427 @util.propertycache
5f8400efca0b revset: added cached generated list to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20719 diff changeset	3428 def _list(self):
5f8400efca0b revset: added cached generated list to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20719 diff changeset	3429 if not self._genlist:
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3430 self._genlist = baseset(iter(self))
20720 5f8400efca0b revset: added cached generated list to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20719 diff changeset	3431 return self._genlist
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3432
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3433 def __iter__(self):
20722 6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3434 """Iterate over both collections without repeating elements
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3435
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3436 If the ascending attribute is not set, iterate over the first one and
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3437 then over the second one checking for membership on the first one so we
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3438 dont yield any duplicates.
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3439
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3440 If the ascending attribute is set, iterate over both collections at the
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3441 same time, yielding only one value at a time in the given order.
6894223ebc38 revset: changed _iterator() method on addset to work with a given order Lucas Moscovicz <lmoscovicz@fb.com> parents: 20721 diff changeset	3442 """
22799 bafa371d7af3 addset: drop caching through generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22798 diff changeset	3443 if self._ascending is None:
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3444 if self._genlist:
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3445 return iter(self._genlist)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3446 def arbitraryordergen():
22799 bafa371d7af3 addset: drop caching through generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22798 diff changeset	3447 for r in self._r1:
bafa371d7af3 addset: drop caching through generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22798 diff changeset	3448 yield r
22881 057ebf7714e1 addset: drop `.set()` usage during iteration Pierre-Yves David <pierre-yves.david@fb.com> parents: 22880 diff changeset	3449 inr1 = self._r1.__contains__
22799 bafa371d7af3 addset: drop caching through generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 22798 diff changeset	3450 for r in self._r2:
22881 057ebf7714e1 addset: drop `.set()` usage during iteration Pierre-Yves David <pierre-yves.david@fb.com> parents: 22880 diff changeset	3451 if not inr1(r):
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3452 yield r
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3453 return arbitraryordergen()
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3454 # try to use our own fast iterator if it exists
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3455 self._trysetasclist()
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3456 if self._ascending:
25130 a94ef7f517e0 revset: use fastasc/fastdesc switch consistently in addset.__iter__ Yuya Nishihara <yuya@tcha.org> parents: 25129 diff changeset	3457 attr = 'fastasc'
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3458 else:
25130 a94ef7f517e0 revset: use fastasc/fastdesc switch consistently in addset.__iter__ Yuya Nishihara <yuya@tcha.org> parents: 25129 diff changeset	3459 attr = 'fastdesc'
a94ef7f517e0 revset: use fastasc/fastdesc switch consistently in addset.__iter__ Yuya Nishihara <yuya@tcha.org> parents: 25129 diff changeset	3460 it = getattr(self, attr)
25115 5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3461 if it is not None:
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3462 return it()
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3463 # maybe half of the component supports fast
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3464 # get iterator for _r1
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3465 iter1 = getattr(self._r1, attr)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3466 if iter1 is None:
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3467 # let's avoid side effect (not sure it matters)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3468 iter1 = iter(sorted(self._r1, reverse=not self._ascending))
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3469 else:
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3470 iter1 = iter1()
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3471 # get iterator for _r2
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3472 iter2 = getattr(self._r2, attr)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3473 if iter2 is None:
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3474 # let's avoid side effect (not sure it matters)
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3475 iter2 = iter(sorted(self._r2, reverse=not self._ascending))
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3476 else:
5548f558db3d revset: fix iteration over ordered addset composed of non-ordered operands Pierre-Yves David <pierre-yves.david@fb.com> parents: 25105 diff changeset	3477 iter2 = iter2()
25131 adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3478 return _iterordered(self._ascending, iter1, iter2)
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3479
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3480 def _trysetasclist(self):
23139 e53f6b72a0e4 spelling: fixes from proofreading of spell checker issues Mads Kiilerich <madski@unity3d.com> parents: 23127 diff changeset	3481 """populate the _asclist attribute if possible and necessary"""
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3482 if self._genlist is not None and self._asclist is None:
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3483 self._asclist = sorted(self._genlist)
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3484
22742 6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3485 @property
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3486 def fastasc(self):
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3487 self._trysetasclist()
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3488 if self._asclist is not None:
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3489 return self._asclist.__iter__
22742 6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3490 iter1 = self._r1.fastasc
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3491 iter2 = self._r2.fastasc
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3492 if None in (iter1, iter2):
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3493 return None
25131 adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3494 return lambda: _iterordered(True, iter1(), iter2())
22742 6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3495
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3496 @property
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3497 def fastdesc(self):
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3498 self._trysetasclist()
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3499 if self._asclist is not None:
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3500 return self._asclist.__reversed__
22742 6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3501 iter1 = self._r1.fastdesc
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3502 iter2 = self._r2.fastdesc
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3503 if None in (iter1, iter2):
6bbc26adcc6a addset: offer a fastasc and fastdesc methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22741 diff changeset	3504 return None
25131 adfe4d9680bf revset: extract addset._iterordered to free function Yuya Nishihara <yuya@tcha.org> parents: 25130 diff changeset	3505 return lambda: _iterordered(False, iter1(), iter2())
22741 ef2c1ea8fb2c addset: split simple and ordered iteration Pierre-Yves David <pierre-yves.david@fb.com> parents: 22740 diff changeset	3506
20694 621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3507 def __contains__(self, x):
621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3508 return x in self._r1 or x in self._r2
621c94378d0d revset: added addset class with its basic methods Lucas Moscovicz <lmoscovicz@fb.com> parents: 20693 diff changeset	3509
20724 e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3510 def sort(self, reverse=False):
e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3511 """Sort the added set
e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3512
e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3513 For this we use the cached list with all the generated values and if we
e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3514 know they are ascending or descending we can sort them in a smart way.
e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3515 """
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3516 self._ascending = not reverse
20724 e9a64b3f2925 revset: added sort method in addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20723 diff changeset	3517
20733 adf4ec7e6f60 revset: added isascending and isdescending methods to _addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20732 diff changeset	3518 def isascending(self):
adf4ec7e6f60 revset: added isascending and isdescending methods to _addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20732 diff changeset	3519 return self._ascending is not None and self._ascending
adf4ec7e6f60 revset: added isascending and isdescending methods to _addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20732 diff changeset	3520
adf4ec7e6f60 revset: added isascending and isdescending methods to _addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20732 diff changeset	3521 def isdescending(self):
adf4ec7e6f60 revset: added isascending and isdescending methods to _addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20732 diff changeset	3522 return self._ascending is not None and not self._ascending
adf4ec7e6f60 revset: added isascending and isdescending methods to _addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20732 diff changeset	3523
29346 38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3524 def istopo(self):
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3525 # not worth the trouble asserting if the two sets combined are still
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3526 # in topographical order. Use the sort() predicate to explicitly sort
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3527 # again instead.
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3528 return False
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3529
20723 fb9852c46a42 revset: added reverse method to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20722 diff changeset	3530 def reverse(self):
22859 513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3531 if self._ascending is None:
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3532 self._list.reverse()
513c0ba61db8 addset: do lazy sorting Pierre-Yves David <pierre-yves.david@fb.com> parents: 22857 diff changeset	3533 else:
20723 fb9852c46a42 revset: added reverse method to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20722 diff changeset	3534 self._ascending = not self._ascending
fb9852c46a42 revset: added reverse method to addset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20722 diff changeset	3535
22810 7f97cb12782f addset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22809 diff changeset	3536 def first(self):
23127 7361d8244efb addset: fix `first` and `last` on sorted addset (issue4426) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23115 diff changeset	3537 for x in self:
7361d8244efb addset: fix `first` and `last` on sorted addset (issue4426) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23115 diff changeset	3538 return x
22810 7f97cb12782f addset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22809 diff changeset	3539 return None
7f97cb12782f addset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22809 diff changeset	3540
7f97cb12782f addset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22809 diff changeset	3541 def last(self):
23127 7361d8244efb addset: fix `first` and `last` on sorted addset (issue4426) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23115 diff changeset	3542 self.reverse()
7361d8244efb addset: fix `first` and `last` on sorted addset (issue4426) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23115 diff changeset	3543 val = self.first()
7361d8244efb addset: fix `first` and `last` on sorted addset (issue4426) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23115 diff changeset	3544 self.reverse()
7361d8244efb addset: fix `first` and `last` on sorted addset (issue4426) Pierre-Yves David <pierre-yves.david@fb.com> parents: 23115 diff changeset	3545 return val
22810 7f97cb12782f addset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22809 diff changeset	3546
24457 c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3547 def __repr__(self):
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3548 d = {None: '', False: '-', True: '+'}[self._ascending]
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3549 return '<%s%s %r, %r>' % (type(self).__name__, d, self._r1, self._r2)
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3550
22795 c21342159fad generatorset: drop the leading underscore in the class name Pierre-Yves David <pierre-yves.david@fb.com> parents: 22794 diff changeset	3551 class generatorset(abstractsmartset):
20705 9cc2249a9461 revset: made generatorset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20703 diff changeset	3552 """Wrap a generator for lazy iteration
9cc2249a9461 revset: made generatorset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20703 diff changeset	3553
9cc2249a9461 revset: made generatorset a private class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20703 diff changeset	3554 Wrapper structure for generators that provides lazy membership and can
20540 fa16c710a3d8 revset: added cached generated list on generatorset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20538 diff changeset	3555 be iterated more than once.
fa16c710a3d8 revset: added cached generated list on generatorset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20538 diff changeset	3556 When asked for membership it generates values until either it finds the
fa16c710a3d8 revset: added cached generated list on generatorset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20538 diff changeset	3557 requested one or has gone through all the elements in the generator
fa16c710a3d8 revset: added cached generated list on generatorset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20538 diff changeset	3558 """
22755 f9a825b593be generatorset: make it possible to use gen as fastasc or fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22754 diff changeset	3559 def __init__(self, gen, iterasc=None):
20739 1b4f2399f3c4 revset: add documentation and comment for _generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20738 diff changeset	3560 """
1b4f2399f3c4 revset: add documentation and comment for _generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20738 diff changeset	3561 gen: a generator producing the values for the generatorset.
1b4f2399f3c4 revset: add documentation and comment for _generatorset Pierre-Yves David <pierre-yves.david@fb.com> parents: 20738 diff changeset	3562 """
20536 532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3563 self._gen = gen
22798 586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3564 self._asclist = None
20536 532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3565 self._cache = {}
22796 43f664bf2e1e generatorset: stop using a base as the _genlist Pierre-Yves David <pierre-yves.david@fb.com> parents: 22795 diff changeset	3566 self._genlist = []
20703 e07b1fd30805 revset: added sort methods to generatorsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20695 diff changeset	3567 self._finished = False
22800 29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3568 self._ascending = True
22755 f9a825b593be generatorset: make it possible to use gen as fastasc or fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22754 diff changeset	3569 if iterasc is not None:
f9a825b593be generatorset: make it possible to use gen as fastasc or fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22754 diff changeset	3570 if iterasc:
22797 61ecabeeadb3 generatorset: move iteration code into _iterator Pierre-Yves David <pierre-yves.david@fb.com> parents: 22796 diff changeset	3571 self.fastasc = self._iterator
22757 d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3572 self.__contains__ = self._asccontains
22755 f9a825b593be generatorset: make it possible to use gen as fastasc or fastdesc Pierre-Yves David <pierre-yves.david@fb.com> parents: 22754 diff changeset	3573 else:
22797 61ecabeeadb3 generatorset: move iteration code into _iterator Pierre-Yves David <pierre-yves.david@fb.com> parents: 22796 diff changeset	3574 self.fastdesc = self._iterator
22757 d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3575 self.__contains__ = self._desccontains
20540 fa16c710a3d8 revset: added cached generated list on generatorset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20538 diff changeset	3576
22739 4ed47a1b2d24 generatorset: implement __nonzero__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22738 diff changeset	3577 def __nonzero__(self):
24936 2aa94b6fe51c revset: make generatorset.__nonzero__ lazy Pierre-Yves David <pierre-yves.david@fb.com> parents: 24932 diff changeset	3578 # Do not use 'for r in self' because it will enforce the iteration
2aa94b6fe51c revset: make generatorset.__nonzero__ lazy Pierre-Yves David <pierre-yves.david@fb.com> parents: 24932 diff changeset	3579 # order (default ascending), possibly unrolling a whole descending
2aa94b6fe51c revset: make generatorset.__nonzero__ lazy Pierre-Yves David <pierre-yves.david@fb.com> parents: 24932 diff changeset	3580 # iterator.
2aa94b6fe51c revset: make generatorset.__nonzero__ lazy Pierre-Yves David <pierre-yves.david@fb.com> parents: 24932 diff changeset	3581 if self._genlist:
2aa94b6fe51c revset: make generatorset.__nonzero__ lazy Pierre-Yves David <pierre-yves.david@fb.com> parents: 24932 diff changeset	3582 return True
2aa94b6fe51c revset: make generatorset.__nonzero__ lazy Pierre-Yves David <pierre-yves.david@fb.com> parents: 24932 diff changeset	3583 for r in self._consumegen():
22739 4ed47a1b2d24 generatorset: implement __nonzero__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22738 diff changeset	3584 return True
4ed47a1b2d24 generatorset: implement __nonzero__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22738 diff changeset	3585 return False
4ed47a1b2d24 generatorset: implement __nonzero__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22738 diff changeset	3586
20536 532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3587 def __contains__(self, x):
532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3588 if x in self._cache:
532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3589 return self._cache[x]
532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3590
20828 3210b7930899 revset: improve performance of _generatorset.__contains__ (issue 4201) Gregory Szorc <gregory.szorc@gmail.com> parents: 20780 diff changeset	3591 # Use new values only, as existing values would be cached.
3210b7930899 revset: improve performance of _generatorset.__contains__ (issue 4201) Gregory Szorc <gregory.szorc@gmail.com> parents: 20780 diff changeset	3592 for l in self._consumegen():
20634 f2bb7ba59456 revset: changed generatorset code to remove unnecesary function call Lucas Moscovicz <lmoscovicz@fb.com> parents: 20613 diff changeset	3593 if l == x:
f2bb7ba59456 revset: changed generatorset code to remove unnecesary function call Lucas Moscovicz <lmoscovicz@fb.com> parents: 20613 diff changeset	3594 return True
20536 532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3595
532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3596 self._cache[x] = False
532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3597 return False
532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3598
22757 d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3599 def _asccontains(self, x):
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3600 """version of contains optimised for ascending generator"""
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3601 if x in self._cache:
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3602 return self._cache[x]
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3603
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3604 # Use new values only, as existing values would be cached.
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3605 for l in self._consumegen():
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3606 if l == x:
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3607 return True
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3608 if l > x:
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3609 break
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3610
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3611 self._cache[x] = False
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3612 return False
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3613
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3614 def _desccontains(self, x):
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3615 """version of contains optimised for descending generator"""
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3616 if x in self._cache:
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3617 return self._cache[x]
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3618
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3619 # Use new values only, as existing values would be cached.
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3620 for l in self._consumegen():
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3621 if l == x:
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3622 return True
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3623 if l < x:
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3624 break
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3625
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3626 self._cache[x] = False
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3627 return False
d34969a4b1a8 generatorset: move membership testing on ordered gen to the main class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22756 diff changeset	3628
20536 532b114a6e02 revset: added generatorset class with cached __contains__ method Lucas Moscovicz <lmoscovicz@fb.com> parents: 20534 diff changeset	3629 def __iter__(self):
22800 29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3630 if self._ascending:
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3631 it = self.fastasc
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3632 else:
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3633 it = self.fastdesc
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3634 if it is not None:
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3635 return it()
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3636 # we need to consume the iterator
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3637 for x in self._consumegen():
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3638 pass
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3639 # recall the same code
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3640 return iter(self)
22797 61ecabeeadb3 generatorset: move iteration code into _iterator Pierre-Yves David <pierre-yves.david@fb.com> parents: 22796 diff changeset	3641
61ecabeeadb3 generatorset: move iteration code into _iterator Pierre-Yves David <pierre-yves.david@fb.com> parents: 22796 diff changeset	3642 def _iterator(self):
20833 47d43e2323c5 revset: fix generatorset race condition Durham Goode <durham@fb.com> parents: 20829 diff changeset	3643 if self._finished:
22670 44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3644 return iter(self._genlist)
20833 47d43e2323c5 revset: fix generatorset race condition Durham Goode <durham@fb.com> parents: 20829 diff changeset	3645
22494 14f6cebfcb8a revset: document the choice made in __generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22487 diff changeset	3646 # We have to use this complex iteration strategy to allow multiple
14f6cebfcb8a revset: document the choice made in __generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22487 diff changeset	3647 # iterations at the same time. We need to be able to catch revision
23139 e53f6b72a0e4 spelling: fixes from proofreading of spell checker issues Mads Kiilerich <madski@unity3d.com> parents: 23127 diff changeset	3648 # removed from _consumegen and added to genlist in another instance.
22494 14f6cebfcb8a revset: document the choice made in __generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22487 diff changeset	3649 #
14f6cebfcb8a revset: document the choice made in __generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22487 diff changeset	3650 # Getting rid of it would provide an about 15% speed up on this
14f6cebfcb8a revset: document the choice made in __generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22487 diff changeset	3651 # iteration.
20833 47d43e2323c5 revset: fix generatorset race condition Durham Goode <durham@fb.com> parents: 20829 diff changeset	3652 genlist = self._genlist
22669 00c8abe64cf3 revset: prefetch an attribute in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22539 diff changeset	3653 nextrev = self._consumegen().next
00c8abe64cf3 revset: prefetch an attribute in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22539 diff changeset	3654 _len = len # cache global lookup
22670 44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3655 def gen():
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3656 i = 0
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3657 while True:
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3658 if i < _len(genlist):
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3659 yield genlist[i]
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3660 else:
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3661 yield nextrev()
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3662 i += 1
44dce874de97 revset: rely on built in iterator when possible in _generatorset.__iter__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22669 diff changeset	3663 return gen()
20828 3210b7930899 revset: improve performance of _generatorset.__contains__ (issue 4201) Gregory Szorc <gregory.szorc@gmail.com> parents: 20780 diff changeset	3664
3210b7930899 revset: improve performance of _generatorset.__contains__ (issue 4201) Gregory Szorc <gregory.szorc@gmail.com> parents: 20780 diff changeset	3665 def _consumegen(self):
22528 b6dc3b79bb25 revset: avoid in loop lookup in _generatorset._consumegen Pierre-Yves David <pierre-yves.david@fb.com> parents: 22527 diff changeset	3666 cache = self._cache
b6dc3b79bb25 revset: avoid in loop lookup in _generatorset._consumegen Pierre-Yves David <pierre-yves.david@fb.com> parents: 22527 diff changeset	3667 genlist = self._genlist.append
20634 f2bb7ba59456 revset: changed generatorset code to remove unnecesary function call Lucas Moscovicz <lmoscovicz@fb.com> parents: 20613 diff changeset	3668 for item in self._gen:
22528 b6dc3b79bb25 revset: avoid in loop lookup in _generatorset._consumegen Pierre-Yves David <pierre-yves.david@fb.com> parents: 22527 diff changeset	3669 cache[item] = True
b6dc3b79bb25 revset: avoid in loop lookup in _generatorset._consumegen Pierre-Yves David <pierre-yves.david@fb.com> parents: 22527 diff changeset	3670 genlist(item)
20634 f2bb7ba59456 revset: changed generatorset code to remove unnecesary function call Lucas Moscovicz <lmoscovicz@fb.com> parents: 20613 diff changeset	3671 yield item
22798 586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3672 if not self._finished:
586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3673 self._finished = True
586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3674 asc = self._genlist[:]
586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3675 asc.sort()
586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3676 self._asclist = asc
586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3677 self.fastasc = asc.__iter__
586d7058ea48 generatorset: get list-based fast iterations after the generator is consumed Pierre-Yves David <pierre-yves.david@fb.com> parents: 22797 diff changeset	3678 self.fastdesc = asc.__reversed__
20703 e07b1fd30805 revset: added sort methods to generatorsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20695 diff changeset	3679
22996 a43d929d1fa1 generatorset: implement __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22995 diff changeset	3680 def __len__(self):
a43d929d1fa1 generatorset: implement __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22995 diff changeset	3681 for x in self._consumegen():
a43d929d1fa1 generatorset: implement __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22995 diff changeset	3682 pass
a43d929d1fa1 generatorset: implement __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22995 diff changeset	3683 return len(self._genlist)
a43d929d1fa1 generatorset: implement __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22995 diff changeset	3684
20703 e07b1fd30805 revset: added sort methods to generatorsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20695 diff changeset	3685 def sort(self, reverse=False):
22800 29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3686 self._ascending = not reverse
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3687
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3688 def reverse(self):
29a8c20e14a8 generatorset: explicitly track iteration order Pierre-Yves David <pierre-yves.david@fb.com> parents: 22799 diff changeset	3689 self._ascending = not self._ascending
20703 e07b1fd30805 revset: added sort methods to generatorsets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20695 diff changeset	3690
22801 6af9e9b6af39 generatorset: implement isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22800 diff changeset	3691 def isascending(self):
6af9e9b6af39 generatorset: implement isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22800 diff changeset	3692 return self._ascending
6af9e9b6af39 generatorset: implement isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22800 diff changeset	3693
6af9e9b6af39 generatorset: implement isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22800 diff changeset	3694 def isdescending(self):
6af9e9b6af39 generatorset: implement isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22800 diff changeset	3695 return not self._ascending
6af9e9b6af39 generatorset: implement isascending and isdescending Pierre-Yves David <pierre-yves.david@fb.com> parents: 22800 diff changeset	3696
29346 38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3697 def istopo(self):
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3698 # not worth the trouble asserting if the two sets combined are still
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3699 # in topographical order. Use the sort() predicate to explicitly sort
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3700 # again instead.
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3701 return False
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3702
22811 c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3703 def first(self):
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3704 if self._ascending:
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3705 it = self.fastasc
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3706 else:
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3707 it = self.fastdesc
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3708 if it is None:
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3709 # we need to consume all and try again
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3710 for x in self._consumegen():
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3711 pass
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3712 return self.first()
25146 f542a2c89b60 generatorset: use 'next()' to simplify the code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25145 diff changeset	3713 return next(it(), None)
22811 c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3714
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3715 def last(self):
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3716 if self._ascending:
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3717 it = self.fastdesc
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3718 else:
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3719 it = self.fastasc
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3720 if it is None:
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3721 # we need to consume all and try again
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3722 for x in self._consumegen():
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3723 pass
c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3724 return self.first()
25146 f542a2c89b60 generatorset: use 'next()' to simplify the code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25145 diff changeset	3725 return next(it(), None)
22811 c1fd827e1ae0 generatorset: implement first and last methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22810 diff changeset	3726
24457 c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3727 def __repr__(self):
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3728 d = {False: '-', True: '+'}[self._ascending]
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3729 return '<%s%s>' % (type(self).__name__, d)
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3730
24116 8b90a60181d1 revset: drop factory that promotes spanset to fullreposet Yuya Nishihara <yuya@tcha.org> parents: 24115 diff changeset	3731 class spanset(abstractsmartset):
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3732 """Duck type for baseset class which represents a range of revisions and
a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3733 can work lazily and without having all the range in memory
20737 b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3734
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3735 Note that spanset(x, y) behave almost like xrange(x, y) except for two
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3736 notable points:
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3737 - when x < y it will be automatically descending,
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3738 - revision filtered with this repoview will be skipped.
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3739
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3740 """
20525 aa73a6327df4 revset: changed spanset to take a repo argument Lucas Moscovicz <lmoscovicz@fb.com> parents: 20521 diff changeset	3741 def __init__(self, repo, start=0, end=None):
20737 b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3742 """
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3743 start: first revision included the set
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3744 (default to 0)
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3745 end: first revision excluded (last+1)
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3746 (default to len(repo)
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3747
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3748 Spanset will be descending if `end` < `start`.
b141080e70c5 revset: added documentation and comment for spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20734 diff changeset	3749 """
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3750 if end is None:
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3751 end = len(repo)
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3752 self._ascending = start <= end
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3753 if not self._ascending:
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3754 start, end = end + 1, start +1
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3755 self._start = start
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3756 self._end = end
20525 aa73a6327df4 revset: changed spanset to take a repo argument Lucas Moscovicz <lmoscovicz@fb.com> parents: 20521 diff changeset	3757 self._hiddenrevs = repo.changelog.filteredrevs
20521 1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3758
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3759 def sort(self, reverse=False):
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3760 self._ascending = not reverse
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3761
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3762 def reverse(self):
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3763 self._ascending = not self._ascending
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3764
29346 38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3765 def istopo(self):
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3766 # not worth the trouble asserting if the two sets combined are still
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3767 # in topographical order. Use the sort() predicate to explicitly sort
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3768 # again instead.
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3769 return False
38e0c83c7ee4 revset: record if a set is in topographical order Martijn Pieters <mjpieters@fb.com> parents: 29304 diff changeset	3770
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3771 def _iterfilter(self, iterrange):
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3772 s = self._hiddenrevs
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3773 for r in iterrange:
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3774 if r not in s:
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3775 yield r
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3776
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3777 def __iter__(self):
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3778 if self._ascending:
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3779 return self.fastasc()
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3780 else:
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3781 return self.fastdesc()
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3782
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3783 def fastasc(self):
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3784 iterrange = xrange(self._start, self._end)
20521 1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3785 if self._hiddenrevs:
22717 b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3786 return self._iterfilter(iterrange)
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3787 return iter(iterrange)
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3788
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3789 def fastdesc(self):
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3790 iterrange = xrange(self._end - 1, self._start - 1, -1)
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3791 if self._hiddenrevs:
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3792 return self._iterfilter(iterrange)
b89f7e3a414d spanset: enforce the order lazily to gain `fastasc` and `fastdesc` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22716 diff changeset	3793 return iter(iterrange)
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3794
21201 c8b9c6147108 revset: fix revision filtering in spanset.contains (regression) Pierre-Yves David <pierre-yves.david@fb.com> parents: 21199 diff changeset	3795 def __contains__(self, rev):
22526 1e6d2b6b37ea revset: do less lookup during spanset.__contains__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22510 diff changeset	3796 hidden = self._hiddenrevs
22718 7b123e5639f4 spanset: do a single range check in __contains__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22717 diff changeset	3797 return ((self._start <= rev < self._end)
22526 1e6d2b6b37ea revset: do less lookup during spanset.__contains__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22510 diff changeset	3798 and not (hidden and rev in hidden))
20482 a979078bd788 revset: added spanset class to represent revision ranges Lucas Moscovicz <lmoscovicz@fb.com> parents: 20481 diff changeset	3799
20716 fa1ac5faa7c4 revset: added __nonzero__ method to spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20714 diff changeset	3800 def __nonzero__(self):
fa1ac5faa7c4 revset: added __nonzero__ method to spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20714 diff changeset	3801 for r in self:
fa1ac5faa7c4 revset: added __nonzero__ method to spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20714 diff changeset	3802 return True
fa1ac5faa7c4 revset: added __nonzero__ method to spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20714 diff changeset	3803 return False
fa1ac5faa7c4 revset: added __nonzero__ method to spanset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20714 diff changeset	3804
20484 0f1ef9e9e904 revset: added operations to spanset to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20483 diff changeset	3805 def __len__(self):
20521 1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3806 if not self._hiddenrevs:
1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3807 return abs(self._end - self._start)
1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3808 else:
1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3809 count = 0
21205 e2031c8ca4f8 revset: also inline spanset._contained in __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 21204 diff changeset	3810 start = self._start
e2031c8ca4f8 revset: also inline spanset._contained in __len__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 21204 diff changeset	3811 end = self._end
20521 1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3812 for rev in self._hiddenrevs:
21284 3e53a64345c1 revset: cosmetic changes in spanset range comparison Pierre-Yves David <pierre-yves.david@fb.com> parents: 21283 diff changeset	3813 if (end < rev <= start) or (start <= rev < end):
20521 1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3814 count += 1
1850a7f5fb66 revset: changed spanset implementation to take hidden revisions into account Lucas Moscovicz <lmoscovicz@fb.com> parents: 20512 diff changeset	3815 return abs(self._end - self._start) - count
20484 0f1ef9e9e904 revset: added operations to spanset to duck type baseset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20483 diff changeset	3816
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3817 def isascending(self):
23826 c90d195320c5 revset: fix spanset.isascending() to honor sort() or reverse() request Yuya Nishihara <yuya@tcha.org> parents: 23724 diff changeset	3818 return self._ascending
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3819
cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3820 def isdescending(self):
23826 c90d195320c5 revset: fix spanset.isascending() to honor sort() or reverse() request Yuya Nishihara <yuya@tcha.org> parents: 23724 diff changeset	3821 return not self._ascending
20725 cf628b50afbb revset: added isascending and isdescending methods to smartset classes Lucas Moscovicz <lmoscovicz@fb.com> parents: 20724 diff changeset	3822
22809 88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3823 def first(self):
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3824 if self._ascending:
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3825 it = self.fastasc
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3826 else:
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3827 it = self.fastdesc
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3828 for x in it():
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3829 return x
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3830 return None
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3831
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3832 def last(self):
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3833 if self._ascending:
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3834 it = self.fastdesc
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3835 else:
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3836 it = self.fastasc
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3837 for x in it():
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3838 return x
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3839 return None
88dad916c008 spanset: implement `first` and `last` methods Pierre-Yves David <pierre-yves.david@fb.com> parents: 22808 diff changeset	3840
24457 c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3841 def __repr__(self):
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3842 d = {False: '-', True: '+'}[self._ascending]
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3843 return '<%s%s %d:%d>' % (type(self).__name__, d,
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3844 self._start, self._end - 1)
c5022f3579b9 revset: add __repr__ to all smartset classes Yuya Nishihara <yuya@tcha.org> parents: 24446 diff changeset	3845
24116 8b90a60181d1 revset: drop factory that promotes spanset to fullreposet Yuya Nishihara <yuya@tcha.org> parents: 24115 diff changeset	3846 class fullreposet(spanset):
22508 2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3847 """a set containing all revisions in the repo
2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3848
24204 d2de20e1451f revset: extend fullreposet to make "null" revision magically appears in set Yuya Nishihara <yuya@tcha.org> parents: 24203 diff changeset	3849 This class exists to host special optimization and magic to handle virtual
d2de20e1451f revset: extend fullreposet to make "null" revision magically appears in set Yuya Nishihara <yuya@tcha.org> parents: 24203 diff changeset	3850 revisions such as "null".
22508 2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3851 """
2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3852
2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3853 def __init__(self, repo):
2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3854 super(fullreposet, self).__init__(repo)
2434c68d82a8 revert: add a fullreposet class Pierre-Yves David <pierre-yves.david@fb.com> parents: 22504 diff changeset	3855
22510 911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3856 def __and__(self, other):
23139 e53f6b72a0e4 spelling: fixes from proofreading of spell checker issues Mads Kiilerich <madski@unity3d.com> parents: 23127 diff changeset	3857 """As self contains the whole repo, all of the other set should also be
e53f6b72a0e4 spelling: fixes from proofreading of spell checker issues Mads Kiilerich <madski@unity3d.com> parents: 23127 diff changeset	3858 in self. Therefore `self & other = other`.
22510 911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3859
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3860 This boldly assumes the other contains valid revs only.
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3861 """
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3862 # other not a smartset, make is so
22883 e7b8cf352614 fullreposet: detect smartset using "isascending" instead of "set" Pierre-Yves David <pierre-yves.david@fb.com> parents: 22882 diff changeset	3863 if not util.safehasattr(other, 'isascending'):
22510 911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3864 # filter out hidden revision
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3865 # (this boldly assumes all smartset are pure)
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3866 #
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3867 # `other` was used with "&", let's assume this is a set like
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3868 # object.
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3869 other = baseset(other - self._hiddenrevs)
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3870
23827 4982fade9733 revset: simplify fullreposet.__and__ to call sort() with boolean flag Yuya Nishihara <yuya@tcha.org> parents: 23822 diff changeset	3871 other.sort(reverse=self.isdescending())
22510 911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3872 return other
911f5a6579d1 revset: fast implementation for fullreposet.__and__ Pierre-Yves David <pierre-yves.david@fb.com> parents: 22509 diff changeset	3873
24458 7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3874 def prettyformatset(revs):
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3875 lines = []
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3876 rs = repr(revs)
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3877 p = 0
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3878 while p < len(rs):
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3879 q = rs.find('<', p + 1)
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3880 if q < 0:
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3881 q = len(rs)
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3882 l = rs.count('<', 0, p) - rs.count('>', 0, p)
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3883 assert l >= 0
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3884 lines.append((l, rs[p:q].rstrip()))
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3885 p = q
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3886 return '\n'.join(' ' * l + s for l, s in lines)
7d87f672d069 debugrevspec: show nesting structure of smartsets if verbose Yuya Nishihara <yuya@tcha.org> parents: 24457 diff changeset	3887
28393 ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	3888 def loadpredicate(ui, extname, registrarobj):
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	3889 """Load revset predicates from specified registrarobj
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	3890 """
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	3891 for name, func in registrarobj._table.iteritems():
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	3892 symbols[name] = func
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	3893 if func._safe:
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	3894 safesymbols.add(name)
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	3895
28395 0383f7a5e86c revset: replace predicate by revsetpredicate of registrar FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28393 diff changeset	3896 # load built-in predicates explicitly to setup safesymbols
0383f7a5e86c revset: replace predicate by revsetpredicate of registrar FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28393 diff changeset	3897 loadpredicate(None, None, predicate)
0383f7a5e86c revset: replace predicate by revsetpredicate of registrar FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28393 diff changeset	3898
12823 80deae3bc5ea hggettext: handle i18nfunctions declaration for docstrings translations Patrick Mezard <pmezard@gmail.com> parents: 12821 diff changeset	3899 # tell hggettext to extract docstrings from these functions:
80deae3bc5ea hggettext: handle i18nfunctions declaration for docstrings translations Patrick Mezard <pmezard@gmail.com> parents: 12821 diff changeset	3900 i18nfunctions = symbols.values()

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/revset.py @ 30782:db38cfc7c29d