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

annotate mercurial/revset.py @ 37004:407934a97bc7

stack: import Evolve stack test file Import Evolve stack test file for starting to have good coverage on stack definition. Differential Revision: https://phab.mercurial-scm.org/D2396

author	Boris Feld <boris.feld@octobus.net>
date	Fri, 19 Jan 2018 16:52:02 +0100
parents	c6061cadb400
children	f0b6fbea00cf

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

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/revset.py @ 37004:407934a97bc7