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

annotate mercurial/revset.py @ 33416:9467d5337292

revset: add experimental relation and subscript operators The proposed syntax [1] was originally 'set{n rel}', but it seemed slightly confusing if template is involved. On the other hand, we want to keep 'set[n]' for future extension. So this patch introduces 'set#rel[n]' ternary operator. I chose '#' just because it looks like applying an attribute. This also adds stubs for 'set[n]' and 'set#rel' operators since these syntax elements are fundamental for constructing 'set#rel[n]'. [1]: https://www.mercurial-scm.org/wiki/RevsetOperatorPlan#ideas_from_mpm

author	Yuya Nishihara <yuya@tcha.org>
date	Sat, 08 Jul 2017 13:07:59 +0900
parents	5d63e5f40bea
children	d1b13d4995ed

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
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	10 import re
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	11
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	12 from .i18n import _
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	13 from . import (
32921 27932a76a88d dagop: split module hosting DAG-related algorithms from revset Yuya Nishihara <yuya@tcha.org> parents: 32903 diff changeset	14 dagop,
26713 a271925699d6 revset: reintroduce and experimental revset for update destination Pierre-Yves David <pierre-yves.david@fb.com> parents: 26638 diff changeset	15 destutil,
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	16 encoding,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	17 error,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	18 hbisect,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	19 match as matchmod,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	20 node,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	21 obsolete as obsmod,
33377 5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	22 obsutil,
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	23 pathutil,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	24 phases,
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	25 registrar,
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	26 repoview,
31044 0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	27 revsetlang,
32681 a3064fe3e495 revset: add support for integer and hex wdir identifiers Yuya Nishihara <yuya@tcha.org> parents: 32480 diff changeset	28 scmutil,
30913 1be65deb3d54 smartset: move set classes and related functions from revset module (API) Yuya Nishihara <yuya@tcha.org> parents: 30850 diff changeset	29 smartset,
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	30 util,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	31 )
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	32
31044 0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	33 # helpers for processing parsed tree
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	34 getsymbol = revsetlang.getsymbol
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	35 getstring = revsetlang.getstring
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	36 getinteger = revsetlang.getinteger
31998 83527d9f1f13 revset: properly parse "descend" argument of followlines() Denis Laxalde <denis@laxalde.org> parents: 31938 diff changeset	37 getboolean = revsetlang.getboolean
31044 0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	38 getlist = revsetlang.getlist
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	39 getrange = revsetlang.getrange
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	40 getargs = revsetlang.getargs
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	41 getargsdict = revsetlang.getargsdict
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	42
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	43 # constants used as an argument of match() and matchany()
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	44 anyorder = revsetlang.anyorder
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	45 defineorder = revsetlang.defineorder
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	46 followorder = revsetlang.followorder
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	47
30913 1be65deb3d54 smartset: move set classes and related functions from revset module (API) Yuya Nishihara <yuya@tcha.org> parents: 30850 diff changeset	48 baseset = smartset.baseset
1be65deb3d54 smartset: move set classes and related functions from revset module (API) Yuya Nishihara <yuya@tcha.org> parents: 30850 diff changeset	49 generatorset = smartset.generatorset
1be65deb3d54 smartset: move set classes and related functions from revset module (API) Yuya Nishihara <yuya@tcha.org> parents: 30850 diff changeset	50 spanset = smartset.spanset
1be65deb3d54 smartset: move set classes and related functions from revset module (API) Yuya Nishihara <yuya@tcha.org> parents: 30850 diff changeset	51 fullreposet = smartset.fullreposet
1be65deb3d54 smartset: move set classes and related functions from revset module (API) Yuya Nishihara <yuya@tcha.org> parents: 30850 diff changeset	52
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	53 # helpers
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	54
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	55 def getset(repo, subset, x):
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	56 if not x:
11383 de544774ebea revset: all your error messages are belong to _ Martin Geisler <mg@lazybytes.net> parents: 11349 diff changeset	57 raise error.ParseError(_("missing argument"))
31809 35b8bb1ef02b revset: stop supporting predicate that returns plain list (API) Yuya Nishihara <yuya@tcha.org> parents: 31667 diff changeset	58 return methods[x[0]](repo, subset, *x[1:])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	59
17003 42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	60 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	61 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	62 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	63 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	64 try:
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	65 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	66 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	67 pass
42c472877825 revset: add a utility for obtaining the source of a given rev Matt Harbison <matt_harbison@yahoo.com> parents: 17002 diff changeset	68 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	69
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	70 # operator methods
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	71
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	72 def stringset(repo, subset, x):
32681 a3064fe3e495 revset: add support for integer and hex wdir identifiers Yuya Nishihara <yuya@tcha.org> parents: 32480 diff changeset	73 x = scmutil.intrev(repo[x])
25265 e16456831516 revset: drop magic of fullreposet membership test (issue4682) Yuya Nishihara <yuya@tcha.org> parents: 25094 diff changeset	74 if (x in subset
e16456831516 revset: drop magic of fullreposet membership test (issue4682) Yuya Nishihara <yuya@tcha.org> parents: 25094 diff changeset	75 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	76 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	77 return baseset()
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	78
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	79 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	80 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	81 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	82
88abbb046e66 revset: deal with empty sets in range endpoints Matt Mackall <mpm@selenic.com> parents: 11446 diff changeset	83 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	84 return baseset()
30043 49d5434d68fb revset: extract function that creates range set from computed revisions Yuya Nishihara <yuya@tcha.org> parents: 29959 diff changeset	85 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	86
30803 d389f19f14aa revset: do not transform range* operators in parsed tree Yuya Nishihara <yuya@tcha.org> parents: 30802 diff changeset	87 def rangeall(repo, subset, x, order):
d389f19f14aa revset: do not transform range* operators in parsed tree Yuya Nishihara <yuya@tcha.org> parents: 30802 diff changeset	88 assert x is None
d389f19f14aa revset: do not transform range* operators in parsed tree Yuya Nishihara <yuya@tcha.org> parents: 30802 diff changeset	89 return _makerangeset(repo, subset, 0, len(repo) - 1, order)
d389f19f14aa revset: do not transform range* operators in parsed tree Yuya Nishihara <yuya@tcha.org> parents: 30802 diff changeset	90
30044 69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	91 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	92 # ':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	93 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	94 if not n:
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	95 return baseset()
69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	96 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	97
30803 d389f19f14aa revset: do not transform range* operators in parsed tree Yuya Nishihara <yuya@tcha.org> parents: 30802 diff changeset	98 def rangepost(repo, subset, x, order):
d389f19f14aa revset: do not transform range* operators in parsed tree Yuya Nishihara <yuya@tcha.org> parents: 30802 diff changeset	99 m = getset(repo, fullreposet(repo), x)
d389f19f14aa revset: do not transform range* operators in parsed tree Yuya Nishihara <yuya@tcha.org> parents: 30802 diff changeset	100 if not m:
d389f19f14aa revset: do not transform range* operators in parsed tree Yuya Nishihara <yuya@tcha.org> parents: 30802 diff changeset	101 return baseset()
d389f19f14aa revset: do not transform range* operators in parsed tree Yuya Nishihara <yuya@tcha.org> parents: 30802 diff changeset	102 return _makerangeset(repo, subset, m.first(), len(repo) - 1, order)
d389f19f14aa revset: do not transform range* operators in parsed tree Yuya Nishihara <yuya@tcha.org> parents: 30802 diff changeset	103
30043 49d5434d68fb revset: extract function that creates range set from computed revisions Yuya Nishihara <yuya@tcha.org> parents: 29959 diff changeset	104 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	105 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	106 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	107 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	108 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	109 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	110 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	111 elif m < n:
20526 9ad6dae67845 revset: changed revsets to use spanset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20525 diff changeset	112 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	113 else:
20526 9ad6dae67845 revset: changed revsets to use spanset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20525 diff changeset	114 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	115
5f56a3b9675e revset: fix order of nested 'range' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29947 diff changeset	116 if order == defineorder:
5f56a3b9675e revset: fix order of nested 'range' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29947 diff changeset	117 return r & subset
5f56a3b9675e revset: fix order of nested 'range' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29947 diff changeset	118 else:
5f56a3b9675e revset: fix order of nested 'range' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29947 diff changeset	119 # 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	120 return subset & r
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	121
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	122 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	123 r = fullreposet(repo)
32921 27932a76a88d dagop: split module hosting DAG-related algorithms from revset Yuya Nishihara <yuya@tcha.org> parents: 32903 diff changeset	124 xs = dagop.reachableroots(repo, getset(repo, r, x), getset(repo, r, y),
27932a76a88d dagop: split module hosting DAG-related algorithms from revset Yuya Nishihara <yuya@tcha.org> parents: 32903 diff changeset	125 includepath=True)
29139 64c1955a0461 revset: make dagrange preserve order of input set Yuya Nishihara <yuya@tcha.org> parents: 29119 diff changeset	126 return subset & xs
16860 e1aa1ed30030 revset: turn dagrange into a function Bryan O'Sullivan <bryano@fb.com> parents: 16859 diff changeset	127
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	128 def andset(repo, subset, x, y, order):
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	129 return getset(repo, getset(repo, subset, x), y)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	130
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	131 def differenceset(repo, subset, x, y, order):
28217 d2ac8b57a75d revset: use smartset minus operator Durham Goode <durham@fb.com> parents: 28139 diff changeset	132 return getset(repo, subset, x) - getset(repo, subset, y)
d2ac8b57a75d revset: use smartset minus operator Durham Goode <durham@fb.com> parents: 28139 diff changeset	133
29933 b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	134 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	135 assert xs
289149111d46 revset: make balanced addsets by orset() without using _combinesets() Yuya Nishihara <yuya@tcha.org> parents: 25927 diff changeset	136 if len(xs) == 1:
289149111d46 revset: make balanced addsets by orset() without using _combinesets() Yuya Nishihara <yuya@tcha.org> parents: 25927 diff changeset	137 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	138 p = len(xs) // 2
29933 b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	139 a = _orsetlist(repo, subset, xs[:p])
b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	140 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	141 return a + b
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	142
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	143 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	144 xs = getlist(x)
2c6a05b938d8 revset: fix order of nested 'or' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29937 diff changeset	145 if order == followorder:
2c6a05b938d8 revset: fix order of nested 'or' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29937 diff changeset	146 # 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	147 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	148 else:
2c6a05b938d8 revset: fix order of nested 'or' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29937 diff changeset	149 return _orsetlist(repo, subset, xs)
29933 b3845cab4ddc revset: wrap arguments of 'or' by 'list' node Yuya Nishihara <yuya@tcha.org> parents: 29926 diff changeset	150
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	151 def notset(repo, subset, x, order):
20366 5ec6321f49a9 revset: added substraction to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20365 diff changeset	152 return subset - getset(repo, subset, x)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	153
33416 9467d5337292 revset: add experimental relation and subscript operators Yuya Nishihara <yuya@tcha.org> parents: 33377 diff changeset	154 def relationset(repo, subset, x, y, order):
9467d5337292 revset: add experimental relation and subscript operators Yuya Nishihara <yuya@tcha.org> parents: 33377 diff changeset	155 raise error.ParseError(_("can't use a relation in this context"))
9467d5337292 revset: add experimental relation and subscript operators Yuya Nishihara <yuya@tcha.org> parents: 33377 diff changeset	156
9467d5337292 revset: add experimental relation and subscript operators Yuya Nishihara <yuya@tcha.org> parents: 33377 diff changeset	157 def relsubscriptset(repo, subset, x, y, z, order):
9467d5337292 revset: add experimental relation and subscript operators Yuya Nishihara <yuya@tcha.org> parents: 33377 diff changeset	158 raise error.ParseError(_("can't use a relation in this context"))
9467d5337292 revset: add experimental relation and subscript operators Yuya Nishihara <yuya@tcha.org> parents: 33377 diff changeset	159
9467d5337292 revset: add experimental relation and subscript operators Yuya Nishihara <yuya@tcha.org> parents: 33377 diff changeset	160 def subscriptset(repo, subset, x, y, order):
9467d5337292 revset: add experimental relation and subscript operators Yuya Nishihara <yuya@tcha.org> parents: 33377 diff changeset	161 raise error.ParseError(_("can't use a subscript in this context"))
9467d5337292 revset: add experimental relation and subscript operators Yuya Nishihara <yuya@tcha.org> parents: 33377 diff changeset	162
27987 b19d8d5d6b51 revset: flatten chained 'list' operations (aka function args) (issue5072) Yuya Nishihara <yuya@tcha.org> parents: 27945 diff changeset	163 def listset(repo, subset, *xs):
27517 c60a9c16ae25 revset: add hint for list error to use or timeless <timeless@mozdev.org> parents: 27440 diff changeset	164 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	165 hint=_('see hg help "revsets.x or y"'))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	166
25704 70a2082f855a revset: add parsing rule for key=value pair Yuya Nishihara <yuya@tcha.org> parents: 25689 diff changeset	167 def keyvaluepair(repo, subset, k, v):
70a2082f855a revset: add parsing rule for key=value pair Yuya Nishihara <yuya@tcha.org> parents: 25689 diff changeset	168 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	169
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	170 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	171 f = getsymbol(a)
9e8d258708bb revset: check invalid function syntax "func-name"() explicitly Yuya Nishihara <yuya@tcha.org> parents: 29425 diff changeset	172 if f in symbols:
30402 155d7ea98085 revset: avoid shadowing a variable with a list comprehension Augie Fackler <augie@google.com> parents: 30342 diff changeset	173 func = symbols[f]
155d7ea98085 revset: avoid shadowing a variable with a list comprehension Augie Fackler <augie@google.com> parents: 30342 diff changeset	174 if getattr(func, '_takeorder', False):
155d7ea98085 revset: avoid shadowing a variable with a list comprehension Augie Fackler <augie@google.com> parents: 30342 diff changeset	175 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	176 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	177
015c0d1087a3 revset: don't suggest private or undocumented queries Matt Harbison <matt_harbison@yahoo.com> parents: 25630 diff changeset	178 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	179
015c0d1087a3 revset: don't suggest private or undocumented queries Matt Harbison <matt_harbison@yahoo.com> parents: 25630 diff changeset	180 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	181 raise error.UnknownIdentifier(f, syms)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	182
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	183 # functions
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	184
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	185 # 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	186 # 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	187 # with:
fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	188 # 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	189 # 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	190 # 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	191 symbols = {}
fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	192
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	193 # 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	194 # (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	195 # 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	196 safesymbols = set()
c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	197
28395 0383f7a5e86c revset: replace predicate by revsetpredicate of registrar FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28393 diff changeset	198 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	199
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	200 @predicate('_destupdate')
26713 a271925699d6 revset: reintroduce and experimental revset for update destination Pierre-Yves David <pierre-yves.david@fb.com> parents: 26638 diff changeset	201 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	202 # experimental revset for update destination
30982 11c253997b0e destutil: drop now-unused "check" parameter from destupdate() Martin von Zweigbergk <martinvonz@google.com> parents: 30913 diff changeset	203 args = getargsdict(x, 'limit', 'clean')
26713 a271925699d6 revset: reintroduce and experimental revset for update destination Pierre-Yves David <pierre-yves.david@fb.com> parents: 26638 diff changeset	204 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	205
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	206 @predicate('_destmerge')
26716 c027641f8a83 revset: rename and test '_destmerge' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26714 diff changeset	207 def _destmerge(repo, subset, x):
c027641f8a83 revset: rename and test '_destmerge' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26714 diff changeset	208 # 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	209 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	210 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	211 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	212 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	213
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	214 @predicate('adds(pattern)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	215 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	216 """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	217
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	218 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	219 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	220 directory.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	221 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	222 # i18n: "adds" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	223 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	224 return checkstatus(repo, subset, pat, 1)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	225
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	226 @predicate('ancestor(*changeset)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	227 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	228 """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	229
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	230 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	231 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	232 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	233 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	234 # 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	235 l = getlist(x)
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	236 rl = fullreposet(repo)
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	237 anc = None
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	238
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	239 # (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	240 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	241 for r in revs:
ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	242 if anc is None:
20991 a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	243 anc = repo[r]
18536 ae645d4f084c revset: change ancestor to accept 0 or more arguments (issue3750) Paul Cavallaro <ptc@fb.com> parents: 18495 diff changeset	244 else:
20991 a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	245 anc = anc.ancestor(repo[r])
a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	246
a05d694599f9 revlog: use context ancestor instead of changelog ancestor Mads Kiilerich <madski@unity3d.com> parents: 20895 diff changeset	247 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	248 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	249 return baseset()
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	250
33019 f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	251 def _ancestors(repo, subset, x, followfirst=False, startdepth=None,
f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	252 stopdepth=None):
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	253 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	254 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	255 return baseset()
33019 f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	256 s = dagop.revancestors(repo, heads, followfirst, startdepth, stopdepth)
23003 62d19ce9d7b6 revset-_ancestor: use & instead of filter Pierre-Yves David <pierre-yves.david@fb.com> parents: 22999 diff changeset	257 return subset & s
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	258
33018 272a44cac57e revset: add depth limit to ancestors() Yuya Nishihara <yuya@tcha.org> parents: 32932 diff changeset	259 @predicate('ancestors(set[, depth])', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	260 def ancestors(repo, subset, x):
32923 2851b24eecc4 help: clarify ancestors() and descendants() include given set (issue5594) Yuya Nishihara <yuya@tcha.org> parents: 32922 diff changeset	261 """Changesets that are ancestors of changesets in set, including the
2851b24eecc4 help: clarify ancestors() and descendants() include given set (issue5594) Yuya Nishihara <yuya@tcha.org> parents: 32922 diff changeset	262 given changesets themselves.
33018 272a44cac57e revset: add depth limit to ancestors() Yuya Nishihara <yuya@tcha.org> parents: 32932 diff changeset	263
272a44cac57e revset: add depth limit to ancestors() Yuya Nishihara <yuya@tcha.org> parents: 32932 diff changeset	264 If depth is specified, the result only includes changesets up to
272a44cac57e revset: add depth limit to ancestors() Yuya Nishihara <yuya@tcha.org> parents: 32932 diff changeset	265 the specified generation.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	266 """
33019 f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	267 # startdepth is for internal use only until we can decide the UI
f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	268 args = getargsdict(x, 'ancestors', 'set depth startdepth')
32932 577759ef2ed2 revset: add support of keyword arguments to ancestors() and descendants() Yuya Nishihara <yuya@tcha.org> parents: 32923 diff changeset	269 if 'set' not in args:
577759ef2ed2 revset: add support of keyword arguments to ancestors() and descendants() Yuya Nishihara <yuya@tcha.org> parents: 32923 diff changeset	270 # i18n: "ancestors" is a keyword
577759ef2ed2 revset: add support of keyword arguments to ancestors() and descendants() Yuya Nishihara <yuya@tcha.org> parents: 32923 diff changeset	271 raise error.ParseError(_('ancestors takes at least 1 argument'))
33019 f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	272 startdepth = stopdepth = None
f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	273 if 'startdepth' in args:
f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	274 n = getinteger(args['startdepth'],
f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	275 "ancestors expects an integer startdepth")
f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	276 if n < 0:
f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	277 raise error.ParseError("negative startdepth")
f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	278 startdepth = n
33018 272a44cac57e revset: add depth limit to ancestors() Yuya Nishihara <yuya@tcha.org> parents: 32932 diff changeset	279 if 'depth' in args:
272a44cac57e revset: add depth limit to ancestors() Yuya Nishihara <yuya@tcha.org> parents: 32932 diff changeset	280 # i18n: "ancestors" is a keyword
272a44cac57e revset: add depth limit to ancestors() Yuya Nishihara <yuya@tcha.org> parents: 32932 diff changeset	281 n = getinteger(args['depth'], _("ancestors expects an integer depth"))
272a44cac57e revset: add depth limit to ancestors() Yuya Nishihara <yuya@tcha.org> parents: 32932 diff changeset	282 if n < 0:
272a44cac57e revset: add depth limit to ancestors() Yuya Nishihara <yuya@tcha.org> parents: 32932 diff changeset	283 raise error.ParseError(_("negative depth"))
272a44cac57e revset: add depth limit to ancestors() Yuya Nishihara <yuya@tcha.org> parents: 32932 diff changeset	284 stopdepth = n + 1
33019 f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	285 return _ancestors(repo, subset, args['set'],
f63d111258da revset: add startdepth limit to ancestors() as internal option Yuya Nishihara <yuya@tcha.org> parents: 33018 diff changeset	286 startdepth=startdepth, stopdepth=stopdepth)
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	287
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	288 @predicate('_firstancestors', safe=True)
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	289 def _firstancestors(repo, subset, x):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	290 # ``_firstancestors(set)``
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	291 # 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	292 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	293
32719 f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	294 def _childrenspec(repo, subset, x, n, order):
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	295 """Changesets that are the Nth child of a changeset
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	296 in set.
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	297 """
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	298 cs = set()
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	299 for r in getset(repo, fullreposet(repo), x):
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	300 for i in range(n):
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	301 c = repo[r].children()
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	302 if len(c) == 0:
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	303 break
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	304 if len(c) > 1:
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	305 raise error.RepoLookupError(
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	306 _("revision in set has more than one child"))
32903 8e02829bec61 revset: fix negative ancestor spec to not return changectx objects Yuya Nishihara <yuya@tcha.org> parents: 32838 diff changeset	307 r = c[0].rev()
32719 f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	308 else:
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	309 cs.add(r)
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	310 return subset & cs
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	311
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	312 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	313 """``set~n``
16683 525fdb738975 cleanup: eradicate long lines Brodie Rao <brodie@sf.io> parents: 16661 diff changeset	314 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	315 in set.
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	316 """
30801 67ee7874e53b revset: factor out getinteger() helper Yuya Nishihara <yuya@tcha.org> parents: 30800 diff changeset	317 n = getinteger(n, _("~ expects a number"))
32719 f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	318 if n < 0:
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	319 # children lookup
f75d0aa5dc83 revset: lookup descendents for negative arguments to ancestor operator David Soria Parra <davidsp@fb.com> parents: 32704 diff changeset	320 return _childrenspec(repo, subset, x, -n, order)
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	321 ps = set()
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	322 cl = repo.changelog
23163 6f1b8b3f12fd revset-ancestorspec: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23162 diff changeset	323 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	324 for i in range(n):
32479 018f638ad88e revset: add support for using ~ operator on wdir() predicate Pulkit Goyal <7895pulkit@gmail.com> parents: 32478 diff changeset	325 try:
018f638ad88e revset: add support for using ~ operator on wdir() predicate Pulkit Goyal <7895pulkit@gmail.com> parents: 32478 diff changeset	326 r = cl.parentrevs(r)[0]
018f638ad88e revset: add support for using ~ operator on wdir() predicate Pulkit Goyal <7895pulkit@gmail.com> parents: 32478 diff changeset	327 except error.WdirUnsupported:
018f638ad88e revset: add support for using ~ operator on wdir() predicate Pulkit Goyal <7895pulkit@gmail.com> parents: 32478 diff changeset	328 r = repo[r].parents()[0].rev()
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	329 ps.add(r)
22531 22ba2c0825da revset: use `subset &` in `ancestorspec` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22530 diff changeset	330 return subset & ps
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	331
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	332 @predicate('author(string)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	333 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	334 """Alias for ``user(string)``.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	335 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	336 # 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	337 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	338 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	339 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	340 condrepr=('<user %r>', n))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	341
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	342 @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	343 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	344 """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	345
15153 fa0a464e4ca5 hbisect: add two new revset descriptions: 'goods' and 'bads' "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15147 diff changeset	346 - ``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	347 - ``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	348 - ``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	349 - ``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	350 - ``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	351 - ``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	352 - ``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	353 """
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	354 # 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	355 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	356 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	357 return subset & state
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	358
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	359 # Backward-compatibility
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	360 # - 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	361 @predicate('bisected', safe=True)
15134 81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	362 def bisected(repo, subset, x):
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	363 return bisect(repo, subset, x)
81adf7777f8f revset: rename bisected() to bisect() "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr> parents: 15133 diff changeset	364
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	365 @predicate('bookmark([name])', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	366 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	367 """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	368
30799 0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns Yuya Nishihara <yuya@tcha.org> parents: 30784 diff changeset	369 Pattern matching is supported for `name`. See :hg:`help revisions.patterns`.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	370 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	371 # i18n: "bookmark" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	372 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	373 if args:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	374 bm = getstring(args[0],
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	375 # i18n: "bookmark" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	376 _('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	377 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	378 bms = set()
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	379 if kind == 'literal':
22105 3efe3c2609e0 revset: bookmark revset interprets 'literal:' prefix correctly (issue4329) Michael O'Connor <mkoconnor@gmail.com> parents: 21939 diff changeset	380 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	381 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	382 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	383 % pattern)
22499 8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	384 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	385 else:
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	386 matchrevs = set()
18495 8260fa9f30b9 bookmarks: don't use bookmarks.listbookmarks in local computations Kevin Bullock <kbullock@ringworld.org> parents: 18473 diff changeset	387 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	388 if matcher(name):
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	389 matchrevs.add(bmrev)
da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	390 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	391 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	392 " that match '%s'") % pattern)
16822 da55d8a77390 revset: add pattern matching to 'bookmarks' revset expression Simon King <simon@simonking.org.uk> parents: 16821 diff changeset	393 for bmrev in matchrevs:
22499 8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	394 bms.add(repo[bmrev].rev())
8c9f9e346acc revset: unify code flow in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22498 diff changeset	395 else:
32331 bd872f64a8ba cleanup: use set literals Martin von Zweigbergk <martinvonz@google.com> parents: 32085 diff changeset	396 bms = {repo[r].rev() for r in repo._bookmarks.values()}
bd872f64a8ba cleanup: use set literals Martin von Zweigbergk <martinvonz@google.com> parents: 32085 diff changeset	397 bms -= {node.nullrev}
22530 faf4f63533ff revset: use `subset &` in `bookmark` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22529 diff changeset	398 return subset & bms
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	399
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	400 @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	401 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	402 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	403 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	404 changesets.
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	405
30784 5dd67f0993ce help: eliminate duplicate text for revset string patterns Matt Harbison <matt_harbison@yahoo.com> parents: 30783 diff changeset	406 Pattern matching is supported for `string`. See
30799 0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns Yuya Nishihara <yuya@tcha.org> parents: 30784 diff changeset	407 :hg:`help revisions.patterns`.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	408 """
24374 77fd1fb538cd revbranchcache: store repo on the object Durham Goode <durham@fb.com> parents: 24366 diff changeset	409 getbi = repo.revbranchcache().branchinfo
32703 9f840d99054c revset: add support for branch(wdir()) and wdir() & branch() Yuya Nishihara <yuya@tcha.org> parents: 32681 diff changeset	410 def getbranch(r):
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch() Yuya Nishihara <yuya@tcha.org> parents: 32681 diff changeset	411 try:
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch() Yuya Nishihara <yuya@tcha.org> parents: 32681 diff changeset	412 return getbi(r)[0]
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch() Yuya Nishihara <yuya@tcha.org> parents: 32681 diff changeset	413 except error.WdirUnsupported:
9f840d99054c revset: add support for branch(wdir()) and wdir() & branch() Yuya Nishihara <yuya@tcha.org> parents: 32681 diff changeset	414 return repo[r].branch()
23787 678f53865c68 revset: use localrepo revbranchcache for branch name filtering Mads Kiilerich <madski@unity3d.com> parents: 23765 diff changeset	415
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	416 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	417 b = getstring(x, '')
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	418 except error.ParseError:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	419 # 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	420 pass
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	421 else:
26481 7d132557e44a util: extract stringmatcher() from revset Matt Harbison <matt_harbison@yahoo.com> parents: 26307 diff changeset	422 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	423 if kind == 'literal':
0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	424 # 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	425 # 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	426 if pattern in repo.branchmap():
32703 9f840d99054c revset: add support for branch(wdir()) and wdir() & branch() Yuya Nishihara <yuya@tcha.org> parents: 32681 diff changeset	427 return subset.filter(lambda r: matcher(getbranch(r)),
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	428 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	429 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	430 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	431 % pattern)
16821 0946502fd3d5 revset: add pattern matching to 'branch' revset expression Simon King <simon@simonking.org.uk> parents: 16820 diff changeset	432 else:
32703 9f840d99054c revset: add support for branch(wdir()) and wdir() & branch() Yuya Nishihara <yuya@tcha.org> parents: 32681 diff changeset	433 return subset.filter(lambda r: matcher(getbranch(r)),
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	434 condrepr=('<branch %r>', b))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	435
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	436 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	437 b = set()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	438 for r in s:
32703 9f840d99054c revset: add support for branch(wdir()) and wdir() & branch() Yuya Nishihara <yuya@tcha.org> parents: 32681 diff changeset	439 b.add(getbranch(r))
22867 5ee9b78ce805 revset-branch: remove usage of `set()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22866 diff changeset	440 c = s.__contains__
32703 9f840d99054c revset: add support for branch(wdir()) and wdir() & branch() Yuya Nishihara <yuya@tcha.org> parents: 32681 diff changeset	441 return subset.filter(lambda r: c(r) or getbranch(r) in b,
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	442 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	443
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	444 @predicate('bumped()', safe=True)
17829 c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	445 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	446 """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	447
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	448 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	449 """
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	450 # i18n: "bumped" is a keyword
c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	451 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	452 bumped = obsmod.getrevs(repo, 'bumped')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	453 return subset & bumped
17829 c73f7a28953c revset: add a bumped revset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17825 diff changeset	454
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	455 @predicate('bundle()', safe=True)
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	456 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	457 """Changesets in the bundle.
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	458
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	459 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	460
03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	461 try:
18411 8b0f0dd56cec bundlerepo: improve performance for bundle() revset expression Mads Kiilerich <madski@unity3d.com> parents: 18382 diff changeset	462 bundlerevs = repo.changelog.bundlerevs
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	463 except AttributeError:
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26571 diff changeset	464 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	465 return subset & bundlerevs
17913 03e552aaae67 bundle: add revset expression to show bundle contents (issue3487) Tomasz Kleczek <tkleczek@fb.com> parents: 17886 diff changeset	466
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	467 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	468 hasset = matchmod.patkind(pat) == 'set'
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	469
23115 c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	470 mcache = [None]
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	471 def matches(x):
ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	472 c = repo[x]
23115 c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	473 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	474 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	475 m = mcache[0]
c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	476 fname = None
c23c03605c59 revset: don't recreate matcher for every revision Martin von Zweigbergk <martinvonz@google.com> parents: 23100 diff changeset	477 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	478 fname = m.files()[0]
16521 592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	479 if fname is not None:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	480 if fname not in c.files():
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	481 return False
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	482 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	483 for f in c.files():
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	484 if m(f):
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	485 break
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	486 else:
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	487 return False
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	488 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	489 if fname is not None:
592701c8eac6 revset: fix adds/modifies/removes and patterns (issue3403) Patrick Mezard <patrick@mezard.eu> parents: 16467 diff changeset	490 if fname in files:
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	491 return True
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	492 else:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	493 for f in files:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	494 if m(f):
20457 ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	495 return True
ed7b674824a3 revset: added lazyset implementation to checkstatus Lucas Moscovicz <lmoscovicz@fb.com> parents: 20456 diff changeset	496
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	497 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	498
29406 c2193e59ef9f revsets: passing a set to baseset() is not wrong Martin von Zweigbergk <martinvonz@google.com> parents: 29389 diff changeset	499 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	500 if not parentset:
3e9049876ace revset: gratuitous code move in '_children' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25549 diff changeset	501 return baseset()
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	502 cs = set()
476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	503 pr = repo.changelog.parentrevs
25567 f140d6207cca revset: use parentsets.min in _children Pierre-Yves David <pierre-yves.david@fb.com> parents: 25566 diff changeset	504 minrev = parentset.min()
30699 5bda147c3139 revset: make children() not look at p2 if null (issue5439) Yuya Nishihara <yuya@tcha.org> parents: 30402 diff changeset	505 nullrev = node.nullrev
29406 c2193e59ef9f revsets: passing a set to baseset() is not wrong Martin von Zweigbergk <martinvonz@google.com> parents: 29389 diff changeset	506 for r in subset:
18063 34a1a639d835 revset.children: ignore rev numbers that are too low Siddharth Agarwal <sid0@fb.com> parents: 17980 diff changeset	507 if r <= minrev:
34a1a639d835 revset.children: ignore rev numbers that are too low Siddharth Agarwal <sid0@fb.com> parents: 17980 diff changeset	508 continue
30699 5bda147c3139 revset: make children() not look at p2 if null (issue5439) Yuya Nishihara <yuya@tcha.org> parents: 30402 diff changeset	509 p1, p2 = pr(r)
5bda147c3139 revset: make children() not look at p2 if null (issue5439) Yuya Nishihara <yuya@tcha.org> parents: 30402 diff changeset	510 if p1 in parentset:
5bda147c3139 revset: make children() not look at p2 if null (issue5439) Yuya Nishihara <yuya@tcha.org> parents: 30402 diff changeset	511 cs.add(r)
5bda147c3139 revset: make children() not look at p2 if null (issue5439) Yuya Nishihara <yuya@tcha.org> parents: 30402 diff changeset	512 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	513 cs.add(r)
20709 71df845d86cf revsets: backout d04aac468bf4 due to performance regressions Matt Mackall <mpm@selenic.com> parents: 20708 diff changeset	514 return baseset(cs)
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	515
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	516 @predicate('children(set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	517 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	518 """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	519 """
23164 7a42e5d4c418 revset-children: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23163 diff changeset	520 s = getset(repo, fullreposet(repo), x)
15899 476a981fdf34 revset: optimize roots and children Matt Mackall <mpm@selenic.com> parents: 15898 diff changeset	521 cs = _children(repo, subset, s)
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	522 return subset & cs
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	523
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	524 @predicate('closed()', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	525 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	526 """Changeset is closed.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	527 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	528 # i18n: "closed" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	529 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	530 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	531 condrepr='<branch closed>')
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	532
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	533 @predicate('contains(pattern)')
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	534 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	535 """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	536 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	537
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	538 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	539 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	540 for efficiency.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	541 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	542 # i18n: "contains" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	543 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	544
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	545 def matches(x):
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	546 if not matchmod.patkind(pat):
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	547 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	548 if pats in repo[x]:
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	549 return True
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	550 else:
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	551 c = repo[x]
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	552 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	553 for f in c.manifest():
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	554 if m(f):
20461 abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	555 return True
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	556 return False
abd8e56a1038 revset: added lazyset implementation to contains revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20460 diff changeset	557
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	558 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	559
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	560 @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	561 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	562 """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	563 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	564 """
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	565
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	566 # 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	567 # 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	568
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	569 rev = None
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	570 # i18n: "converted" is a keyword
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	571 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	572 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	573 # 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	574 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	575
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	576 def _matchvalue(r):
0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	577 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	578 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	579
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	580 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	581 condrepr=('<converted %r>', rev))
17002 0eb522625eb2 revset: add a predicate for finding converted changesets Matt Harbison <matt_harbison@yahoo.com> parents: 16862 diff changeset	582
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	583 @predicate('date(interval)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	584 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	585 """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	586 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	587 # i18n: "date" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	588 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	589 dm = util.matchdate(ds)
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	590 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	591 condrepr=('<date %r>', ds))
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	592
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	593 @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	594 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	595 """Search commit message for string. The match is case-insensitive.
30783 931a60880df4 revset: add regular expression support to 'desc' Matt Harbison <matt_harbison@yahoo.com> parents: 30782 diff changeset	596
30784 5dd67f0993ce help: eliminate duplicate text for revset string patterns Matt Harbison <matt_harbison@yahoo.com> parents: 30783 diff changeset	597 Pattern matching is supported for `string`. See
30799 0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns Yuya Nishihara <yuya@tcha.org> parents: 30784 diff changeset	598 :hg:`help revisions.patterns`.
14650 93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	599 """
93731b3efd0d revset: add desc(string) to search in commit messages Thomas Arendsen Hein <thomas@intevation.de> parents: 14649 diff changeset	600 # i18n: "desc" is a keyword
30783 931a60880df4 revset: add regular expression support to 'desc' Matt Harbison <matt_harbison@yahoo.com> parents: 30782 diff changeset	601 ds = getstring(x, _("desc requires a string"))
931a60880df4 revset: add regular expression support to 'desc' Matt Harbison <matt_harbison@yahoo.com> parents: 30782 diff changeset	602
931a60880df4 revset: add regular expression support to 'desc' Matt Harbison <matt_harbison@yahoo.com> parents: 30782 diff changeset	603 kind, pattern, matcher = _substringmatcher(ds, casesensitive=False)
931a60880df4 revset: add regular expression support to 'desc' Matt Harbison <matt_harbison@yahoo.com> parents: 30782 diff changeset	604
931a60880df4 revset: add regular expression support to 'desc' Matt Harbison <matt_harbison@yahoo.com> parents: 30782 diff changeset	605 return subset.filter(lambda r: matcher(repo[r].description()),
931a60880df4 revset: add regular expression support to 'desc' Matt Harbison <matt_harbison@yahoo.com> parents: 30782 diff changeset	606 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	607
33092 a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	608 def _descendants(repo, subset, x, followfirst=False, startdepth=None,
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	609 stopdepth=None):
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	610 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	611 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	612 return baseset()
33092 a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	613 s = dagop.revdescendants(repo, roots, followfirst, startdepth, stopdepth)
33087 d83b189aef83 dagop: change revdescendants() to include all root revisions Yuya Nishihara <yuya@tcha.org> parents: 33019 diff changeset	614 return subset & s
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	615
33092 a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	616 @predicate('descendants(set[, depth])', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	617 def descendants(repo, subset, x):
32923 2851b24eecc4 help: clarify ancestors() and descendants() include given set (issue5594) Yuya Nishihara <yuya@tcha.org> parents: 32922 diff changeset	618 """Changesets which are descendants of changesets in set, including the
2851b24eecc4 help: clarify ancestors() and descendants() include given set (issue5594) Yuya Nishihara <yuya@tcha.org> parents: 32922 diff changeset	619 given changesets themselves.
33092 a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	620
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	621 If depth is specified, the result only includes changesets up to
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	622 the specified generation.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	623 """
33092 a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	624 # startdepth is for internal use only until we can decide the UI
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	625 args = getargsdict(x, 'descendants', 'set depth startdepth')
32932 577759ef2ed2 revset: add support of keyword arguments to ancestors() and descendants() Yuya Nishihara <yuya@tcha.org> parents: 32923 diff changeset	626 if 'set' not in args:
577759ef2ed2 revset: add support of keyword arguments to ancestors() and descendants() Yuya Nishihara <yuya@tcha.org> parents: 32923 diff changeset	627 # i18n: "descendants" is a keyword
577759ef2ed2 revset: add support of keyword arguments to ancestors() and descendants() Yuya Nishihara <yuya@tcha.org> parents: 32923 diff changeset	628 raise error.ParseError(_('descendants takes at least 1 argument'))
33092 a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	629 startdepth = stopdepth = None
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	630 if 'startdepth' in args:
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	631 n = getinteger(args['startdepth'],
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	632 "descendants expects an integer startdepth")
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	633 if n < 0:
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	634 raise error.ParseError("negative startdepth")
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	635 startdepth = n
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	636 if 'depth' in args:
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	637 # i18n: "descendants" is a keyword
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	638 n = getinteger(args['depth'], _("descendants expects an integer depth"))
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	639 if n < 0:
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	640 raise error.ParseError(_("negative depth"))
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	641 stopdepth = n + 1
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	642 return _descendants(repo, subset, args['set'],
a53bfc2845f2 revset: add depth limit to descendants() (issue5374) Yuya Nishihara <yuya@tcha.org> parents: 33087 diff changeset	643 startdepth=startdepth, stopdepth=stopdepth)
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	644
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	645 @predicate('_firstdescendants', safe=True)
16409 2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	646 def _firstdescendants(repo, subset, x):
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	647 # ``_firstdescendants(set)``
2cbd7dd0cc1f graphlog: fix --follow-first --rev combinations Patrick Mezard <patrick@mezard.eu> parents: 16402 diff changeset	648 # 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	649 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	650
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	651 @predicate('destination([set])', safe=True)
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	652 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	653 """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	654 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	655 is the same as passing all().
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	656 """
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	657 if x is not None:
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	658 sources = getset(repo, fullreposet(repo), x)
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	659 else:
24201 77ef059b3317 revset: drop unnecessary calls of getall() with empty argument Yuya Nishihara <yuya@tcha.org> parents: 24163 diff changeset	660 sources = fullreposet(repo)
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	661
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	662 dests = set()
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	663
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	664 # 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	665 # 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	666 # 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	667 # 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	668 # 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	669 # grafts.
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	670 for r in subset:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	671 src = _getrevsource(repo, r)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	672 lineage = None
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	673
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	674 while src is not None:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	675 if lineage is None:
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	676 lineage = list()
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	677
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	678 lineage.append(r)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	679
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	680 # 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	681 # set. Since every candidate dest is visited by way of iterating
17494 74801685aaa2 spelling: further timeless@mozdev.org parents: 17291 diff changeset	682 # 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	683 # 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	684 # 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	685 # further.
22944 5aae3dea8044 revset: better naming of variables containing the value of a single argument Mads Kiilerich <madski@unity3d.com> parents: 22891 diff changeset	686 if src in sources or src in dests:
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	687 dests.update(lineage)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	688 break
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	689
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	690 r = src
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	691 src = _getrevsource(repo, r)
a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	692
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	693 return subset.filter(dests.__contains__,
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	694 condrepr=lambda: '<destination %r>' % sorted(dests))
17186 a3da6f298592 revset: add destination() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17185 diff changeset	695
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	696 @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	697 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	698 """
18071 bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	699 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	700 """
bea754715961 obsolete: add revset and test for divergent changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 18063 diff changeset	701 # 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	702 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	703 divergent = obsmod.getrevs(repo, 'divergent')
22533 5b65429721d5 revset: use `subset &` in `divergent` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22532 diff changeset	704 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	705
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	706 @predicate('extinct()', safe=True)
17173 c621f84dbb35 obsolete: compute extinct changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17171 diff changeset	707 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	708 """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	709 """
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	710 # 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	711 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	712 extincts = obsmod.getrevs(repo, 'extinct')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	713 return subset & extincts
17173 c621f84dbb35 obsolete: compute extinct changesets Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 17171 diff changeset	714
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	715 @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	716 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	717 """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	718 optional value.
f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	719
30784 5dd67f0993ce help: eliminate duplicate text for revset string patterns Matt Harbison <matt_harbison@yahoo.com> parents: 30783 diff changeset	720 Pattern matching is supported for `value`. See
30799 0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns Yuya Nishihara <yuya@tcha.org> parents: 30784 diff changeset	721 :hg:`help revisions.patterns`.
16824 f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	722 """
25767 026105c442d7 revset: rename getkwargs() to getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 25766 diff changeset	723 args = getargsdict(x, 'extra', 'label value')
25706 b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	724 if 'label' not in args:
b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	725 # i18n: "extra" is a keyword
b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	726 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	727 # i18n: "extra" is a keyword
25706 b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	728 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	729 'a string'))
16661 de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	730 value = None
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	731
25706 b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	732 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	733 # i18n: "extra" is a keyword
25706 b7f53c474e2c revset: port extra() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 25705 diff changeset	734 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	735 'a string'))
26481 7d132557e44a util: extract stringmatcher() from revset Matt Harbison <matt_harbison@yahoo.com> parents: 26307 diff changeset	736 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	737
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	738 def _matchvalue(r):
de4b42daf396 revset: add function for matching extra data (issue2767) Henrik Stuart <hg@hstuart.dk> parents: 16657 diff changeset	739 extra = repo[r].extra()
16824 f3b8c82a559c revset: add pattern matching to 'extra' revset expression Simon King <simon@simonking.org.uk> parents: 16823 diff changeset	740 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	741
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	742 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	743 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	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('filelog(pattern)', safe=True)
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	746 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	747 """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	748
21199 e9c2f76be74b help: clarify distinction among `contains`/`file`/`filelog` Greg Hurrell <glh@fb.com> parents: 21173 diff changeset	749 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	750 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	751 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	752 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	753
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	754 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	755 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	756 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	757
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	758 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	759 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	760 """
c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	761
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	762 # 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	763 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	764 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	765 cl = repo.changelog
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	766
15964 6e37b8282aa2 revsets: provide contexts for filesets Matt Mackall <mpm@selenic.com> parents: 15949 diff changeset	767 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	768 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	769 files = [f]
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	770 else:
20288 b61ad01c4e73 revset: use "canonpath()" for "filelog()" pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20287 diff changeset	771 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	772 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	773
34364a4b25eb linkrev: work around linkrev to filtered entry in 'filelog' revset Pierre-Yves David <pierre-yves.david@fb.com> parents: 23704 diff changeset	774 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	775 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	776 known = {}
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	777 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	778 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	779 fn = fl.node(fr)
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	780 if fn in known:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	781 s.add(known[fn])
23821 7a7f437ab63d filelog: remove trailing "form feed" character Martin von Zweigbergk <martinvonz@google.com> parents: 23820 diff changeset	782 continue
27945 4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	783
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	784 lr = fl.linkrev(fr)
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	785 if lr in cl:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	786 s.add(lr)
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	787 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	788 # 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	789 # ahead in changelog
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	790 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	791 scanpos = None
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	792 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	793 # 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	794 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	795 try:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	796 # 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	797 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	798 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	799 if n == fn:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	800 s.add(r)
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	801 scanpos = r
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	802 break
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	803 else:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	804 known[n] = r
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	805 except error.ManifestLookupError:
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	806 # deletion in changelog
4186d359046a log: speed up single file log with hidden revs (issue4747) Matt Mackall <mpm@selenic.com> parents: 27637 diff changeset	807 continue
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	808
22534 6261b9c549a2 revset: use `subset &` in `filelog` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22533 diff changeset	809 return subset & s
14342 c0b6a734b4f3 revset: introduce filelog() to emulate log's fast path Matt Mackall <mpm@selenic.com> parents: 14318 diff changeset	810
32820 348b491c0934 revset: fix order of first/last members in compound expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 32819 diff changeset	811 @predicate('first(set, [n])', safe=True, takeorder=True)
348b491c0934 revset: fix order of first/last members in compound expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 32819 diff changeset	812 def first(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	813 """An alias for limit().
15117 0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	814 """
32820 348b491c0934 revset: fix order of first/last members in compound expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 32819 diff changeset	815 return limit(repo, subset, x, order)
15117 0ab1c3a1f3b2 revsets: add first alias for last Matt Mackall <mpm@selenic.com> parents: 15116 diff changeset	816
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	817 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	818 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	819 "and an optional revset") % name)
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	820 c = repo['.']
352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	821 if l:
26102 5618858dce26 revsets: makes follow() supports file patterns (issue4757) (BC) liscju <piotr.listkiewicz@gmail.com> parents: 26099 diff changeset	822 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	823 rev = None
cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	824 if len(l) >= 2:
30178 d61c42c1a35c revset: make follow() reject more than one start revisions Yuya Nishihara <yuya@tcha.org> parents: 30071 diff changeset	825 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	826 if len(revs) != 1:
29825 cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	827 raise error.RepoLookupError(
30178 d61c42c1a35c revset: make follow() reject more than one start revisions Yuya Nishihara <yuya@tcha.org> parents: 30071 diff changeset	828 _("%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	829 rev = revs.last()
29825 cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	830 c = repo[rev]
26102 5618858dce26 revsets: makes follow() supports file patterns (issue4757) (BC) liscju <piotr.listkiewicz@gmail.com> parents: 26099 diff changeset	831 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	832 ctx=repo[rev], default='path')
26102 5618858dce26 revsets: makes follow() supports file patterns (issue4757) (BC) liscju <piotr.listkiewicz@gmail.com> parents: 26099 diff changeset	833
28008 86c4cbdaffee revset: use manifest.matches in _follow revset Durham Goode <durham@fb.com> parents: 27945 diff changeset	834 files = c.manifest().walk(matcher)
86c4cbdaffee revset: use manifest.matches in _follow revset Durham Goode <durham@fb.com> parents: 27945 diff changeset	835
26102 5618858dce26 revsets: makes follow() supports file patterns (issue4757) (BC) liscju <piotr.listkiewicz@gmail.com> parents: 26099 diff changeset	836 s = set()
28008 86c4cbdaffee revset: use manifest.matches in _follow revset Durham Goode <durham@fb.com> parents: 27945 diff changeset	837 for fname in files:
86c4cbdaffee revset: use manifest.matches in _follow revset Durham Goode <durham@fb.com> parents: 27945 diff changeset	838 fctx = c[fname]
86c4cbdaffee revset: use manifest.matches in _follow revset Durham Goode <durham@fb.com> parents: 27945 diff changeset	839 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	840 # 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	841 s.add(fctx.introrev())
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	842 else:
32921 27932a76a88d dagop: split module hosting DAG-related algorithms from revset Yuya Nishihara <yuya@tcha.org> parents: 32903 diff changeset	843 s = dagop.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	844
22535 44f471102f3a revset: use `subset &` in `follow` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22534 diff changeset	845 return subset & s
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	846
29825 cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	847 @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	848 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	849 """
24366 e8ea31131705 revset: replace "working copy" with "working directory" in function help Yuya Nishihara <yuya@tcha.org> parents: 24306 diff changeset	850 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	851 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	852 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	853 """
16185 352053e6cd8e context: add followfirst arg to filectx and workingfilectx Patrick Mezard <patrick@mezard.eu> parents: 16181 diff changeset	854 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	855
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	856 @predicate('_followfirst', safe=True)
16174 0a73c4bd9f47 graphlog: implement --follow-first Patrick Mezard <patrick@mezard.eu> parents: 16161 diff changeset	857 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	858 # ``followfirst([pattern[, startrev]])``
cbf9984a7957 revset: support "follow(renamed.py, e22f4f3f06c3)" (issue5334) G?bor Stefanik <gabor.stefanik@nng.com> parents: 29791 diff changeset	859 # 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	860 # 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	861 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	862
31938 5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	863 @predicate('followlines(file, fromline:toline[, startrev=., descend=False])',
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	864 safe=True)
30719 42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	865 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	866 """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	867
30800 cd23879cbac7 revset: rename rev argument of followlines() to startrev Yuya Nishihara <yuya@tcha.org> parents: 30799 diff changeset	868 Line range corresponds to 'file' content at 'startrev' and should hence be
cd23879cbac7 revset: rename rev argument of followlines() to startrev Yuya Nishihara <yuya@tcha.org> parents: 30799 diff changeset	869 consistent with file size. If startrev is not specified, working directory's
30719 42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	870 parent is used.
31938 5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	871
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	872 By default, ancestors of 'startrev' are returned. If 'descend' is True,
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	873 descendants of 'startrev' are returned though renames are (currently) not
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	874 followed in this direction.
30719 42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	875 """
31938 5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	876 args = getargsdict(x, 'followlines', 'file *lines startrev descend')
30804 4227f80f72b2 revset: abuse x:y syntax to specify line range of followlines() Yuya Nishihara <yuya@tcha.org> parents: 30803 diff changeset	877 if len(args['lines']) != 1:
4227f80f72b2 revset: abuse x:y syntax to specify line range of followlines() Yuya Nishihara <yuya@tcha.org> parents: 30803 diff changeset	878 raise error.ParseError(_("followlines requires a line range"))
30719 42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	879
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	880 rev = '.'
30800 cd23879cbac7 revset: rename rev argument of followlines() to startrev Yuya Nishihara <yuya@tcha.org> parents: 30799 diff changeset	881 if 'startrev' in args:
cd23879cbac7 revset: rename rev argument of followlines() to startrev Yuya Nishihara <yuya@tcha.org> parents: 30799 diff changeset	882 revs = getset(repo, fullreposet(repo), args['startrev'])
30754 26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	883 if len(revs) != 1:
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	884 raise error.ParseError(
32085 2a2744dffecf revset: add i18n comments to error messages for followlines predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 31998 diff changeset	885 # i18n: "followlines" is a keyword
30754 26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	886 _("followlines expects exactly one revision"))
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	887 rev = revs.last()
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	888
26209cb7184e revset: parse variable-length arguments of followlines() by getargsdict() Yuya Nishihara <yuya@tcha.org> parents: 30753 diff changeset	889 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	890 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	891 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	892 else:
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	893 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	894 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	895 if len(files) != 1:
32085 2a2744dffecf revset: add i18n comments to error messages for followlines predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 31998 diff changeset	896 # i18n: "followlines" is a keyword
30719 42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	897 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	898 fname = files[0]
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	899
32085 2a2744dffecf revset: add i18n comments to error messages for followlines predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 31998 diff changeset	900 # i18n: "followlines" is a keyword
30804 4227f80f72b2 revset: abuse x:y syntax to specify line range of followlines() Yuya Nishihara <yuya@tcha.org> parents: 30803 diff changeset	901 lr = getrange(args['lines'][0], _("followlines expects a line range"))
30801 67ee7874e53b revset: factor out getinteger() helper Yuya Nishihara <yuya@tcha.org> parents: 30800 diff changeset	902 fromline, toline = [getinteger(a, _("line range bounds must be integers"))
30804 4227f80f72b2 revset: abuse x:y syntax to specify line range of followlines() Yuya Nishihara <yuya@tcha.org> parents: 30803 diff changeset	903 for a in lr]
31667 080734cd2440 revset: factor out linerange processing into a utility function Denis Laxalde <denis.laxalde@logilab.fr> parents: 31093 diff changeset	904 fromline, toline = util.processlinerange(fromline, toline)
30719 42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	905
42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	906 fctx = repo[rev].filectx(fname)
31998 83527d9f1f13 revset: properly parse "descend" argument of followlines() Denis Laxalde <denis@laxalde.org> parents: 31938 diff changeset	907 descend = False
83527d9f1f13 revset: properly parse "descend" argument of followlines() Denis Laxalde <denis@laxalde.org> parents: 31938 diff changeset	908 if 'descend' in args:
83527d9f1f13 revset: properly parse "descend" argument of followlines() Denis Laxalde <denis@laxalde.org> parents: 31938 diff changeset	909 descend = getboolean(args['descend'],
32085 2a2744dffecf revset: add i18n comments to error messages for followlines predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 31998 diff changeset	910 # i18n: "descend" is a keyword
2a2744dffecf revset: add i18n comments to error messages for followlines predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 31998 diff changeset	911 _("descend argument must be a boolean"))
31998 83527d9f1f13 revset: properly parse "descend" argument of followlines() Denis Laxalde <denis@laxalde.org> parents: 31938 diff changeset	912 if descend:
31938 5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	913 rs = generatorset(
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	914 (c.rev() for c, _linerange
32922 582080a4a812 dagop: move blockancestors() and blockdescendants() from context Yuya Nishihara <yuya@tcha.org> parents: 32921 diff changeset	915 in dagop.blockdescendants(fctx, fromline, toline)),
31938 5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	916 iterasc=True)
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	917 else:
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	918 rs = generatorset(
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	919 (c.rev() for c, _linerange
32922 582080a4a812 dagop: move blockancestors() and blockdescendants() from context Yuya Nishihara <yuya@tcha.org> parents: 32921 diff changeset	920 in dagop.blockancestors(fctx, fromline, toline)),
31938 5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	921 iterasc=False)
5e3b49defbff revset: add a 'descend' argument to followlines to return descendants Denis Laxalde <denis.laxalde@logilab.fr> parents: 31810 diff changeset	922 return subset & rs
30719 42c75b4fa46a revset: add a followlines(file, fromline, toline[, rev]) revset Denis Laxalde <denis.laxalde@logilab.fr> parents: 30702 diff changeset	923
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	924 @predicate('all()', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	925 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	926 """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	927 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	928 # i18n: "all" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	929 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	930 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	931
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	932 @predicate('grep(regex)')
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	933 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	934 """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	935 to ensure special escape characters are handled correctly. Unlike
cb4ff8ef466b merge with stable Martin Geisler <mg@aragost.com> parents: 14343 14356 diff changeset	936 ``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	937 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	938 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	939 # i18n: "grep" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	940 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	941 except re.error as e:
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	942 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	943
6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	944 def matches(x):
6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	945 c = repo[x]
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	946 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	947 if gr.search(e):
20453 6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	948 return True
6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	949 return False
6aa7dcae6bd8 revset: added lazyset implementation to grep revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20452 diff changeset	950
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	951 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	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('_matchfiles', safe=True)
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	954 def _matchfiles(repo, subset, x):
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	955 # _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	956 #
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	957 # [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	958 #
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	959 # 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	960 # 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	961 # 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	962 # 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	963 # 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	964 # 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	965 # 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	966
28271 5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles Yuya Nishihara <yuya@tcha.org> parents: 28217 diff changeset	967 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	968 pats, inc, exc = [], [], []
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	969 rev, default = None, None
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	970 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	971 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	972 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	973 if prefix == 'p:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	974 pats.append(value)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	975 elif prefix == 'i:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	976 inc.append(value)
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	977 elif prefix == 'x:':
5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	978 exc.append(value)
16181 1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	979 elif prefix == 'r:':
1fd352aa08fc graphlog: evaluate FILE/-I/-X filesets on the working dir Patrick Mezard <patrick@mezard.eu> parents: 16174 diff changeset	980 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	981 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	982 'revision')
23950 caff3675cba5 log: evaluate filesets on working copy, not its parent Martin von Zweigbergk <martinvonz@google.com> parents: 23847 diff changeset	983 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	984 rev = value
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	985 elif prefix == 'd:':
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	986 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	987 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	988 'default mode')
16411 4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	989 default = value
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	990 else:
28271 5c454ab69558 revset: drop translation markers from error messages of internal _matchfiles Yuya Nishihara <yuya@tcha.org> parents: 28217 diff changeset	991 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	992 if not default:
4c2edcd84175 graphlog: correctly handle calls in subdirectories Patrick Mezard <patrick@mezard.eu> parents: 16409 diff changeset	993 default = 'glob'
20458 8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	994
23061 f2aeff8a87b6 revset: avoid recalculating filesets Matt Mackall <mpm@selenic.com> parents: 23019 diff changeset	995 m = matchmod.match(repo.root, repo.getcwd(), pats, include=inc,
f2aeff8a87b6 revset: avoid recalculating filesets Matt Mackall <mpm@selenic.com> parents: 23019 diff changeset	996 exclude=exc, ctx=repo[rev], default=default)
f2aeff8a87b6 revset: avoid recalculating filesets Matt Mackall <mpm@selenic.com> parents: 23019 diff changeset	997
27028 f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	998 # 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	999 # revisions is quite expensive.
27440 ff305ab2e0d7 log: speed up hg log <file\|folder> Laurent Charignon <lcharignon@fb.com> parents: 27293 diff changeset	1000 getfiles = repo.changelog.readfiles
27028 f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	1001 wdirrev = node.wdirrev
20458 8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1002 def matches(x):
27028 f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	1003 if x == wdirrev:
f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	1004 files = repo[x].files()
f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	1005 else:
27440 ff305ab2e0d7 log: speed up hg log <file\|folder> Laurent Charignon <lcharignon@fb.com> parents: 27293 diff changeset	1006 files = getfiles(x)
27028 f92053df8f0b revset: speed up '_matchfiles' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26778 diff changeset	1007 for f in files:
16161 5a627b49b4d9 graphlog: paths/-I/-X handling requires a new revset Patrick Mezard <patrick@mezard.eu> parents: 16096 diff changeset	1008 if m(f):
20458 8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1009 return True
8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1010 return False
8dabcc889e33 revset: added lazyset implementation to _matchfiles Lucas Moscovicz <lmoscovicz@fb.com> parents: 20457 diff changeset	1011
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1012 return subset.filter(matches,
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1013 condrepr=('<matchfiles patterns=%r, include=%r '
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1014 'exclude=%r, default=%r, rev=%r>',
534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1015 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	1016
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1017 @predicate('file(pattern)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1018 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	1019 """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	1020
17265 c30307eeec4b revset: polish explanation of the difference between file() and filelog() Greg Ward <greg@gerg.ca> parents: 17259 diff changeset	1021 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	1022 instead.
20289 96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1023
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1024 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	1025 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1026 # i18n: "file" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1027 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	1028 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	1029
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1030 @predicate('head()', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1031 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	1032 """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	1033 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1034 # i18n: "head" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1035 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	1036 hs = set()
25620 5f87f2305ad0 revset: translate node directly with changelog in 'head' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25619 diff changeset	1037 cl = repo.changelog
29407 20fabe814f89 revsets: use itervalues() where only values are needed Martin von Zweigbergk <martinvonz@google.com> parents: 29406 diff changeset	1038 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	1039 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	1040 return subset & baseset(hs)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1041
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1042 @predicate('heads(set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1043 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	1044 """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	1045 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1046 s = getset(repo, subset, x)
20366 5ec6321f49a9 revset: added substraction to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20365 diff changeset	1047 ps = parents(repo, subset, x)
5ec6321f49a9 revset: added substraction to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20365 diff changeset	1048 return s - ps
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1049
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1050 @predicate('hidden()', safe=True)
17390 74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1051 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	1052 """Hidden changesets.
17390 74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1053 """
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1054 # i18n: "hidden" is a keyword
74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1055 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	1056 hiddenrevs = repoview.filterrevs(repo, 'visible')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1057 return subset & hiddenrevs
17390 74b44f25b4b1 revset: add hidden() revset Patrick Mezard <patrick@mezard.eu> parents: 17291 diff changeset	1058
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1059 @predicate('keyword(string)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1060 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	1061 """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	1062 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	1063
b1012cb1bec3 revset: point to 'grep' in the 'keyword' help for regex searches Matt Harbison <matt_harbison@yahoo.com> parents: 30754 diff changeset	1064 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	1065 ``grep(regex)``.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1066 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1067 # 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	1068 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	1069
abb91b74f758 revset: added lazyset implementation to keyword revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20446 diff changeset	1070 def matches(r):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1071 c = repo[r]
25551 c1d163ce7394 revset: gratuitous formating fix in keyword Pierre-Yves David <pierre-yves.david@fb.com> parents: 25550 diff changeset	1072 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	1073 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	1074
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1075 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	1076
32820 348b491c0934 revset: fix order of first/last members in compound expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 32819 diff changeset	1077 @predicate('limit(set[, n[, offset]])', safe=True, takeorder=True)
348b491c0934 revset: fix order of first/last members in compound expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 32819 diff changeset	1078 def limit(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	1079 """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	1080 """
26638 7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1081 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	1082 if 'set' not in args:
179764469754 revset: port limit() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 26636 diff changeset	1083 # i18n: "limit" is a keyword
26638 7afaf2566e25 revset: add optional offset argument to limit() predicate Yuya Nishihara <yuya@tcha.org> parents: 26637 diff changeset	1084 raise error.ParseError(_("limit requires one to three arguments"))
30802 5eb3e4568c94 revset: add default value to getinteger() helper Yuya Nishihara <yuya@tcha.org> parents: 30801 diff changeset	1085 # i18n: "limit" is a keyword
5eb3e4568c94 revset: add default value to getinteger() helper Yuya Nishihara <yuya@tcha.org> parents: 30801 diff changeset	1086 lim = getinteger(args.get('n'), _("limit expects a number"), default=1)
32818 b36ec65ea583 revset: reject negative number to select first/last n members Yuya Nishihara <yuya@tcha.org> parents: 32817 diff changeset	1087 if lim < 0:
b36ec65ea583 revset: reject negative number to select first/last n members Yuya Nishihara <yuya@tcha.org> parents: 32817 diff changeset	1088 raise error.ParseError(_("negative number to select"))
30802 5eb3e4568c94 revset: add default value to getinteger() helper Yuya Nishihara <yuya@tcha.org> parents: 30801 diff changeset	1089 # i18n: "limit" is a keyword
5eb3e4568c94 revset: add default value to getinteger() helper Yuya Nishihara <yuya@tcha.org> parents: 30801 diff changeset	1090 ofs = getinteger(args.get('offset'), _("limit expects a number"), default=0)
30801 67ee7874e53b revset: factor out getinteger() helper Yuya Nishihara <yuya@tcha.org> parents: 30800 diff changeset	1091 if ofs < 0:
67ee7874e53b revset: factor out getinteger() helper Yuya Nishihara <yuya@tcha.org> parents: 30800 diff changeset	1092 raise error.ParseError(_("negative offset"))
26637 179764469754 revset: port limit() to support keyword arguments Yuya Nishihara <yuya@tcha.org> parents: 26636 diff changeset	1093 os = getset(repo, fullreposet(repo), args['set'])
32838 4710cc4dac99 smartset: extract method to slice abstractsmartset Yuya Nishihara <yuya@tcha.org> parents: 32820 diff changeset	1094 ls = os.slice(ofs, ofs + lim)
32820 348b491c0934 revset: fix order of first/last members in compound expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 32819 diff changeset	1095 if order == followorder and lim > 1:
348b491c0934 revset: fix order of first/last members in compound expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 32819 diff changeset	1096 return subset & ls
32819 3e6f9bff7e3f revset: filter first/last members by __and__ operation Yuya Nishihara <yuya@tcha.org> parents: 32818 diff changeset	1097 return ls & subset
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1098
32820 348b491c0934 revset: fix order of first/last members in compound expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 32819 diff changeset	1099 @predicate('last(set, [n])', safe=True, takeorder=True)
348b491c0934 revset: fix order of first/last members in compound expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 32819 diff changeset	1100 def last(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	1101 """Last n members of set, defaulting to 1.
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1102 """
611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1103 # 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	1104 l = getargs(x, 1, 2, _("last requires one or two arguments"))
30801 67ee7874e53b revset: factor out getinteger() helper Yuya Nishihara <yuya@tcha.org> parents: 30800 diff changeset	1105 lim = 1
67ee7874e53b revset: factor out getinteger() helper Yuya Nishihara <yuya@tcha.org> parents: 30800 diff changeset	1106 if len(l) == 2:
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1107 # i18n: "last" is a keyword
30801 67ee7874e53b revset: factor out getinteger() helper Yuya Nishihara <yuya@tcha.org> parents: 30800 diff changeset	1108 lim = getinteger(l[1], _("last expects a number"))
32818 b36ec65ea583 revset: reject negative number to select first/last n members Yuya Nishihara <yuya@tcha.org> parents: 32817 diff changeset	1109 if lim < 0:
b36ec65ea583 revset: reject negative number to select first/last n members Yuya Nishihara <yuya@tcha.org> parents: 32817 diff changeset	1110 raise error.ParseError(_("negative number to select"))
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1111 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	1112 os.reverse()
32838 4710cc4dac99 smartset: extract method to slice abstractsmartset Yuya Nishihara <yuya@tcha.org> parents: 32820 diff changeset	1113 ls = os.slice(0, lim)
32820 348b491c0934 revset: fix order of first/last members in compound expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 32819 diff changeset	1114 if order == followorder and lim > 1:
348b491c0934 revset: fix order of first/last members in compound expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 32819 diff changeset	1115 return subset & ls
32819 3e6f9bff7e3f revset: filter first/last members by __and__ operation Yuya Nishihara <yuya@tcha.org> parents: 32818 diff changeset	1116 ls.reverse()
3e6f9bff7e3f revset: filter first/last members by __and__ operation Yuya Nishihara <yuya@tcha.org> parents: 32818 diff changeset	1117 return ls & subset
14061 611d2f8a4ba2 revsets: add a last function Matt Mackall <mpm@selenic.com> parents: 14057 diff changeset	1118
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1119 @predicate('max(set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1120 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	1121 """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	1122 """
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1123 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	1124 try:
20754 f15ff553b762 revset: changed minrev and maxrev implementations to use ordered sets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20753 diff changeset	1125 m = os.max()
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1126 if m in subset:
28427 969a4615c4c4 revset: add inspection data to max() and min() functions Yuya Nishihara <yuya@tcha.org> parents: 28426 diff changeset	1127 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	1128 except ValueError:
ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1129 # 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	1130 # Same as python's max().
ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1131 pass
28427 969a4615c4c4 revset: add inspection data to max() and min() functions Yuya Nishihara <yuya@tcha.org> parents: 28426 diff changeset	1132 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	1133
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1134 @predicate('merge()', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1135 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	1136 """Changeset is a merge changeset.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1137 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1138 # i18n: "merge" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1139 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	1140 cl = repo.changelog
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1141 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	1142 condrepr='<merge>')
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1143
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1144 @predicate('branchpoint()', safe=True)
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1145 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	1146 """Changesets with more than one child.
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1147 """
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1148 # i18n: "branchpoint" is a keyword
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1149 getargs(x, 0, 0, _("branchpoint takes no arguments"))
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1150 cl = repo.changelog
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1151 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	1152 return baseset()
25549 f93ff3ab8d14 revset: mark spots that should use 'smartset.min()' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25548 diff changeset	1153 # 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	1154 # (and if it is not, it should.)
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1155 baserev = min(subset)
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1156 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	1157 for r in cl.revs(start=baserev + 1):
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1158 for p in cl.parentrevs(r):
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1159 if p >= baserev:
69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1160 parentscount[p - baserev] += 1
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1161 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	1162 condrepr='<branchpoint>')
17753 69d5078d760d revsets: add branchpoint() function Ivan Andrus <darthandrus@gmail.com> parents: 17675 diff changeset	1163
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1164 @predicate('min(set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1165 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	1166 """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	1167 """
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1168 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	1169 try:
20754 f15ff553b762 revset: changed minrev and maxrev implementations to use ordered sets Lucas Moscovicz <lmoscovicz@fb.com> parents: 20753 diff changeset	1170 m = os.min()
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1171 if m in subset:
28427 969a4615c4c4 revset: add inspection data to max() and min() functions Yuya Nishihara <yuya@tcha.org> parents: 28426 diff changeset	1172 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	1173 except ValueError:
ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1174 # 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	1175 # Same as python's min().
ade5c488d622 revset: remove existence check from min() and max() Durham Goode <durham@fb.com> parents: 26304 diff changeset	1176 pass
28427 969a4615c4c4 revset: add inspection data to max() and min() functions Yuya Nishihara <yuya@tcha.org> parents: 28426 diff changeset	1177 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	1178
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1179 @predicate('modifies(pattern)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1180 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	1181 """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	1182
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1183 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	1184 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	1185 directory.
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1186 """
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1187 # i18n: "modifies" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1188 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	1189 return checkstatus(repo, subset, pat, 0)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1190
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1191 @predicate('named(namespace)')
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1192 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	1193 """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	1194
30784 5dd67f0993ce help: eliminate duplicate text for revset string patterns Matt Harbison <matt_harbison@yahoo.com> parents: 30783 diff changeset	1195 Pattern matching is supported for `namespace`. See
30799 0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns Yuya Nishihara <yuya@tcha.org> parents: 30784 diff changeset	1196 :hg:`help revisions.patterns`.
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1197 """
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1198 # i18n: "named" is a keyword
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1199 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	1200
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1201 ns = getstring(args[0],
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1202 # i18n: "named" is a keyword
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1203 _('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	1204 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	1205 namespaces = set()
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1206 if kind == 'literal':
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1207 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	1208 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	1209 % ns)
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1210 namespaces.add(repo.names[pattern])
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1211 else:
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1212 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	1213 if matcher(name):
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1214 namespaces.add(ns)
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1215 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	1216 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	1217 " that match '%s'") % pattern)
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1218
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1219 names = set()
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1220 for ns in namespaces:
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1221 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	1222 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	1223 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	1224
32331 bd872f64a8ba cleanup: use set literals Martin von Zweigbergk <martinvonz@google.com> parents: 32085 diff changeset	1225 names -= {node.nullrev}
23836 3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1226 return subset & names
3fb61fcbc4e4 namespaces: add revset for 'named(namespace)' Sean Farley <sean.michael.farley@gmail.com> parents: 23833 diff changeset	1227
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1228 @predicate('id(string)', safe=True)
16417 b4b0c6931e11 revset: avoid demandimport bug Matt Mackall <mpm@selenic.com> parents: 16415 diff changeset	1229 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	1230 """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	1231 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1232 # 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	1233 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	1234 # 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	1235 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	1236 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	1237 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	1238 rn = repo.changelog.rev(node.bin(n))
32681 a3064fe3e495 revset: add support for integer and hex wdir identifiers Yuya Nishihara <yuya@tcha.org> parents: 32480 diff changeset	1239 except error.WdirUnsupported:
a3064fe3e495 revset: add support for integer and hex wdir identifiers Yuya Nishihara <yuya@tcha.org> parents: 32480 diff changeset	1240 rn = node.wdirrev
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	1241 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	1242 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	1243 else:
16735 47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1244 rn = None
32704 af854b1b36f8 revlog: add support for partial matching of wdir node id Yuya Nishihara <yuya@tcha.org> parents: 32703 diff changeset	1245 try:
af854b1b36f8 revlog: add support for partial matching of wdir node id Yuya Nishihara <yuya@tcha.org> parents: 32703 diff changeset	1246 pm = repo.changelog._partialmatch(n)
af854b1b36f8 revlog: add support for partial matching of wdir node id Yuya Nishihara <yuya@tcha.org> parents: 32703 diff changeset	1247 if pm is not None:
32681 a3064fe3e495 revset: add support for integer and hex wdir identifiers Yuya Nishihara <yuya@tcha.org> parents: 32480 diff changeset	1248 rn = repo.changelog.rev(pm)
32704 af854b1b36f8 revlog: add support for partial matching of wdir node id Yuya Nishihara <yuya@tcha.org> parents: 32703 diff changeset	1249 except error.WdirUnsupported:
af854b1b36f8 revlog: add support for partial matching of wdir node id Yuya Nishihara <yuya@tcha.org> parents: 32703 diff changeset	1250 rn = node.wdirrev
16735 47b8ec0eb7fb revset: fix traceback for bogus revisions in id(rev) Matt Harbison <matt_harbison@yahoo.com> parents: 16640 diff changeset	1251
23005 9bfe68357c01 revset-node: speedup by a few hundred fold Pierre-Yves David <pierre-yves.david@fb.com> parents: 23004 diff changeset	1252 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	1253 return baseset()
9bfe68357c01 revset-node: speedup by a few hundred fold Pierre-Yves David <pierre-yves.david@fb.com> parents: 23004 diff changeset	1254 result = baseset([rn])
9bfe68357c01 revset-node: speedup by a few hundred fold Pierre-Yves David <pierre-yves.david@fb.com> parents: 23004 diff changeset	1255 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	1256
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1257 @predicate('obsolete()', safe=True)
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1258 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	1259 """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	1260 # i18n: "obsolete" is a keyword
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1261 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	1262 obsoletes = obsmod.getrevs(repo, 'obsolete')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1263 return subset & obsoletes
17170 63a4a3871607 revset: add an `obsolete` symbol Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17102 diff changeset	1264
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1265 @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	1266 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	1267 """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	1268 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	1269 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	1270 (i.e. ::<set1> - ::<set2>).
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1271 """
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1272 cl = repo.changelog
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1273 # i18n: "only" is a keyword
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1274 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	1275 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	1276 if len(args) == 1:
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1277 if not include:
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1278 return baseset()
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1279
32921 27932a76a88d dagop: split module hosting DAG-related algorithms from revset Yuya Nishihara <yuya@tcha.org> parents: 32903 diff changeset	1280 descendants = set(dagop.revdescendants(repo, include, False))
23466 d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1281 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	1282 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	1283 else:
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1284 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	1285
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1286 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	1287 # 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	1288 # 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	1289 return subset & results
d5b1a452cc32 revset: move 'only' so that functions are sorted alphabetically Yuya Nishihara <yuya@tcha.org> parents: 23426 diff changeset	1290
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1291 @predicate('origin([set])', safe=True)
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1292 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	1293 """
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1294 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	1295 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	1296 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	1297 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	1298 for the first operation is selected.
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1299 """
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1300 if x is not None:
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1301 dests = getset(repo, fullreposet(repo), x)
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1302 else:
24201 77ef059b3317 revset: drop unnecessary calls of getall() with empty argument Yuya Nishihara <yuya@tcha.org> parents: 24163 diff changeset	1303 dests = fullreposet(repo)
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1304
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1305 def _firstsrc(rev):
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1306 src = _getrevsource(repo, rev)
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1307 if src is None:
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1308 return None
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1309
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1310 while True:
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1311 prev = _getrevsource(repo, src)
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1312
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1313 if prev is None:
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1314 return src
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1315 src = prev
2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1316
32331 bd872f64a8ba cleanup: use set literals Martin von Zweigbergk <martinvonz@google.com> parents: 32085 diff changeset	1317 o = {_firstsrc(r) for r in dests}
bd872f64a8ba cleanup: use set literals Martin von Zweigbergk <martinvonz@google.com> parents: 32085 diff changeset	1318 o -= {None}
25554 94441df6206c revset: mark spots that use 'set' instead of 'smartset' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25553 diff changeset	1319 # 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	1320 # 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	1321 return subset & o
17185 2c7c4824969e revset: add origin() predicate Matt Harbison <matt_harbison@yahoo.com> parents: 17173 diff changeset	1322
30850 41e31a6f5296 revset: prevent using outgoing() and remote() in hgweb session (BC) Yuya Nishihara <yuya@tcha.org> parents: 30804 diff changeset	1323 @predicate('outgoing([path])', safe=False)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1324 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	1325 """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	1326 default push location.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1327 """
24722 02a5618e2fbf revset: don't import discovery at module level Gregory Szorc <gregory.szorc@gmail.com> parents: 24708 diff changeset	1328 # Avoid cycles.
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	1329 from . import (
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	1330 discovery,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	1331 hg,
e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	1332 )
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1333 # 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	1334 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	1335 # i18n: "outgoing" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1336 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	1337 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	1338 dest, branches = hg.parseurl(dest)
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1339 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	1340 if revs:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1341 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	1342 other = hg.peer(repo, {}, dest)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1343 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	1344 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	1345 repo.ui.popbuffer()
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1346 cl = repo.changelog
32331 bd872f64a8ba cleanup: use set literals Martin von Zweigbergk <martinvonz@google.com> parents: 32085 diff changeset	1347 o = {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	1348 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	1349
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1350 @predicate('p1([set])', safe=True)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1351 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	1352 """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	1353 """
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1354 if x is None:
13878 a8d13ee0ce68 misc: replace .parents()[0] with p1() Matt Mackall <mpm@selenic.com> parents: 13873 diff changeset	1355 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	1356 if p >= 0:
a428db9ab61d revset: use `subset &` in bare `p1()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22537 diff changeset	1357 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	1358 return baseset()
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1359
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1360 ps = set()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1361 cl = repo.changelog
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1362 for r in getset(repo, fullreposet(repo), x):
32442 e8c043375b53 revset: make `hg log -r 'wdir()^'` work (issue4905) Pulkit Goyal <7895pulkit@gmail.com> parents: 32331 diff changeset	1363 try:
e8c043375b53 revset: make `hg log -r 'wdir()^'` work (issue4905) Pulkit Goyal <7895pulkit@gmail.com> parents: 32331 diff changeset	1364 ps.add(cl.parentrevs(r)[0])
e8c043375b53 revset: make `hg log -r 'wdir()^'` work (issue4905) Pulkit Goyal <7895pulkit@gmail.com> parents: 32331 diff changeset	1365 except error.WdirUnsupported:
e8c043375b53 revset: make `hg log -r 'wdir()^'` work (issue4905) Pulkit Goyal <7895pulkit@gmail.com> parents: 32331 diff changeset	1366 ps.add(repo[r].parents()[0].rev())
32331 bd872f64a8ba cleanup: use set literals Martin von Zweigbergk <martinvonz@google.com> parents: 32085 diff changeset	1367 ps -= {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	1368 # 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	1369 # 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	1370 return subset & ps
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1371
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1372 @predicate('p2([set])', safe=True)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1373 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	1374 """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	1375 """
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1376 if x is None:
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1377 ps = repo[x].parents()
a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1378 try:
12935 98b79c892768 revset: fix p1, p2 and parents in dirstate case (a5f7f1e9340e) Patrick Mezard <pmezard@gmail.com> parents: 12929 diff changeset	1379 p = ps[1].rev()
22539 6f434ef54222 revset: use `subset &` in bare `p2()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22538 diff changeset	1380 if p >= 0:
6f434ef54222 revset: use `subset &` in bare `p2()` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22538 diff changeset	1381 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	1382 return baseset()
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1383 except IndexError:
22802 1fcd361efaf4 baseset: use default value instead of [] when possible Pierre-Yves David <pierre-yves.david@fb.com> parents: 22801 diff changeset	1384 return baseset()
12928 a5f7f1e9340e revsets: let p1() and p2() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12859 diff changeset	1385
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1386 ps = set()
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1387 cl = repo.changelog
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1388 for r in getset(repo, fullreposet(repo), x):
32478 c8fb2a82b5f9 revset: add support for p2(wdir()) to get second parent of working directory Pulkit Goyal <7895pulkit@gmail.com> parents: 32477 diff changeset	1389 try:
c8fb2a82b5f9 revset: add support for p2(wdir()) to get second parent of working directory Pulkit Goyal <7895pulkit@gmail.com> parents: 32477 diff changeset	1390 ps.add(cl.parentrevs(r)[1])
c8fb2a82b5f9 revset: add support for p2(wdir()) to get second parent of working directory Pulkit Goyal <7895pulkit@gmail.com> parents: 32477 diff changeset	1391 except error.WdirUnsupported:
c8fb2a82b5f9 revset: add support for p2(wdir()) to get second parent of working directory Pulkit Goyal <7895pulkit@gmail.com> parents: 32477 diff changeset	1392 parents = repo[r].parents()
c8fb2a82b5f9 revset: add support for p2(wdir()) to get second parent of working directory Pulkit Goyal <7895pulkit@gmail.com> parents: 32477 diff changeset	1393 if len(parents) == 2:
c8fb2a82b5f9 revset: add support for p2(wdir()) to get second parent of working directory Pulkit Goyal <7895pulkit@gmail.com> parents: 32477 diff changeset	1394 ps.add(parents[1])
32331 bd872f64a8ba cleanup: use set literals Martin von Zweigbergk <martinvonz@google.com> parents: 32085 diff changeset	1395 ps -= {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	1396 # 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	1397 # 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	1398 return subset & ps
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1399
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	1400 def parentpost(repo, subset, x, order):
29935 d2d1be3009ca revset: add stub to handle parentpost operation Yuya Nishihara <yuya@tcha.org> parents: 29934 diff changeset	1401 return p1(repo, subset, x)
d2d1be3009ca revset: add stub to handle parentpost operation Yuya Nishihara <yuya@tcha.org> parents: 29934 diff changeset	1402
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1403 @predicate('parents([set])', safe=True)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1404 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	1405 """
12929 515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	1406 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	1407 """
12929 515c2786e1cf revsets: let parents() return parents of working dir Kevin Bullock <kbullock@ringworld.org> parents: 12928 diff changeset	1408 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	1409 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	1410 else:
35af9361a049 revset: refactor parents() into a single return point Pierre-Yves David <pierre-yves.david@fb.com> parents: 22495 diff changeset	1411 ps = set()
35af9361a049 revset: refactor parents() into a single return point Pierre-Yves David <pierre-yves.david@fb.com> parents: 22495 diff changeset	1412 cl = repo.changelog
25716 d50677c3bf44 revset: prefetch method in "parents" Pierre-Yves David <pierre-yves.david@fb.com> parents: 25706 diff changeset	1413 up = ps.update
d50677c3bf44 revset: prefetch method in "parents" Pierre-Yves David <pierre-yves.david@fb.com> parents: 25706 diff changeset	1414 parentrevs = cl.parentrevs
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1415 for r in getset(repo, fullreposet(repo), x):
32477 e72c5263ccaf revset: use try-except instead of if-else because of perf Pulkit Goyal <7895pulkit@gmail.com> parents: 32476 diff changeset	1416 try:
e72c5263ccaf revset: use try-except instead of if-else because of perf Pulkit Goyal <7895pulkit@gmail.com> parents: 32476 diff changeset	1417 up(parentrevs(r))
e72c5263ccaf revset: use try-except instead of if-else because of perf Pulkit Goyal <7895pulkit@gmail.com> parents: 32476 diff changeset	1418 except error.WdirUnsupported:
25716 d50677c3bf44 revset: prefetch method in "parents" Pierre-Yves David <pierre-yves.david@fb.com> parents: 25706 diff changeset	1419 up(p.rev() for p in repo[r].parents())
32331 bd872f64a8ba cleanup: use set literals Martin von Zweigbergk <martinvonz@google.com> parents: 32085 diff changeset	1420 ps -= {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	1421 return subset & ps
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1422
31037 17b5cda5a84a revset: use phasecache.getrevset Jun Wu <quark@fb.com> parents: 30982 diff changeset	1423 def _phase(repo, subset, *targets):
17b5cda5a84a revset: use phasecache.getrevset Jun Wu <quark@fb.com> parents: 30982 diff changeset	1424 """helper to select all rev in <targets> phases"""
17b5cda5a84a revset: use phasecache.getrevset Jun Wu <quark@fb.com> parents: 30982 diff changeset	1425 s = repo._phasecache.getrevset(repo, targets)
17b5cda5a84a revset: use phasecache.getrevset Jun Wu <quark@fb.com> parents: 30982 diff changeset	1426 return subset & s
25621 21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1427
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1428 @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	1429 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	1430 """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	1431 # 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	1432 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	1433 target = phases.draft
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1434 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	1435
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1436 @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	1437 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	1438 """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	1439 # 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	1440 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	1441 target = phases.secret
21a874693619 revset: refactor the non-public phase code Pierre-Yves David <pierre-yves.david@fb.com> parents: 25620 diff changeset	1442 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	1443
29936 09a84e747c88 revset: pass around ordering flags to operations Yuya Nishihara <yuya@tcha.org> parents: 29935 diff changeset	1444 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	1445 """``set^0``
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1446 The set.
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1447 ``set^1`` (or ``set^``), ``set^2``
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1448 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	1449 """
12320 40c40c6f20b8 revset: handle re.compile() errors in grep() Brodie Rao <brodie@bitheap.org> parents: 11882 diff changeset	1450 try:
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1451 n = int(n[1])
14072 2e4d79dcc0a0 revset: add missing whitespace Kevin Gessner <kevin@kevingessner.com> parents: 14070 diff changeset	1452 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	1453 raise ValueError
14851 f96c354493d7 revsets: actually catch type error on tip^p1(tip) (issue2884) Matt Mackall <mpm@selenic.com> parents: 14842 diff changeset	1454 except (TypeError, ValueError):
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1455 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	1456 ps = set()
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1457 cl = repo.changelog
23165 7e8737e6ab08 revset-parentspec: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23164 diff changeset	1458 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	1459 if n == 0:
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1460 ps.add(r)
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	1461 elif n == 1:
32474 f064e2f72c49 revset: add support for "wdir()^n" Pulkit Goyal <7895pulkit@gmail.com> parents: 32473 diff changeset	1462 try:
f064e2f72c49 revset: add support for "wdir()^n" Pulkit Goyal <7895pulkit@gmail.com> parents: 32473 diff changeset	1463 ps.add(cl.parentrevs(r)[0])
f064e2f72c49 revset: add support for "wdir()^n" Pulkit Goyal <7895pulkit@gmail.com> parents: 32473 diff changeset	1464 except error.WdirUnsupported:
f064e2f72c49 revset: add support for "wdir()^n" Pulkit Goyal <7895pulkit@gmail.com> parents: 32473 diff changeset	1465 ps.add(repo[r].parents()[0].rev())
32476 14482f8e6ce6 revset: remove redundant condition and change to else from elif Pulkit Goyal <7895pulkit@gmail.com> parents: 32474 diff changeset	1466 else:
32474 f064e2f72c49 revset: add support for "wdir()^n" Pulkit Goyal <7895pulkit@gmail.com> parents: 32473 diff changeset	1467 try:
f064e2f72c49 revset: add support for "wdir()^n" Pulkit Goyal <7895pulkit@gmail.com> parents: 32473 diff changeset	1468 parents = cl.parentrevs(r)
f064e2f72c49 revset: add support for "wdir()^n" Pulkit Goyal <7895pulkit@gmail.com> parents: 32473 diff changeset	1469 if parents[1] != node.nullrev:
f064e2f72c49 revset: add support for "wdir()^n" Pulkit Goyal <7895pulkit@gmail.com> parents: 32473 diff changeset	1470 ps.add(parents[1])
f064e2f72c49 revset: add support for "wdir()^n" Pulkit Goyal <7895pulkit@gmail.com> parents: 32473 diff changeset	1471 except error.WdirUnsupported:
f064e2f72c49 revset: add support for "wdir()^n" Pulkit Goyal <7895pulkit@gmail.com> parents: 32473 diff changeset	1472 parents = repo[r].parents()
f064e2f72c49 revset: add support for "wdir()^n" Pulkit Goyal <7895pulkit@gmail.com> parents: 32473 diff changeset	1473 if len(parents) == 2:
f064e2f72c49 revset: add support for "wdir()^n" Pulkit Goyal <7895pulkit@gmail.com> parents: 32473 diff changeset	1474 ps.add(parents[1].rev())
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1475 return subset & ps
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1476
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1477 @predicate('present(set)', safe=True)
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1478 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	1479 """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	1480 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	1481
0a730d3c5aae doc: add detail explanation for 'present()' predicate of revsets FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16735 diff changeset	1482 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	1483 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	1484 to continue even in such cases.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1485 """
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1486 try:
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1487 return getset(repo, subset, x)
df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1488 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	1489 return baseset()
11944 df52ff0980fe revset: predicate to avoid lookup errors Wagner Bruna <wbruna@softwareexpress.com.br> parents: 11886 diff changeset	1490
25224 d032f57936f5 revset: drop docstring from internal _notpublic() function Yuya Nishihara <yuya@tcha.org> parents: 25191 diff changeset	1491 # 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	1492 @predicate('_notpublic', safe=True)
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1493 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	1494 getargs(x, 0, 0, "_notpublic takes no arguments")
31037 17b5cda5a84a revset: use phasecache.getrevset Jun Wu <quark@fb.com> parents: 30982 diff changeset	1495 return _phase(repo, subset, phases.draft, phases.secret)
25191 08d1ef09ed37 revset: optimize not public revset Laurent Charignon <lcharignon@fb.com> parents: 25149 diff changeset	1496
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1497 @predicate('public()', safe=True)
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1498 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	1499 """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	1500 # 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	1501 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	1502 phase = repo._phasecache.phase
c8f32accd00a revset-phases: prefetch attributes in phasesrelated revsets Pierre-Yves David <pierre-yves.david@fb.com> parents: 23018 diff changeset	1503 target = phases.public
c8f32accd00a revset-phases: prefetch attributes in phasesrelated revsets Pierre-Yves David <pierre-yves.david@fb.com> parents: 23018 diff changeset	1504 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	1505 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	1506 cache=False)
15819 33ca11b010e2 phases: implements simple revset symbol Pierre-Yves David <pierre-yves.david@ens-lyon.org> parents: 15791 diff changeset	1507
30850 41e31a6f5296 revset: prevent using outgoing() and remote() in hgweb session (BC) Yuya Nishihara <yuya@tcha.org> parents: 30804 diff changeset	1508 @predicate('remote([id [,path]])', safe=False)
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1509 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	1510 """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	1511 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	1512 synonym for the current local branch.
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1513 """
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1514
25971 e9cd028f2dff revset: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25929 diff changeset	1515 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	1516 # i18n: "remote" is a keyword
27293 9e06e7fb037d grammar: favor zero, one, two over ... or no timeless <timeless@mozdev.org> parents: 27028 diff changeset	1517 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	1518
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1519 q = '.'
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1520 if len(l) > 0:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1521 # i18n: "remote" is a keyword
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1522 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	1523 if q == '.':
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1524 q = repo['.'].branch()
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1525
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1526 dest = ''
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1527 if len(l) > 1:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1528 # i18n: "remote" is a keyword
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1529 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	1530 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	1531 dest, branches = hg.parseurl(dest)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1532 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	1533 if revs:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1534 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	1535 other = hg.peer(repo, {}, dest)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1536 n = other.lookup(q)
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1537 if n in repo:
878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1538 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	1539 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	1540 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	1541 return baseset()
15936 878bc4a62a73 revset: add remote() predicate to lookup remote revisions Matt Mackall <mpm@selenic.com> parents: 15903 diff changeset	1542
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1543 @predicate('removes(pattern)', safe=True)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1544 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	1545 """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	1546
96be25f1da45 revset: add explanation about the pattern without explicit kind FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 20288 diff changeset	1547 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	1548 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	1549 directory.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1550 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1551 # 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	1552 pat = getstring(x, _("removes requires a pattern"))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1553 return checkstatus(repo, subset, pat, 2)
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1554
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1555 @predicate('rev(number)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1556 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	1557 """Revision with the given numeric identifier.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1558 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1559 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1560 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	1561 try:
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1562 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1563 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	1564 except (TypeError, ValueError):
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1565 # i18n: "rev" is a keyword
8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1566 raise error.ParseError(_("rev expects a number"))
32681 a3064fe3e495 revset: add support for integer and hex wdir identifiers Yuya Nishihara <yuya@tcha.org> parents: 32480 diff changeset	1567 if l not in repo.changelog and l not in (node.nullrev, node.wdirrev):
23062 ba89f7b542c9 revset: have rev() drop out-of-range or filtered rev explicitly (issue4396) Yuya Nishihara <yuya@tcha.org> parents: 23061 diff changeset	1568 return baseset()
22537 bbf4f3dfd700 revset: use `subset &` in `rev` Pierre-Yves David <pierre-yves.david@fb.com> parents: 22536 diff changeset	1569 return subset & baseset([l])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1570
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1571 @predicate('matching(revision [, field])', safe=True)
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1572 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	1573 """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	1574 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	1575
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1576 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	1577 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	1578
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1579 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	1580
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1581 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	1582 ``date``, ``files``, ``phase``, ``parents``, ``substate``, ``user``
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1583 and ``diff``.
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1584 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	1585 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	1586 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	1587
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1588 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	1589 ``summary`` matches the first line of the description.
16639 00290bd359fe revset: documentation typo "metatadata" Jesse Glick <jesse.glick@oracle.com> parents: 16528 diff changeset	1590 ``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	1591 (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	1592
5d803620ca05 doc: flatten description of 'matching()' predicate to be formatted well FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 16521 diff changeset	1593 ``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	1594 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	1595 """
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	1596 # i18n: "matching" is a keyword
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1597 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	1598
23166 30e0dcd7c5ff revset-matching: call 'getset' on a 'fullreposet' Pierre-Yves David <pierre-yves.david@fb.com> parents: 23165 diff changeset	1599 revs = getset(repo, fullreposet(repo), l[0])
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1600
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1601 fieldlist = ['metadata']
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1602 if len(l) > 1:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1603 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	1604 # i18n: "matching" is a keyword
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1605 _("matching requires a string "
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1606 "as its second argument")).split()
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1607
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1608 # 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	1609 # expand the 'special' 'metadata' field type
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1610 # 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	1611 fields = []
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1612 for field in fieldlist:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1613 if field == 'metadata':
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1614 fields += ['user', 'description', 'date']
17102 d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1615 elif field == 'diff':
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1616 # 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	1617 # 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	1618 # also match the files first
d9a046ae4d8e revset: add "diff" field to "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 17100 diff changeset	1619 fields += ['files', 'diff']
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1620 else:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1621 if field == 'author':
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1622 field = 'user'
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1623 fields.append(field)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1624 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	1625 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	1626 # 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	1627 fields.discard('summary')
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1628
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1629 # 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	1630 # 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	1631 # 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	1632 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	1633 '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	1634 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	1635 try:
984e0412e82b revset: speedup matching() by first matching fields that take less time to Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16445 diff changeset	1636 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	1637 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	1638 # 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	1639 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	1640 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	1641 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	1642
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1643 # 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	1644 # 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	1645 getfieldfuncs = []
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1646 _funcs = {
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1647 'user': lambda r: repo[r].user(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1648 'branch': lambda r: repo[r].branch(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1649 'date': lambda r: repo[r].date(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1650 'description': lambda r: repo[r].description(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1651 'files': lambda r: repo[r].files(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1652 'parents': lambda r: repo[r].parents(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1653 'phase': lambda r: repo[r].phase(),
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1654 'substate': lambda r: repo[r].substate,
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1655 '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	1656 '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	1657 }
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1658 for info in fields:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1659 getfield = _funcs.get(info, None)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1660 if getfield is None:
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1661 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	1662 # i18n: "matching" is a keyword
16402 1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1663 _("unexpected field name passed to matching: %s") % info)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1664 getfieldfuncs.append(getfield)
1fb2f1400ea8 revset: add "matching" keyword Angel Ezquerra <angel.ezquerra@gmail.com> parents: 16218 diff changeset	1665 # 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	1666 # 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	1667 # 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	1668 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	1669
20459 51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1670 def matches(x):
51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1671 for rev in revs:
51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1672 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	1673 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	1674 for n, f in enumerate(getfieldfuncs):
20459 51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1675 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	1676 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	1677 if match:
20459 51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1678 return True
51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1679 return False
51890507c6b3 revset: added lazyset implementation to matching revset Lucas Moscovicz <lmoscovicz@fb.com> parents: 20458 diff changeset	1680
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1681 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	1682
29949 89dbae952ec1 revset: make reverse() noop depending on ordering requirement (BC) Yuya Nishihara <yuya@tcha.org> parents: 29948 diff changeset	1683 @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	1684 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	1685 """Reverse order of set.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1686 """
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1687 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	1688 if order == defineorder:
89dbae952ec1 revset: make reverse() noop depending on ordering requirement (BC) Yuya Nishihara <yuya@tcha.org> parents: 29948 diff changeset	1689 l.reverse()
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1690 return l
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1691
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1692 @predicate('roots(set)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1693 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	1694 """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	1695 """
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	1696 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	1697 parents = repo.changelog.parentrevs
46a96dd4d976 revset: improves time complexity of 'roots(xxx)' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25634 diff changeset	1698 def filter(r):
46a96dd4d976 revset: improves time complexity of 'roots(xxx)' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25634 diff changeset	1699 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	1700 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	1701 return False
46a96dd4d976 revset: improves time complexity of 'roots(xxx)' Pierre-Yves David <pierre-yves.david@fb.com> parents: 25634 diff changeset	1702 return True
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1703 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	1704
29265 3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1705 _sortkeyfuncs = {
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1706 'rev': lambda c: c.rev(),
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1707 'branch': lambda c: c.branch(),
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1708 'desc': lambda c: c.description(),
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1709 'user': lambda c: c.user(),
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1710 'author': lambda c: c.user(),
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1711 'date': lambda c: c.date()[0],
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1712 }
3f9e68864ccc revset: define table of sort() key functions Yuya Nishihara <yuya@tcha.org> parents: 29264 diff changeset	1713
29365 f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1714 def _getsortargs(x):
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1715 """Parse sort options into (set, [(key, reverse)], opts)"""
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1716 args = getargsdict(x, 'sort', 'set keys topo.firstbranch')
29238 e150c1d5f262 revset: use getargsdict for sort() Martijn Pieters <mjpieters@fb.com> parents: 29216 diff changeset	1717 if 'set' not in args:
e150c1d5f262 revset: use getargsdict for sort() Martijn Pieters <mjpieters@fb.com> parents: 29216 diff changeset	1718 # i18n: "sort" is a keyword
e150c1d5f262 revset: use getargsdict for sort() Martijn Pieters <mjpieters@fb.com> parents: 29216 diff changeset	1719 raise error.ParseError(_('sort requires one or two arguments'))
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1720 keys = "rev"
29238 e150c1d5f262 revset: use getargsdict for sort() Martijn Pieters <mjpieters@fb.com> parents: 29216 diff changeset	1721 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	1722 # i18n: "sort" is a keyword
29238 e150c1d5f262 revset: use getargsdict for sort() Martijn Pieters <mjpieters@fb.com> parents: 29216 diff changeset	1723 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	1724
29363 2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1725 keyflags = []
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1726 for k in keys.split():
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1727 fk = k
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1728 reverse = (k[0] == '-')
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1729 if reverse:
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1730 k = k[1:]
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1731 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	1732 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	1733 keyflags.append((k, reverse))
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1734
2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1735 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	1736 # 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	1737 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	1738 'with other sort keys'))
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1739
29364 76a1a703e23d revset: build dict of extra sort options before evaluating set Yuya Nishihara <yuya@tcha.org> parents: 29363 diff changeset	1740 opts = {}
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1741 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	1742 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	1743 opts['topo.firstbranch'] = args['topo.firstbranch']
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1744 else:
2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1745 # 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	1746 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	1747 'when using the topo sort key'))
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1748
29365 f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1749 return args['set'], keyflags, opts
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1750
29950 285a8c3e53f2 revset: make sort() noop depending on ordering requirement (BC) Yuya Nishihara <yuya@tcha.org> parents: 29949 diff changeset	1751 @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	1752 def sort(repo, subset, x, order):
29365 f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1753 """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	1754 as ``-key`` to sort in descending order.
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1755
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1756 The keys can be:
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1757
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1758 - ``rev`` for the revision number,
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1759 - ``branch`` for the branch name,
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1760 - ``desc`` for the commit message (description),
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1761 - ``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	1762 - ``date`` for the commit date
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1763 - ``topo`` for a reverse topographical sort
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1764
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1765 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	1766 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	1767 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	1768
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1769 """
f652e84f23f2 revset: extract function that validates sort() arguments Yuya Nishihara <yuya@tcha.org> parents: 29364 diff changeset	1770 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	1771 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	1772
29950 285a8c3e53f2 revset: make sort() noop depending on ordering requirement (BC) Yuya Nishihara <yuya@tcha.org> parents: 29949 diff changeset	1773 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	1774 return revs
29363 2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1775 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	1776 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	1777 return revs
29363 2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1778 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	1779 firstbranch = ()
76a1a703e23d revset: build dict of extra sort options before evaluating set Yuya Nishihara <yuya@tcha.org> parents: 29363 diff changeset	1780 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	1781 firstbranch = getset(repo, subset, opts['topo.firstbranch'])
32921 27932a76a88d dagop: split module hosting DAG-related algorithms from revset Yuya Nishihara <yuya@tcha.org> parents: 32903 diff changeset	1782 revs = baseset(dagop.toposort(revs, repo.changelog.parentrevs,
27932a76a88d dagop: split module hosting DAG-related algorithms from revset Yuya Nishihara <yuya@tcha.org> parents: 32903 diff changeset	1783 firstbranch),
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1784 istopo=True)
29363 2d18c61173f1 revset: build list of (key, reverse) pairs before sorting Yuya Nishihara <yuya@tcha.org> parents: 29362 diff changeset	1785 if keyflags[0][1]:
29348 2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1786 revs.reverse()
2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1787 return revs
2188f170f5b6 revset: add new topographical sort Martijn Pieters <mjpieters@fb.com> parents: 29347 diff changeset	1788
29001 923fa9e06ea0 revset: make sort() do dumb multi-pass sorting for multiple keys (issue5218) Yuya Nishihara <yuya@tcha.org> parents: 28910 diff changeset	1789 # 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	1790 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	1791 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	1792 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	1793 return baseset([c.rev() for c in ctxs])
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	1794
27584 fc7c8cac6a4b revset: use decorator to register a function as revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27517 diff changeset	1795 @predicate('subrepo([pattern])')
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1796 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	1797 """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	1798 pattern is named, any subrepo changes are returned.
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1799 """
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1800 # i18n: "subrepo" is a keyword
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1801 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	1802 pat = None
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1803 if len(args) != 0:
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1804 pat = getstring(args[0], _("subrepo requires a pattern"))
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1805
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1806 m = matchmod.exact(repo.root, repo.root, ['.hgsubstate'])
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1807
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1808 def submatches(names):
26481 7d132557e44a util: extract stringmatcher() from revset Matt Harbison <matt_harbison@yahoo.com> parents: 26307 diff changeset	1809 k, p, m = util.stringmatcher(pat)
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1810 for name in names:
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1811 if m(name):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1812 yield name
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1813
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1814 def matches(x):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1815 c = repo[x]
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1816 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	1817
28272 760f9d04842a revset: define "pat" variable unconditionally in subrepo() Yuya Nishihara <yuya@tcha.org> parents: 28271 diff changeset	1818 if pat is None:
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1819 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	1820
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1821 if s.added:
25149 3f0744eeaeaf cleanup: use __builtins__.any instead of util.any Augie Fackler <augie@google.com> parents: 25146 diff changeset	1822 return any(submatches(c.substate.keys()))
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1823
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1824 if s.modified:
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1825 subs = set(c.p1().substate.keys())
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1826 subs.update(c.substate.keys())
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1827
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1828 for path in submatches(subs):
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1829 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	1830 return True
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1831
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1832 if s.removed:
25149 3f0744eeaeaf cleanup: use __builtins__.any instead of util.any Augie Fackler <augie@google.com> parents: 25146 diff changeset	1833 return any(submatches(c.p1().substate.keys()))
24446 582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1834
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1835 return False
582cfcc843c7 revset: add the 'subrepo' symbol Matt Harbison <matt_harbison@yahoo.com> parents: 24419 diff changeset	1836
28424 534f968d33e5 revset: add inspection data to all filter() calls Yuya Nishihara <yuya@tcha.org> parents: 28423 diff changeset	1837 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	1838
33377 5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1839 def _mapbynodefunc(repo, s, f):
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1840 """(repo, smartset, [node] -> [node]) -> smartset
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1841
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1842 Helper method to map a smartset to another smartset given a function only
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1843 talking about nodes. Handles converting between rev numbers and nodes, and
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1844 filtering.
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1845 """
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1846 cl = repo.unfiltered().changelog
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1847 torev = cl.rev
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1848 tonode = cl.node
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1849 nodemap = cl.nodemap
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1850 result = set(torev(n) for n in f(tonode(r) for r in s) if n in nodemap)
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1851 return smartset.baseset(result - repo.changelog.filteredrevs)
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1852
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1853 @predicate('successors(set)', safe=True)
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1854 def successors(repo, subset, x):
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1855 """All successors for set, including the given set themselves"""
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1856 s = getset(repo, fullreposet(repo), x)
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1857 f = lambda nodes: obsutil.allsuccessors(repo.obsstore, nodes)
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1858 d = _mapbynodefunc(repo, s, f)
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1859 return subset & d
5d63e5f40bea revset: define successors revset Jun Wu <quark@fb.com> parents: 33336 diff changeset	1860
30782 db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	1861 def _substringmatcher(pattern, casesensitive=True):
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	1862 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	1863 casesensitive=casesensitive)
16823 b23bacb230c9 revset: add pattern matching to the 'user' revset expression Simon King <simon@simonking.org.uk> parents: 16822 diff changeset	1864 if kind == 'literal':
30782 db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	1865 if not casesensitive:
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	1866 pattern = encoding.lower(pattern)
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	1867 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	1868 else:
db38cfc7c29d revset: stop lowercasing the regex pattern for 'author' Matt Harbison <matt_harbison@yahoo.com> parents: 30772 diff changeset	1869 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	1870 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	1871
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1872 @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	1873 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	1874 """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	1875
30784 5dd67f0993ce help: eliminate duplicate text for revset string patterns Matt Harbison <matt_harbison@yahoo.com> parents: 30783 diff changeset	1876 Pattern matching is supported for `name`. See
30799 0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns Yuya Nishihara <yuya@tcha.org> parents: 30784 diff changeset	1877 :hg:`help revisions.patterns`.
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1878 """
12815 079a618ea89d revset: add translator comments to i18n strings Martin Geisler <mg@lazybytes.net> parents: 12786 diff changeset	1879 # 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	1880 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	1881 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	1882 if args:
16820 20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1883 pattern = getstring(args[0],
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1884 # i18n: "tag" is a keyword
20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1885 _('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	1886 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	1887 if kind == 'literal':
16825 b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	1888 # avoid resolving all tags
b6ef1395d77f revset: avoid validating all tag nodes for tag(x) Matt Mackall <mpm@selenic.com> parents: 16824 diff changeset	1889 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	1890 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	1891 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	1892 % pattern)
32331 bd872f64a8ba cleanup: use set literals Martin von Zweigbergk <martinvonz@google.com> parents: 32085 diff changeset	1893 s = {repo[tn].rev()}
16820 20f55613fb2a revset: add pattern matching to 'tag' revset expression Simon King <simon@simonking.org.uk> parents: 16819 diff changeset	1894 else:
32331 bd872f64a8ba cleanup: use set literals Martin von Zweigbergk <martinvonz@google.com> parents: 32085 diff changeset	1895 s = {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	1896 else:
32331 bd872f64a8ba cleanup: use set literals Martin von Zweigbergk <martinvonz@google.com> parents: 32085 diff changeset	1897 s = {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	1898 return subset & s
11280 a5eb0bf7e158 revset: add tagged predicate Matt Mackall <mpm@selenic.com> parents: 11279 diff changeset	1899
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1900 @predicate('tagged', safe=True)
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1901 def tagged(repo, subset, x):
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1902 return tag(repo, subset, x)
165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	1903
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1904 @predicate('unstable()', safe=True)
17171 9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	1905 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	1906 """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	1907 """
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	1908 # 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	1909 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	1910 unstables = obsmod.getrevs(repo, 'unstable')
20367 2ac278aab2b4 revset: added intersection to baseset class Lucas Moscovicz <lmoscovicz@fb.com> parents: 20366 diff changeset	1911 return subset & unstables
17171 9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	1912
9c750c3e4fac obsolete: compute unstable changeset Pierre-Yves David <pierre-yves.david@logilab.fr> parents: 17170 diff changeset	1913
27587 c8dc480142a8 revset: use decorator to mark a predicate as safe FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 27586 diff changeset	1914 @predicate('user(string)', safe=True)
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1915 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	1916 """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	1917
30784 5dd67f0993ce help: eliminate duplicate text for revset string patterns Matt Harbison <matt_harbison@yahoo.com> parents: 30783 diff changeset	1918 Pattern matching is supported for `string`. See
30799 0b49449a01f4 help: use :hg: role and canonical name to point to revset string patterns Yuya Nishihara <yuya@tcha.org> parents: 30784 diff changeset	1919 :hg:`help revisions.patterns`.
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	1920 """
13915 8f81d6f4047f revset: rearrange code so functions are sorted alphabetically Idan Kamara <idankk86@gmail.com> parents: 13914 diff changeset	1921 return author(repo, subset, x)
13359 87f248e78173 bookmarks: move revset support to core Matt Mackall <mpm@selenic.com> parents: 13031 diff changeset	1922
32473 bb5dc19484b8 revset: add parentheses after wdir since its a function Pulkit Goyal <7895pulkit@gmail.com> parents: 32442 diff changeset	1923 @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	1924 def wdir(repo, subset, x):
30701 8b1d87243710 revset: document wdir() as an experimental function Yuya Nishihara <yuya@tcha.org> parents: 30700 diff changeset	1925 """Working directory. (EXPERIMENTAL)"""
24419 0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	1926 # 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	1927 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	1928 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	1929 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	1930 return baseset()
0e41f110e69e revset: add wdir() function to specify workingctx revision by command Yuya Nishihara <yuya@tcha.org> parents: 24374 diff changeset	1931
29939 e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	1932 def _orderedlist(repo, subset, x):
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1933 s = getstring(x, "internal error")
6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1934 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	1935 return baseset()
25341 9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1936 # 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	1937 # 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	1938 cl = repo.changelog
25341 9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1939 ls = []
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1940 seen = set()
9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1941 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	1942 try:
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	1943 # fast path for integer revision
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	1944 r = int(t)
ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	1945 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	1946 raise ValueError
26143 42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	1947 revs = [r]
25344 ceaf04bb14ff revset: add fast path for _list() of integer revisions Yuya Nishihara <yuya@tcha.org> parents: 25343 diff changeset	1948 except ValueError:
26143 42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	1949 revs = stringset(repo, subset, t)
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	1950
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	1951 for r in revs:
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	1952 if r in seen:
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	1953 continue
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	1954 if (r in subset
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	1955 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	1956 ls.append(r)
42bb1812686f revset: fix resolving strings from a list Durham Goode <durham@fb.com> parents: 26102 diff changeset	1957 seen.add(r)
25341 9d6cc87bd507 revset: make internal _list() expression remove duplicated revisions Yuya Nishihara <yuya@tcha.org> parents: 25309 diff changeset	1958 return baseset(ls)
15898 6902e13ddd03 revset: optimize building large lists in formatrevspec Matt Mackall <mpm@selenic.com> parents: 15837 diff changeset	1959
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	1960 # for internal use
29939 e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	1961 @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	1962 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	1963 if order == followorder:
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	1964 # 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	1965 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	1966 else:
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	1967 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	1968
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	1969 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	1970 s = getstring(x, "internal error")
98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	1971 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	1972 return baseset()
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	1973 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	1974 s = subset
20566 98024950ade0 revset: added _intlist method to replace _list for %ld Lucas Moscovicz <lmoscovicz@fb.com> parents: 20552 diff changeset	1975 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	1976
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	1977 # for internal use
29939 e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	1978 @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	1979 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	1980 if order == followorder:
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	1981 # 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	1982 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	1983 else:
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	1984 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	1985
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	1986 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	1987 s = getstring(x, "internal error")
0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	1988 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	1989 return baseset()
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	1990 cl = repo.changelog
0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	1991 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	1992 s = subset
20569 0d4be103c734 revset: added _hexlist method to replace _list for %ln Lucas Moscovicz <lmoscovicz@fb.com> parents: 20566 diff changeset	1993 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	1994
29939 e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	1995 # for internal use
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	1996 @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	1997 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	1998 if order == followorder:
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	1999 # 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	2000 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	2001 else:
e34cd85dc5b1 revset: fix order of nested '_(\|int\|hex)list' expression (BC) Yuya Nishihara <yuya@tcha.org> parents: 29938 diff changeset	2002 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	2003
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2004 methods = {
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2005 "range": rangeset,
30803 d389f19f14aa revset: do not transform range* operators in parsed tree Yuya Nishihara <yuya@tcha.org> parents: 30802 diff changeset	2006 "rangeall": rangeall,
30044 69b61d0bb008 revset: do not rewrite ':y' to '0:y' (issue5385) Yuya Nishihara <yuya@tcha.org> parents: 30043 diff changeset	2007 "rangepre": rangepre,
30803 d389f19f14aa revset: do not transform range* operators in parsed tree Yuya Nishihara <yuya@tcha.org> parents: 30802 diff changeset	2008 "rangepost": rangepost,
16860 e1aa1ed30030 revset: turn dagrange into a function Bryan O'Sullivan <bryano@fb.com> parents: 16859 diff changeset	2009 "dagrange": dagrange,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2010 "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	2011 "symbol": stringset,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2012 "and": andset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2013 "or": orset,
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2014 "not": notset,
28217 d2ac8b57a75d revset: use smartset minus operator Durham Goode <durham@fb.com> parents: 28139 diff changeset	2015 "difference": differenceset,
33416 9467d5337292 revset: add experimental relation and subscript operators Yuya Nishihara <yuya@tcha.org> parents: 33377 diff changeset	2016 "relation": relationset,
9467d5337292 revset: add experimental relation and subscript operators Yuya Nishihara <yuya@tcha.org> parents: 33377 diff changeset	2017 "relsubscript": relsubscriptset,
9467d5337292 revset: add experimental relation and subscript operators Yuya Nishihara <yuya@tcha.org> parents: 33377 diff changeset	2018 "subscript": subscriptset,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2019 "list": listset,
25704 70a2082f855a revset: add parsing rule for key=value pair Yuya Nishihara <yuya@tcha.org> parents: 25689 diff changeset	2020 "keyvalue": keyvaluepair,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2021 "func": func,
14070 305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	2022 "ancestor": ancestorspec,
305c97670d7a revset: add ^ and ~ operators from parentrevspec extension Kevin Gessner <kevin@kevingessner.com> parents: 14061 diff changeset	2023 "parent": parentspec,
29935 d2d1be3009ca revset: add stub to handle parentpost operation Yuya Nishihara <yuya@tcha.org> parents: 29934 diff changeset	2024 "parentpost": parentpost,
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2025 }
c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2026
24518 dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2027 def posttreebuilthook(tree, repo):
dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2028 # 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	2029 pass
dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2030
29959 1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2031 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	2032 """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	2033
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2034 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	2035 set.
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2036 """
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2037 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	2038
33336 4672db164c98 revset: make repo.anyrevs accept customized alias override (API) Jun Wu <quark@fb.com> parents: 33092 diff changeset	2039 def matchany(ui, specs, repo=None, order=defineorder, localalias=None):
25927 44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2040 """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	2041 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	2042
1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2043 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	2044 set.
33336 4672db164c98 revset: make repo.anyrevs accept customized alias override (API) Jun Wu <quark@fb.com> parents: 33092 diff changeset	2045
4672db164c98 revset: make repo.anyrevs accept customized alias override (API) Jun Wu <quark@fb.com> parents: 33092 diff changeset	2046 If localalias is not None, it is a dict {name: definitionstring}. It takes
4672db164c98 revset: make repo.anyrevs accept customized alias override (API) Jun Wu <quark@fb.com> parents: 33092 diff changeset	2047 precedence over [revsetalias] config section.
29959 1b5931604a5a revset: add option to make matcher takes the ordering of the input set Yuya Nishihara <yuya@tcha.org> parents: 29950 diff changeset	2048 """
25927 44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2049 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	2050 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	2051 return baseset()
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2052 return mfunc
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2053 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	2054 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	2055 lookup = None
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2056 if repo:
44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2057 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	2058 if len(specs) == 1:
31044 0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	2059 tree = revsetlang.parse(specs[0], lookup)
25927 44da63623fca revset: add matchany() to construct OR expression from a list of specs Yuya Nishihara <yuya@tcha.org> parents: 25926 diff changeset	2060 else:
31044 0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	2061 tree = ('or',
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	2062 ('list',) + tuple(revsetlang.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	2063
33336 4672db164c98 revset: make repo.anyrevs accept customized alias override (API) Jun Wu <quark@fb.com> parents: 33092 diff changeset	2064 aliases = []
4672db164c98 revset: make repo.anyrevs accept customized alias override (API) Jun Wu <quark@fb.com> parents: 33092 diff changeset	2065 warn = None
14900 fc3d6f300d7d revset: allow bypassing alias expansion Matt Mackall <mpm@selenic.com> parents: 14851 diff changeset	2066 if ui:
33336 4672db164c98 revset: make repo.anyrevs accept customized alias override (API) Jun Wu <quark@fb.com> parents: 33092 diff changeset	2067 aliases.extend(ui.configitems('revsetalias'))
4672db164c98 revset: make repo.anyrevs accept customized alias override (API) Jun Wu <quark@fb.com> parents: 33092 diff changeset	2068 warn = ui.warn
4672db164c98 revset: make repo.anyrevs accept customized alias override (API) Jun Wu <quark@fb.com> parents: 33092 diff changeset	2069 if localalias:
4672db164c98 revset: make repo.anyrevs accept customized alias override (API) Jun Wu <quark@fb.com> parents: 33092 diff changeset	2070 aliases.extend(localalias.items())
4672db164c98 revset: make repo.anyrevs accept customized alias override (API) Jun Wu <quark@fb.com> parents: 33092 diff changeset	2071 if aliases:
4672db164c98 revset: make repo.anyrevs accept customized alias override (API) Jun Wu <quark@fb.com> parents: 33092 diff changeset	2072 tree = revsetlang.expandaliases(tree, aliases, warn=warn)
31044 0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	2073 tree = revsetlang.foldconcat(tree)
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	2074 tree = revsetlang.analyze(tree, order)
0b8356705de6 revset: split language services to revsetlang module (API) Yuya Nishihara <yuya@tcha.org> parents: 31037 diff changeset	2075 tree = revsetlang.optimize(tree)
24518 dd5e56f08d13 revset: add hook after tree parsing Laurent Charignon <lcharignon@fb.com> parents: 24459 diff changeset	2076 posttreebuilthook(tree, repo)
29910 41491cf936f2 revset: add public function to create matcher from evaluatable tree Yuya Nishihara <yuya@tcha.org> parents: 29909 diff changeset	2077 return makematcher(tree)
41491cf936f2 revset: add public function to create matcher from evaluatable tree Yuya Nishihara <yuya@tcha.org> parents: 29909 diff changeset	2078
41491cf936f2 revset: add public function to create matcher from evaluatable tree Yuya Nishihara <yuya@tcha.org> parents: 29909 diff changeset	2079 def makematcher(tree):
41491cf936f2 revset: add public function to create matcher from evaluatable tree Yuya Nishihara <yuya@tcha.org> parents: 29909 diff changeset	2080 """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	2081 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	2082 if subset is None:
24115 ff24af40728b revset: specify fullreposet without using spanset factory Yuya Nishihara <yuya@tcha.org> parents: 24114 diff changeset	2083 subset = fullreposet(repo)
31810 81abd0d12c86 revset: stop supporting plain list as input set (API) Yuya Nishihara <yuya@tcha.org> parents: 31809 diff changeset	2084 return getset(repo, subset, tree)
11275 c9ce8ecd6ca1 revset: introduce revset core Matt Mackall <mpm@selenic.com> parents: diff changeset	2085 return mfunc
12821 165079e564f0 revsets: generate predicate help dynamically Patrick Mezard <pmezard@gmail.com> parents: 12815 diff changeset	2086
28393 ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	2087 def loadpredicate(ui, extname, registrarobj):
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	2088 """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	2089 """
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	2090 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	2091 symbols[name] = func
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	2092 if func._safe:
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	2093 safesymbols.add(name)
ac11ba7c2e56 registrar: define revsetpredicate to decorate revset predicate FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28272 diff changeset	2094
28395 0383f7a5e86c revset: replace predicate by revsetpredicate of registrar FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28393 diff changeset	2095 # 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	2096 loadpredicate(None, None, predicate)
0383f7a5e86c revset: replace predicate by revsetpredicate of registrar FUJIWARA Katsunori <foozy@lares.dti.ne.jp> parents: 28393 diff changeset	2097
12823 80deae3bc5ea hggettext: handle i18nfunctions declaration for docstrings translations Patrick Mezard <pmezard@gmail.com> parents: 12821 diff changeset	2098 # 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	2099 i18nfunctions = symbols.values()

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/revset.py @ 33416:9467d5337292