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

annotate mercurial/match.py @ 52640:24ee91ba9aa8

pyupgrade: drop usage of py3 aliases for `OSError` These were different classes in py2, but now a handful of error classes are just an alias of `OSError`, like `IOError`, `EnvironmentError`, `WindowsError`, etc. This is the result of running a hacked version of `pyupgrade` 3.19.1[1] $ hg files -0 'relglob:**.py' | xargs -0 \ pyupgrade --py38-plus --keep-percent-format --keep-mock --keep-runtime-typing The hack is because it doesn't have command line switches to disable most changes, so it makes tons of unrelated changes all at once. The hack is to 1) patch `pyupgrade._main._fix_tokens()` to immediately return its content arg 2) change `pyupgrade._data.register_decorator()` to only register the function if it's from the fixer we're interested in: if func.__module__ in ( "pyupgrade._plugins.exceptions", ): FUNCS[tp].append(func) return func [1] https://github.com/asottile/pyupgrade

author	Matt Harbison <matt_harbison@yahoo.com>
date	Sun, 05 Jan 2025 21:03:17 -0500
parents	bbb43c5b753a
children	5cc8deb96b48

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 #
46819 d4ba4d51f85f contributor: change mentions of mpm to olivia Rapha?l Gom?s <rgomes@octobus.net> parents: 46064 diff changeset	3 # Copyright 2008, 2009 Olivia Mackall <olivia@selenic.com> and others
8231 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
51859 f4733654f144 typing: add `from __future__ import annotations` to most files Matt Harbison <matt_harbison@yahoo.com> parents: 51753 diff changeset	8 from __future__ import annotations
25958 c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	9
46872 8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	10 import bisect
25958 c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	11 import copy
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	12 import itertools
25958 c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	13 import os
c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	14 import re
51922 70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	15 import typing
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	16
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	17 from typing import (
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	18 Any,
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	19 Callable,
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	20 List,
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	21 Tuple,
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	22 Union,
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	23 overload,
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	24 )
25958 c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	25
c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	26 from .i18n import _
c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	27 from . import (
36050 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	28 encoding,
26587 56b2bcea2529 error: get Abort from 'error' instead of 'util' Pierre-Yves David <pierre-yves.david@fb.com> parents: 26014 diff changeset	29 error,
25958 c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	30 pathutil,
42452 a3a8887e4426 rust: using policy.importrust from Python callers Georges Racinet <georges.racinet@octobus.net> parents: 42367 diff changeset	31 policy,
36572 9adfa48792a7 match: some minimal pycompat fixes guided by test-hgignore.t Augie Fackler <augie@google.com> parents: 36050 diff changeset	32 pycompat,
25958 c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	33 util,
c4ccf2d394a7 match: use absolute_import Gregory Szorc <gregory.szorc@gmail.com> parents: 25875 diff changeset	34 )
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	35 from .utils import stringutil
6576 69f3e9ac7c56 walk: introduce match objects Matt Mackall <mpm@selenic.com> parents: diff changeset	36
44137 3bd77c64bc74 rust-filepatterns: remove bridge code for filepatterns-related functions Rapha?l Gom?s <rgomes@octobus.net> parents: 44009 diff changeset	37 rustmod = policy.importrust('dirstate')
42329 c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42195 diff changeset	38
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	39 allpatternkinds = (
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	40 b're',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	41 b'glob',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	42 b'path',
50692 1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	43 b'filepath',
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	44 b'relglob',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	45 b'relpath',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	46 b'relre',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	47 b'rootglob',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	48 b'listfile',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	49 b'listfile0',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	50 b'set',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	51 b'include',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	52 b'subinclude',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	53 b'rootfilesin',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	54 )
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	55 cwdrelativepatternkinds = (b'relpath', b'glob')
33684 2be0bf186950 match: expose some data and functionality to other modules Kostia Balytskyi <ikostia@fb.com> parents: 33582 diff changeset	56
24636 36872036169b treemanifest: further optimize treemanifest.matches() Drew Gottlieb <drgott@google.com> parents: 24452 diff changeset	57 propertycache = util.propertycache
36872036169b treemanifest: further optimize treemanifest.matches() Drew Gottlieb <drgott@google.com> parents: 24452 diff changeset	58
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	59
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	60 def _rematcher(regex):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	61 """compile the regexp with the best available regexp engine and return a
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	62 matcher function"""
21909 335bb8b80443 match: use util.re.compile instead of util.compilere Siddharth Agarwal <sid0@fb.com> parents: 21815 diff changeset	63 m = util.re.compile(regex)
16943 8d08a28aa63e matcher: use re2 bindings if available Bryan O'Sullivan <bryano@fb.com> parents: 16791 diff changeset	64 try:
8d08a28aa63e matcher: use re2 bindings if available Bryan O'Sullivan <bryano@fb.com> parents: 16791 diff changeset	65 # 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	66 return m.test_match
8d08a28aa63e matcher: use re2 bindings if available Bryan O'Sullivan <bryano@fb.com> parents: 16791 diff changeset	67 except AttributeError:
8d08a28aa63e matcher: use re2 bindings if available Bryan O'Sullivan <bryano@fb.com> parents: 16791 diff changeset	68 return m.match
8d08a28aa63e matcher: use re2 bindings if available Bryan O'Sullivan <bryano@fb.com> parents: 16791 diff changeset	69
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	70
44009 e685fac56693 match: resolve filesets against the passed `cwd`, not the current one Matt Harbison <matt_harbison@yahoo.com> parents: 44002 diff changeset	71 def _expandsets(cwd, kindpats, ctx=None, listsubrepos=False, badfn=None):
38612 760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38611 diff changeset	72 '''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: 38611 diff changeset	73 matchers = []
14675 cfc89398f710 match: introduce basic fileset support Matt Mackall <mpm@selenic.com> parents: 14674 diff changeset	74 other = []
cfc89398f710 match: introduce basic fileset support Matt Mackall <mpm@selenic.com> parents: 14674 diff changeset	75
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	76 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	77 if kind == b'set':
41022 481249481392 match: fix assertion for fileset with no context (issue6046) Yuya Nishihara <yuya@tcha.org> parents: 40345 diff changeset	78 if ctx is None:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	79 raise error.ProgrammingError(
43117 8ff1ecfadcd1 cleanup: join string literals that are already on one line Martin von Zweigbergk <martinvonz@google.com> parents: 43106 diff changeset	80 b"fileset expression with no context"
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	81 )
44009 e685fac56693 match: resolve filesets against the passed `cwd`, not the current one Matt Harbison <matt_harbison@yahoo.com> parents: 44002 diff changeset	82 matchers.append(ctx.matchfileset(cwd, 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	83
755d23a49170 match: resolve filesets in subrepos for commands given the '-S' argument Matt Harbison <matt_harbison@yahoo.com> parents: 25114 diff changeset	84 if listsubrepos:
755d23a49170 match: resolve filesets in subrepos for commands given the '-S' argument Matt Harbison <matt_harbison@yahoo.com> parents: 25114 diff changeset	85 for subpath in ctx.substate:
44009 e685fac56693 match: resolve filesets against the passed `cwd`, not the current one Matt Harbison <matt_harbison@yahoo.com> parents: 44002 diff changeset	86 sm = ctx.sub(subpath).matchfileset(cwd, pat, badfn=badfn)
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	87 pm = prefixdirmatcher(subpath, sm, badfn=badfn)
38612 760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38611 diff changeset	88 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	89
14675 cfc89398f710 match: introduce basic fileset support Matt Mackall <mpm@selenic.com> parents: 14674 diff changeset	90 continue
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	91 other.append((kind, pat, source))
38612 760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38611 diff changeset	92 return matchers, other
14675 cfc89398f710 match: introduce basic fileset support Matt Mackall <mpm@selenic.com> parents: 14674 diff changeset	93
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	94
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	95 def _expandsubinclude(kindpats, root):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	96 """Returns the list of subinclude matcher args and the kindpats without the
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	97 subincludes in it."""
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	98 relmatchers = []
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	99 other = []
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	100
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	101 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	102 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	103 sourceroot = pathutil.dirname(util.normpath(source))
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	104 pat = util.pconvert(pat)
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	105 path = pathutil.join(sourceroot, pat)
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	106
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	107 newroot = pathutil.dirname(path)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	108 matcherargs = (newroot, b'', [], [b'include:%s' % path])
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	109
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	110 prefix = pathutil.canonpath(root, root, newroot)
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	111 if prefix:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	112 prefix += b'/'
32132 6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31433 diff changeset	113 relmatchers.append((prefix, matcherargs))
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	114 else:
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	115 other.append((kind, pat, source))
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	116
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	117 return relmatchers, other
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	118
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	119
24447 d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 23686 diff changeset	120 def _kindpatsalwaysmatch(kindpats):
45946 464539c305aa formatting: drop a few extra double quotes in docstrings Matt Harbison <matt_harbison@yahoo.com> parents: 45942 diff changeset	121 """Checks whether the kindspats match everything, as e.g.
24447 d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 23686 diff changeset	122 'relpath:.' does.
d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 23686 diff changeset	123 """
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	124 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	125 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	126 return False
d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 23686 diff changeset	127 return True
d44d53bc9a1e matcher: make e.g. 'relpath:.' lead to fast paths Martin von Zweigbergk <martinvonz@google.com> parents: 23686 diff changeset	128
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	129
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	130 def _buildkindpatsmatcher(
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	131 matchercls,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	132 root,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	133 cwd,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	134 kindpats,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	135 ctx=None,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	136 listsubrepos=False,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	137 badfn=None,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	138 ):
38580 9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38579 diff changeset	139 matchers = []
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	140 fms, kindpats = _expandsets(
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	141 cwd,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	142 kindpats,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	143 ctx=ctx,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	144 listsubrepos=listsubrepos,
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	145 badfn=badfn,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	146 )
38580 9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38579 diff changeset	147 if kindpats:
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	148 m = matchercls(root, kindpats, badfn=badfn)
38580 9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38579 diff changeset	149 matchers.append(m)
38612 760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38611 diff changeset	150 if fms:
760cc5dc01e8 fileset: restrict getfileset() to not return a computed set (API) Yuya Nishihara <yuya@tcha.org> parents: 38611 diff changeset	151 matchers.extend(fms)
38580 9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38579 diff changeset	152 if not matchers:
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	153 return nevermatcher(badfn=badfn)
38580 9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38579 diff changeset	154 if len(matchers) == 1:
9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38579 diff changeset	155 return matchers[0]
9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38579 diff changeset	156 return unionmatcher(matchers)
9f9ffe5f687c match: compose 'set:' pattern as matcher Yuya Nishihara <yuya@tcha.org> parents: 38579 diff changeset	157
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	158
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	159 def match(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	160 root,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	161 cwd,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	162 patterns=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	163 include=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	164 exclude=None,
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	165 default=b'glob',
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	166 auditor=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	167 ctx=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	168 listsubrepos=False,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	169 warn=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	170 badfn=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	171 icasefs=False,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	172 ):
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	173 r"""build an object to match a set of file patterns
32395 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	174
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	175 arguments:
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	176 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: 32325 diff changeset	177 cwd - the current working directory, if relevant
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	178 patterns - patterns to find
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	179 include - patterns to include (unless they are excluded)
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	180 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: 32325 diff changeset	181 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	182 auditor - optional path auditor
bee1647578b7 match: complete documentation of match() parameters Denis Laxalde <denis@laxalde.org> parents: 42082 diff changeset	183 ctx - optional changecontext
bee1647578b7 match: complete documentation of match() parameters Denis Laxalde <denis@laxalde.org> parents: 42082 diff changeset	184 listsubrepos - if True, recurse into subrepositories
32395 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	185 warn - optional function used for printing warnings
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	186 badfn - optional bad() callback for this matcher instead of the default
32401 284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	187 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: 32400 diff changeset	188 normalizes the given patterns to the case in the filesystem
32395 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	189
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	190 a pattern is one of:
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	191 'glob:<glob>' - a glob relative to cwd
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	192 're:<regexp>' - a regular expression
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	193 '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: 32325 diff changeset	194 recursively
50692 1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	195 'filepath:<path>' - an exact path to a single file, relative to the
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	196 repository root
32395 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	197 '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: 32325 diff changeset	198 matched non-recursively (will not match subdirectories)
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	199 '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: 32325 diff changeset	200 'relpath:<path>' - a path relative to cwd
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	201 '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: 32325 diff changeset	202 'set:<fileset>' - a fileset expression
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	203 '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: 32325 diff changeset	204 '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: 32325 diff changeset	205 the same directory
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	206 '<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	207
43964 8f67735344ae tests: convert the `root` arg of matchmod.match() to local path separators Matt Harbison <matt_harbison@yahoo.com> parents: 43950 diff changeset	208 >>> def _match(root, args, *kwargs):
8f67735344ae tests: convert the `root` arg of matchmod.match() to local path separators Matt Harbison <matt_harbison@yahoo.com> parents: 43950 diff changeset	209 ... return match(util.localpath(root), args, *kwargs)
8f67735344ae tests: convert the `root` arg of matchmod.match() to local path separators Matt Harbison <matt_harbison@yahoo.com> parents: 43950 diff changeset	210
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	211 Usually a patternmatcher is returned:
50304 805d4a462abb py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences Mads Kiilerich <mads@kiilerich.com> parents: 49805 diff changeset	212 >>> _match(b'/foo', b'.', [br're:.\.c$', b'path:foo/a', b'.py'])
50337 47686726545d match: sort patterns before compiling them into a regex Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50304 diff changeset	213 <patternmatcher patterns='[^/]\\.py$\|foo/a(?:/\|$)\|.\\.c$'>
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 Combining 'patterns' with 'include' (resp. 'exclude') gives an
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	216 intersectionmatcher (resp. a differencematcher):
50304 805d4a462abb py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences Mads Kiilerich <mads@kiilerich.com> parents: 49805 diff changeset	217 >>> type(_match(b'/foo', b'.', [br're:.*\.c$'], include=[b'path:lib']))
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	218 <class 'mercurial.match.intersectionmatcher'>
50304 805d4a462abb py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences Mads Kiilerich <mads@kiilerich.com> parents: 49805 diff changeset	219 >>> type(_match(b'/foo', b'.', [br're:.*\.c$'], exclude=[b'path:build']))
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	220 <class 'mercurial.match.differencematcher'>
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	221
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	222 Notice that, if 'patterns' is empty, an alwaysmatcher is returned:
43964 8f67735344ae tests: convert the `root` arg of matchmod.match() to local path separators Matt Harbison <matt_harbison@yahoo.com> parents: 43950 diff changeset	223 >>> _match(b'/foo', b'.', [])
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	224 <alwaysmatcher>
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	225
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	226 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	227 pattern has no prefix:
50304 805d4a462abb py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences Mads Kiilerich <mads@kiilerich.com> parents: 49805 diff changeset	228 >>> _match(b'/foo', b'.', [br'.*\.c$'], default=b're')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	229 <patternmatcher patterns='.*\\.c$'>
43964 8f67735344ae tests: convert the `root` arg of matchmod.match() to local path separators Matt Harbison <matt_harbison@yahoo.com> parents: 43950 diff changeset	230 >>> _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	231 <patternmatcher patterns='main\\.py(?:/\|$)'>
43964 8f67735344ae tests: convert the `root` arg of matchmod.match() to local path separators Matt Harbison <matt_harbison@yahoo.com> parents: 43950 diff changeset	232 >>> _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	233 <patternmatcher patterns='main.py'>
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	234
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	235 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	236 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	237 are two ways of doing this check.
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	238
50304 805d4a462abb py3: fix for Python 3.12 emitting SyntaxWarning on invalid escape sequences Mads Kiilerich <mads@kiilerich.com> parents: 49805 diff changeset	239 >>> m = _match(b'/foo', b'', [br're:.*\.c$', b'relpath:a'])
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	240
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	241 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	242 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	243 >>> m(b'a')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	244 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	245 >>> m(b'main.c')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	246 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	247 >>> m(b'test.py')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	248 False
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	249
42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	250 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	251 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	252 >>> m.exact(b'a')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	253 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	254 >>> m.exact(b'main.c')
42084 42537dfc7a7c match: add doctest examples in match() Denis Laxalde <denis@laxalde.org> parents: 42083 diff changeset	255 False
32395 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	256 """
43949 8b1a9ba375e5 match: make sure `root` argument is always an absolute path (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43735 diff changeset	257 assert os.path.isabs(root)
43965 8a81fa44f7bb match: don't util.normpath() cwd Matt Harbison <matt_harbison@yahoo.com> parents: 43964 diff changeset	258 cwd = os.path.join(root, util.localpath(cwd))
32401 284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	259 normalize = _donormalize
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	260 if icasefs:
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	261 dirstate = ctx.repo().dirstate
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	262 dsnormalize = dirstate.normalize
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	263
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	264 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: 32400 diff changeset	265 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: 32400 diff changeset	266 kindpats = []
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	267 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	268 if kind not in (b're', b'relre'): # regex can't be normalized
32401 284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	269 p = pats
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	270 pats = dsnormalize(pats)
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	271
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	272 # 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: 32400 diff changeset	273 if p != pats and p in dirstate:
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	274 kindpats.append((kind, p, source))
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	275
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	276 kindpats.append((kind, pats, source))
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	277 return kindpats
284b18303f61 match: replace icasefsmatch() function by flag to regular match() Martin von Zweigbergk <martinvonz@google.com> parents: 32400 diff changeset	278
41622 635a12c53ea6 match: remove unused "exact" argument (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41528 diff changeset	279 if patterns:
32556 5f08eca8f8d3 match: move normalize() call out of matcher constructors Martin von Zweigbergk <martinvonz@google.com> parents: 32555 diff changeset	280 kindpats = normalize(patterns, default, root, cwd, auditor, warn)
32557 3fdcc34c0aba match: remove special-casing of always-matching patterns in patternmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32556 diff changeset	281 if _kindpatsalwaysmatch(kindpats):
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	282 m = alwaysmatcher(badfn)
32557 3fdcc34c0aba match: remove special-casing of always-matching patterns in patternmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32556 diff changeset	283 else:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	284 m = _buildkindpatsmatcher(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	285 patternmatcher,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	286 root,
44009 e685fac56693 match: resolve filesets against the passed `cwd`, not the current one Matt Harbison <matt_harbison@yahoo.com> parents: 44002 diff changeset	287 cwd,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	288 kindpats,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	289 ctx=ctx,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	290 listsubrepos=listsubrepos,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	291 badfn=badfn,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	292 )
32553 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	293 else:
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	294 # It's a little strange that no patterns means to match everything.
32650 783394c0c978 match: simplify nevermatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32605 diff changeset	295 # Consider changing this to match nothing (probably using nevermatcher).
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	296 m = alwaysmatcher(badfn)
32553 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	297
32497 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	298 if include:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	299 kindpats = normalize(include, b'glob', root, cwd, auditor, warn)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	300 im = _buildkindpatsmatcher(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	301 includematcher,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	302 root,
44009 e685fac56693 match: resolve filesets against the passed `cwd`, not the current one Matt Harbison <matt_harbison@yahoo.com> parents: 44002 diff changeset	303 cwd,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	304 kindpats,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	305 ctx=ctx,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	306 listsubrepos=listsubrepos,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	307 badfn=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	308 )
32497 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	309 m = intersectmatchers(m, im)
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	310 if exclude:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	311 kindpats = normalize(exclude, b'glob', root, cwd, auditor, warn)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	312 em = _buildkindpatsmatcher(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	313 includematcher,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	314 root,
44009 e685fac56693 match: resolve filesets against the passed `cwd`, not the current one Matt Harbison <matt_harbison@yahoo.com> parents: 44002 diff changeset	315 cwd,
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	316 kindpats,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	317 ctx=ctx,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	318 listsubrepos=listsubrepos,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	319 badfn=None,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	320 )
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	321 m = differencematcher(m, em)
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	322 return m
32395 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	323
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	324
41676 0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41675 diff changeset	325 def exact(files, badfn=None):
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	326 return exactmatcher(files, badfn=badfn)
32395 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	327
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	328
41676 0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41675 diff changeset	329 def always(badfn=None):
0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41675 diff changeset	330 return alwaysmatcher(badfn)
32395 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	331
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	332
41676 0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41675 diff changeset	333 def never(badfn=None):
0531dff73d0b match: delete unused root and cwd arguments from {always,never,exact}() (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41675 diff changeset	334 return nevermatcher(badfn)
32605 e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32557 diff changeset	335
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	336
32395 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	337 def badmatch(match, badfn):
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	338 """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: 32325 diff changeset	339 one.
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	340 """
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	341 m = copy.copy(match)
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	342 m.bad = badfn
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	343 return m
24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	344
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	345
42085 54e6d7ef5ca5 match: make _donormalize's auditor and warn arguments optional Denis Laxalde <denis@laxalde.org> parents: 42084 diff changeset	346 def _donormalize(patterns, default, root, cwd, auditor=None, warn=None):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	347 """Convert 'kind:pat' from the patterns list to tuples with kind and
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	348 normalized and rooted patterns and with listfiles expanded."""
32397 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	349 kindpats = []
50692 1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	350 kinds_to_normalize = (
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	351 b'relglob',
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	352 b'path',
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	353 b'filepath',
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	354 b'rootfilesin',
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	355 b'rootglob',
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	356 )
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	357
32397 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	358 for kind, pat in [_patsplit(p, default) for p in patterns]:
33684 2be0bf186950 match: expose some data and functionality to other modules Kostia Balytskyi <ikostia@fb.com> parents: 33582 diff changeset	359 if kind in cwdrelativepatternkinds:
42085 54e6d7ef5ca5 match: make _donormalize's auditor and warn arguments optional Denis Laxalde <denis@laxalde.org> parents: 42084 diff changeset	360 pat = pathutil.canonpath(root, cwd, pat, auditor=auditor)
50692 1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	361 elif kind in kinds_to_normalize:
32397 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	362 pat = util.normpath(pat)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	363 elif kind in (b'listfile', b'listfile0'):
32397 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	364 try:
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	365 files = util.readfile(pat)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	366 if kind == b'listfile0':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	367 files = files.split(b'\0')
32397 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	368 else:
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	369 files = files.splitlines()
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	370 files = [f for f in files if f]
52640 24ee91ba9aa8 pyupgrade: drop usage of py3 aliases for `OSError` Matt Harbison <matt_harbison@yahoo.com> parents: 52578 diff changeset	371 except OSError:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	372 raise error.Abort(_(b"unable to read file list (%s)") % pat)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	373 for k, p, source in _donormalize(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	374 files, default, root, cwd, auditor, warn
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	375 ):
32397 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	376 kindpats.append((k, p, pat))
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	377 continue
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	378 elif kind == b'include':
32397 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	379 try:
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	380 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: 32396 diff changeset	381 includepats = readpatternfile(fullpath, warn)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	382 for k, p, source in _donormalize(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	383 includepats, default, root, cwd, auditor, warn
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	384 ):
32397 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	385 kindpats.append((k, p, source or pat))
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	386 except error.Abort as inst:
43485 6ff196d2553b match: suppress error about subscripting an exception Augie Fackler <augie@google.com> parents: 43117 diff changeset	387 raise error.Abort(
6ff196d2553b match: suppress error about subscripting an exception Augie Fackler <augie@google.com> parents: 43117 diff changeset	388 b'%s: %s'
45682 d2e1dcd4490d errors: name arguments to Abort constructor Martin von Zweigbergk <martinvonz@google.com> parents: 44530 diff changeset	389 % (
d2e1dcd4490d errors: name arguments to Abort constructor Martin von Zweigbergk <martinvonz@google.com> parents: 44530 diff changeset	390 pat,
d2e1dcd4490d errors: name arguments to Abort constructor Martin von Zweigbergk <martinvonz@google.com> parents: 44530 diff changeset	391 inst.message,
49805 a06a503e3cf8 typing: drop an unnecessary warning disabling comment in match.py Matt Harbison <matt_harbison@yahoo.com> parents: 49645 diff changeset	392 )
43485 6ff196d2553b match: suppress error about subscripting an exception Augie Fackler <augie@google.com> parents: 43117 diff changeset	393 )
52640 24ee91ba9aa8 pyupgrade: drop usage of py3 aliases for `OSError` Matt Harbison <matt_harbison@yahoo.com> parents: 52578 diff changeset	394 except OSError as inst:
32397 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	395 if warn:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	396 warn(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	397 _(b"skipping unreadable pattern file '%s': %s\n")
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	398 % (pat, stringutil.forcebytestr(inst.strerror))
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	399 )
32397 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	400 continue
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	401 # 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	402 kindpats.append((kind, pat, b''))
32397 0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	403 return kindpats
0ec4cd6fe051 match: move body of _normalize() to a static function Martin von Zweigbergk <martinvonz@google.com> parents: 32396 diff changeset	404
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	405
48946 642e31cb55f0 py3: use class X: instead of class X(object): Gregory Szorc <gregory.szorc@gmail.com> parents: 48941 diff changeset	406 class basematcher:
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	407 def __init__(self, badfn=None):
51598 ea3343104f07 largefiles: track if a matcher was tampered with Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51566 diff changeset	408 self._was_tampered_with = False
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	409 if badfn is not None:
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	410 self.bad = badfn
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	411
51671 bc94cbb49b30 typing: add some trivial type hints to `mercurial/match.py` Matt Harbison <matt_harbison@yahoo.com> parents: 51622 diff changeset	412 def was_tampered_with_nonrec(self) -> bool:
51598 ea3343104f07 largefiles: track if a matcher was tampered with Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51566 diff changeset	413 # [_was_tampered_with] is used to track if when extensions changed the matcher
ea3343104f07 largefiles: track if a matcher was tampered with Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51566 diff changeset	414 # behavior (crazy stuff!), so we disable the rust fast path.
ea3343104f07 largefiles: track if a matcher was tampered with Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51566 diff changeset	415 return self._was_tampered_with
ea3343104f07 largefiles: track if a matcher was tampered with Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51566 diff changeset	416
51671 bc94cbb49b30 typing: add some trivial type hints to `mercurial/match.py` Matt Harbison <matt_harbison@yahoo.com> parents: 51622 diff changeset	417 def was_tampered_with(self) -> bool:
51622 aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	418 return self.was_tampered_with_nonrec()
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	419
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	420 def __call__(self, fn):
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	421 return self.matchfn(fn)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	422
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	423 # 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: 32444 diff changeset	424 # Subscribers to these events must monkeypatch the matcher object.
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	425 def bad(self, f, msg):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	426 """Callback from dirstate.walk for each explicit file that can't be
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	427 found/accessed, with an error message."""
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	428
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	429 # 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: 32444 diff changeset	430 # by recursive traversal is visited.
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	431 traversedir = None
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	432
32459 9f781f43f2ce match: make basematcher._files a @propertycache Martin von Zweigbergk <martinvonz@google.com> parents: 32458 diff changeset	433 @propertycache
9f781f43f2ce match: make basematcher._files a @propertycache Martin von Zweigbergk <martinvonz@google.com> parents: 32458 diff changeset	434 def _files(self):
9f781f43f2ce match: make basematcher._files a @propertycache Martin von Zweigbergk <martinvonz@google.com> parents: 32458 diff changeset	435 return []
9f781f43f2ce match: make basematcher._files a @propertycache Martin von Zweigbergk <martinvonz@google.com> parents: 32458 diff changeset	436
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	437 def files(self):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	438 """Explicitly listed files or patterns or roots:
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	439 if no patterns or .always(): empty list,
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	440 if exact: list exact files,
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	441 if not .anypats(): list all files and dirs,
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	442 else: optimal roots"""
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	443 return self._files
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	444
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	445 @propertycache
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	446 def _fileset(self):
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	447 return set(self._files)
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	448
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	449 def exact(self, f):
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	450 '''Returns True if f is in .files().'''
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	451 return f in self._fileset
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	452
32463 43e091847c4d match: make matchfn a method on the class Martin von Zweigbergk <martinvonz@google.com> parents: 32461 diff changeset	453 def matchfn(self, f):
43e091847c4d match: make matchfn a method on the class Martin von Zweigbergk <martinvonz@google.com> parents: 32461 diff changeset	454 return False
43e091847c4d match: make matchfn a method on the class Martin von Zweigbergk <martinvonz@google.com> parents: 32461 diff changeset	455
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	456 def visitdir(self, dir):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	457 """Decides whether a directory should be visited based on whether it
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	458 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: 32444 diff changeset	459 based on the match's primary, included, and excluded patterns.
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	460
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	461 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: 32444 diff changeset	462 should be visited. Otherwise returns True or False indicating whether
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	463 the given directory should be visited.
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	464 """
33478 cf15c3cc304c match: make base matcher return True for visitdir Durham Goode <durham@fb.com> parents: 33448 diff changeset	465 return True
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	466
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	467 def visitchildrenset(self, dir):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	468 """Decides whether a directory should be visited based on whether it
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	469 has potential matches in it or one of its subdirectories, and
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	470 potentially lists which subdirectories of that directory should be
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	471 visited. This is based on the match's primary, included, and excluded
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	472 patterns.
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	473
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	474 This function is very similar to 'visitdir', and the following mapping
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	475 can be applied:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	476
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	477 visitdir \| visitchildrenlist
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	478 ----------+-------------------
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	479 False \| set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	480 'all' \| 'all'
39260 27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38958 diff changeset	481 True \| 'this' OR non-empty set of subdirs -or files- to visit
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	482
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	483 Example:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	484 Assume matchers ['path:foo/bar', 'rootfilesin:qux'], we would return
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	485 the following values (assuming the implementation of visitchildrenset
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	486 is capable of recognizing this; some implementations are not).
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	487
42341 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42329 diff changeset	488 '' -> {'foo', 'qux'}
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	489 'baz' -> set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	490 'foo' -> {'bar'}
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	491 # Ideally this would be 'all', but since the prefix nature of matchers
39260 27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38958 diff changeset	492 # 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: 38958 diff changeset	493 # '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: 38958 diff changeset	494 # in.
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	495 'foo/bar' -> 'this'
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	496 'qux' -> 'this'
39260 27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38958 diff changeset	497
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38958 diff changeset	498 Important:
27946fca8a05 match: document that visitchildrenset might return files Kyle Lippincott <spectral@google.com> parents: 38958 diff changeset	499 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: 38958 diff changeset	500 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: 38958 diff changeset	501 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: 38958 diff changeset	502 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: 38958 diff changeset	503 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: 38958 diff changeset	504 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: 38958 diff changeset	505 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: 38958 diff changeset	506 will always return 'this').
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	507 """
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	508 return b'this'
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	509
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	510 def always(self):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	511 """Matcher will match everything and .files() will be empty --
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	512 optimization might be possible."""
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	513 return False
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	514
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	515 def isexact(self):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	516 """Matcher will match exactly the list of files in .files() --
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	517 optimization might be possible."""
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	518 return False
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	519
a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	520 def prefix(self):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	521 """Matcher will match the paths in .files() recursively --
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	522 optimization might be possible."""
33379 7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	523 return False
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	524
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	525 def anypats(self):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	526 """None of .always(), .isexact(), and .prefix() is true --
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	527 optimizations will be difficult."""
33379 7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	528 return not self.always() and not self.isexact() and not self.prefix()
32458 a04bc55201c3 match: extract base class for matchers Martin von Zweigbergk <martinvonz@google.com> parents: 32444 diff changeset	529
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	530
32553 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	531 class alwaysmatcher(basematcher):
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	532 '''Matches everything.'''
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	533
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	534 def __init__(self, badfn=None):
ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	535 super(alwaysmatcher, self).__init__(badfn)
32553 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	536
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	537 def always(self):
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	538 return True
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	539
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	540 def matchfn(self, f):
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	541 return True
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	542
20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	543 def visitdir(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	544 return b'all'
32553 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	545
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	546 def visitchildrenset(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	547 return b'all'
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	548
32553 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	549 def __repr__(self):
36050 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	550 return r'<alwaysmatcher>'
32553 20c9f3ecc192 match: handle everything-matching using new alwaysmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32552 diff changeset	551
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	552
32605 e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32557 diff changeset	553 class nevermatcher(basematcher):
e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32557 diff changeset	554 '''Matches nothing.'''
e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32557 diff changeset	555
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	556 def __init__(self, badfn=None):
ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	557 super(nevermatcher, self).__init__(badfn)
32605 e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32557 diff changeset	558
33378 adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	559 # 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	560 # 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	561 # 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	562 # 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	563 # 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	564 def isexact(self):
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	565 return True
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	566
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	567 def prefix(self):
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	568 return True
adf95bfb423a match: make nevermatcher an exact matcher and a prefix matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33358 diff changeset	569
33582 44bc181b9835 match: override visitdir() in nevermatcher to return False Martin von Zweigbergk <martinvonz@google.com> parents: 33497 diff changeset	570 def visitdir(self, dir):
44bc181b9835 match: override visitdir() in nevermatcher to return False Martin von Zweigbergk <martinvonz@google.com> parents: 33497 diff changeset	571 return False
44bc181b9835 match: override visitdir() in nevermatcher to return False Martin von Zweigbergk <martinvonz@google.com> parents: 33497 diff changeset	572
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	573 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	574 return set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	575
32605 e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32557 diff changeset	576 def __repr__(self):
36050 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	577 return r'<nevermatcher>'
32605 e6ff007e107e match: introduce nevermatcher for when no ignore files are present Siddharth Agarwal <sid0@fb.com> parents: 32557 diff changeset	578
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	579
38577 76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38475 diff changeset	580 class predicatematcher(basematcher):
76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38475 diff changeset	581 """A matcher adapter for a simple boolean function"""
76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38475 diff changeset	582
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	583 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: 41672 diff changeset	584 super(predicatematcher, self).__init__(badfn)
38577 76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38475 diff changeset	585 self.matchfn = predfn
76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38475 diff changeset	586 self._predrepr = predrepr
76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38475 diff changeset	587
76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38475 diff changeset	588 @encoding.strmethod
76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38475 diff changeset	589 def __repr__(self):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	590 s = stringutil.buildrepr(self._predrepr) or pycompat.byterepr(
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	591 self.matchfn
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	592 )
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	593 return b'<predicatenmatcher pred=%s>' % s
38577 76838305b9dd match: add basic wrapper for boolean function Yuya Nishihara <yuya@tcha.org> parents: 38475 diff changeset	594
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	595
45999 c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	596 def path_or_parents_in_set(path, prefix_set):
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	597 """Returns True if `path` (or any parent of `path`) is in `prefix_set`."""
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	598 l = len(prefix_set)
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	599 if l == 0:
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	600 return False
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	601 if path in prefix_set:
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	602 return True
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	603 # If there's more than 5 paths in prefix_set, it's probably quicker to
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	604 # "walk up" the directory hierarchy instead, with the assumption that most
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	605 # directory hierarchies are relatively shallow and hash lookup is cheap.
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	606 if l > 5:
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	607 return any(
46064 1f0ed7e63c2a formatting: re-blacken match.py Matt Harbison <matt_harbison@yahoo.com> parents: 45999 diff changeset	608 parentdir in prefix_set for parentdir in pathutil.finddirs(path)
45999 c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	609 )
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	610
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	611 # FIXME: Ideally we'd never get to this point if this is the case - we'd
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	612 # recognize ourselves as an 'always' matcher and skip this.
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	613 if b'' in prefix_set:
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	614 return True
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	615
48884 7f5e91cdebcd match: delete Python 2 conditional code Gregory Szorc <gregory.szorc@gmail.com> parents: 48875 diff changeset	616 sl = ord(b'/')
45999 c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	617
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	618 # We already checked that path isn't in prefix_set exactly, so
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	619 # `path[len(pf)] should never raise IndexError.
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	620 return any(path.startswith(pf) and path[len(pf)] == sl for pf in prefix_set)
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	621
c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	622
32501 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32500 diff changeset	623 class patternmatcher(basematcher):
43721 bfbbf48d51e8 py3: make doc strings containing deprecated '\.' escape sequence raw strings Daniel Ploch <dploch@google.com> parents: 43117 diff changeset	624 r"""Matches a set of (kind, pat, source) against a 'root' directory.
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	625
bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	626 >>> kindpats = [
42186 fd384911f51b match: use raw strings to avoid illegal baskslash escape Gregory Szorc <gregory.szorc@gmail.com> parents: 42099 diff changeset	627 ... (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	628 ... (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	629 ... (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	630 ... (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	631 ... ]
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	632 >>> 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	633 >>> 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	634 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	635 >>> m(b'b.txt')
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	636 False
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	637 >>> 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	638 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	639 >>> 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	640 False
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	641 >>> 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	642 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	643 >>> 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	644 True
bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	645
bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	646 >>> m.files()
50337 47686726545d match: sort patterns before compiling them into a regex Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50304 diff changeset	647 [b'', b'foo/a', b'', b'b']
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	648 >>> 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	649 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	650 >>> m.exact(b'b')
42081 bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	651 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	652 >>> 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	653 False
bf777c1e78dd match: add a docstring with doctest examples to patternmatcher Denis Laxalde <denis@laxalde.org> parents: 42080 diff changeset	654 """
32395 24245b54aa8a match: replace match class by match function (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32325 diff changeset	655
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	656 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: 41672 diff changeset	657 super(patternmatcher, self).__init__(badfn)
50337 47686726545d match: sort patterns before compiling them into a regex Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50304 diff changeset	658 kindpats.sort()
8581 101d305c1d0b match: fold _matcher into match.__init__ Matt Mackall <mpm@selenic.com> parents: 8580 diff changeset	659
51600 a2afa35641c9 matchers: support patternmatcher in rust Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51598 diff changeset	660 if rustmod is not None:
a2afa35641c9 matchers: support patternmatcher in rust Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51598 diff changeset	661 # We need to pass the patterns to Rust because they can contain
a2afa35641c9 matchers: support patternmatcher in rust Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51598 diff changeset	662 # patterns from the user interface
a2afa35641c9 matchers: support patternmatcher in rust Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51598 diff changeset	663 self._kindpats = kindpats
a2afa35641c9 matchers: support patternmatcher in rust Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51598 diff changeset	664
51566 b32c3146ec34 match: fix the "visitdir" method on "rootfilesin" matchers Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 50692 diff changeset	665 roots, dirs, parents = _rootsdirsandparents(kindpats)
32557 3fdcc34c0aba match: remove special-casing of always-matching patterns in patternmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32556 diff changeset	666 self._files = _explicitfiles(kindpats)
51566 b32c3146ec34 match: fix the "visitdir" method on "rootfilesin" matchers Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 50692 diff changeset	667 self._dirs_explicit = set(dirs)
b32c3146ec34 match: fix the "visitdir" method on "rootfilesin" matchers Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 50692 diff changeset	668 self._dirs = parents
33405 6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	669 self._prefix = _prefix(kindpats)
50338 81c7d04f4722 match: match explicit file using a set Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50337 diff changeset	670 self._pats, self._matchfn = _buildmatch(kindpats, b'$', root)
81c7d04f4722 match: match explicit file using a set Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50337 diff changeset	671
81c7d04f4722 match: match explicit file using a set Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50337 diff changeset	672 def matchfn(self, fn):
81c7d04f4722 match: match explicit file using a set Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50337 diff changeset	673 if fn in self._fileset:
81c7d04f4722 match: match explicit file using a set Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50337 diff changeset	674 return True
81c7d04f4722 match: match explicit file using a set Pierre-Yves David <pierre-yves.david@octobus.net> parents: 50337 diff changeset	675 return self._matchfn(fn)
8587 8f15d54437b9 match: fold match into _match base class Matt Mackall <mpm@selenic.com> parents: 8586 diff changeset	676
24636 36872036169b treemanifest: further optimize treemanifest.matches() Drew Gottlieb <drgott@google.com> parents: 24452 diff changeset	677 def visitdir(self, dir):
33405 6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	678 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	679 return b'all'
51566 b32c3146ec34 match: fix the "visitdir" method on "rootfilesin" matchers Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 50692 diff changeset	680 return (
b32c3146ec34 match: fix the "visitdir" method on "rootfilesin" matchers Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 50692 diff changeset	681 dir in self._dirs
b32c3146ec34 match: fix the "visitdir" method on "rootfilesin" matchers Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 50692 diff changeset	682 or path_or_parents_in_set(dir, self._fileset)
b32c3146ec34 match: fix the "visitdir" method on "rootfilesin" matchers Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 50692 diff changeset	683 or path_or_parents_in_set(dir, self._dirs_explicit)
b32c3146ec34 match: fix the "visitdir" method on "rootfilesin" matchers Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 50692 diff changeset	684 )
24636 36872036169b treemanifest: further optimize treemanifest.matches() Drew Gottlieb <drgott@google.com> parents: 24452 diff changeset	685
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	686 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	687 ret = self.visitdir(dir)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	688 if ret is True:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	689 return b'this'
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	690 elif not ret:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	691 return set()
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	692 assert ret == b'all'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	693 return b'all'
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	694
33379 7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	695 def prefix(self):
33405 6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	696 return self._prefix
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	697
36050 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	698 @encoding.strmethod
32406 952017471f93 match: implement __repr__() and update users (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32401 diff changeset	699 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	700 return b'<patternmatcher patterns=%r>' % pycompat.bytestr(self._pats)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	701
32501 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32500 diff changeset	702
43523 c21aca51b392 utils: move the `dirs` definition in pathutil (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43506 diff changeset	703 # This is basically a reimplementation of pathutil.dirs that stores the
c21aca51b392 utils: move the `dirs` definition in pathutil (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43506 diff changeset	704 # children instead of just a count of them, plus a small optional optimization
c21aca51b392 utils: move the `dirs` definition in pathutil (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43506 diff changeset	705 # to avoid some directories we don't need.
48946 642e31cb55f0 py3: use class X: instead of class X(object): Gregory Szorc <gregory.szorc@gmail.com> parents: 48941 diff changeset	706 class _dirchildren:
39460 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	707 def __init__(self, paths, onlyinclude=None):
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	708 self._dirs = {}
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	709 self._onlyinclude = onlyinclude or []
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	710 addpath = self.addpath
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	711 for f in paths:
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	712 addpath(f)
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	713
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	714 def addpath(self, path):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	715 if path == b'':
39460 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	716 return
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	717 dirs = self._dirs
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	718 findsplitdirs = _dirchildren._findsplitdirs
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	719 for d, b in findsplitdirs(path):
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	720 if d not in self._onlyinclude:
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	721 continue
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	722 dirs.setdefault(d, set()).add(b)
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	723
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	724 @staticmethod
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	725 def _findsplitdirs(path):
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	726 # yields (dirname, basename) tuples, walking back to the root. This is
43633 0b7733719d21 utils: move finddirs() to pathutil Martin von Zweigbergk <martinvonz@google.com> parents: 43595 diff changeset	727 # very similar to pathutil.finddirs, except:
39460 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	728 # - 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: 39261 diff changeset	729 # Unlike manifest._splittopdir, this does not suffix `dirname` with a
42341 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42329 diff changeset	730 # slash.
39460 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	731 oldpos = len(path)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	732 pos = path.rfind(b'/')
39460 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	733 while pos != -1:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	734 yield path[:pos], path[pos + 1 : oldpos]
39460 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	735 oldpos = pos
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	736 pos = path.rfind(b'/', 0, pos)
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	737 yield b'', path[:oldpos]
39460 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	738
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	739 def get(self, path):
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	740 return self._dirs.get(path, set())
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	741
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	742
32501 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32500 diff changeset	743 class includematcher(basematcher):
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	744 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: 41672 diff changeset	745 super(includematcher, self).__init__(badfn)
44530 4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44452 diff changeset	746 if rustmod is not None:
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44452 diff changeset	747 # We need to pass the patterns to Rust because they can contain
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44452 diff changeset	748 # patterns from the user interface
4d1634e59f13 rust-status: use bare hg status fastpath from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 44452 diff changeset	749 self._kindpats = kindpats
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	750 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	751 self._prefix = _prefix(kindpats)
38954 5a7df82de142 includematcher: separate "parents" from "dirs" spectral <spectral@google.com> parents: 38750 diff changeset	752 roots, dirs, parents = _rootsdirsandparents(kindpats)
32502 3026f19b4b01 match: remove support for non-include patterns from includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32501 diff changeset	753 # roots are directories which are recursively included.
32503 361808a2b0b8 match: simplify includematcher a bit Martin von Zweigbergk <martinvonz@google.com> parents: 32502 diff changeset	754 self._roots = set(roots)
32502 3026f19b4b01 match: remove support for non-include patterns from includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32501 diff changeset	755 # dirs are directories which are non-recursively included.
32503 361808a2b0b8 match: simplify includematcher a bit Martin von Zweigbergk <martinvonz@google.com> parents: 32502 diff changeset	756 self._dirs = set(dirs)
38954 5a7df82de142 includematcher: separate "parents" from "dirs" spectral <spectral@google.com> parents: 38750 diff changeset	757 # parents are directories which are non-recursively included because
5a7df82de142 includematcher: separate "parents" from "dirs" spectral <spectral@google.com> parents: 38750 diff changeset	758 # they are needed to get to items in _dirs or _roots.
42361 c4b8f8637d7a match: de-flake test-doctest.py by not depending on util.dirs() order Martin von Zweigbergk <martinvonz@google.com> parents: 42346 diff changeset	759 self._parents = parents
32501 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32500 diff changeset	760
7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32500 diff changeset	761 def visitdir(self, dir):
33405 6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	762 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	763 return b'all'
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	764 return (
45999 c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	765 dir in self._dirs
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	766 or dir in self._parents
45999 c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	767 or path_or_parents_in_set(dir, self._roots)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	768 )
32501 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32500 diff changeset	769
39460 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	770 @propertycache
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	771 def _allparentschildren(self):
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	772 # 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: 39261 diff changeset	773 # 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: 39261 diff changeset	774 # dirs = ['foo/bar']
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	775 # parents = ['foo']
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	776 # 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: 39261 diff changeset	777 # 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: 39261 diff changeset	778 return _dirchildren(
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	779 itertools.chain(self._dirs, self._roots, self._parents),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	780 onlyinclude=self._parents,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	781 )
39460 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	782
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	783 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	784 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	785 return b'all'
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	786 # Note: this does not include the 'dir in self._parents' case from
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	787 # visitdir, that's handled below.
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	788 if (
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	789 b'' in self._roots
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	790 or dir in self._dirs
45999 c4c7a6b61146 match: skip walking up the directory hierarchy if the number of pats are small Kyle Lippincott <spectral@google.com> parents: 45946 diff changeset	791 or path_or_parents_in_set(dir, self._roots)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	792 ):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	793 return b'this'
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	794
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	795 if dir in self._parents:
39460 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	796 return self._allparentschildren.get(dir) or set()
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	797 return set()
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	798
36050 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	799 @encoding.strmethod
32501 7095dbc266e3 match: split up main matcher into patternmatcher and includematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32500 diff changeset	800 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	801 return b'<includematcher includes=%r>' % pycompat.bytestr(self._pats)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	802
32406 952017471f93 match: implement __repr__() and update users (API) Martin von Zweigbergk <martinvonz@google.com> parents: 32401 diff changeset	803
32499 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	804 class exactmatcher(basematcher):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	805 r"""Matches the input files exactly. They are interpreted as paths, not
32499 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	806 patterns (so no kind-prefixes).
42080 f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41676 diff changeset	807
42186 fd384911f51b match: use raw strings to avoid illegal baskslash escape Gregory Szorc <gregory.szorc@gmail.com> parents: 42099 diff changeset	808 >>> 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	809 >>> m(b'a.txt')
42080 f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41676 diff changeset	810 True
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	811 >>> m(b'b.txt')
42080 f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41676 diff changeset	812 False
f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41676 diff changeset	813
f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41676 diff changeset	814 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: 41676 diff changeset	815 >>> m.files()
f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41676 diff changeset	816 ['a.txt', 're:.*\\.c$']
f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41676 diff changeset	817
f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41676 diff changeset	818 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	819 >>> m(b'main.c')
42080 f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41676 diff changeset	820 False
42186 fd384911f51b match: use raw strings to avoid illegal baskslash escape Gregory Szorc <gregory.szorc@gmail.com> parents: 42099 diff changeset	821 >>> m(br're:.*\.c$')
42080 f3db5c805a67 match: add doctest examples for exactmatcher Denis Laxalde <denis@laxalde.org> parents: 41676 diff changeset	822 True
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	823 """
32499 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	824
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	825 def __init__(self, files, badfn=None):
ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	826 super(exactmatcher, self).__init__(badfn)
32499 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	827
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	828 if isinstance(files, list):
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	829 self._files = files
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	830 else:
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	831 self._files = list(files)
32543 cf7c88986e9f match: define exactmatcher.matchfn statically Yuya Nishihara <yuya@tcha.org> parents: 32542 diff changeset	832
cf7c88986e9f match: define exactmatcher.matchfn statically Yuya Nishihara <yuya@tcha.org> parents: 32542 diff changeset	833 matchfn = basematcher.exact
32499 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	834
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	835 @propertycache
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	836 def _dirs(self):
43523 c21aca51b392 utils: move the `dirs` definition in pathutil (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43506 diff changeset	837 return set(pathutil.dirs(self._fileset))
32499 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	838
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	839 def visitdir(self, dir):
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	840 return dir in self._dirs
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	841
46872 8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	842 @propertycache
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	843 def _visitchildrenset_candidates(self):
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	844 """A memoized set of candidates for visitchildrenset."""
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	845 return self._fileset \| self._dirs - {b''}
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	846
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	847 @propertycache
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	848 def _sorted_visitchildrenset_candidates(self):
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	849 """A memoized sorted list of candidates for visitchildrenset."""
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	850 return sorted(self._visitchildrenset_candidates)
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	851
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	852 def visitchildrenset(self, dir):
39261 c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39260 diff changeset	853 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: 39260 diff changeset	854 return set()
c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39260 diff changeset	855
46872 8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	856 if dir == b'':
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	857 candidates = self._visitchildrenset_candidates
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	858 else:
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	859 candidates = self._sorted_visitchildrenset_candidates
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	860 d = dir + b'/'
46872 8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	861 # Use bisect to find the first element potentially starting with d
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	862 # (i.e. >= d). This should always find at least one element (we'll
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	863 # assert later if this is not the case).
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	864 first = bisect.bisect_left(candidates, d)
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	865 # We need a representation of the first element that is > d that
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	866 # does not start with d, so since we added a `/` on the end of dir,
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	867 # we'll add whatever comes after slash (we could probably assume
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	868 # that `0` is after `/`, but let's not) to the end of dir instead.
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	869 dnext = dir + encoding.strtolocal(chr(ord(b'/') + 1))
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	870 # Use bisect to find the first element >= d_next
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	871 last = bisect.bisect_left(candidates, dnext, lo=first)
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	872 dlen = len(d)
8bca353b1ebc match: convert O(n) to O(log n) in exactmatcher.visitchildrenset Kyle Lippincott <spectral@google.com> parents: 46819 diff changeset	873 candidates = {c[dlen:] for c in candidates[first:last]}
39261 c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39260 diff changeset	874 # self._dirs includes all of the directories, recursively, so if
42341 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42329 diff changeset	875 # we're attempting to match foo/bar/baz.txt, it'll have '', 'foo',
39261 c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39260 diff changeset	876 # '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: 39260 diff changeset	877 # '/' 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: 39260 diff changeset	878 # 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	879 ret = {c for c in candidates if b'/' not in c}
39261 c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39260 diff changeset	880 # 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: 39260 diff changeset	881 # 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: 39260 diff changeset	882 assert ret
c9a3f7f5c023 match: make exactmatcher.visitchildrenset return file children as well Kyle Lippincott <spectral@google.com> parents: 39260 diff changeset	883 return ret
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	884
32499 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	885 def isexact(self):
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	886 return True
a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	887
36050 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	888 @encoding.strmethod
32499 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	889 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	890 return b'<exactmatcher files=%r>' % self._files
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	891
32499 a3583852861a match: handle exact matching using new exactmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32497 diff changeset	892
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	893 class differencematcher(basematcher):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	894 """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: 35164 diff changeset	895 does not.
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	896
43715 5e1b0470cee7 match: remove explicitdir attribute Martin von Zweigbergk <martinvonz@google.com> parents: 43633 diff changeset	897 The second matcher's non-matching-attributes (bad, traversedir) are ignored.
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	898 """
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	899
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	900 def __init__(self, m1, m2):
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	901 super(differencematcher, self).__init__()
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	902 self._m1 = m1
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	903 self._m2 = m2
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	904 self.bad = m1.bad
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	905 self.traversedir = m1.traversedir
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	906
51671 bc94cbb49b30 typing: add some trivial type hints to `mercurial/match.py` Matt Harbison <matt_harbison@yahoo.com> parents: 51622 diff changeset	907 def was_tampered_with(self) -> bool:
51622 aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	908 return (
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	909 self.was_tampered_with_nonrec()
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	910 or self._m1.was_tampered_with()
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	911 or self._m2.was_tampered_with()
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	912 )
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	913
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	914 def matchfn(self, f):
35659 821d8a5ab4ff match: do not weirdly include explicit files excluded by -X option Yuya Nishihara <yuya@tcha.org> parents: 35164 diff changeset	915 return self._m1(f) and not self._m2(f)
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	916
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	917 @propertycache
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	918 def _files(self):
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	919 if self.isexact():
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	920 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: 32464 diff changeset	921 # 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: 32464 diff changeset	922 # 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: 32464 diff changeset	923 # 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: 32464 diff changeset	924 # 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: 32464 diff changeset	925 # because the "dir" in m1 may not be a file.
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	926 return self._m1.files()
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	927
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	928 def visitdir(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	929 if self._m2.visitdir(dir) == b'all':
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	930 return False
41528 b7a0efb3c370 match: teach diffmatcher.visitdir() to return 'all' if possible Pulkit Goyal <pulkit@yandex-team.ru> parents: 41282 diff changeset	931 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	932 # 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	933 return self._m1.visitdir(dir)
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	934 return bool(self._m1.visitdir(dir))
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	935
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	936 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	937 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	938 if m2_set == b'all':
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	939 return set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	940 m1_set = self._m1.visitchildrenset(dir)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	941 # Possible values for m1: 'all', 'this', set(...), set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	942 # Possible values for m2: 'this', set(...), set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	943 # 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: 38954 diff changeset	944 # 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: 38954 diff changeset	945 # return True, not 'all', for some reason.
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	946 if not m2_set:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	947 return m1_set
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	948 if m1_set in [b'all', b'this']:
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	949 # 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: 38954 diff changeset	950 # 'this' or set(foo)), since m2 might return set() for a
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	951 # subdirectory.
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	952 return b'this'
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	953 # Possible values for m1: set(...), set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	954 # Possible values for m2: 'this', set(...)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	955 # We ignore m2's set results. They're possibly incorrect:
42341 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42329 diff changeset	956 # m1 = path:dir/subdir, m2=rootfilesin:dir, visitchildrenset(''):
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	957 # m1 returns {'dir'}, m2 returns {'dir'}, if we subtracted we'd
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	958 # return set(), which is not correct, we still need to visit 'dir'!
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	959 return m1_set
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	960
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	961 def isexact(self):
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	962 return self._m1.isexact()
a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	963
36050 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	964 @encoding.strmethod
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	965 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	966 return b'<differencematcher m1=%r, m2=%r>' % (self._m1, self._m2)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	967
32465 a83a7d27911e match: handle excludes using new differencematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32464 diff changeset	968
32497 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	969 def intersectmatchers(m1, m2):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	970 """Composes two matchers by matching if both of them match.
32497 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	971
43715 5e1b0470cee7 match: remove explicitdir attribute Martin von Zweigbergk <martinvonz@google.com> parents: 43633 diff changeset	972 The second matcher's non-matching-attributes (bad, traversedir) are ignored.
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	973 """
32497 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	974 if m1 is None or m2 is None:
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	975 return m1 or m2
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	976 if m1.always():
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	977 m = copy.copy(m2)
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	978 # 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: 32496 diff changeset	979 # one thing to copy from m1.
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	980 m.bad = m1.bad
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	981 m.traversedir = m1.traversedir
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	982 return m
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	983 if m2.always():
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	984 m = copy.copy(m1)
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	985 return m
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	986 return intersectionmatcher(m1, m2)
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	987
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	988
32497 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	989 class intersectionmatcher(basematcher):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	990 def __init__(self, m1, m2):
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	991 super(intersectionmatcher, self).__init__()
32497 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	992 self._m1 = m1
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	993 self._m2 = m2
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	994 self.bad = m1.bad
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	995 self.traversedir = m1.traversedir
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	996
51671 bc94cbb49b30 typing: add some trivial type hints to `mercurial/match.py` Matt Harbison <matt_harbison@yahoo.com> parents: 51622 diff changeset	997 def was_tampered_with(self) -> bool:
51622 aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	998 return (
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	999 self.was_tampered_with_nonrec()
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	1000 or self._m1.was_tampered_with()
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	1001 or self._m2.was_tampered_with()
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	1002 )
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	1003
32497 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1004 @propertycache
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1005 def _files(self):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1006 if self.isexact():
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1007 m1, m2 = self._m1, self._m2
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1008 if not m1.isexact():
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1009 m1, m2 = m2, m1
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1010 return [f for f in m1.files() if m2(f)]
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1011 # 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: 32496 diff changeset	1012 # 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: 32496 diff changeset	1013 # 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: 32496 diff changeset	1014 # "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: 32496 diff changeset	1015 return self._m1.files() + self._m2.files()
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1016
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1017 def matchfn(self, f):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1018 return self._m1(f) and self._m2(f)
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1019
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1020 def visitdir(self, dir):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1021 visit1 = self._m1.visitdir(dir)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1022 if visit1 == b'all':
32497 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1023 return self._m2.visitdir(dir)
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1024 # bool() because visit1=True + visit2='all' should not be 'all'
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1025 return bool(visit1 and self._m2.visitdir(dir))
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1026
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1027 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1028 m1_set = self._m1.visitchildrenset(dir)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1029 if not m1_set:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1030 return set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1031 m2_set = self._m2.visitchildrenset(dir)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1032 if not m2_set:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1033 return set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1034
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1035 if m1_set == b'all':
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1036 return m2_set
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1037 elif m2_set == b'all':
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1038 return m1_set
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1039
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1040 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	1041 return b'this'
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1042
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1043 assert isinstance(m1_set, set) and isinstance(m2_set, set)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1044 return m1_set.intersection(m2_set)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1045
32497 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1046 def always(self):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1047 return self._m1.always() and self._m2.always()
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1048
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1049 def isexact(self):
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1050 return self._m1.isexact() or self._m2.isexact()
9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1051
36050 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	1052 @encoding.strmethod
32497 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1053 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1054 return b'<intersectionmatcher m1=%r, m2=%r>' % (self._m1, self._m2)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1055
32497 9eccd559c592 match: handle includes using new intersectionmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32496 diff changeset	1056
32460 f9445b528687 match: make subdirmatcher extend basematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32459 diff changeset	1057 class subdirmatcher(basematcher):
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1058 """Adapt a matcher to work on a subdirectory only.
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1059
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1060 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	1061
34137 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1062 >>> from . import pycompat
44002 d9d78e70149a tests: fix failing doctest in match.py by adding dummy auditor Martin von Zweigbergk <martinvonz@google.com> parents: 43965 diff changeset	1063 >>> m1 = match(util.localpath(b'/root'), b'', [b'a.txt', b'sub/b.txt'], auditor=lambda name: None)
34131 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33684 diff changeset	1064 >>> m2 = subdirmatcher(b'sub', m1)
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	1065 >>> m2(b'a.txt')
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1066 False
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	1067 >>> m2(b'b.txt')
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1068 True
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	1069 >>> m2.matchfn(b'a.txt')
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1070 False
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	1071 >>> m2.matchfn(b'b.txt')
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1072 True
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1073 >>> m2.files()
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1074 ['b.txt']
34131 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33684 diff changeset	1075 >>> m2.exact(b'b.txt')
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1076 True
12268 83aaeba32b88 narrowmatcher: propagate bad method Martin Geisler <mg@lazybytes.net> parents: 12267 diff changeset	1077 >>> def bad(f, msg):
34137 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1078 ... print(pycompat.sysstr(b"%s: %s" % (f, msg)))
12268 83aaeba32b88 narrowmatcher: propagate bad method Martin Geisler <mg@lazybytes.net> parents: 12267 diff changeset	1079 >>> m1.bad = bad
34131 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33684 diff changeset	1080 >>> m2.bad(b'x.txt', b'No such file')
12268 83aaeba32b88 narrowmatcher: propagate bad method Martin Geisler <mg@lazybytes.net> parents: 12267 diff changeset	1081 sub/x.txt: No such file
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1082 """
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1083
51753 a1e4fa9330d8 typing: add type hints around the matcher for subrepo archiving Matt Harbison <matt_harbison@yahoo.com> parents: 51671 diff changeset	1084 def __init__(self, path: bytes, matcher: basematcher) -> None:
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	1085 super(subdirmatcher, self).__init__()
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1086 self._path = path
b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1087 self._matcher = matcher
32460 f9445b528687 match: make subdirmatcher extend basematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32459 diff changeset	1088 self._always = matcher.always()
12165 b7fbf24c8a93 match: add narrowmatcher class Martin Geisler <mg@lazybytes.net> parents: 12163 diff changeset	1089
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1090 self._files = [
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1091 f[len(path) + 1 :]
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1092 for f in matcher._files
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1093 if f.startswith(path + b"/")
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1094 ]
25194 ef4538ba67ef match: explicitly naming a subrepo implies always() for the submatcher Matt Harbison <matt_harbison@yahoo.com> parents: 24790 diff changeset	1095
32325 763d72925691 match: use match.prefix() in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32324 diff changeset	1096 # 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: 32324 diff changeset	1097 # a prefix matcher, this submatcher always matches.
763d72925691 match: use match.prefix() in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32324 diff changeset	1098 if matcher.prefix():
25195 472a685a4961 merge with stable Matt Mackall <mpm@selenic.com> parents: 25189 25194 diff changeset	1099 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	1100
51671 bc94cbb49b30 typing: add some trivial type hints to `mercurial/match.py` Matt Harbison <matt_harbison@yahoo.com> parents: 51622 diff changeset	1101 def was_tampered_with(self) -> bool:
51622 aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	1102 return (
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	1103 self.was_tampered_with_nonrec() or self._matcher.was_tampered_with()
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	1104 )
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	1105
32324 77dac8fd30ee match: avoid accessing match._pathrestricted from subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32323 diff changeset	1106 def bad(self, f, msg):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1107 self._matcher.bad(self._path + b"/" + f, msg)
32324 77dac8fd30ee match: avoid accessing match._pathrestricted from subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32323 diff changeset	1108
32464 2e80a691e575 match: override matchfn() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32463 diff changeset	1109 def matchfn(self, f):
2e80a691e575 match: override matchfn() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32463 diff changeset	1110 # 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: 32463 diff changeset	1111 # 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: 32463 diff changeset	1112 # 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: 32463 diff changeset	1113 # 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	1114 return self._matcher.matchfn(self._path + b"/" + f)
32464 2e80a691e575 match: override matchfn() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32463 diff changeset	1115
32323 0aa4032a97e1 match: override visitdir() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32322 diff changeset	1116 def visitdir(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1117 if dir == b'':
32323 0aa4032a97e1 match: override visitdir() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32322 diff changeset	1118 dir = self._path
0aa4032a97e1 match: override visitdir() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32322 diff changeset	1119 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1120 dir = self._path + b"/" + dir
32323 0aa4032a97e1 match: override visitdir() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32322 diff changeset	1121 return self._matcher.visitdir(dir)
0aa4032a97e1 match: override visitdir() the usual way in subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32322 diff changeset	1122
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1123 def visitchildrenset(self, dir):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1124 if dir == b'':
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1125 dir = self._path
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1126 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1127 dir = self._path + b"/" + dir
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1128 return self._matcher.visitchildrenset(dir)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1129
32460 f9445b528687 match: make subdirmatcher extend basematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32459 diff changeset	1130 def always(self):
f9445b528687 match: make subdirmatcher extend basematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32459 diff changeset	1131 return self._always
f9445b528687 match: make subdirmatcher extend basematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32459 diff changeset	1132
33379 7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	1133 def prefix(self):
7ddb2aa2b7af match: express anypats(), not prefix(), in terms of the others Martin von Zweigbergk <martinvonz@google.com> parents: 33378 diff changeset	1134 return self._matcher.prefix() and not self._always
32460 f9445b528687 match: make subdirmatcher extend basematcher Martin von Zweigbergk <martinvonz@google.com> parents: 32459 diff changeset	1135
36050 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	1136 @encoding.strmethod
32552 e7aa11f3abcd match: add __repr__ for subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32543 diff changeset	1137 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1138 return b'<subdirmatcher path=%r, matcher=%r>' % (
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1139 self._path,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1140 self._matcher,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1141 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1142
32552 e7aa11f3abcd match: add __repr__ for subdirmatcher Martin von Zweigbergk <martinvonz@google.com> parents: 32543 diff changeset	1143
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1144 class prefixdirmatcher(basematcher):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1145 """Adapt a matcher to work on a parent directory.
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1146
43715 5e1b0470cee7 match: remove explicitdir attribute Martin von Zweigbergk <martinvonz@google.com> parents: 43633 diff changeset	1147 The matcher's non-matching-attributes (bad, traversedir) are ignored.
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1148
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1149 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: 38581 diff changeset	1150 this matcher to the root of the wrapped matcher.
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1151
43949 8b1a9ba375e5 match: make sure `root` argument is always an absolute path (API) Martin von Zweigbergk <martinvonz@google.com> parents: 43735 diff changeset	1152 >>> m1 = match(util.localpath(b'/root/d/e'), b'f', [b'../a.txt', b'b.txt'], auditor=lambda name: None)
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	1153 >>> 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	1154 >>> m2(b'a.txt')
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1155 False
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	1156 >>> m2(b'd/e/a.txt')
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1157 True
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	1158 >>> m2(b'd/e/b.txt')
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1159 False
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1160 >>> m2.files()
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1161 ['d/e/a.txt', 'd/e/f/b.txt']
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1162 >>> m2.exact(b'd/e/a.txt')
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1163 True
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1164 >>> m2.visitdir(b'd')
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1165 True
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1166 >>> m2.visitdir(b'd/e')
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1167 True
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1168 >>> m2.visitdir(b'd/e/f')
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1169 True
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1170 >>> m2.visitdir(b'd/e/g')
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1171 False
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1172 >>> m2.visitdir(b'd/ef')
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1173 False
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1174 """
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1175
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	1176 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: 41672 diff changeset	1177 super(prefixdirmatcher, self).__init__(badfn)
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1178 if not path:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1179 raise error.ProgrammingError(b'prefix path must not be empty')
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1180 self._path = path
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1181 self._pathprefix = path + b'/'
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1182 self._matcher = matcher
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1183
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1184 @propertycache
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1185 def _files(self):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1186 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: 38581 diff changeset	1187
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1188 def matchfn(self, f):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1189 if not f.startswith(self._pathprefix):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1190 return False
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1191 return self._matcher.matchfn(f[len(self._pathprefix) :])
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1192
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1193 @propertycache
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1194 def _pathdirs(self):
43633 0b7733719d21 utils: move finddirs() to pathutil Martin von Zweigbergk <martinvonz@google.com> parents: 43595 diff changeset	1195 return set(pathutil.finddirs(self._path))
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1196
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1197 def visitdir(self, dir):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1198 if dir == self._path:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1199 return self._matcher.visitdir(b'')
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1200 if dir.startswith(self._pathprefix):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1201 return self._matcher.visitdir(dir[len(self._pathprefix) :])
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1202 return dir in self._pathdirs
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1203
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1204 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1205 if dir == self._path:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1206 return self._matcher.visitchildrenset(b'')
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1207 if dir.startswith(self._pathprefix):
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1208 return self._matcher.visitchildrenset(dir[len(self._pathprefix) :])
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1209 if dir in self._pathdirs:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1210 return b'this'
38958 b9f94d67ea73 match: add missing "return set()", add FIXME to test to doc a bug Kyle Lippincott <spectral@google.com> parents: 38957 diff changeset	1211 return set()
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1212
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1213 def isexact(self):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1214 return self._matcher.isexact()
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1215
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1216 def prefix(self):
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1217 return self._matcher.prefix()
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1218
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1219 @encoding.strmethod
0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1220 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1221 return b'<prefixdirmatcher path=%r, matcher=%r>' % (
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1222 pycompat.bytestr(self._path),
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1223 self._matcher,
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1224 )
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1225
38611 0ba4cf3f088f match: add prefixdirmatcher to adapt subrepo matcher back Yuya Nishihara <yuya@tcha.org> parents: 38581 diff changeset	1226
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1227 class unionmatcher(basematcher):
33448 04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1228 """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	1229
43715 5e1b0470cee7 match: remove explicitdir attribute Martin von Zweigbergk <martinvonz@google.com> parents: 43633 diff changeset	1230 The non-matching-attributes (bad, traversedir) are taken from the first
5e1b0470cee7 match: remove explicitdir attribute Martin von Zweigbergk <martinvonz@google.com> parents: 43633 diff changeset	1231 matcher.
33448 04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1232 """
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1233
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1234 def __init__(self, matchers):
33448 04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1235 m1 = matchers[0]
41675 ddbebce94665 match: delete unused root and cwd arguments to constructors (API) Martin von Zweigbergk <martinvonz@google.com> parents: 41672 diff changeset	1236 super(unionmatcher, self).__init__()
33448 04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1237 self.traversedir = m1.traversedir
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1238 self._matchers = matchers
3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1239
51671 bc94cbb49b30 typing: add some trivial type hints to `mercurial/match.py` Matt Harbison <matt_harbison@yahoo.com> parents: 51622 diff changeset	1240 def was_tampered_with(self) -> bool:
51622 aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	1241 return self.was_tampered_with_nonrec() or any(
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	1242 map(lambda m: m.was_tampered_with(), self._matchers)
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	1243 )
aa23b19e6da4 match: make `was_tampered_with` work recursively Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 51600 diff changeset	1244
33380 892d255ec2a1 match: override matchfn instead of __call__ for consistency Martin von Zweigbergk <martinvonz@google.com> parents: 33379 diff changeset	1245 def matchfn(self, f):
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1246 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	1247 if match(f):
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1248 return True
3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1249 return False
3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1250
33448 04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1251 def visitdir(self, dir):
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1252 r = False
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1253 for m in self._matchers:
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1254 v = m.visitdir(dir)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1255 if v == b'all':
33448 04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1256 return v
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1257 r \|= v
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1258 return r
04be8aec44a8 match: make unionmatcher a proper matcher Martin von Zweigbergk <martinvonz@google.com> parents: 33447 diff changeset	1259
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1260 def visitchildrenset(self, dir):
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1261 r = set()
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1262 this = False
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1263 for m in self._matchers:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1264 v = m.visitchildrenset(dir)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1265 if not v:
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1266 continue
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1267 if v == b'all':
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1268 return v
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1269 if this or v == b'this':
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1270 this = True
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1271 # don't break, we might have an 'all' in here.
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1272 continue
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1273 assert isinstance(v, set)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1274 r = r.union(v)
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1275 if this:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1276 return b'this'
38955 081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1277 return r
081cc9a95b65 match: add visitchildrenset complement to visitdir spectral <spectral@google.com> parents: 38954 diff changeset	1278
36050 c4fa47f880d3 py3: make sure we return str from __repr__ Pulkit Goyal <7895pulkit@gmail.com> parents: 35659 diff changeset	1279 @encoding.strmethod
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 diff changeset	1280 def __repr__(self):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1281 return b'<unionmatcher matchers=%r>' % self._matchers
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1282
33319 3c84591e7321 match: move matchers from sparse into core Gregory Szorc <gregory.szorc@gmail.com> parents: 33306 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 patkind(pattern, default=None):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1285 r"""If pattern is 'kind:pat' with a known kind, return kind.
42082 413a75da98ce match: add doctest examples for patkind() Denis Laxalde <denis@laxalde.org> parents: 42081 diff changeset	1286
42186 fd384911f51b match: use raw strings to avoid illegal baskslash escape Gregory Szorc <gregory.szorc@gmail.com> parents: 42099 diff changeset	1287 >>> patkind(br're:.*\.c$')
42082 413a75da98ce match: add doctest examples for patkind() Denis Laxalde <denis@laxalde.org> parents: 42081 diff changeset	1288 're'
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	1289 >>> patkind(b'glob:*.c')
42082 413a75da98ce match: add doctest examples for patkind() Denis Laxalde <denis@laxalde.org> parents: 42081 diff changeset	1290 'glob'
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	1291 >>> patkind(b'relpath:test.py')
42082 413a75da98ce match: add doctest examples for patkind() Denis Laxalde <denis@laxalde.org> parents: 42081 diff changeset	1292 'relpath'
42098 5753e5949b51 py3: add b'' prefixes to new doctests in match.py Pulkit Goyal <pulkit@yandex-team.ru> parents: 42087 diff changeset	1293 >>> 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	1294 >>> patkind(b'main.py', default=b're')
42082 413a75da98ce match: add doctest examples for patkind() Denis Laxalde <denis@laxalde.org> parents: 42081 diff changeset	1295 're'
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1296 """
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1297 return _patsplit(pattern, default)[0]
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1298
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1299
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1300 def _patsplit(pattern, default):
9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1301 """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	1302 pattern."""
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1303 if b':' in pattern:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1304 kind, pat = pattern.split(b':', 1)
33684 2be0bf186950 match: expose some data and functionality to other modules Kostia Balytskyi <ikostia@fb.com> parents: 33582 diff changeset	1305 if kind in allpatternkinds:
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1306 return kind, pat
9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1307 return default, pattern
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1308
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1309
8582 a4c199e12b5a match: remove head and tail args from _globre Matt Mackall <mpm@selenic.com> parents: 8581 diff changeset	1310 def _globre(pat):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1311 r"""Convert an extended glob string to a regexp string.
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1312
34137 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1313 >>> from . import pycompat
a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1314 >>> def bprint(s):
a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1315 ... print(pycompat.sysstr(s))
a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1316 >>> bprint(_globre(br'?'))
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1317 .
34137 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1318 >>> bprint(_globre(br'*'))
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1319 [^/]*
34137 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1320 >>> bprint(_globre(br'**'))
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1321 .*
34137 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1322 >>> bprint(_globre(br'**/a'))
21815 a4b67bf1f0a5 match: make glob '*/' match the empty string Siddharth Agarwal <sid0@fb.com>* parents: 21191 diff changeset	1323 (?:.*/)?a
34137 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1324 >>> bprint(_globre(br'a/**/b'))
38475 67dc32d4e790 cleanup: migrate from re.escape to stringutil.reescape Augie Fackler <augie@google.com> parents: 38019 diff changeset	1325 a/(?:.*/)?b
34137 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1326 >>> bprint(_globre(br'[a*?!^][^b][!c]'))
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1327 [a*?!^][\^b][^c]
34137 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1328 >>> bprint(_globre(br'{a,b}'))
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1329 (?:a\|b)
34137 a8994d08e4a2 doctest: use print_function and convert bytes to unicode where needed Yuya Nishihara <yuya@tcha.org> parents: 34131 diff changeset	1330 >>> bprint(_globre(br'.\*\?'))
21112 03782d2fc776 match: _globre doctests Mads Kiilerich <madski@unity3d.com> parents: 21111 diff changeset	1331 \.\*\?
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1332 """
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1333 i, n = 0, len(pat)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1334 res = b''
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1335 group = 0
40684 e6c9ef5e11a0 match: provide and use a quick way to escape a single byte Boris Feld <boris.feld@octobus.net> parents: 40345 diff changeset	1336 escape = util.stringutil.regexbytesescapemap.get
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1337
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10263 diff changeset	1338 def peek():
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1339 return i < n and pat[i : i + 1]
2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1340
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1341 while i < n:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1342 c = pat[i : i + 1]
10282 08a0f04b56bd many, many trivial check-code fixups Matt Mackall <mpm@selenic.com> parents: 10263 diff changeset	1343 i += 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1344 if c not in b'*?[{},\\':
40684 e6c9ef5e11a0 match: provide and use a quick way to escape a single byte Boris Feld <boris.feld@octobus.net> parents: 40345 diff changeset	1345 res += escape(c, c)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1346 elif c == b'*':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1347 if peek() == b'*':
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1348 i += 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1349 if peek() == b'/':
21815 a4b67bf1f0a5 match: make glob '*/' match the empty string Siddharth Agarwal <sid0@fb.com>* parents: 21191 diff changeset	1350 i += 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1351 res += b'(?:.*/)?'
21815 a4b67bf1f0a5 match: make glob '*/' match the empty string Siddharth Agarwal <sid0@fb.com>* parents: 21191 diff changeset	1352 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1353 res += b'.*'
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1354 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1355 res += b'[^/]*'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1356 elif c == b'?':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1357 res += b'.'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1358 elif c == b'[':
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1359 j = i
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1360 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	1361 j += 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1362 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	1363 j += 1
7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1364 if j >= n:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1365 res += b'\\['
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1366 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1367 stuff = pat[i:j].replace(b'\\', b'\\\\')
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1368 i = j + 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1369 if stuff[0:1] == b'!':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1370 stuff = b'^' + stuff[1:]
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1371 elif stuff[0:1] == b'^':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1372 stuff = b'\\' + stuff
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1373 res = b'%s[%s]' % (res, stuff)
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1374 elif c == b'{':
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1375 group += 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1376 res += b'(?:'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1377 elif c == b'}' and group:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1378 res += b')'
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1379 group -= 1
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1380 elif c == b',' and group:
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1381 res += b'\|'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1382 elif c == b'\\':
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1383 p = peek()
7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1384 if p:
7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1385 i += 1
40684 e6c9ef5e11a0 match: provide and use a quick way to escape a single byte Boris Feld <boris.feld@octobus.net> parents: 40345 diff changeset	1386 res += escape(p, p)
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1387 else:
40684 e6c9ef5e11a0 match: provide and use a quick way to escape a single byte Boris Feld <boris.feld@octobus.net> parents: 40345 diff changeset	1388 res += escape(c, c)
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1389 else:
40684 e6c9ef5e11a0 match: provide and use a quick way to escape a single byte Boris Feld <boris.feld@octobus.net> parents: 40345 diff changeset	1390 res += escape(c, c)
8582 a4c199e12b5a match: remove head and tail args from _globre Matt Mackall <mpm@selenic.com> parents: 8581 diff changeset	1391 return res
8570 7fe2012b3bd0 match: move util match functions over Matt Mackall <mpm@selenic.com> parents: 8568 diff changeset	1392
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1393
49645 c4874ebe8644 match: make the FLAG_RE pattern a raw string Matt Harbison <matt_harbison@yahoo.com> parents: 49605 diff changeset	1394 FLAG_RE = util.re.compile(br'^$\?([aiLmsux]+)$(.*)')
49603 3eda36e9b3d6 matcher: fix issues regex flag contained in pattern (issue6759) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48946 diff changeset	1395
3eda36e9b3d6 matcher: fix issues regex flag contained in pattern (issue6759) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 48946 diff changeset	1396
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1397 def _regex(kind, pat, globsuffix):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1398 """Convert a (normalized) pattern of any kind into a
42329 c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42195 diff changeset	1399 regular expression.
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1400 globsuffix is appended to the regexp of globs."""
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1401 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	1402 return b''
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1403 if kind == b're':
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1404 return pat
50692 1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1405 if kind == b'filepath':
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1406 raise error.ProgrammingError(
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1407 "'filepath:' patterns should not be converted to a regex"
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1408 )
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1409 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	1410 if pat == b'.':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1411 return b''
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1412 return util.stringutil.reescape(pat) + b'(?:/\|$)'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1413 if kind == b'rootfilesin':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1414 if pat == b'.':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1415 escaped = b''
31012 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30399 diff changeset	1416 else:
88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30399 diff changeset	1417 # Pattern is a directory name.
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1418 escaped = util.stringutil.reescape(pat) + b'/'
31012 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30399 diff changeset	1419 # 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	1420 return escaped + b'[^/]+$'
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1421 if kind == b'relglob':
42864 72890d8f9860 match: simplify the regexps created for glob patterns Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42766 diff changeset	1422 globre = _globre(pat)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1423 if globre.startswith(b'[^/]*'):
42864 72890d8f9860 match: simplify the regexps created for glob patterns Valentin Gatien-Baron <valentin.gatienbaron@gmail.com> parents: 42766 diff changeset	1424 # 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: 42766 diff changeset	1425 # 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	1426 return b'.' + globre[len(b'[^/]') :] + globsuffix
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1427 return b'(?:\|.*/)' + globre + globsuffix
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1428 if kind == b'relre':
49605 b3480822a251 matcher: do not prepend '.' to pattern using ^ after flags Pierre-Yves David <pierre-yves.david@octobus.net>* parents: 49603 diff changeset	1429 flag = None
b3480822a251 matcher: do not prepend '.' to pattern using ^ after flags Pierre-Yves David <pierre-yves.david@octobus.net>* parents: 49603 diff changeset	1430 m = FLAG_RE.match(pat)
b3480822a251 matcher: do not prepend '.' to pattern using ^ after flags Pierre-Yves David <pierre-yves.david@octobus.net>* parents: 49603 diff changeset	1431 if m:
b3480822a251 matcher: do not prepend '.' to pattern using ^ after flags Pierre-Yves David <pierre-yves.david@octobus.net>* parents: 49603 diff changeset	1432 flag, pat = m.groups()
b3480822a251 matcher: do not prepend '.' to pattern using ^ after flags Pierre-Yves David <pierre-yves.david@octobus.net>* parents: 49603 diff changeset	1433 if not pat.startswith(b'^'):
b3480822a251 matcher: do not prepend '.' to pattern using ^ after flags Pierre-Yves David <pierre-yves.david@octobus.net>* parents: 49603 diff changeset	1434 pat = b'.*' + pat
b3480822a251 matcher: do not prepend '.' to pattern using ^ after flags Pierre-Yves David <pierre-yves.david@octobus.net>* parents: 49603 diff changeset	1435 if flag is not None:
b3480822a251 matcher: do not prepend '.' to pattern using ^ after flags Pierre-Yves David <pierre-yves.david@octobus.net>* parents: 49603 diff changeset	1436 pat = br'(?%s:%s)' % (flag, pat)
b3480822a251 matcher: do not prepend '.' to pattern using ^ after flags Pierre-Yves David <pierre-yves.david@octobus.net>* parents: 49603 diff changeset	1437 return pat
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1438 if kind in (b'glob', b'rootglob'):
38578 2d487b9cac07 match: explode if unsupported pattern passed down to _regex() builder Yuya Nishihara <yuya@tcha.org> parents: 38577 diff changeset	1439 return _globre(pat) + globsuffix
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1440 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	1441
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1442
41669 a13268524c25 match: delete unused argument "listsubrepos" from _buildmatch() Martin von Zweigbergk <martinvonz@google.com> parents: 41668 diff changeset	1443 def _buildmatch(kindpats, globsuffix, root):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1444 """Return regexp string and a matcher function for kindpats.
89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1445 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	1446 matchfuncs = []
714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1447
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	1448 subincludes, kindpats = _expandsubinclude(kindpats, root)
19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	1449 if subincludes:
32132 6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31433 diff changeset	1450 submatchers = {}
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1451
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	1452 def matchsubinclude(f):
32132 6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31433 diff changeset	1453 for prefix, matcherargs in subincludes:
6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31433 diff changeset	1454 if f.startswith(prefix):
6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31433 diff changeset	1455 mf = submatchers.get(prefix)
6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31433 diff changeset	1456 if mf is None:
6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31433 diff changeset	1457 mf = match(*matcherargs)
6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31433 diff changeset	1458 submatchers[prefix] = mf
6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31433 diff changeset	1459
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1460 if mf(f[len(prefix) :]):
32132 6dea1701f170 match: make subinclude construction lazy Durham Goode <durham@fb.com> parents: 31433 diff changeset	1461 return True
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	1462 return False
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1463
25283 19d0e5efa6ca match: enable 'subinclude:' syntax Durham Goode <durham@fb.com> parents: 25250 diff changeset	1464 matchfuncs.append(matchsubinclude)
14675 cfc89398f710 match: introduce basic fileset support Matt Mackall <mpm@selenic.com> parents: 14674 diff changeset	1465
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1466 regex = b''
25239 714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1467 if kindpats:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1468 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: 39460 diff changeset	1469 dirs = {p for k, p, s in kindpats}
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1470
40242 19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39460 diff changeset	1471 def mf(f):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1472 i = f.rfind(b'/')
40242 19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39460 diff changeset	1473 if i >= 0:
19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39460 diff changeset	1474 dir = f[:i]
19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39460 diff changeset	1475 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1476 dir = b'.'
40242 19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39460 diff changeset	1477 return dir in dirs
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1478
40345 d30a19d10441 match: fix up a repr to not crash on Python 3 Augie Fackler <augie@google.com> parents: 40242 diff changeset	1479 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: 39460 diff changeset	1480 matchfuncs.append(mf)
19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39460 diff changeset	1481 else:
19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39460 diff changeset	1482 regex, mf = _buildregexmatch(kindpats, globsuffix)
19ed212de2d1 match: optimize matcher when all patterns are of rootfilesin kind Martin von Zweigbergk <martinvonz@google.com> parents: 39460 diff changeset	1483 matchfuncs.append(mf)
25239 714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1484
714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1485 if len(matchfuncs) == 1:
714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1486 return regex, matchfuncs[0]
714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1487 else:
714f612f2afc match: allow unioning arbitrary match functions Durham Goode <durham@fb.com> parents: 25238 diff changeset	1488 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	1489
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1490
40774 8306dac48061 match: extract a literal constant into a symbolic one Boris Feld <boris.feld@octobus.net> parents: 40757 diff changeset	1491 MAX_RE_SIZE = 20000
8306dac48061 match: extract a literal constant into a symbolic one Boris Feld <boris.feld@octobus.net> parents: 40757 diff changeset	1492
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1493
40776 ce401300f981 match: extract function that group regexps Boris Feld <boris.feld@octobus.net> parents: 40775 diff changeset	1494 def _joinregexes(regexps):
ce401300f981 match: extract function that group regexps Boris Feld <boris.feld@octobus.net> parents: 40775 diff changeset	1495 """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	1496 return b'\|'.join(regexps)
40776 ce401300f981 match: extract function that group regexps Boris Feld <boris.feld@octobus.net> parents: 40775 diff changeset	1497
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1498
21111 9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1499 def _buildregexmatch(kindpats, globsuffix):
9d28fd795215 match: improve documentation - docstrings and more descriptive variable naming Mads Kiilerich <madski@unity3d.com> parents: 21079 diff changeset	1500 """Build a match function from a list of kinds and kindpats,
40775 4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40774 diff changeset	1501 return regexp string and a matcher function.
4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40774 diff changeset	1502
4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40774 diff changeset	1503 Test too large input
4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40774 diff changeset	1504 >>> _buildregexmatch([
40947 9e462fb88f79 match: fix doctest to use bytes instead of str Augie Fackler <augie@google.com> parents: 40782 diff changeset	1505 ... (b'relglob', b'?' * MAX_RE_SIZE, b'')
9e462fb88f79 match: fix doctest to use bytes instead of str Augie Fackler <augie@google.com> parents: 40782 diff changeset	1506 ... ], b'$')
40775 4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40774 diff changeset	1507 Traceback (most recent call last):
4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40774 diff changeset	1508 ...
40778 69bd3176da7c match: raise an Abort error instead of OverflowError Boris Feld <boris.feld@octobus.net> parents: 40777 diff changeset	1509 Abort: matcher pattern is too long (20009 bytes)
40775 4e02f25f31c6 match: test for overflow error in pattern Boris Feld <boris.feld@octobus.net> parents: 40774 diff changeset	1510 """
8574 63a7ed2128d5 match: unnest functions in _matcher Matt Mackall <mpm@selenic.com> parents: 8573 diff changeset	1511 try:
40777 3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1512 allgroups = []
50692 1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1513 regexps = []
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1514 exact = set()
51566 b32c3146ec34 match: fix the "visitdir" method on "rootfilesin" matchers Arseniy Alekseyev <aalekseyev@janestreet.com> parents: 50692 diff changeset	1515 for kind, pattern, _source in kindpats:
50692 1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1516 if kind == b'filepath':
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1517 exact.add(pattern)
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1518 continue
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1519 regexps.append(_regex(kind, pattern, globsuffix))
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1520
40777 3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1521 fullregexp = _joinregexes(regexps)
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1522
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1523 startidx = 0
40782 3984409e144b match: drop unnecessary wrapping of regex in group Martin von Zweigbergk <martinvonz@google.com> parents: 40781 diff changeset	1524 groupsize = 0
40777 3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1525 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: 40776 diff changeset	1526 piecesize = len(r)
40782 3984409e144b match: drop unnecessary wrapping of regex in group Martin von Zweigbergk <martinvonz@google.com> parents: 40781 diff changeset	1527 if piecesize > MAX_RE_SIZE:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1528 msg = _(b"matcher pattern is too long (%d bytes)") % piecesize
40778 69bd3176da7c match: raise an Abort error instead of OverflowError Boris Feld <boris.feld@octobus.net> parents: 40777 diff changeset	1529 raise error.Abort(msg)
40780 1e019f45fa88 match: make "groupsize" include the trailing "\|" Martin von Zweigbergk <martinvonz@google.com> parents: 40779 diff changeset	1530 elif (groupsize + piecesize) > MAX_RE_SIZE:
40777 3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1531 group = regexps[startidx:idx]
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1532 allgroups.append(_joinregexes(group))
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1533 startidx = idx
40782 3984409e144b match: drop unnecessary wrapping of regex in group Martin von Zweigbergk <martinvonz@google.com> parents: 40781 diff changeset	1534 groupsize = 0
40777 3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1535 groupsize += piecesize + 1
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1536
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1537 if startidx == 0:
42087 2e2699af5649 match: let regex match function return a boolean Denis Laxalde <denis@laxalde.org> parents: 42086 diff changeset	1538 matcher = _rematcher(fullregexp)
42099 bccb322f1496 match: fix re2 compability broken in 2e2699af5649 Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42098 diff changeset	1539 func = lambda s: bool(matcher(s))
40777 3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1540 else:
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1541 group = regexps[startidx:]
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1542 allgroups.append(_joinregexes(group))
3c842749debc match: avoid translating glob to matcher multiple times for large sets Boris Feld <boris.feld@octobus.net> parents: 40776 diff changeset	1543 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: 40776 diff changeset	1544 func = lambda s: any(m(s) for m in allmatchers)
50692 1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1545
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1546 actualfunc = func
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1547 if exact:
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1548 # An empty regex will always match, so only call the regex if
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1549 # there were any actual patterns to match.
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1550 if not regexps:
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1551 actualfunc = lambda s: s in exact
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1552 else:
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1553 actualfunc = lambda s: s in exact or func(s)
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1554 return fullregexp, actualfunc
8574 63a7ed2128d5 match: unnest functions in _matcher Matt Mackall <mpm@selenic.com> parents: 8573 diff changeset	1555 except re.error:
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	1556 for k, p, s in kindpats:
50692 1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1557 if k == b'filepath':
1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1558 continue
8574 63a7ed2128d5 match: unnest functions in _matcher Matt Mackall <mpm@selenic.com> parents: 8573 diff changeset	1559 try:
40782 3984409e144b match: drop unnecessary wrapping of regex in group Martin von Zweigbergk <martinvonz@google.com> parents: 40781 diff changeset	1560 _rematcher(_regex(k, p, globsuffix))
8574 63a7ed2128d5 match: unnest functions in _matcher Matt Mackall <mpm@selenic.com> parents: 8573 diff changeset	1561 except re.error:
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	1562 if s:
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1563 raise error.Abort(
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1564 _(b"%s: invalid pattern (%s): %s") % (s, k, p)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1565 )
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	1566 else:
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1567 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	1568 raise error.Abort(_(b"invalid pattern"))
8574 63a7ed2128d5 match: unnest functions in _matcher Matt Mackall <mpm@selenic.com> parents: 8573 diff changeset	1569
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1570
31013 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1571 def _patternrootsanddirs(kindpats):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1572 """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	1573
31013 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1574 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: 31012 diff changeset	1575 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: 31012 diff changeset	1576 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: 31012 diff changeset	1577 directories.
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1578 """
8576 ec4ed21db4b2 match: split up _normalizepats Matt Mackall <mpm@selenic.com> parents: 8575 diff changeset	1579 r = []
31013 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1580 d = []
25213 08a8e9da0ae7 match: add source to kindpats list Durham Goode <durham@fb.com> parents: 25195 diff changeset	1581 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	1582 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	1583 root = []
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1584 for p in pat.split(b'/'):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1585 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	1586 break
0f06e72abfdc match: fold _globprefix into _roots Matt Mackall <mpm@selenic.com> parents: 8583 diff changeset	1587 root.append(p)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1588 r.append(b'/'.join(root))
50692 1c31b343e514 match: add `filepath:` pattern to match an exact filepath relative to the root Rapha?l Gom?s <rgomes@octobus.net> parents: 50338 diff changeset	1589 elif kind in (b'relpath', b'path', b'filepath'):
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1590 if pat == b'.':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1591 pat = b''
42341 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42329 diff changeset	1592 r.append(pat)
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1593 elif kind in (b'rootfilesin',):
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1594 if pat == b'.':
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1595 pat = b''
42341 27d6956d386b match: use '' instead of '.' for root directory (API) Martin von Zweigbergk <martinvonz@google.com> parents: 42329 diff changeset	1596 d.append(pat)
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1597 else: # relglob, re, relre
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1598 r.append(b'')
31013 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1599 return r, d
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1600
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1601
31013 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1602 def _roots(kindpats):
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1603 '''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: 31012 diff changeset	1604 roots, dirs = _patternrootsanddirs(kindpats)
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1605 return roots
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1606
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1607
38954 5a7df82de142 includematcher: separate "parents" from "dirs" spectral <spectral@google.com> parents: 38750 diff changeset	1608 def _rootsdirsandparents(kindpats):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1609 """Returns roots and exact directories from patterns.
31013 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1610
38957 f356be1a7ba3 match: correct doc for _rootsdirsandparents after 5a7df82de142 Kyle Lippincott <spectral@google.com> parents: 38955 diff changeset	1611 `roots` are directories to match recursively, `dirs` should
f356be1a7ba3 match: correct doc for _rootsdirsandparents after 5a7df82de142 Kyle Lippincott <spectral@google.com> parents: 38955 diff changeset	1612 be matched non-recursively, and `parents` are the implicitly required
f356be1a7ba3 match: correct doc for _rootsdirsandparents after 5a7df82de142 Kyle Lippincott <spectral@google.com> parents: 38955 diff changeset	1613 directories to walk to items in either roots or dirs.
f356be1a7ba3 match: correct doc for _rootsdirsandparents after 5a7df82de142 Kyle Lippincott <spectral@google.com> parents: 38955 diff changeset	1614
f356be1a7ba3 match: correct doc for _rootsdirsandparents after 5a7df82de142 Kyle Lippincott <spectral@google.com> parents: 38955 diff changeset	1615 Returns a tuple of (roots, dirs, parents).
31013 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1616
42367 96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42362 diff changeset	1617 >>> r = _rootsdirsandparents(
34131 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33684 diff changeset	1618 ... [(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: 33684 diff changeset	1619 ... (b'glob', b'g*', b'')])
42367 96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42362 diff changeset	1620 >>> 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: 42362 diff changeset	1621 (['g/h', 'g/h', ''], []) ['', 'g']
96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42362 diff changeset	1622 >>> r = _rootsdirsandparents(
34131 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33684 diff changeset	1623 ... [(b'rootfilesin', b'g/h', b''), (b'rootfilesin', b'', b'')])
42367 96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42362 diff changeset	1624 >>> 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: 42362 diff changeset	1625 ([], ['g/h', '']) ['', 'g']
96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42362 diff changeset	1626 >>> r = _rootsdirsandparents(
34131 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33684 diff changeset	1627 ... [(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: 33684 diff changeset	1628 ... (b'path', b'', b'')])
42367 96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42362 diff changeset	1629 >>> 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: 42362 diff changeset	1630 (['r', 'p/p', ''], []) ['', 'p']
96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42362 diff changeset	1631 >>> r = _rootsdirsandparents(
34131 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33684 diff changeset	1632 ... [(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: 33684 diff changeset	1633 ... (b'relre', b'rr', b'')])
42367 96fc696a9cb2 match: stabilize _rootsdirsandparents doctest Pierre-Yves David <pierre-yves.david@octobus.net> parents: 42362 diff changeset	1634 >>> 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: 42362 diff changeset	1635 (['', '', ''], []) ['']
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1636 """
31013 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1637 r, d = _patternrootsanddirs(kindpats)
693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1638
42361 c4b8f8637d7a match: de-flake test-doctest.py by not depending on util.dirs() order Martin von Zweigbergk <martinvonz@google.com> parents: 42346 diff changeset	1639 p = set()
c4b8f8637d7a match: de-flake test-doctest.py by not depending on util.dirs() order Martin von Zweigbergk <martinvonz@google.com> parents: 42346 diff changeset	1640 # Add the parents as non-recursive/exact directories, since they must be
31013 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1641 # scanned to get to either the roots or the other exact directories.
43523 c21aca51b392 utils: move the `dirs` definition in pathutil (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43506 diff changeset	1642 p.update(pathutil.dirs(d))
c21aca51b392 utils: move the `dirs` definition in pathutil (API) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 43506 diff changeset	1643 p.update(pathutil.dirs(r))
31013 693a5bb47854 match: making visitdir() deal with non-recursive entries Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 31012 diff changeset	1644
39460 35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	1645 # 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: 39261 diff changeset	1646 # returning.
35ecaa999a12 match: improve includematcher.visitchildrenset to be much faster and cached Kyle Lippincott <spectral@google.com> parents: 39261 diff changeset	1647 # 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: 39261 diff changeset	1648 # 'dirs' to also be in 'parents', consider removing them before returning.
38954 5a7df82de142 includematcher: separate "parents" from "dirs" spectral <spectral@google.com> parents: 38750 diff changeset	1649 return r, d, p
8576 ec4ed21db4b2 match: split up _normalizepats Matt Mackall <mpm@selenic.com> parents: 8575 diff changeset	1650
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1651
31012 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30399 diff changeset	1652 def _explicitfiles(kindpats):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1653 """Returns the potential explicit filenames from the patterns.
31012 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30399 diff changeset	1654
34131 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33684 diff changeset	1655 >>> _explicitfiles([(b'path', b'foo/bar', b'')])
31012 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30399 diff changeset	1656 ['foo/bar']
34131 0fa781320203 doctest: bulk-replace string literals with b'' for Python 3 Yuya Nishihara <yuya@tcha.org> parents: 33684 diff changeset	1657 >>> _explicitfiles([(b'rootfilesin', b'foo/bar', b'')])
31012 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30399 diff changeset	1658 []
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1659 """
31012 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30399 diff changeset	1660 # 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: 30399 diff changeset	1661 # directory names).
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1662 filable = [kp for kp in kindpats if kp[0] not in (b'rootfilesin',)]
31012 88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30399 diff changeset	1663 return _roots(filable)
88358446da16 match: adding support for matching files inside a directory Rodrigo Damazio Bovendorp <rdamazio@google.com> parents: 30399 diff changeset	1664
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1665
33405 6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	1666 def _prefix(kindpats):
6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	1667 '''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	1668 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	1669 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	1670 return False
6aa643762641 match: inverse _anypats(), making it _prefix() Martin von Zweigbergk <martinvonz@google.com> parents: 33380 diff changeset	1671 return True
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1672
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1673
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1674 _commentre = None
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1675
51922 70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1676 if typing.TYPE_CHECKING:
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1677 from typing_extensions import (
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1678 Literal,
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1679 )
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1680
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1681 @overload
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1682 def readpatternfile(
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1683 filepath: bytes, warn: Callable[[bytes], Any], sourceinfo: Literal[True]
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1684 ) -> List[Tuple[bytes, int, bytes]]:
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1685 ...
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1686
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1687 @overload
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1688 def readpatternfile(
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1689 filepath: bytes,
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1690 warn: Callable[[bytes], Any],
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1691 sourceinfo: Literal[False],
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1692 ) -> List[bytes]:
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1693 ...
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1694
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1695 @overload
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1696 def readpatternfile(
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1697 filepath: bytes,
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1698 warn: Callable[[bytes], Any],
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1699 sourceinfo: bool = False,
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1700 ) -> List[Union[Tuple[bytes, int, bytes], bytes]]:
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1701 ...
70fe33bdab54 typing: add type hints for the overloads of `matchmod.readpatternfile()` Matt Harbison <matt_harbison@yahoo.com> parents: 51859 diff changeset	1702
43076 2372284d9457 formatting: blacken the codebase Augie Fackler <augie@google.com> parents: 42864 diff changeset	1703
27595 9e2d01707e71 match: add option to return line and lineno from readpattern Laurent Charignon <lcharignon@fb.com> parents: 27343 diff changeset	1704 def readpatternfile(filepath, warn, sourceinfo=False):
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1705 """parse a pattern file, returning a list of
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1706 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	1707 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	1708
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1709 trailing white space is dropped.
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1710 the escape character is backslash.
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1711 comments start with #.
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1712 empty lines are skipped.
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1713
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1714 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	1715
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1716 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	1717 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	1718 re:pattern # non-rooted regular expression
dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1719 glob:pattern # non-rooted glob
41282 4fab8a7d2d72 match: support rooted globs in hgignore Valentin Gatien-Baron <vgatien-baron@janestreet.com> parents: 41129 diff changeset	1720 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	1721 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	1722
9e2d01707e71 match: add option to return line and lineno from readpattern Laurent Charignon <lcharignon@fb.com> parents: 27343 diff changeset	1723 if sourceinfo is set, returns a list of tuples:
42329 c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42195 diff changeset	1724 (pattern, lineno, originalline).
c7652f7440d9 rust-filepatterns: call new Rust implementations from Python Rapha?l Gom?s <rgomes@octobus.net> parents: 42195 diff changeset	1725 This is useful to debug ignore patterns.
45942 89a2afe31e82 formating: upgrade to black 20.8b1 Augie Fackler <raf@durin42.com> parents: 45682 diff changeset	1726 """
25216 dc562165044a ignore: use 'include:' rules instead of custom syntax Durham Goode <durham@fb.com> parents: 25215 diff changeset	1727
40685 e41f6c2e69c4 match: reformat `syntaxes` dictionary for better maintainability Boris Feld <boris.feld@octobus.net> parents: 40684 diff changeset	1728 syntaxes = {
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1729 b're': b'relre:',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1730 b'regexp': b'relre:',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1731 b'glob': b'relglob:',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1732 b'rootglob': b'rootglob:',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1733 b'include': b'include',
687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1734 b'subinclude': b'subinclude',
40685 e41f6c2e69c4 match: reformat `syntaxes` dictionary for better maintainability Boris Feld <boris.feld@octobus.net> parents: 40684 diff changeset	1735 }
43077 687b865b95ad formatting: byteify all mercurial/ and hgext/ string literals Augie Fackler <augie@google.com> parents: 43076 diff changeset	1736 syntax = b'relre:'
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1737 patterns = []
6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1738
52578 bbb43c5b753a match: don't leak a file descriptor when I/O fails reading a pattern file Matt Harbison <matt_harbison@yahoo.com> parents: 52577 diff changeset	1739 with open(filepath, 'rb') as fp:
52577 a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1740 for lineno, line in enumerate(fp, start=1):
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1741 if b"#" in line:
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1742 global _commentre
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1743 if not _commentre:
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1744 _commentre = util.re.compile(br'((?:^\|[^\\])(?:\\\\))#.')
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1745 # remove comments prefixed by an even number of escapes
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1746 m = _commentre.search(line)
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1747 if m:
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1748 line = line[: m.end(1)]
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1749 # fixup properly escaped comments that survived the above
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1750 line = line.replace(b"\\#", b"#")
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1751 line = line.rstrip()
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1752 if not line:
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1753 continue
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1754
52577 a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1755 if line.startswith(b'syntax:'):
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1756 s = line[7:].strip()
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1757 try:
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1758 syntax = syntaxes[s]
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1759 except KeyError:
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1760 if warn:
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1761 warn(
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1762 _(b"%s: ignoring invalid syntax '%s'\n")
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1763 % (filepath, s)
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1764 )
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1765 continue
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1766
52577 a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1767 linesyntax = syntax
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1768 for s, rels in syntaxes.items():
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1769 if line.startswith(rels):
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1770 linesyntax = rels
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1771 line = line[len(rels) :]
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1772 break
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1773 elif line.startswith(s + b':'):
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1774 linesyntax = rels
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1775 line = line[len(s) + 1 :]
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1776 break
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1777 if sourceinfo:
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1778 patterns.append((linesyntax + line, lineno, line))
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1779 else:
a58f7f809fa5 match: indent a large block of code that needs a context manager Matt Harbison <matt_harbison@yahoo.com> parents: 52380 diff changeset	1780 patterns.append(linesyntax + line)
52578 bbb43c5b753a match: don't leak a file descriptor when I/O fails reading a pattern file Matt Harbison <matt_harbison@yahoo.com> parents: 52577 diff changeset	1781
25167 6f7048cc2419 ignore: move readpatternfile to match.py Durham Goode <durham@fb.com> parents: 25122 diff changeset	1782 return patterns

Mercurial > public > mercurial-scm > hg

annotate mercurial/match.py @ 52640:24ee91ba9aa8