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

annotate mercurial/match.py @ 43106:d783f945a701

py3: finish porting iteritems() to pycompat and remove source transformer This commit finishes porting .iteritems() to pycompat.iteritems() for the mercurial package. The translation of .iteritems() to .items() was the last conversion performed by the source transformer. With the porting to pycompat complete, we no longer have a need for the source transformer. So the source transformer has been removed. Good riddance! The code base is now compatible with Python 2 and Python 3. For the record, as the person who introduced the source transformer, it brings me joy to delete it. It accomplished its goal to facilitate a port to Python 3 without overly burdening people on some painful low-level differences between Python 2 and 3. It is unfortunate we still have to wallpaper over many differences with the pycompat shim. But it is what it is. Differential Revision: https://phab.mercurial-scm.org/D7015

author	Gregory Szorc <gregory.szorc@gmail.com>
date	Mon, 07 Oct 2019 00:04:04 -0400
parents	eef9a2d67051
children	8ff1ecfadcd1

rev	line source
8761 0289f384e1e5 Generally replace "file name" with "filename" in help and comments. timeless <timeless@gmail.com> parents: 8682 diff changeset	1 # match.py - filename matching
8231 5d4d88a4f5e6 match: add copyright and license header Martin Geisler <mg@lazybytes.net> parents: 8152 diff changeset	2 #
5d4d88a4f5e6 match: add copyright and license header Martin Geisler <mg@lazybytes.net> parents: 8152 diff changeset	3 # Copyright 2008, 2009 Matt Mackall <mpm@selenic.com> and others
5d4d88a4f5e6 match: add copyright and license header Martin Geisler <mg@lazybytes.net> parents: 8152 diff changeset	4 #
5d4d88a4f5e6 match: add copyright and license header Martin Geisler <mg@lazybytes.net> parents: 8152 diff changeset	5 # This software may be used and distributed according to the terms of the
10263 25e572394f5c Update license to GPLv2+ Matt Mackall <mpm@selenic.com> parents: 9036 diff changeset	6 # GNU General Public License version 2 or any later version.
8231 5d4d88a4f5e6 match: add copyright and license header Martin Geisler <mg@lazybytes.net> parents: 8152 diff changeset	7
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	8 from __future__ import absolute_import, print_function
25958 c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	9
c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	10 import copy
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	11 import itertools
25958 c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	12 import os
c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	13 import re
c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	14
c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	15 from .i18n import _
43085 eef9a2d67051 py3: manually import pycompat.open into files that need it Gregory Szorc <gregory.szorc@gmail.com> parents: 43077 diff changeset	16 from .pycompat import open
25958 c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	17 from . import (
36088 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	18 encoding,
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26014 diff changeset	19 error,
25958 c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	20 pathutil,
42468 a3a8887e4426 rust: using policy.importrust from Python callers Georges Racinet <georges.racinet@octobus.net> parents: 42389 diff changeset	21 policy,
36601 9adfa48792a7 match: some minimal pycompat fixes guided by test-hgignore.t Augie Fackler <augie@google.com> parents: 36088 diff changeset	22 pycompat,
25958 c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	23 util,
c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	24 )
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	25 from .utils import stringutil
6576 69f3e9ac7c56 walk: introduce match objects Matt Mackall <mpm@selenic.com> parents: diff changeset	26
42782 e94c8f584ee2 py3: do not convert rust module/attribute names to bytes Yuya Nishihara <yuya@tcha.org> parents: 42468 diff changeset	27 rustmod = policy.importrust(r'filepatterns')
42351 c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	28
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	29 allpatternkinds = (
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	30 b're',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	31 b'glob',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	32 b'path',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	33 b'relglob',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	34 b'relpath',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	35 b'relre',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	36 b'rootglob',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	37 b'listfile',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	38 b'listfile0',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	39 b'set',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	40 b'include',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	41 b'subinclude',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	42 b'rootfilesin',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	43 )
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	44 cwdrelativepatternkinds = (b'relpath', b'glob')
33710 2be0bf186950 match: expose some data and functionality to other modules Kostia Balytskyi <ikostia@fb.com> parents: 33582 diff changeset	45
24636 36872036169b treemanifest: further optimize treemanifest.matches() Drew Gottlieb <drgott@google.com> parents: 24452 diff changeset	46 propertycache = util.propertycache
36872036169b treemanifest: further optimize treemanifest.matches() Drew Gottlieb <drgott@google.com> parents: 24452 diff changeset	47
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	48
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	49 def _rematcher(regex):
9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	50 '''compile the regexp with the best available regexp engine and return a
9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	51 matcher function'''
21909 335bb8b80443 match: use util.re.compile instead of util.compilere Siddharth Agarwal <sid0@fb.com> parents: 21815 diff changeset	52 m = util.re.compile(regex)
16943 8d08a28aa63e matcher: use re2 bindings if available Bryan O'Sullivan <bryano@fb.com> parents: 16791 diff changeset	53 try:
8d08a28aa63e matcher: use re2 bindings if available Bryan O'Sullivan <bryano@fb.com> parents: 16791 diff changeset	54 # slightly faster, provided by facebook's re2 bindings
8d08a28aa63e matcher: use re2 bindings if available Bryan O'Sullivan <bryano@fb.com> parents: 16791 diff changeset	55 return m.test_match
8d08a28aa63e matcher: use re2 bindings if available Bryan O'Sullivan <bryano@fb.com> parents: 16791 diff changeset	56 except AttributeError:
8d08a28aa63e matcher: use re2 bindings if available Bryan O'Sullivan <bryano@fb.com> parents: 16791 diff changeset	57 return m.match
8d08a28aa63e matcher: use re2 bindings if available Bryan O'Sullivan <bryano@fb.com> parents: 16791 diff changeset	58
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	59
42086 1721b92f2b5e match: make arguments of _expandsets() optional Denis Laxalde <denis@laxalde.org> parents: 42085 diff changeset	60 def _expandsets(kindpats, ctx=None, listsubrepos=False, badfn=None):
38613 760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38612 diff changeset	61 '''Returns the kindpats list with the 'set' patterns expanded to matchers'''
760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38612 diff changeset	62 matchers = []
14675 cfc89398f710 match: introduce basic fileset support Matt Mackall <mpm@selenic.com> parents: 14674 diff changeset	63 other = []
cfc89398f710 match: introduce basic fileset support Matt Mackall <mpm@selenic.com> parents: 14674 diff changeset	64
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	65 for kind, pat, source in kindpats:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	66 if kind == b'set':
40478 481249481392 match: fix assertion for fileset with no context (issue6046) Yuya Nishihara <yuya@tcha.org> parents: 40345 diff changeset	67 if ctx is None:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	68 raise error.ProgrammingError(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	69 b"fileset expression with no " b"context"
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	70 )
38613 760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38612 diff changeset	71 matchers.append(ctx.matchfileset(pat, badfn=badfn))
25122 755d23a49170 match: resolve filesets in subrepos for commands given the '-S' argument Matt Harbison <matt_harbison@yahoo.com> parents: 25114 diff changeset	72
755d23a49170 match: resolve filesets in subrepos for commands given the '-S' argument Matt Harbison <matt_harbison@yahoo.com> parents: 25114 diff changeset	73 if listsubrepos:
755d23a49170 match: resolve filesets in subrepos for commands given the '-S' argument Matt Harbison <matt_harbison@yahoo.com> parents: 25114 diff changeset	74 for subpath in ctx.substate:
38613 760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38612 diff changeset	75 sm = ctx.sub(subpath).matchfileset(pat, badfn=badfn)
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	76 pm = prefixdirmatcher(subpath, sm, badfn=badfn)
38613 760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38612 diff changeset	77 matchers.append(pm)
25122 755d23a49170 match: resolve filesets in subrepos for commands given the '-S' argument Matt Harbison <matt_harbison@yahoo.com> parents: 25114 diff changeset	78
14675 cfc89398f710 match: introduce basic fileset support Matt Mackall <mpm@selenic.com> parents: 14674 diff changeset	79 continue
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	80 other.append((kind, pat, source))
38613 760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38612 diff changeset	81 return matchers, other
14675 cfc89398f710 match: introduce basic fileset support Matt Mackall <mpm@selenic.com> parents: 14674 diff changeset	82
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	83
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	84 def _expandsubinclude(kindpats, root):
32185 6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31442 diff changeset	85 '''Returns the list of subinclude matcher args and the kindpats without the
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	86 subincludes in it.'''
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	87 relmatchers = []
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	88 other = []
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	89
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	90 for kind, pat, source in kindpats:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	91 if kind == b'subinclude':
25301 caaf4045eca8 match: normpath the ignore source when expanding the 'subinclude' kind Matt Harbison <matt_harbison@yahoo.com> parents: 25283 diff changeset	92 sourceroot = pathutil.dirname(util.normpath(source))
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	93 pat = util.pconvert(pat)
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	94 path = pathutil.join(sourceroot, pat)
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	95
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	96 newroot = pathutil.dirname(path)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	97 matcherargs = (newroot, b'', [], [b'include:%s' % path])
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	98
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	99 prefix = pathutil.canonpath(root, root, newroot)
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	100 if prefix:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	101 prefix += b'/'
32185 6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31442 diff changeset	102 relmatchers.append((prefix, matcherargs))
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	103 else:
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	104 other.append((kind, pat, source))
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	105
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	106 return relmatchers, other
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	107
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	108
24447 d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 23686 diff changeset	109 def _kindpatsalwaysmatch(kindpats):
d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 23686 diff changeset	110 """"Checks whether the kindspats match everything, as e.g.
d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 23686 diff changeset	111 'relpath:.' does.
d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 23686 diff changeset	112 """
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	113 for kind, pat, source in kindpats:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	114 if pat != b'' or kind not in [b'relpath', b'glob']:
24447 d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 23686 diff changeset	115 return False
d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 23686 diff changeset	116 return True
d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 23686 diff changeset	117
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	118
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	119 def _buildkindpatsmatcher(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	120 matchercls, root, kindpats, ctx=None, listsubrepos=False, badfn=None
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	121 ):
38581 9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38580 diff changeset	122 matchers = []
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	123 fms, kindpats = _expandsets(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	124 kindpats, ctx=ctx, listsubrepos=listsubrepos, badfn=badfn
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	125 )
38581 9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38580 diff changeset	126 if kindpats:
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	127 m = matchercls(root, kindpats, badfn=badfn)
38581 9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38580 diff changeset	128 matchers.append(m)
38613 760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38612 diff changeset	129 if fms:
760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38612 diff changeset	130 matchers.extend(fms)
38581 9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38580 diff changeset	131 if not matchers:
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	132 return nevermatcher(badfn=badfn)
38581 9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38580 diff changeset	133 if len(matchers) == 1:
9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38580 diff changeset	134 return matchers[0]
9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38580 diff changeset	135 return unionmatcher(matchers)
9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38580 diff changeset	136
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	137
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	138 def match(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	139 root,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	140 cwd,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	141 patterns=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	142 include=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	143 exclude=None,
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	144 default=b'glob',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	145 auditor=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	146 ctx=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	147 listsubrepos=False,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	148 warn=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	149 badfn=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	150 icasefs=False,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	151 ):
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	152 r"""build an object to match a set of file patterns
32433 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	153
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	154 arguments:
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	155 root - the canonical root of the tree you're matching against
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	156 cwd - the current working directory, if relevant
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	157 patterns - patterns to find
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	158 include - patterns to include (unless they are excluded)
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	159 exclude - patterns to exclude (even if they are included)
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	160 default - if a pattern in patterns has no explicit type, assume this one
42083 bee1647578b7 match: complete documentation of match() parameters Denis Laxalde <denis@laxalde.org> parents: 42082 diff changeset	161 auditor - optional path auditor
bee1647578b7 match: complete documentation of match() parameters Denis Laxalde <denis@laxalde.org> parents: 42082 diff changeset	162 ctx - optional changecontext
bee1647578b7 match: complete documentation of match() parameters Denis Laxalde <denis@laxalde.org> parents: 42082 diff changeset	163 listsubrepos - if True, recurse into subrepositories
32433 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	164 warn - optional function used for printing warnings
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	165 badfn - optional bad() callback for this matcher instead of the default
32439 284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	166 icasefs - make a matcher for wdir on case insensitive filesystems, which
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	167 normalizes the given patterns to the case in the filesystem
32433 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	168
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	169 a pattern is one of:
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	170 'glob:<glob>' - a glob relative to cwd
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	171 're:<regexp>' - a regular expression
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	172 'path:<path>' - a path relative to repository root, which is matched
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	173 recursively
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	174 'rootfilesin:<path>' - a path relative to repository root, which is
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	175 matched non-recursively (will not match subdirectories)
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	176 'relglob:<glob>' - an unrooted glob (*.c matches C files in all dirs)
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	177 'relpath:<path>' - a path relative to cwd
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	178 'relre:<regexp>' - a regexp that needn't match the start of a name
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	179 'set:<fileset>' - a fileset expression
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	180 'include:<path>' - a file of patterns to read and include
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	181 'subinclude:<path>' - a file of patterns to match against files under
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	182 the same directory
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	183 '<something>' - a pattern of the specified default type
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	184
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	185 Usually a patternmatcher is returned:
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	186 >>> match(b'foo', b'.', [b're:.\.c$', b'path:foo/a', b'.py'])
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	187 <patternmatcher patterns='.\\.c$\|foo/a(?:/\|$)\|[^/]\\.py$'>
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	188
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	189 Combining 'patterns' with 'include' (resp. 'exclude') gives an
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	190 intersectionmatcher (resp. a differencematcher):
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	191 >>> type(match(b'foo', b'.', [b're:.*\.c$'], include=[b'path:lib']))
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	192 <class 'mercurial.match.intersectionmatcher'>
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	193 >>> type(match(b'foo', b'.', [b're:.*\.c$'], exclude=[b'path:build']))
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	194 <class 'mercurial.match.differencematcher'>
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	195
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	196 Notice that, if 'patterns' is empty, an alwaysmatcher is returned:
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	197 >>> match(b'foo', b'.', [])
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	198 <alwaysmatcher>
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	199
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	200 The 'default' argument determines which kind of pattern is assumed if a
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	201 pattern has no prefix:
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	202 >>> match(b'foo', b'.', [b'.*\.c$'], default=b're')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	203 <patternmatcher patterns='.*\\.c$'>
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	204 >>> match(b'foo', b'.', [b'main.py'], default=b'relpath')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	205 <patternmatcher patterns='main\\.py(?:/\|$)'>
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	206 >>> match(b'foo', b'.', [b'main.py'], default=b're')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	207 <patternmatcher patterns='main.py'>
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	208
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	209 The primary use of matchers is to check whether a value (usually a file
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	210 name) matches againset one of the patterns given at initialization. There
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	211 are two ways of doing this check.
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	212
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	213 >>> m = match(b'foo', b'', [b're:.*\.c$', b'relpath:a'])
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	214
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	215 1. Calling the matcher with a file name returns True if any pattern
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	216 matches that file name:
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	217 >>> m(b'a')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	218 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	219 >>> m(b'main.c')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	220 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	221 >>> m(b'test.py')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	222 False
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	223
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	224 2. Using the exact() method only returns True if the file name matches one
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	225 of the exact patterns (i.e. not re: or glob: patterns):
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	226 >>> m.exact(b'a')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	227 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	228 >>> m.exact(b'main.c')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	229 False
32433 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	230 """
32439 284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	231 normalize = _donormalize
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	232 if icasefs:
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	233 dirstate = ctx.repo().dirstate
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	234 dsnormalize = dirstate.normalize
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	235
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	236 def normalize(patterns, default, root, cwd, auditor, warn):
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	237 kp = _donormalize(patterns, default, root, cwd, auditor, warn)
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	238 kindpats = []
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	239 for kind, pats, source in kp:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	240 if kind not in (b're', b'relre'): # regex can't be normalized
32439 284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	241 p = pats
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	242 pats = dsnormalize(pats)
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	243
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	244 # Preserve the original to handle a case only rename.
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	245 if p != pats and p in dirstate:
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	246 kindpats.append((kind, p, source))
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	247
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	248 kindpats.append((kind, pats, source))
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	249 return kindpats
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32438 diff changeset	250
41633 635a12c53ea6 match: remove unused "exact" argument (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41542 diff changeset	251 if patterns:
32589 5f08eca8f8d3 match: move normalize() call out of matcher constructors Martin von Zweigbergk <martinvonz@google.com> parents: 32588 diff changeset	252 kindpats = normalize(patterns, default, root, cwd, auditor, warn)
32590 3fdcc34c0aba match: remove special-casing of always-matching patterns in patternmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32589 diff changeset	253 if _kindpatsalwaysmatch(kindpats):
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	254 m = alwaysmatcher(badfn)
32590 3fdcc34c0aba match: remove special-casing of always-matching patterns in patternmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32589 diff changeset	255 else:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	256 m = _buildkindpatsmatcher(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	257 patternmatcher,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	258 root,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	259 kindpats,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	260 ctx=ctx,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	261 listsubrepos=listsubrepos,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	262 badfn=badfn,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	263 )
32586 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	264 else:
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	265 # It's a little strange that no patterns means to match everything.
32673 783394c0c978 match: simplify nevermatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32631 diff changeset	266 # Consider changing this to match nothing (probably using nevermatcher).
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	267 m = alwaysmatcher(badfn)
32586 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	268
32530 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	269 if include:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	270 kindpats = normalize(include, b'glob', root, cwd, auditor, warn)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	271 im = _buildkindpatsmatcher(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	272 includematcher,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	273 root,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	274 kindpats,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	275 ctx=ctx,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	276 listsubrepos=listsubrepos,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	277 badfn=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	278 )
32530 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	279 m = intersectmatchers(m, im)
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	280 if exclude:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	281 kindpats = normalize(exclude, b'glob', root, cwd, auditor, warn)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	282 em = _buildkindpatsmatcher(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	283 includematcher,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	284 root,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	285 kindpats,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	286 ctx=ctx,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	287 listsubrepos=listsubrepos,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	288 badfn=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	289 )
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	290 m = differencematcher(m, em)
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	291 return m
32433 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	292
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	293
41687 0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41686 diff changeset	294 def exact(files, badfn=None):
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	295 return exactmatcher(files, badfn=badfn)
32433 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	296
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	297
41687 0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41686 diff changeset	298 def always(badfn=None):
0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41686 diff changeset	299 return alwaysmatcher(badfn)
32433 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	300
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	301
41687 0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41686 diff changeset	302 def never(badfn=None):
0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41686 diff changeset	303 return nevermatcher(badfn)
32631 e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32590 diff changeset	304
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	305
32433 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	306 def badmatch(match, badfn):
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	307 """Make a copy of the given matcher, replacing its bad method with the given
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	308 one.
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	309 """
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	310 m = copy.copy(match)
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	311 m.bad = badfn
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	312 return m
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	313
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	314
42085 54e6d7ef5ca5 match: make _donormalize's auditor and warn arguments optional Denis Laxalde <denis@laxalde.org> parents: 42084 diff changeset	315 def _donormalize(patterns, default, root, cwd, auditor=None, warn=None):
32435 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	316 '''Convert 'kind:pat' from the patterns list to tuples with kind and
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	317 normalized and rooted patterns and with listfiles expanded.'''
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	318 kindpats = []
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	319 for kind, pat in [_patsplit(p, default) for p in patterns]:
33710 2be0bf186950 match: expose some data and functionality to other modules Kostia Balytskyi <ikostia@fb.com> parents: 33582 diff changeset	320 if kind in cwdrelativepatternkinds:
42085 54e6d7ef5ca5 match: make _donormalize's auditor and warn arguments optional Denis Laxalde <denis@laxalde.org> parents: 42084 diff changeset	321 pat = pathutil.canonpath(root, cwd, pat, auditor=auditor)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	322 elif kind in (b'relglob', b'path', b'rootfilesin', b'rootglob'):
32435 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	323 pat = util.normpath(pat)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	324 elif kind in (b'listfile', b'listfile0'):
32435 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	325 try:
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	326 files = util.readfile(pat)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	327 if kind == b'listfile0':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	328 files = files.split(b'\0')
32435 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	329 else:
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	330 files = files.splitlines()
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	331 files = [f for f in files if f]
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	332 except EnvironmentError:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	333 raise error.Abort(_(b"unable to read file list (%s)") % pat)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	334 for k, p, source in _donormalize(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	335 files, default, root, cwd, auditor, warn
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	336 ):
32435 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	337 kindpats.append((k, p, pat))
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	338 continue
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	339 elif kind == b'include':
32435 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	340 try:
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	341 fullpath = os.path.join(root, util.localpath(pat))
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	342 includepats = readpatternfile(fullpath, warn)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	343 for k, p, source in _donormalize(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	344 includepats, default, root, cwd, auditor, warn
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	345 ):
32435 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	346 kindpats.append((k, p, source or pat))
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	347 except error.Abort as inst:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	348 raise error.Abort(b'%s: %s' % (pat, inst[0]))
32435 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	349 except IOError as inst:
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	350 if warn:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	351 warn(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	352 _(b"skipping unreadable pattern file '%s': %s\n")
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	353 % (pat, stringutil.forcebytestr(inst.strerror))
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	354 )
32435 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	355 continue
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	356 # else: re or relre - which cannot be normalized
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	357 kindpats.append((kind, pat, b''))
32435 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	358 return kindpats
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32434 diff changeset	359
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	360
32492 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	361 class basematcher(object):
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	362 def __init__(self, badfn=None):
32492 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	363 if badfn is not None:
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	364 self.bad = badfn
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	365
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	366 def __call__(self, fn):
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	367 return self.matchfn(fn)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	368
32492 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	369 # Callbacks related to how the matcher is used by dirstate.walk.
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	370 # Subscribers to these events must monkeypatch the matcher object.
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	371 def bad(self, f, msg):
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	372 '''Callback from dirstate.walk for each explicit file that can't be
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	373 found/accessed, with an error message.'''
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	374
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	375 # If an explicitdir is set, it will be called when an explicitly listed
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	376 # directory is visited.
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	377 explicitdir = None
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	378
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	379 # If an traversedir is set, it will be called when a directory discovered
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	380 # by recursive traversal is visited.
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	381 traversedir = None
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	382
32493 9f781f43f2ce match: make basematcher._files a @propertycache Martin von Zweigbergk <martinvonz@google.com> parents: 32492 diff changeset	383 @propertycache
9f781f43f2ce match: make basematcher._files a @propertycache Martin von Zweigbergk <martinvonz@google.com> parents: 32492 diff changeset	384 def _files(self):
9f781f43f2ce match: make basematcher._files a @propertycache Martin von Zweigbergk <martinvonz@google.com> parents: 32492 diff changeset	385 return []
9f781f43f2ce match: make basematcher._files a @propertycache Martin von Zweigbergk <martinvonz@google.com> parents: 32492 diff changeset	386
32492 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	387 def files(self):
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	388 '''Explicitly listed files or patterns or roots:
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	389 if no patterns or .always(): empty list,
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	390 if exact: list exact files,
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	391 if not .anypats(): list all files and dirs,
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	392 else: optimal roots'''
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	393 return self._files
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	394
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	395 @propertycache
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	396 def _fileset(self):
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	397 return set(self._files)
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	398
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	399 def exact(self, f):
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	400 '''Returns True if f is in .files().'''
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	401 return f in self._fileset
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	402
32497 43e091847c4d match: make matchfn a method on the class Martin von Zweigbergk <martinvonz@google.com> parents: 32495 diff changeset	403 def matchfn(self, f):
43e091847c4d match: make matchfn a method on the class Martin von Zweigbergk <martinvonz@google.com> parents: 32495 diff changeset	404 return False
43e091847c4d match: make matchfn a method on the class Martin von Zweigbergk <martinvonz@google.com> parents: 32495 diff changeset	405
32492 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	406 def visitdir(self, dir):
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	407 '''Decides whether a directory should be visited based on whether it
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	408 has potential matches in it or one of its subdirectories. This is
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	409 based on the match's primary, included, and excluded patterns.
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	410
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	411 Returns the string 'all' if the given directory and all subdirectories
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	412 should be visited. Otherwise returns True or False indicating whether
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	413 the given directory should be visited.
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	414 '''
33478 cf15c3cc304c match: make base matcher return True for visitdir Durham Goode <durham@fb.com> parents: 33448 diff changeset	415 return True
32492 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	416
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	417 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	418 '''Decides whether a directory should be visited based on whether it
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	419 has potential matches in it or one of its subdirectories, and
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	420 potentially lists which subdirectories of that directory should be
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	421 visited. This is based on the match's primary, included, and excluded
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	422 patterns.
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	423
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	424 This function is very similar to 'visitdir', and the following mapping
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	425 can be applied:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	426
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	427 visitdir \| visitchildrenlist
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	428 ----------+-------------------
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	429 False \| set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	430 'all' \| 'all'
39288 27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	431 True \| 'this' OR non-empty set of subdirs -or files- to visit
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	432
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	433 Example:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	434 Assume matchers ['path:foo/bar', 'rootfilesin:qux'], we would return
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	435 the following values (assuming the implementation of visitchildrenset
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	436 is capable of recognizing this; some implementations are not).
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	437
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42351 diff changeset	438 '' -> {'foo', 'qux'}
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	439 'baz' -> set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	440 'foo' -> {'bar'}
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	441 # Ideally this would be 'all', but since the prefix nature of matchers
39288 27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	442 # is applied to the entire matcher, we have to downgrade this to
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	443 # 'this' due to the non-prefix 'rootfilesin'-kind matcher being mixed
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	444 # in.
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	445 'foo/bar' -> 'this'
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	446 'qux' -> 'this'
39288 27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	447
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	448 Important:
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	449 Most matchers do not know if they're representing files or
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	450 directories. They see ['path:dir/f'] and don't know whether 'f' is a
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	451 file or a directory, so visitchildrenset('dir') for most matchers will
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	452 return {'f'}, but if the matcher knows it's a file (like exactmatcher
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	453 does), it may return 'this'. Do not rely on the return being a set
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	454 indicating that there are no files in this dir to investigate (or
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	455 equivalently that if there are files to investigate in 'dir' that it
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38996 diff changeset	456 will always return 'this').
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	457 '''
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	458 return b'this'
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	459
32492 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	460 def always(self):
33379 7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	461 '''Matcher will match everything and .files() will be empty --
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	462 optimization might be possible.'''
32492 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	463 return False
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	464
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	465 def isexact(self):
33379 7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	466 '''Matcher will match exactly the list of files in .files() --
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	467 optimization might be possible.'''
32492 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	468 return False
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	469
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	470 def prefix(self):
33379 7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	471 '''Matcher will match the paths in .files() recursively --
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	472 optimization might be possible.'''
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	473 return False
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	474
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	475 def anypats(self):
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	476 '''None of .always(), .isexact(), and .prefix() is true --
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	477 optimizations will be difficult.'''
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	478 return not self.always() and not self.isexact() and not self.prefix()
32492 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32482 diff changeset	479
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	480
32586 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	481 class alwaysmatcher(basematcher):
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	482 '''Matches everything.'''
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	483
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	484 def __init__(self, badfn=None):
ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	485 super(alwaysmatcher, self).__init__(badfn)
32586 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	486
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	487 def always(self):
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	488 return True
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	489
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	490 def matchfn(self, f):
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	491 return True
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	492
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	493 def visitdir(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	494 return b'all'
32586 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	495
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	496 def visitchildrenset(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	497 return b'all'
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	498
32586 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	499 def __repr__(self):
36088 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	500 return r'<alwaysmatcher>'
32586 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32585 diff changeset	501
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	502
32631 e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32590 diff changeset	503 class nevermatcher(basematcher):
e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32590 diff changeset	504 '''Matches nothing.'''
e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32590 diff changeset	505
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	506 def __init__(self, badfn=None):
ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	507 super(nevermatcher, self).__init__(badfn)
32631 e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32590 diff changeset	508
33378 adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	509 # It's a little weird to say that the nevermatcher is an exact matcher
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	510 # or a prefix matcher, but it seems to make sense to let callers take
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	511 # fast paths based on either. There will be no exact matches, nor any
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	512 # prefixes (files() returns []), so fast paths iterating over them should
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	513 # be efficient (and correct).
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	514 def isexact(self):
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	515 return True
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	516
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	517 def prefix(self):
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	518 return True
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	519
33582 44bc181b9835 match: override visitdir() in nevermatcher to return False Martin von Zweigbergk <martinvonz@google.com> parents: 33497 diff changeset	520 def visitdir(self, dir):
44bc181b9835 match: override visitdir() in nevermatcher to return False Martin von Zweigbergk <martinvonz@google.com> parents: 33497 diff changeset	521 return False
44bc181b9835 match: override visitdir() in nevermatcher to return False Martin von Zweigbergk <martinvonz@google.com> parents: 33497 diff changeset	522
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	523 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	524 return set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	525
32631 e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32590 diff changeset	526 def __repr__(self):
36088 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	527 return r'<nevermatcher>'
32631 e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32590 diff changeset	528
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	529
38578 76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38479 diff changeset	530 class predicatematcher(basematcher):
76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38479 diff changeset	531 """A matcher adapter for a simple boolean function"""
76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38479 diff changeset	532
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	533 def __init__(self, predfn, predrepr=None, badfn=None):
ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	534 super(predicatematcher, self).__init__(badfn)
38578 76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38479 diff changeset	535 self.matchfn = predfn
76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38479 diff changeset	536 self._predrepr = predrepr
76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38479 diff changeset	537
76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38479 diff changeset	538 @encoding.strmethod
76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38479 diff changeset	539 def __repr__(self):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	540 s = stringutil.buildrepr(self._predrepr) or pycompat.byterepr(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	541 self.matchfn
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	542 )
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	543 return b'<predicatenmatcher pred=%s>' % s
38578 76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38479 diff changeset	544
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	545
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42351 diff changeset	546 def normalizerootdir(dir, funcname):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	547 if dir == b'.':
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	548 util.nouideprecwarn(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	549 b"match.%s() no longer accepts " b"'.', use '' instead." % funcname,
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	550 b'5.1',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	551 )
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	552 return b''
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42351 diff changeset	553 return dir
27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42351 diff changeset	554
27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42351 diff changeset	555
32534 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32533 diff changeset	556 class patternmatcher(basematcher):
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	557 """Matches a set of (kind, pat, source) against a 'root' directory.
bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	558
bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	559 >>> kindpats = [
42224 fd384911f51b match: use raw strings to avoid illegal baskslash escape Gregory Szorc <gregory.szorc@gmail.com> parents: 42099 diff changeset	560 ... (b're', br'.*\.c$', b''),
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	561 ... (b'path', b'foo/a', b''),
5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	562 ... (b'relpath', b'b', b''),
5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	563 ... (b'glob', b'*.h', b''),
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	564 ... ]
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	565 >>> m = patternmatcher(b'foo', kindpats)
5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	566 >>> m(b'main.c') # matches re:.*\.c$
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	567 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	568 >>> m(b'b.txt')
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	569 False
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	570 >>> m(b'foo/a') # matches path:foo/a
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	571 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	572 >>> m(b'a') # does not match path:b, since 'root' is 'foo'
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	573 False
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	574 >>> m(b'b') # matches relpath:b, since 'root' is 'foo'
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	575 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	576 >>> m(b'lib.h') # matches glob:*.h
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	577 True
bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	578
bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	579 >>> m.files()
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42351 diff changeset	580 ['', 'foo/a', 'b', '']
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	581 >>> m.exact(b'foo/a')
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	582 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	583 >>> m.exact(b'b')
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	584 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	585 >>> m.exact(b'lib.h') # exact matches are for (rel)path kinds
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	586 False
bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	587 """
32433 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32365 diff changeset	588
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	589 def __init__(self, root, kindpats, badfn=None):
ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	590 super(patternmatcher, self).__init__(badfn)
8581 101d305c1d0b match: fold _matcher into match.__init__ Matt Mackall <mpm@selenic.com> parents: 8580 diff changeset	591
32590 3fdcc34c0aba match: remove special-casing of always-matching patterns in patternmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32589 diff changeset	592 self._files = _explicitfiles(kindpats)
33405 6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	593 self._prefix = _prefix(kindpats)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	594 self._pats, self.matchfn = _buildmatch(kindpats, b'$', root)
8587 8f15d54437b9 match: fold match into _match base class Matt Mackall <mpm@selenic.com> parents: 8586 diff changeset	595
32362 23c9a2a71c6e match: make _fileroots a @propertycache and rename it to _fileset Martin von Zweigbergk <martinvonz@google.com> parents: 32352 diff changeset	596 @propertycache
24636 36872036169b treemanifest: further optimize treemanifest.matches() Drew Gottlieb <drgott@google.com> parents: 24452 diff changeset	597 def _dirs(self):
42368 38d85ec06552 match: drop unnecessary adding of '' to set of dirs Martin von Zweigbergk <martinvonz@google.com> parents: 42365 diff changeset	598 return set(util.dirs(self._fileset))
24636 36872036169b treemanifest: further optimize treemanifest.matches() Drew Gottlieb <drgott@google.com> parents: 24452 diff changeset	599
36872036169b treemanifest: further optimize treemanifest.matches() Drew Gottlieb <drgott@google.com> parents: 24452 diff changeset	600 def visitdir(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	601 dir = normalizerootdir(dir, b'visitdir')
33405 6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	602 if self._prefix and dir in self._fileset:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	603 return b'all'
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	604 return (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	605 dir in self._fileset
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	606 or dir in self._dirs
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	607 or any(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	608 parentdir in self._fileset for parentdir in util.finddirs(dir)
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	609 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	610 )
24636 36872036169b treemanifest: further optimize treemanifest.matches() Drew Gottlieb <drgott@google.com> parents: 24452 diff changeset	611
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	612 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	613 ret = self.visitdir(dir)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	614 if ret is True:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	615 return b'this'
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	616 elif not ret:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	617 return set()
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	618 assert ret == b'all'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	619 return b'all'
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	620
33379 7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	621 def prefix(self):
33405 6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	622 return self._prefix
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	623
36088 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	624 @encoding.strmethod
32444 952017471f93 match: implement __repr__() and update users (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32439 diff changeset	625 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	626 return b'<patternmatcher patterns=%r>' % pycompat.bytestr(self._pats)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	627
32534 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32533 diff changeset	628
39477 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	629 # This is basically a reimplementation of util.dirs that stores the children
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	630 # instead of just a count of them, plus a small optional optimization to avoid
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	631 # some directories we don't need.
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	632 class _dirchildren(object):
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	633 def __init__(self, paths, onlyinclude=None):
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	634 self._dirs = {}
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	635 self._onlyinclude = onlyinclude or []
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	636 addpath = self.addpath
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	637 for f in paths:
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	638 addpath(f)
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	639
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	640 def addpath(self, path):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	641 if path == b'':
39477 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	642 return
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	643 dirs = self._dirs
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	644 findsplitdirs = _dirchildren._findsplitdirs
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	645 for d, b in findsplitdirs(path):
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	646 if d not in self._onlyinclude:
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	647 continue
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	648 dirs.setdefault(d, set()).add(b)
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	649
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	650 @staticmethod
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	651 def _findsplitdirs(path):
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	652 # yields (dirname, basename) tuples, walking back to the root. This is
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	653 # very similar to util.finddirs, except:
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	654 # - produces a (dirname, basename) tuple, not just 'dirname'
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	655 # Unlike manifest._splittopdir, this does not suffix `dirname` with a
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42351 diff changeset	656 # slash.
39477 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	657 oldpos = len(path)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	658 pos = path.rfind(b'/')
39477 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	659 while pos != -1:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	660 yield path[:pos], path[pos + 1 : oldpos]
39477 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	661 oldpos = pos
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	662 pos = path.rfind(b'/', 0, pos)
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	663 yield b'', path[:oldpos]
39477 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	664
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	665 def get(self, path):
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	666 return self._dirs.get(path, set())
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	667
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	668
32534 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32533 diff changeset	669 class includematcher(basematcher):
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	670 def __init__(self, root, kindpats, badfn=None):
ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	671 super(includematcher, self).__init__(badfn)
32534 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32533 diff changeset	672
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	673 self._pats, self.matchfn = _buildmatch(kindpats, b'(?:/\|$)', root)
33405 6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	674 self._prefix = _prefix(kindpats)
38992 5a7df82de142 includematcher: separate "parents" from "dirs" spectral <spectral@google.com> parents: 38750 diff changeset	675 roots, dirs, parents = _rootsdirsandparents(kindpats)
32535 3026f19b4b01 match: remove support for non-include patterns from includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32534 diff changeset	676 # roots are directories which are recursively included.
32536 361808a2b0b8 match: simplify includematcher a bit Martin von Zweigbergk <martinvonz@google.com> parents: 32535 diff changeset	677 self._roots = set(roots)
32535 3026f19b4b01 match: remove support for non-include patterns from includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32534 diff changeset	678 # dirs are directories which are non-recursively included.
32536 361808a2b0b8 match: simplify includematcher a bit Martin von Zweigbergk <martinvonz@google.com> parents: 32535 diff changeset	679 self._dirs = set(dirs)
38992 5a7df82de142 includematcher: separate "parents" from "dirs" spectral <spectral@google.com> parents: 38750 diff changeset	680 # parents are directories which are non-recursively included because
5a7df82de142 includematcher: separate "parents" from "dirs" spectral <spectral@google.com> parents: 38750 diff changeset	681 # they are needed to get to items in _dirs or _roots.
42383 c4b8f8637d7a match: de-flake test-doctest.py by not depending on util.dirs() order Martin von Zweigbergk <martinvonz@google.com> parents: 42368 diff changeset	682 self._parents = parents
32534 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32533 diff changeset	683
7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32533 diff changeset	684 def visitdir(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	685 dir = normalizerootdir(dir, b'visitdir')
33405 6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	686 if self._prefix and dir in self._roots:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	687 return b'all'
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	688 return (
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	689 dir in self._roots
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	690 or dir in self._dirs
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	691 or dir in self._parents
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	692 or any(parentdir in self._roots for parentdir in util.finddirs(dir))
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	693 )
32534 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32533 diff changeset	694
39477 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	695 @propertycache
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	696 def _allparentschildren(self):
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	697 # It may seem odd that we add dirs, roots, and parents, and then
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	698 # restrict to only parents. This is to catch the case of:
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	699 # dirs = ['foo/bar']
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	700 # parents = ['foo']
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	701 # if we asked for the children of 'foo', but had only added
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	702 # self._parents, we wouldn't be able to respond ['bar'].
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	703 return _dirchildren(
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	704 itertools.chain(self._dirs, self._roots, self._parents),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	705 onlyinclude=self._parents,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	706 )
39477 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	707
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	708 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	709 if self._prefix and dir in self._roots:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	710 return b'all'
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	711 # Note: this does not include the 'dir in self._parents' case from
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	712 # visitdir, that's handled below.
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	713 if (
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	714 b'' in self._roots
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	715 or dir in self._roots
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	716 or dir in self._dirs
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	717 or any(parentdir in self._roots for parentdir in util.finddirs(dir))
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	718 ):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	719 return b'this'
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	720
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	721 if dir in self._parents:
39477 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	722 return self._allparentschildren.get(dir) or set()
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	723 return set()
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	724
36088 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	725 @encoding.strmethod
32534 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32533 diff changeset	726 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	727 return b'<includematcher includes=%r>' % pycompat.bytestr(self._pats)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	728
32444 952017471f93 match: implement __repr__() and update users (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32439 diff changeset	729
32532 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	730 class exactmatcher(basematcher):
42080 f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41687 diff changeset	731 r'''Matches the input files exactly. They are interpreted as paths, not
32532 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	732 patterns (so no kind-prefixes).
42080 f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41687 diff changeset	733
42224 fd384911f51b match: use raw strings to avoid illegal baskslash escape Gregory Szorc <gregory.szorc@gmail.com> parents: 42099 diff changeset	734 >>> m = exactmatcher([b'a.txt', br're:.*\.c$'])
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	735 >>> m(b'a.txt')
42080 f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41687 diff changeset	736 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	737 >>> m(b'b.txt')
42080 f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41687 diff changeset	738 False
f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41687 diff changeset	739
f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41687 diff changeset	740 Input files that would be matched are exactly those returned by .files()
f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41687 diff changeset	741 >>> m.files()
f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41687 diff changeset	742 ['a.txt', 're:.*\\.c$']
f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41687 diff changeset	743
f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41687 diff changeset	744 So pattern 're:.*\.c$' is not considered as a regex, but as a file name
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	745 >>> m(b'main.c')
42080 f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41687 diff changeset	746 False
42224 fd384911f51b match: use raw strings to avoid illegal baskslash escape Gregory Szorc <gregory.szorc@gmail.com> parents: 42099 diff changeset	747 >>> m(br're:.*\.c$')
42080 f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41687 diff changeset	748 True
32532 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	749 '''
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	750
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	751 def __init__(self, files, badfn=None):
ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	752 super(exactmatcher, self).__init__(badfn)
32532 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	753
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	754 if isinstance(files, list):
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	755 self._files = files
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	756 else:
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	757 self._files = list(files)
32576 cf7c88986e9f match: define exactmatcher.matchfn statically Yuya Nishihara <yuya@tcha.org> parents: 32575 diff changeset	758
cf7c88986e9f match: define exactmatcher.matchfn statically Yuya Nishihara <yuya@tcha.org> parents: 32575 diff changeset	759 matchfn = basematcher.exact
32532 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	760
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	761 @propertycache
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	762 def _dirs(self):
42368 38d85ec06552 match: drop unnecessary adding of '' to set of dirs Martin von Zweigbergk <martinvonz@google.com> parents: 42365 diff changeset	763 return set(util.dirs(self._fileset))
32532 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	764
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	765 def visitdir(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	766 dir = normalizerootdir(dir, b'visitdir')
32532 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	767 return dir in self._dirs
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	768
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	769 def visitchildrenset(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	770 dir = normalizerootdir(dir, b'visitchildrenset')
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42351 diff changeset	771
39289 c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39288 diff changeset	772 if not self._fileset or dir not in self._dirs:
c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39288 diff changeset	773 return set()
c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39288 diff changeset	774
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	775 candidates = self._fileset \| self._dirs - {b''}
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	776 if dir != b'':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	777 d = dir + b'/'
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	778 candidates = set(c[len(d) :] for c in candidates if c.startswith(d))
39289 c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39288 diff changeset	779 # self._dirs includes all of the directories, recursively, so if
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42351 diff changeset	780 # we're attempting to match foo/bar/baz.txt, it'll have '', 'foo',
39289 c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39288 diff changeset	781 # 'foo/bar' in it. Thus we can safely ignore a candidate that has a
c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39288 diff changeset	782 # '/' in it, indicating a it's for a subdir-of-a-subdir; the
c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39288 diff changeset	783 # immediate subdir will be in there without a slash.
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	784 ret = {c for c in candidates if b'/' not in c}
39289 c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39288 diff changeset	785 # We really do not expect ret to be empty, since that would imply that
c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39288 diff changeset	786 # there's something in _dirs that didn't have a file in _fileset.
c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39288 diff changeset	787 assert ret
c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39288 diff changeset	788 return ret
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	789
32532 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	790 def isexact(self):
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	791 return True
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	792
36088 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	793 @encoding.strmethod
32532 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	794 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	795 return b'<exactmatcher files=%r>' % self._files
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	796
32532 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32530 diff changeset	797
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	798 class differencematcher(basematcher):
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	799 '''Composes two matchers by matching if the first matches and the second
35659 821d8a5ab4ff match: do not weirdly include explicit files excluded by -X option Yuya Nishihara <yuya@tcha.org> parents: 35185 diff changeset	800 does not.
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	801
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	802 The second matcher's non-matching-attributes (bad, explicitdir,
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	803 traversedir) are ignored.
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	804 '''
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	805
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	806 def __init__(self, m1, m2):
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	807 super(differencematcher, self).__init__()
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	808 self._m1 = m1
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	809 self._m2 = m2
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	810 self.bad = m1.bad
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	811 self.explicitdir = m1.explicitdir
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	812 self.traversedir = m1.traversedir
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	813
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	814 def matchfn(self, f):
35659 821d8a5ab4ff match: do not weirdly include explicit files excluded by -X option Yuya Nishihara <yuya@tcha.org> parents: 35185 diff changeset	815 return self._m1(f) and not self._m2(f)
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	816
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	817 @propertycache
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	818 def _files(self):
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	819 if self.isexact():
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	820 return [f for f in self._m1.files() if self(f)]
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	821 # If m1 is not an exact matcher, we can't easily figure out the set of
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	822 # files, because its files() are not always files. For example, if
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	823 # m1 is "path:dir" and m2 is "rootfileins:.", we don't
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	824 # want to remove "dir" from the set even though it would match m2,
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	825 # because the "dir" in m1 may not be a file.
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	826 return self._m1.files()
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	827
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	828 def visitdir(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	829 if self._m2.visitdir(dir) == b'all':
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	830 return False
41542 b7a0efb3c370 match: teach diffmatcher.visitdir() to return 'all' if possible Pulkit Goyal <pulkit@yandex-team.ru> parents: 41282 diff changeset	831 elif not self._m2.visitdir(dir):
b7a0efb3c370 match: teach diffmatcher.visitdir() to return 'all' if possible Pulkit Goyal <pulkit@yandex-team.ru> parents: 41282 diff changeset	832 # m2 does not match dir, we can return 'all' here if possible
b7a0efb3c370 match: teach diffmatcher.visitdir() to return 'all' if possible Pulkit Goyal <pulkit@yandex-team.ru> parents: 41282 diff changeset	833 return self._m1.visitdir(dir)
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	834 return bool(self._m1.visitdir(dir))
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	835
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	836 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	837 m2_set = self._m2.visitchildrenset(dir)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	838 if m2_set == b'all':
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	839 return set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	840 m1_set = self._m1.visitchildrenset(dir)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	841 # Possible values for m1: 'all', 'this', set(...), set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	842 # Possible values for m2: 'this', set(...), set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	843 # If m2 has nothing under here that we care about, return m1, even if
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	844 # it's 'all'. This is a change in behavior from visitdir, which would
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	845 # return True, not 'all', for some reason.
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	846 if not m2_set:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	847 return m1_set
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	848 if m1_set in [b'all', b'this']:
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	849 # Never return 'all' here if m2_set is any kind of non-empty (either
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	850 # 'this' or set(foo)), since m2 might return set() for a
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	851 # subdirectory.
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	852 return b'this'
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	853 # Possible values for m1: set(...), set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	854 # Possible values for m2: 'this', set(...)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	855 # We ignore m2's set results. They're possibly incorrect:
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42351 diff changeset	856 # m1 = path:dir/subdir, m2=rootfilesin:dir, visitchildrenset(''):
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	857 # m1 returns {'dir'}, m2 returns {'dir'}, if we subtracted we'd
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	858 # return set(), which is not correct, we still need to visit 'dir'!
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	859 return m1_set
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	860
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	861 def isexact(self):
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	862 return self._m1.isexact()
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	863
36088 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	864 @encoding.strmethod
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	865 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	866 return b'<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	867
32499 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32498 diff changeset	868
32530 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	869 def intersectmatchers(m1, m2):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	870 '''Composes two matchers by matching if both of them match.
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	871
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	872 The second matcher's non-matching-attributes (bad, explicitdir,
32530 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	873 traversedir) are ignored.
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	874 '''
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	875 if m1 is None or m2 is None:
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	876 return m1 or m2
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	877 if m1.always():
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	878 m = copy.copy(m2)
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	879 # TODO: Consider encapsulating these things in a class so there's only
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	880 # one thing to copy from m1.
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	881 m.bad = m1.bad
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	882 m.explicitdir = m1.explicitdir
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	883 m.traversedir = m1.traversedir
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	884 return m
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	885 if m2.always():
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	886 m = copy.copy(m1)
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	887 return m
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	888 return intersectionmatcher(m1, m2)
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	889
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	890
32530 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	891 class intersectionmatcher(basematcher):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	892 def __init__(self, m1, m2):
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	893 super(intersectionmatcher, self).__init__()
32530 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	894 self._m1 = m1
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	895 self._m2 = m2
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	896 self.bad = m1.bad
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	897 self.explicitdir = m1.explicitdir
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	898 self.traversedir = m1.traversedir
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	899
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	900 @propertycache
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	901 def _files(self):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	902 if self.isexact():
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	903 m1, m2 = self._m1, self._m2
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	904 if not m1.isexact():
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	905 m1, m2 = m2, m1
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	906 return [f for f in m1.files() if m2(f)]
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	907 # It neither m1 nor m2 is an exact matcher, we can't easily intersect
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	908 # the set of files, because their files() are not always files. For
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	909 # example, if intersecting a matcher "-I glob:foo.txt" with matcher of
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	910 # "path:dir2", we don't want to remove "dir2" from the set.
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	911 return self._m1.files() + self._m2.files()
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	912
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	913 def matchfn(self, f):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	914 return self._m1(f) and self._m2(f)
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	915
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	916 def visitdir(self, dir):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	917 visit1 = self._m1.visitdir(dir)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	918 if visit1 == b'all':
32530 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	919 return self._m2.visitdir(dir)
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	920 # bool() because visit1=True + visit2='all' should not be 'all'
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	921 return bool(visit1 and self._m2.visitdir(dir))
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	922
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	923 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	924 m1_set = self._m1.visitchildrenset(dir)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	925 if not m1_set:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	926 return set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	927 m2_set = self._m2.visitchildrenset(dir)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	928 if not m2_set:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	929 return set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	930
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	931 if m1_set == b'all':
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	932 return m2_set
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	933 elif m2_set == b'all':
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	934 return m1_set
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	935
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	936 if m1_set == b'this' or m2_set == b'this':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	937 return b'this'
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	938
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	939 assert isinstance(m1_set, set) and isinstance(m2_set, set)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	940 return m1_set.intersection(m2_set)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	941
32530 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	942 def always(self):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	943 return self._m1.always() and self._m2.always()
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	944
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	945 def isexact(self):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	946 return self._m1.isexact() or self._m2.isexact()
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	947
36088 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	948 @encoding.strmethod
32530 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	949 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	950 return b'<intersectionmatcher m1=%r, m2=%r>' % (self._m1, self._m2)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	951
32530 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32529 diff changeset	952
32494 f9445b528687 match: make subdirmatcher extend basematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32493 diff changeset	953 class subdirmatcher(basematcher):
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	954 """Adapt a matcher to work on a subdirectory only.
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	955
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	956 The paths are remapped to remove/insert the path as needed:
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	957
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	958 >>> from . import pycompat
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	959 >>> m1 = match(b'root', b'', [b'a.txt', b'sub/b.txt'])
0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	960 >>> m2 = subdirmatcher(b'sub', m1)
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	961 >>> m2(b'a.txt')
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	962 False
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	963 >>> m2(b'b.txt')
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	964 True
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	965 >>> m2.matchfn(b'a.txt')
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	966 False
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	967 >>> m2.matchfn(b'b.txt')
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	968 True
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	969 >>> m2.files()
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	970 ['b.txt']
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	971 >>> m2.exact(b'b.txt')
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	972 True
12268 83aaeba32b88 narrowmatcher: propagate bad method Martin Geisler <mg@lazybytes.net> parents: 12267 diff changeset	973 >>> def bad(f, msg):
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	974 ... print(pycompat.sysstr(b"%s: %s" % (f, msg)))
12268 83aaeba32b88 narrowmatcher: propagate bad method Martin Geisler <mg@lazybytes.net> parents: 12267 diff changeset	975 >>> m1.bad = bad
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	976 >>> m2.bad(b'x.txt', b'No such file')
12268 83aaeba32b88 narrowmatcher: propagate bad method Martin Geisler <mg@lazybytes.net> parents: 12267 diff changeset	977 sub/x.txt: No such file
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	978 """
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	979
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	980 def __init__(self, path, matcher):
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	981 super(subdirmatcher, self).__init__()
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	982 self._path = path
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	983 self._matcher = matcher
32494 f9445b528687 match: make subdirmatcher extend basematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32493 diff changeset	984 self._always = matcher.always()
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	985
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	986 self._files = [
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	987 f[len(path) + 1 :]
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	988 for f in matcher._files
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	989 if f.startswith(path + b"/")
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	990 ]
25194 ef4538ba67ef match: explicitly naming a subrepo implies always() for the submatcher Matt Harbison <matt_harbison@yahoo.com> parents: 24790 diff changeset	991
32365 763d72925691 match: use match.prefix() in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32364 diff changeset	992 # If the parent repo had a path to this subrepo and the matcher is
763d72925691 match: use match.prefix() in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32364 diff changeset	993 # a prefix matcher, this submatcher always matches.
763d72925691 match: use match.prefix() in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32364 diff changeset	994 if matcher.prefix():
25195 472a685a4961 merge with stable Matt Mackall <mpm@selenic.com> parents: 25189 25194 diff changeset	995 self._always = any(f == path for f in matcher._files)
25194 ef4538ba67ef match: explicitly naming a subrepo implies always() for the submatcher Matt Harbison <matt_harbison@yahoo.com> parents: 24790 diff changeset	996
32364 77dac8fd30ee match: avoid accessing match._pathrestricted from subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32363 diff changeset	997 def bad(self, f, msg):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	998 self._matcher.bad(self._path + b"/" + f, msg)
32364 77dac8fd30ee match: avoid accessing match._pathrestricted from subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32363 diff changeset	999
32498 2e80a691e575 match: override matchfn() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	1000 def matchfn(self, f):
2e80a691e575 match: override matchfn() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	1001 # Some information is lost in the superclass's constructor, so we
2e80a691e575 match: override matchfn() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	1002 # can not accurately create the matching function for the subdirectory
2e80a691e575 match: override matchfn() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	1003 # from the inputs. Instead, we override matchfn() and visitdir() to
2e80a691e575 match: override matchfn() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	1004 # call the original matcher with the subdirectory path prepended.
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1005 return self._matcher.matchfn(self._path + b"/" + f)
32498 2e80a691e575 match: override matchfn() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	1006
32363 0aa4032a97e1 match: override visitdir() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32362 diff changeset	1007 def visitdir(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1008 dir = normalizerootdir(dir, b'visitdir')
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1009 if dir == b'':
32363 0aa4032a97e1 match: override visitdir() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32362 diff changeset	1010 dir = self._path
0aa4032a97e1 match: override visitdir() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32362 diff changeset	1011 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1012 dir = self._path + b"/" + dir
32363 0aa4032a97e1 match: override visitdir() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32362 diff changeset	1013 return self._matcher.visitdir(dir)
0aa4032a97e1 match: override visitdir() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32362 diff changeset	1014
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1015 def visitchildrenset(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1016 dir = normalizerootdir(dir, b'visitchildrenset')
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1017 if dir == b'':
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1018 dir = self._path
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1019 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1020 dir = self._path + b"/" + dir
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1021 return self._matcher.visitchildrenset(dir)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1022
32494 f9445b528687 match: make subdirmatcher extend basematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32493 diff changeset	1023 def always(self):
f9445b528687 match: make subdirmatcher extend basematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32493 diff changeset	1024 return self._always
f9445b528687 match: make subdirmatcher extend basematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32493 diff changeset	1025
33379 7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	1026 def prefix(self):
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	1027 return self._matcher.prefix() and not self._always
32494 f9445b528687 match: make subdirmatcher extend basematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32493 diff changeset	1028
36088 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	1029 @encoding.strmethod
32585 e7aa11f3abcd match: add __repr__ for subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32576 diff changeset	1030 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1031 return b'<subdirmatcher path=%r, matcher=%r>' % (
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1032 self._path,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1033 self._matcher,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1034 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1035
32585 e7aa11f3abcd match: add __repr__ for subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32576 diff changeset	1036
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1037 class prefixdirmatcher(basematcher):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1038 """Adapt a matcher to work on a parent directory.
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1039
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	1040 The matcher's non-matching-attributes (bad, explicitdir, traversedir) are
ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	1041 ignored.
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1042
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1043 The prefix path should usually be the relative path from the root of
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1044 this matcher to the root of the wrapped matcher.
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1045
38750 a8bfaf592033 doctest: convert matcher root to native path Yuya Nishihara <yuya@tcha.org> parents: 38613 diff changeset	1046 >>> m1 = match(util.localpath(b'root/d/e'), b'f', [b'../a.txt', b'b.txt'])
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	1047 >>> m2 = prefixdirmatcher(b'd/e', m1)
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	1048 >>> m2(b'a.txt')
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1049 False
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	1050 >>> m2(b'd/e/a.txt')
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1051 True
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	1052 >>> m2(b'd/e/b.txt')
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1053 False
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1054 >>> m2.files()
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1055 ['d/e/a.txt', 'd/e/f/b.txt']
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1056 >>> m2.exact(b'd/e/a.txt')
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1057 True
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1058 >>> m2.visitdir(b'd')
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1059 True
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1060 >>> m2.visitdir(b'd/e')
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1061 True
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1062 >>> m2.visitdir(b'd/e/f')
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1063 True
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1064 >>> m2.visitdir(b'd/e/g')
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1065 False
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1066 >>> m2.visitdir(b'd/ef')
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1067 False
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1068 """
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1069
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	1070 def __init__(self, path, matcher, badfn=None):
ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	1071 super(prefixdirmatcher, self).__init__(badfn)
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1072 if not path:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1073 raise error.ProgrammingError(b'prefix path must not be empty')
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1074 self._path = path
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1075 self._pathprefix = path + b'/'
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1076 self._matcher = matcher
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1077
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1078 @propertycache
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1079 def _files(self):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1080 return [self._pathprefix + f for f in self._matcher._files]
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1081
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1082 def matchfn(self, f):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1083 if not f.startswith(self._pathprefix):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1084 return False
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1085 return self._matcher.matchfn(f[len(self._pathprefix) :])
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1086
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1087 @propertycache
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1088 def _pathdirs(self):
42368 38d85ec06552 match: drop unnecessary adding of '' to set of dirs Martin von Zweigbergk <martinvonz@google.com> parents: 42365 diff changeset	1089 return set(util.finddirs(self._path))
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1090
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1091 def visitdir(self, dir):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1092 if dir == self._path:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1093 return self._matcher.visitdir(b'')
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1094 if dir.startswith(self._pathprefix):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1095 return self._matcher.visitdir(dir[len(self._pathprefix) :])
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1096 return dir in self._pathdirs
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1097
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1098 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1099 if dir == self._path:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1100 return self._matcher.visitchildrenset(b'')
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1101 if dir.startswith(self._pathprefix):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1102 return self._matcher.visitchildrenset(dir[len(self._pathprefix) :])
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1103 if dir in self._pathdirs:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1104 return b'this'
38996 b9f94d67ea73 match: add missing "return set()", add FIXME to test to doc a bug Kyle Lippincott <spectral@google.com> parents: 38995 diff changeset	1105 return set()
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1106
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1107 def isexact(self):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1108 return self._matcher.isexact()
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1109
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1110 def prefix(self):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1111 return self._matcher.prefix()
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1112
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1113 @encoding.strmethod
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1114 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1115 return b'<prefixdirmatcher path=%r, matcher=%r>' % (
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1116 pycompat.bytestr(self._path),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1117 self._matcher,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1118 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1119
38612 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38582 diff changeset	1120
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1121 class unionmatcher(basematcher):
33448 04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1122 """A matcher that is the union of several matchers.
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1123
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	1124 The non-matching-attributes (bad, explicitdir, traversedir) are taken from
ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	1125 the first matcher.
33448 04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1126 """
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1127
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1128 def __init__(self, matchers):
33448 04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1129 m1 = matchers[0]
41686 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41683 diff changeset	1130 super(unionmatcher, self).__init__()
33448 04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1131 self.explicitdir = m1.explicitdir
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1132 self.traversedir = m1.traversedir
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1133 self._matchers = matchers
3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1134
33380 892d255ec2a1 match: override matchfn instead of __call__ for consistency Martin von Zweigbergk <martinvonz@google.com> parents: 33379 diff changeset	1135 def matchfn(self, f):
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1136 for match in self._matchers:
33380 892d255ec2a1 match: override matchfn instead of __call__ for consistency Martin von Zweigbergk <martinvonz@google.com> parents: 33379 diff changeset	1137 if match(f):
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1138 return True
3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1139 return False
3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1140
33448 04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1141 def visitdir(self, dir):
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1142 r = False
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1143 for m in self._matchers:
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1144 v = m.visitdir(dir)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1145 if v == b'all':
33448 04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1146 return v
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1147 r \|= v
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1148 return r
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1149
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1150 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1151 r = set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1152 this = False
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1153 for m in self._matchers:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1154 v = m.visitchildrenset(dir)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1155 if not v:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1156 continue
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1157 if v == b'all':
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1158 return v
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1159 if this or v == b'this':
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1160 this = True
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1161 # don't break, we might have an 'all' in here.
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1162 continue
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1163 assert isinstance(v, set)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1164 r = r.union(v)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1165 if this:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1166 return b'this'
38993 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1167 return r
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38992 diff changeset	1168
36088 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	1169 @encoding.strmethod
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1170 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1171 return b'<unionmatcher matchers=%r>' % self._matchers
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1172
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1173
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1174 def patkind(pattern, default=None):
42082 413a75da98ce match: add doctest examples for patkind() Denis Laxalde <denis@laxalde.org> parents: 42081 diff changeset	1175 '''If pattern is 'kind:pat' with a known kind, return kind.
413a75da98ce match: add doctest examples for patkind() Denis Laxalde <denis@laxalde.org> parents: 42081 diff changeset	1176
42224 fd384911f51b match: use raw strings to avoid illegal baskslash escape Gregory Szorc <gregory.szorc@gmail.com> parents: 42099 diff changeset	1177 >>> patkind(br're:.*\.c$')
42082 413a75da98ce match: add doctest examples for patkind() Denis Laxalde <denis@laxalde.org> parents: 42081 diff changeset	1178 're'
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	1179 >>> patkind(b'glob:*.c')
42082 413a75da98ce match: add doctest examples for patkind() Denis Laxalde <denis@laxalde.org> parents: 42081 diff changeset	1180 'glob'
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	1181 >>> patkind(b'relpath:test.py')
42082 413a75da98ce match: add doctest examples for patkind() Denis Laxalde <denis@laxalde.org> parents: 42081 diff changeset	1182 'relpath'
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	1183 >>> patkind(b'main.py')
5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	1184 >>> patkind(b'main.py', default=b're')
42082 413a75da98ce match: add doctest examples for patkind() Denis Laxalde <denis@laxalde.org> parents: 42081 diff changeset	1185 're'
413a75da98ce match: add doctest examples for patkind() Denis Laxalde <denis@laxalde.org> parents: 42081 diff changeset	1186 '''
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1187 return _patsplit(pattern, default)[0]
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1188
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1189
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1190 def _patsplit(pattern, default):
9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1191 """Split a string into the optional pattern kind prefix and the actual
9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1192 pattern."""
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1193 if b':' in pattern:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1194 kind, pat = pattern.split(b':', 1)
33710 2be0bf186950 match: expose some data and functionality to other modules Kostia Balytskyi <ikostia@fb.com> parents: 33582 diff changeset	1195 if kind in allpatternkinds:
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1196 return kind, pat
9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1197 return default, pattern
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1198
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1199
8582 a4c199e12b5a match: remove head and tail args from _globre Matt Mackall <mpm@selenic.com> parents: 8581 diff changeset	1200 def _globre(pat):
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1201 r'''Convert an extended glob string to a regexp string.
03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1202
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	1203 >>> from . import pycompat
a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	1204 >>> def bprint(s):
a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	1205 ... print(pycompat.sysstr(s))
a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	1206 >>> bprint(_globre(br'?'))
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1207 .
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	1208 >>> bprint(_globre(br'*'))
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1209 [^/]*
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	1210 >>> bprint(_globre(br'**'))
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1211 .*
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	1212 >>> bprint(_globre(br'**/a'))
21815 a4b67bf1f0a5 match: make glob '*/' match the empty string Siddharth Agarwal <sid0@fb.com>* parents: 21191 diff changeset	1213 (?:.*/)?a
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	1214 >>> bprint(_globre(br'a/**/b'))
38479 67dc32d4e790 cleanup: migrate from re.escape to stringutil.reescape Augie Fackler <augie@google.com> parents: 38061 diff changeset	1215 a/(?:.*/)?b
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	1216 >>> bprint(_globre(br'[a*?!^][^b][!c]'))
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1217 [a*?!^][\^b][^c]
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	1218 >>> bprint(_globre(br'{a,b}'))
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1219 (?:a\|b)
34152 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34146 diff changeset	1220 >>> bprint(_globre(br'.\*\?'))
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1221 \.\*\?
03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1222 '''
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1223 i, n = 0, len(pat)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1224 res = b''
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1225 group = 0
40723 e6c9ef5e11a0 match: provide and use a quick way to escape a single byte Boris Feld <boris.feld@octobus.net> parents: 40345 diff changeset	1226 escape = util.stringutil.regexbytesescapemap.get
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1227
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10263 diff changeset	1228 def peek():
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1229 return i < n and pat[i : i + 1]
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1230
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1231 while i < n:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1232 c = pat[i : i + 1]
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10263 diff changeset	1233 i += 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1234 if c not in b'*?[{},\\':
40723 e6c9ef5e11a0 match: provide and use a quick way to escape a single byte Boris Feld <boris.feld@octobus.net> parents: 40345 diff changeset	1235 res += escape(c, c)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1236 elif c == b'*':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1237 if peek() == b'*':
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1238 i += 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1239 if peek() == b'/':
21815 a4b67bf1f0a5 match: make glob '*/' match the empty string Siddharth Agarwal <sid0@fb.com>* parents: 21191 diff changeset	1240 i += 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1241 res += b'(?:.*/)?'
21815 a4b67bf1f0a5 match: make glob '*/' match the empty string Siddharth Agarwal <sid0@fb.com>* parents: 21191 diff changeset	1242 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1243 res += b'.*'
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1244 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1245 res += b'[^/]*'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1246 elif c == b'?':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1247 res += b'.'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1248 elif c == b'[':
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1249 j = i
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1250 if j < n and pat[j : j + 1] in b'!]':
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1251 j += 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1252 while j < n and pat[j : j + 1] != b']':
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1253 j += 1
7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1254 if j >= n:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1255 res += b'\\['
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1256 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1257 stuff = pat[i:j].replace(b'\\', b'\\\\')
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1258 i = j + 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1259 if stuff[0:1] == b'!':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1260 stuff = b'^' + stuff[1:]
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1261 elif stuff[0:1] == b'^':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1262 stuff = b'\\' + stuff
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1263 res = b'%s[%s]' % (res, stuff)
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1264 elif c == b'{':
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1265 group += 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1266 res += b'(?:'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1267 elif c == b'}' and group:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1268 res += b')'
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1269 group -= 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1270 elif c == b',' and group:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1271 res += b'\|'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1272 elif c == b'\\':
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1273 p = peek()
7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1274 if p:
7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1275 i += 1
40723 e6c9ef5e11a0 match: provide and use a quick way to escape a single byte Boris Feld <boris.feld@octobus.net> parents: 40345 diff changeset	1276 res += escape(p, p)
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1277 else:
40723 e6c9ef5e11a0 match: provide and use a quick way to escape a single byte Boris Feld <boris.feld@octobus.net> parents: 40345 diff changeset	1278 res += escape(c, c)
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1279 else:
40723 e6c9ef5e11a0 match: provide and use a quick way to escape a single byte Boris Feld <boris.feld@octobus.net> parents: 40345 diff changeset	1280 res += escape(c, c)
8582 a4c199e12b5a match: remove head and tail args from _globre Matt Mackall <mpm@selenic.com> parents: 8581 diff changeset	1281 return res
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1282
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1283
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1284 def _regex(kind, pat, globsuffix):
42351 c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1285 '''Convert a (normalized) pattern of any kind into a
c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1286 regular expression.
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1287 globsuffix is appended to the regexp of globs.'''
42351 c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1288
42468 a3a8887e4426 rust: using policy.importrust from Python callers Georges Racinet <georges.racinet@octobus.net> parents: 42389 diff changeset	1289 if rustmod is not None:
42351 c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1290 try:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1291 return rustmod.build_single_regex(kind, pat, globsuffix)
42468 a3a8887e4426 rust: using policy.importrust from Python callers Georges Racinet <georges.racinet@octobus.net> parents: 42389 diff changeset	1292 except rustmod.PatternError:
42351 c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1293 raise error.ProgrammingError(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1294 b'not a regex pattern: %s:%s' % (kind, pat)
42351 c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1295 )
c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1296
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1297 if not pat and kind in (b'glob', b'relpath'):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1298 return b''
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1299 if kind == b're':
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1300 return pat
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1301 if kind in (b'path', b'relpath'):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1302 if pat == b'.':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1303 return b''
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1304 return util.stringutil.reescape(pat) + b'(?:/\|$)'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1305 if kind == b'rootfilesin':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1306 if pat == b'.':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1307 escaped = b''
31032 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1308 else:
88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1309 # Pattern is a directory name.
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1310 escaped = util.stringutil.reescape(pat) + b'/'
31032 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1311 # Anything after the pattern must be a non-directory.
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1312 return escaped + b'[^/]+$'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1313 if kind == b'relglob':
42870 72890d8f9860 match: simplify the regexps created for glob patterns Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42782 diff changeset	1314 globre = _globre(pat)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1315 if globre.startswith(b'[^/]*'):
42870 72890d8f9860 match: simplify the regexps created for glob patterns Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42782 diff changeset	1316 # When pat has the form *XYZ (common), make the returned regex more
72890d8f9860 match: simplify the regexps created for glob patterns Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42782 diff changeset	1317 # legible by returning the regex for XYZ instead of /*XYZ.
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1318 return b'.' + globre[len(b'[^/]') :] + globsuffix
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1319 return b'(?:\|.*/)' + globre + globsuffix
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1320 if kind == b'relre':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1321 if pat.startswith(b'^'):
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1322 return pat
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1323 return b'.*' + pat
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1324 if kind in (b'glob', b'rootglob'):
38579 2d487b9cac07 match: explode if unsupported pattern passed down to _regex() builder Yuya Nishihara <yuya@tcha.org> parents: 38578 diff changeset	1325 return _globre(pat) + globsuffix
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1326 raise error.ProgrammingError(b'not a regex pattern: %s:%s' % (kind, pat))
8574 63a7ed2128d5 match: unnest functions in _matcher Matt Mackall <mpm@selenic.com> parents: 8573 diff changeset	1327
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1328
41680 a13268524c25 match: delete unused argument "listsubrepos" from _buildmatch() Martin von Zweigbergk <martinvonz@google.com> parents: 41679 diff changeset	1329 def _buildmatch(kindpats, globsuffix, root):
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1330 '''Return regexp string and a matcher function for kindpats.
9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1331 globsuffix is appended to the regexp of globs.'''
25239 714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1332 matchfuncs = []
714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1333
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	1334 subincludes, kindpats = _expandsubinclude(kindpats, root)
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	1335 if subincludes:
32185 6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31442 diff changeset	1336 submatchers = {}
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1337
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	1338 def matchsubinclude(f):
32185 6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31442 diff changeset	1339 for prefix, matcherargs in subincludes:
6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31442 diff changeset	1340 if f.startswith(prefix):
6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31442 diff changeset	1341 mf = submatchers.get(prefix)
6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31442 diff changeset	1342 if mf is None:
6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31442 diff changeset	1343 mf = match(*matcherargs)
6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31442 diff changeset	1344 submatchers[prefix] = mf
6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31442 diff changeset	1345
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1346 if mf(f[len(prefix) :]):
32185 6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31442 diff changeset	1347 return True
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	1348 return False
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1349
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	1350 matchfuncs.append(matchsubinclude)
14675 cfc89398f710 match: introduce basic fileset support Matt Mackall <mpm@selenic.com> parents: 14674 diff changeset	1351
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1352 regex = b''
25239 714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1353 if kindpats:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1354 if all(k == b'rootfilesin' for k, p, s in kindpats):
40242 19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39477 diff changeset	1355 dirs = {p for k, p, s in kindpats}
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1356
40242 19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39477 diff changeset	1357 def mf(f):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1358 i = f.rfind(b'/')
40242 19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39477 diff changeset	1359 if i >= 0:
19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39477 diff changeset	1360 dir = f[:i]
19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39477 diff changeset	1361 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1362 dir = b'.'
40242 19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39477 diff changeset	1363 return dir in dirs
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1364
40345 d30a19d10441 match: fix up a repr to not crash on Python 3 Augie Fackler <augie@google.com> parents: 40242 diff changeset	1365 regex = b'rootfilesin: %s' % stringutil.pprint(list(sorted(dirs)))
40242 19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39477 diff changeset	1366 matchfuncs.append(mf)
19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39477 diff changeset	1367 else:
19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39477 diff changeset	1368 regex, mf = _buildregexmatch(kindpats, globsuffix)
19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39477 diff changeset	1369 matchfuncs.append(mf)
25239 714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1370
714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1371 if len(matchfuncs) == 1:
714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1372 return regex, matchfuncs[0]
714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1373 else:
714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1374 return regex, lambda f: any(mf(f) for mf in matchfuncs)
14675 cfc89398f710 match: introduce basic fileset support Matt Mackall <mpm@selenic.com> parents: 14674 diff changeset	1375
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1376
40808 8306dac48061 match: extract a literal constant into a symbolic one Boris Feld <boris.feld@octobus.net> parents: 40791 diff changeset	1377 MAX_RE_SIZE = 20000
8306dac48061 match: extract a literal constant into a symbolic one Boris Feld <boris.feld@octobus.net> parents: 40791 diff changeset	1378
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1379
40810 ce401300f981 match: extract function that group regexps Boris Feld <boris.feld@octobus.net> parents: 40809 diff changeset	1380 def _joinregexes(regexps):
ce401300f981 match: extract function that group regexps Boris Feld <boris.feld@octobus.net> parents: 40809 diff changeset	1381 """gather multiple regular expressions into a single one"""
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1382 return b'\|'.join(regexps)
40810 ce401300f981 match: extract function that group regexps Boris Feld <boris.feld@octobus.net> parents: 40809 diff changeset	1383
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1384
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1385 def _buildregexmatch(kindpats, globsuffix):
9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1386 """Build a match function from a list of kinds and kindpats,
40809 4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40808 diff changeset	1387 return regexp string and a matcher function.
4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40808 diff changeset	1388
4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40808 diff changeset	1389 Test too large input
4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40808 diff changeset	1390 >>> _buildregexmatch([
40960 9e462fb88f79 match: fix doctest to use bytes instead of str Augie Fackler <augie@google.com> parents: 40816 diff changeset	1391 ... (b'relglob', b'?' * MAX_RE_SIZE, b'')
9e462fb88f79 match: fix doctest to use bytes instead of str Augie Fackler <augie@google.com> parents: 40816 diff changeset	1392 ... ], b'$')
40809 4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40808 diff changeset	1393 Traceback (most recent call last):
4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40808 diff changeset	1394 ...
40812 69bd3176da7c match: raise an Abort error instead of OverflowError Boris Feld <boris.feld@octobus.net> parents: 40811 diff changeset	1395 Abort: matcher pattern is too long (20009 bytes)
40809 4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40808 diff changeset	1396 """
8574 63a7ed2128d5 match: unnest functions in _matcher Matt Mackall <mpm@selenic.com> parents: 8573 diff changeset	1397 try:
40811 3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1398 allgroups = []
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1399 regexps = [_regex(k, p, globsuffix) for (k, p, s) in kindpats]
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1400 fullregexp = _joinregexes(regexps)
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1401
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1402 startidx = 0
40816 3984409e144b match: drop unnecessary wrapping of regex in group Martin von Zweigbergk <martinvonz@google.com> parents: 40815 diff changeset	1403 groupsize = 0
40811 3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1404 for idx, r in enumerate(regexps):
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1405 piecesize = len(r)
40816 3984409e144b match: drop unnecessary wrapping of regex in group Martin von Zweigbergk <martinvonz@google.com> parents: 40815 diff changeset	1406 if piecesize > MAX_RE_SIZE:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1407 msg = _(b"matcher pattern is too long (%d bytes)") % piecesize
40812 69bd3176da7c match: raise an Abort error instead of OverflowError Boris Feld <boris.feld@octobus.net> parents: 40811 diff changeset	1408 raise error.Abort(msg)
40814 1e019f45fa88 match: make "groupsize" include the trailing "\|" Martin von Zweigbergk <martinvonz@google.com> parents: 40813 diff changeset	1409 elif (groupsize + piecesize) > MAX_RE_SIZE:
40811 3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1410 group = regexps[startidx:idx]
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1411 allgroups.append(_joinregexes(group))
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1412 startidx = idx
40816 3984409e144b match: drop unnecessary wrapping of regex in group Martin von Zweigbergk <martinvonz@google.com> parents: 40815 diff changeset	1413 groupsize = 0
40811 3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1414 groupsize += piecesize + 1
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1415
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1416 if startidx == 0:
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	1417 matcher = _rematcher(fullregexp)
42099 bccb322f1496 match: fix re2 compability broken in 2e2699af5649 Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42098 diff changeset	1418 func = lambda s: bool(matcher(s))
40811 3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1419 else:
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1420 group = regexps[startidx:]
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1421 allgroups.append(_joinregexes(group))
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1422 allmatchers = [_rematcher(g) for g in allgroups]
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1423 func = lambda s: any(m(s) for m in allmatchers)
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40810 diff changeset	1424 return fullregexp, func
8574 63a7ed2128d5 match: unnest functions in _matcher Matt Mackall <mpm@selenic.com> parents: 8573 diff changeset	1425 except re.error:
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	1426 for k, p, s in kindpats:
8574 63a7ed2128d5 match: unnest functions in _matcher Matt Mackall <mpm@selenic.com> parents: 8573 diff changeset	1427 try:
40816 3984409e144b match: drop unnecessary wrapping of regex in group Martin von Zweigbergk <martinvonz@google.com> parents: 40815 diff changeset	1428 _rematcher(_regex(k, p, globsuffix))
8574 63a7ed2128d5 match: unnest functions in _matcher Matt Mackall <mpm@selenic.com> parents: 8573 diff changeset	1429 except re.error:
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	1430 if s:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1431 raise error.Abort(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1432 _(b"%s: invalid pattern (%s): %s") % (s, k, p)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1433 )
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	1434 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1435 raise error.Abort(_(b"invalid pattern (%s): %s") % (k, p))
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1436 raise error.Abort(_(b"invalid pattern"))
8574 63a7ed2128d5 match: unnest functions in _matcher Matt Mackall <mpm@selenic.com> parents: 8573 diff changeset	1437
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1438
31033 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1439 def _patternrootsanddirs(kindpats):
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1440 '''Returns roots and directories corresponding to each pattern.
21079 b02ab6486a78 match: make it more clear what _roots do and that it ends up in match()._files Mads Kiilerich <madski@unity3d.com> parents: 20401 diff changeset	1441
31033 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1442 This calculates the roots and directories exactly matching the patterns and
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1443 returns a tuple of (roots, dirs) for each. It does not return other
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1444 directories which may also need to be considered, like the parent
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1445 directories.
21079 b02ab6486a78 match: make it more clear what _roots do and that it ends up in match()._files Mads Kiilerich <madski@unity3d.com> parents: 20401 diff changeset	1446 '''
8576 ec4ed21db4b2 match: split up _normalizepats Matt Mackall <mpm@selenic.com> parents: 8575 diff changeset	1447 r = []
31033 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1448 d = []
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	1449 for kind, pat, source in kindpats:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1450 if kind in (b'glob', b'rootglob'): # find the non-glob prefix
8584 0f06e72abfdc match: fold _globprefix into _roots Matt Mackall <mpm@selenic.com> parents: 8583 diff changeset	1451 root = []
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1452 for p in pat.split(b'/'):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1453 if b'[' in p or b'{' in p or b'*' in p or b'?' in p:
8584 0f06e72abfdc match: fold _globprefix into _roots Matt Mackall <mpm@selenic.com> parents: 8583 diff changeset	1454 break
0f06e72abfdc match: fold _globprefix into _roots Matt Mackall <mpm@selenic.com> parents: 8583 diff changeset	1455 root.append(p)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1456 r.append(b'/'.join(root))
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1457 elif kind in (b'relpath', b'path'):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1458 if pat == b'.':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1459 pat = b''
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42351 diff changeset	1460 r.append(pat)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1461 elif kind in (b'rootfilesin',):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1462 if pat == b'.':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1463 pat = b''
42363 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42351 diff changeset	1464 d.append(pat)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1465 else: # relglob, re, relre
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1466 r.append(b'')
31033 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1467 return r, d
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1468
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1469
31033 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1470 def _roots(kindpats):
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1471 '''Returns root directories to match recursively from the given patterns.'''
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1472 roots, dirs = _patternrootsanddirs(kindpats)
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1473 return roots
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1474
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1475
38992 5a7df82de142 includematcher: separate "parents" from "dirs" spectral <spectral@google.com> parents: 38750 diff changeset	1476 def _rootsdirsandparents(kindpats):
31033 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1477 '''Returns roots and exact directories from patterns.
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1478
38995 f356be1a7ba3 match: correct doc for _rootsdirsandparents after 5a7df82de142 Kyle Lippincott <spectral@google.com> parents: 38993 diff changeset	1479 `roots` are directories to match recursively, `dirs` should
f356be1a7ba3 match: correct doc for _rootsdirsandparents after 5a7df82de142 Kyle Lippincott <spectral@google.com> parents: 38993 diff changeset	1480 be matched non-recursively, and `parents` are the implicitly required
f356be1a7ba3 match: correct doc for _rootsdirsandparents after 5a7df82de142 Kyle Lippincott <spectral@google.com> parents: 38993 diff changeset	1481 directories to walk to items in either roots or dirs.
f356be1a7ba3 match: correct doc for _rootsdirsandparents after 5a7df82de142 Kyle Lippincott <spectral@google.com> parents: 38993 diff changeset	1482
f356be1a7ba3 match: correct doc for _rootsdirsandparents after 5a7df82de142 Kyle Lippincott <spectral@google.com> parents: 38993 diff changeset	1483 Returns a tuple of (roots, dirs, parents).
31033 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1484
42389 96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42384 diff changeset	1485 >>> r = _rootsdirsandparents(
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	1486 ... [(b'glob', b'g/h/*', b''), (b'glob', b'g/h', b''),
0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	1487 ... (b'glob', b'g*', b'')])
42389 96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42384 diff changeset	1488 >>> print(r[0:2], sorted(r[2])) # the set has an unstable output
96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42384 diff changeset	1489 (['g/h', 'g/h', ''], []) ['', 'g']
96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42384 diff changeset	1490 >>> r = _rootsdirsandparents(
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	1491 ... [(b'rootfilesin', b'g/h', b''), (b'rootfilesin', b'', b'')])
42389 96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42384 diff changeset	1492 >>> print(r[0:2], sorted(r[2])) # the set has an unstable output
96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42384 diff changeset	1493 ([], ['g/h', '']) ['', 'g']
96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42384 diff changeset	1494 >>> r = _rootsdirsandparents(
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	1495 ... [(b'relpath', b'r', b''), (b'path', b'p/p', b''),
0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	1496 ... (b'path', b'', b'')])
42389 96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42384 diff changeset	1497 >>> print(r[0:2], sorted(r[2])) # the set has an unstable output
96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42384 diff changeset	1498 (['r', 'p/p', ''], []) ['', 'p']
96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42384 diff changeset	1499 >>> r = _rootsdirsandparents(
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	1500 ... [(b'relglob', b'rg*', b''), (b're', b're/', b''),
0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	1501 ... (b'relre', b'rr', b'')])
42389 96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42384 diff changeset	1502 >>> print(r[0:2], sorted(r[2])) # the set has an unstable output
96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42384 diff changeset	1503 (['', '', ''], []) ['']
31033 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1504 '''
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1505 r, d = _patternrootsanddirs(kindpats)
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1506
42383 c4b8f8637d7a match: de-flake test-doctest.py by not depending on util.dirs() order Martin von Zweigbergk <martinvonz@google.com> parents: 42368 diff changeset	1507 p = set()
c4b8f8637d7a match: de-flake test-doctest.py by not depending on util.dirs() order Martin von Zweigbergk <martinvonz@google.com> parents: 42368 diff changeset	1508 # Add the parents as non-recursive/exact directories, since they must be
31033 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1509 # scanned to get to either the roots or the other exact directories.
42383 c4b8f8637d7a match: de-flake test-doctest.py by not depending on util.dirs() order Martin von Zweigbergk <martinvonz@google.com> parents: 42368 diff changeset	1510 p.update(util.dirs(d))
c4b8f8637d7a match: de-flake test-doctest.py by not depending on util.dirs() order Martin von Zweigbergk <martinvonz@google.com> parents: 42368 diff changeset	1511 p.update(util.dirs(r))
31033 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31032 diff changeset	1512
39477 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	1513 # FIXME: all uses of this function convert these to sets, do so before
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	1514 # returning.
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	1515 # FIXME: all uses of this function do not need anything in 'roots' and
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39289 diff changeset	1516 # 'dirs' to also be in 'parents', consider removing them before returning.
38992 5a7df82de142 includematcher: separate "parents" from "dirs" spectral <spectral@google.com> parents: 38750 diff changeset	1517 return r, d, p
8576 ec4ed21db4b2 match: split up _normalizepats Matt Mackall <mpm@selenic.com> parents: 8575 diff changeset	1518
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1519
31032 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1520 def _explicitfiles(kindpats):
88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1521 '''Returns the potential explicit filenames from the patterns.
88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1522
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	1523 >>> _explicitfiles([(b'path', b'foo/bar', b'')])
31032 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1524 ['foo/bar']
34146 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33710 diff changeset	1525 >>> _explicitfiles([(b'rootfilesin', b'foo/bar', b'')])
31032 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1526 []
88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1527 '''
88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1528 # Keep only the pattern kinds where one can specify filenames (vs only
88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1529 # directory names).
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1530 filable = [kp for kp in kindpats if kp[0] not in (b'rootfilesin',)]
31032 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1531 return _roots(filable)
88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30409 diff changeset	1532
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1533
33405 6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	1534 def _prefix(kindpats):
6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	1535 '''Whether all the patterns match a prefix (i.e. recursively)'''
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	1536 for kind, pat, source in kindpats:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1537 if kind not in (b'path', b'relpath'):
33405 6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	1538 return False
6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	1539 return True
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1540
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1541
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1542 _commentre = None
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1543
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1544
27595 9e2d01707e71 match: add option to return line and lineno from readpattern Laurent Charignon <lcharignon@fb.com> parents: 27343 diff changeset	1545 def readpatternfile(filepath, warn, sourceinfo=False):
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1546 '''parse a pattern file, returning a list of
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1547 patterns. These patterns should be given to compile()
25216 dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1548 to be validated and converted into a match function.
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1549
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1550 trailing white space is dropped.
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1551 the escape character is backslash.
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1552 comments start with #.
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1553 empty lines are skipped.
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1554
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1555 lines can be of the following formats:
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1556
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1557 syntax: regexp # defaults following lines to non-rooted regexps
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1558 syntax: glob # defaults following lines to non-rooted globs
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1559 re:pattern # non-rooted regular expression
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1560 glob:pattern # non-rooted glob
41282 4fab8a7d2d72 match: support rooted globs in hgignore Valentin Gatien-Baron <vgatien-baron@janestreet.com> parents: 41130 diff changeset	1561 rootglob:pat # rooted glob (same root as ^ in regexps)
27595 9e2d01707e71 match: add option to return line and lineno from readpattern Laurent Charignon <lcharignon@fb.com> parents: 27343 diff changeset	1562 pattern # pattern of the current default type
9e2d01707e71 match: add option to return line and lineno from readpattern Laurent Charignon <lcharignon@fb.com> parents: 27343 diff changeset	1563
9e2d01707e71 match: add option to return line and lineno from readpattern Laurent Charignon <lcharignon@fb.com> parents: 27343 diff changeset	1564 if sourceinfo is set, returns a list of tuples:
42351 c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1565 (pattern, lineno, originalline).
c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1566 This is useful to debug ignore patterns.
27595 9e2d01707e71 match: add option to return line and lineno from readpattern Laurent Charignon <lcharignon@fb.com> parents: 27343 diff changeset	1567 '''
25216 dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1568
42468 a3a8887e4426 rust: using policy.importrust from Python callers Georges Racinet <georges.racinet@octobus.net> parents: 42389 diff changeset	1569 if rustmod is not None:
a3a8887e4426 rust: using policy.importrust from Python callers Georges Racinet <georges.racinet@octobus.net> parents: 42389 diff changeset	1570 result, warnings = rustmod.read_pattern_file(
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1571 filepath, bool(warn), sourceinfo,
42351 c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1572 )
c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1573
c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1574 for warning_params in warnings:
c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1575 # Can't be easily emitted from Rust, because it would require
c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1576 # a mechanism for both gettext and calling the `warn` function.
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1577 warn(_(b"%s: ignoring invalid syntax '%s'\n") % warning_params)
42351 c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1578
c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1579 return result
c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42230 diff changeset	1580
40724 e41f6c2e69c4 match: reformat `syntaxes` dictionary for better maintainability Boris Feld <boris.feld@octobus.net> parents: 40723 diff changeset	1581 syntaxes = {
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1582 b're': b'relre:',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1583 b'regexp': b'relre:',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1584 b'glob': b'relglob:',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1585 b'rootglob': b'rootglob:',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1586 b'include': b'include',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1587 b'subinclude': b'subinclude',
40724 e41f6c2e69c4 match: reformat `syntaxes` dictionary for better maintainability Boris Feld <boris.feld@octobus.net> parents: 40723 diff changeset	1588 }
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1589 syntax = b'relre:'
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1590 patterns = []
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1591
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1592 fp = open(filepath, b'rb')
30409 7f3593c29473 match: migrate to util.iterfile Jun Wu <quark@fb.com> parents: 29814 diff changeset	1593 for lineno, line in enumerate(util.iterfile(fp), start=1):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1594 if b"#" in line:
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1595 global _commentre
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1596 if not _commentre:
31429 40704098853f match: make regular expression bytes to prevent TypeError Pulkit Goyal <7895pulkit@gmail.com> parents: 31412 diff changeset	1597 _commentre = util.re.compile(br'((?:^\|[^\\])(?:\\\\))#.')
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1598 # remove comments prefixed by an even number of escapes
27327 d500341e4f55 match: use re2 in readpatternfile if possible Bryan O'Sullivan <bos@serpentine.com> parents: 26781 diff changeset	1599 m = _commentre.search(line)
d500341e4f55 match: use re2 in readpatternfile if possible Bryan O'Sullivan <bos@serpentine.com> parents: 26781 diff changeset	1600 if m:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1601 line = line[: m.end(1)]
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1602 # fixup properly escaped comments that survived the above
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1603 line = line.replace(b"\\#", b"#")
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1604 line = line.rstrip()
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1605 if not line:
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1606 continue
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1607
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1608 if line.startswith(b'syntax:'):
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1609 s = line[7:].strip()
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1610 try:
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1611 syntax = syntaxes[s]
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1612 except KeyError:
25214 08703b10c3ae match: add optional warn argument Durham Goode <durham@fb.com> parents: 25213 diff changeset	1613 if warn:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1614 warn(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1615 _(b"%s: ignoring invalid syntax '%s'\n") % (filepath, s)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1616 )
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1617 continue
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1618
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1619 linesyntax = syntax
43106 d783f945a701 py3: finish porting iteritems() to pycompat and remove source transformer Gregory Szorc <gregory.szorc@gmail.com> parents: 43085 diff changeset	1620 for s, rels in pycompat.iteritems(syntaxes):
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1621 if line.startswith(rels):
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1622 linesyntax = rels
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1623 line = line[len(rels) :]
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1624 break
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1625 elif line.startswith(s + b':'):
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1626 linesyntax = rels
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42870 diff changeset	1627 line = line[len(s) + 1 :]
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1628 break
27595 9e2d01707e71 match: add option to return line and lineno from readpattern Laurent Charignon <lcharignon@fb.com> parents: 27343 diff changeset	1629 if sourceinfo:
9e2d01707e71 match: add option to return line and lineno from readpattern Laurent Charignon <lcharignon@fb.com> parents: 27343 diff changeset	1630 patterns.append((linesyntax + line, lineno, line))
9e2d01707e71 match: add option to return line and lineno from readpattern Laurent Charignon <lcharignon@fb.com> parents: 27343 diff changeset	1631 else:
9e2d01707e71 match: add option to return line and lineno from readpattern Laurent Charignon <lcharignon@fb.com> parents: 27343 diff changeset	1632 patterns.append(linesyntax + line)
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1633 fp.close()
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1634 return patterns

Mercurial > public > mercurial-scm > hg-stable

annotate mercurial/match.py @ 43106:d783f945a701