/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/globbing.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/globbing.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
20
20
expressions.
21
21
"""
22
22
 
 
23
from __future__ import absolute_import
 
24
 
23
25
import re
24
26
 
25
 
from bzrlib.trace import (
26
 
    warning
 
27
from . import (
 
28
    lazy_regex,
 
29
    )
 
30
from .trace import (
 
31
    mutter,
 
32
    warning,
27
33
    )
28
34
 
29
35
 
36
42
    must not contain capturing groups.
37
43
    """
38
44
 
39
 
    _expand = re.compile(ur'\\&')
 
45
    _expand = lazy_regex.lazy_compile(u'\\\\&')
40
46
 
41
47
    def __init__(self, source=None):
42
48
        self._pat = None
72
78
 
73
79
    def __call__(self, text):
74
80
        if not self._pat:
75
 
            self._pat = re.compile(
76
 
                    u'|'.join([u'(%s)' % p for p in self._pats]),
77
 
                    re.UNICODE)
 
81
            self._pat = lazy_regex.lazy_compile(
 
82
                u'|'.join([u'(%s)' % p for p in self._pats]),
 
83
                re.UNICODE)
78
84
        return self._pat.sub(self._do_sub, text)
79
85
 
80
86
    def _do_sub(self, m):
86
92
 
87
93
 
88
94
_sub_named = Replacer()
89
 
_sub_named.add(ur'\[:digit:\]', ur'\d')
90
 
_sub_named.add(ur'\[:space:\]', ur'\s')
91
 
_sub_named.add(ur'\[:alnum:\]', ur'\w')
92
 
_sub_named.add(ur'\[:ascii:\]', ur'\0-\x7f')
93
 
_sub_named.add(ur'\[:blank:\]', ur' \t')
94
 
_sub_named.add(ur'\[:cntrl:\]', ur'\0-\x1f\x7f-\x9f')
 
95
_sub_named.add(r'\[:digit:\]', r'\d')
 
96
_sub_named.add(r'\[:space:\]', r'\s')
 
97
_sub_named.add(r'\[:alnum:\]', r'\w')
 
98
_sub_named.add(r'\[:ascii:\]', r'\0-\x7f')
 
99
_sub_named.add(r'\[:blank:\]', r' \t')
 
100
_sub_named.add(r'\[:cntrl:\]', r'\0-\x1f\x7f-\x9f')
95
101
 
96
102
 
97
103
def _sub_group(m):
123
129
 
124
130
_sub_re = Replacer()
125
131
_sub_re.add(u'^RE:', u'')
126
 
_sub_re.add(u'\((?!\?)', u'(?:')
127
 
_sub_re.add(u'\(\?P<.*>', _invalid_regex(u'(?:'))
128
 
_sub_re.add(u'\(\?P=[^)]*\)', _invalid_regex(u''))
129
 
_sub_re.add(ur'\\+$', _trailing_backslashes_regex)
 
132
_sub_re.add(u'\\((?!\\?)', u'(?:')
 
133
_sub_re.add(u'\\(\\?P<.*>', _invalid_regex(u'(?:'))
 
134
_sub_re.add(u'\\(\\?P=[^)]*\\)', _invalid_regex(u''))
 
135
_sub_re.add(r'\\+$', _trailing_backslashes_regex)
130
136
 
131
137
 
132
138
_sub_fullpath = Replacer()
133
 
_sub_fullpath.add(ur'^RE:.*', _sub_re) # RE:<anything> is a regex
134
 
_sub_fullpath.add(ur'\[\^?\]?(?:[^][]|\[:[^]]+:\])+\]', _sub_group) # char group
135
 
_sub_fullpath.add(ur'(?:(?<=/)|^)(?:\.?/)+', u'') # canonicalize path
136
 
_sub_fullpath.add(ur'\\.', ur'\&') # keep anything backslashed
137
 
_sub_fullpath.add(ur'[(){}|^$+.]', ur'\\&') # escape specials
138
 
_sub_fullpath.add(ur'(?:(?<=/)|^)\*\*+/', ur'(?:.*/)?') # **/ after ^ or /
139
 
_sub_fullpath.add(ur'\*+', ur'[^/]*') # * elsewhere
140
 
_sub_fullpath.add(ur'\?', ur'[^/]') # ? everywhere
 
139
_sub_fullpath.add(r'^RE:.*', _sub_re)  # RE:<anything> is a regex
 
140
_sub_fullpath.add(r'\[\^?\]?(?:[^][]|\[:[^]]+:\])+\]',
 
141
                  _sub_group)  # char group
 
142
_sub_fullpath.add(r'(?:(?<=/)|^)(?:\.?/)+', u'')  # canonicalize path
 
143
_sub_fullpath.add(r'\\.', r'\&')  # keep anything backslashed
 
144
_sub_fullpath.add(r'[(){}|^$+.]', r'\\&')  # escape specials
 
145
_sub_fullpath.add(r'(?:(?<=/)|^)\*\*+/', r'(?:.*/)?')  # **/ after ^ or /
 
146
_sub_fullpath.add(r'\*+', r'[^/]*')  # * elsewhere
 
147
_sub_fullpath.add(r'\?', r'[^/]')  # ? everywhere
141
148
 
142
149
 
143
150
_sub_basename = Replacer()
144
 
_sub_basename.add(ur'\[\^?\]?(?:[^][]|\[:[^]]+:\])+\]', _sub_group) # char group
145
 
_sub_basename.add(ur'\\.', ur'\&') # keep anything backslashed
146
 
_sub_basename.add(ur'[(){}|^$+.]', ur'\\&') # escape specials
147
 
_sub_basename.add(ur'\*+', ur'.*') # * everywhere
148
 
_sub_basename.add(ur'\?', ur'.') # ? everywhere
 
151
_sub_basename.add(r'\[\^?\]?(?:[^][]|\[:[^]]+:\])+\]',
 
152
                  _sub_group)  # char group
 
153
_sub_basename.add(r'\\.', r'\&')  # keep anything backslashed
 
154
_sub_basename.add(r'[(){}|^$+.]', r'\\&')  # escape specials
 
155
_sub_basename.add(r'\*+', r'.*')  # * everywhere
 
156
_sub_basename.add(r'\?', r'.')  # ? everywhere
149
157
 
150
158
 
151
159
def _sub_extension(pattern):
177
185
    so are matched first, then the basename patterns, then the fullpath
178
186
    patterns.
179
187
    """
 
188
    # We want to _add_patterns in a specific order (as per type_list below)
 
189
    # starting with the shortest and going to the longest.
 
190
    # As some Python version don't support ordered dicts the list below is
 
191
    # used to select inputs for _add_pattern in a specific order.
 
192
    pattern_types = ["extension", "basename", "fullpath"]
 
193
 
 
194
    pattern_info = {
 
195
        "extension": {
 
196
            "translator": _sub_extension,
 
197
            "prefix": r'(?:.*/)?(?!.*/)(?:.*\.)'
 
198
        },
 
199
        "basename": {
 
200
            "translator": _sub_basename,
 
201
            "prefix": r'(?:.*/)?(?!.*/)'
 
202
        },
 
203
        "fullpath": {
 
204
            "translator": _sub_fullpath,
 
205
            "prefix": r''
 
206
        },
 
207
    }
 
208
 
180
209
    def __init__(self, patterns):
181
210
        self._regex_patterns = []
182
 
        path_patterns = []
183
 
        base_patterns = []
184
 
        ext_patterns = []
 
211
        pattern_lists = {
 
212
            "extension": [],
 
213
            "basename": [],
 
214
            "fullpath": [],
 
215
        }
185
216
        for pat in patterns:
186
217
            pat = normalize_pattern(pat)
187
 
            if pat.startswith(u'RE:') or u'/' in pat:
188
 
                path_patterns.append(pat)
189
 
            elif pat.startswith(u'*.'):
190
 
                ext_patterns.append(pat)
191
 
            else:
192
 
                base_patterns.append(pat)
193
 
        self._add_patterns(ext_patterns,_sub_extension,
194
 
            prefix=r'(?:.*/)?(?!.*/)(?:.*\.)')
195
 
        self._add_patterns(base_patterns,_sub_basename,
196
 
            prefix=r'(?:.*/)?(?!.*/)')
197
 
        self._add_patterns(path_patterns,_sub_fullpath)
 
218
            pattern_lists[Globster.identify(pat)].append(pat)
 
219
        pi = Globster.pattern_info
 
220
        for t in Globster.pattern_types:
 
221
            self._add_patterns(pattern_lists[t], pi[t]["translator"],
 
222
                               pi[t]["prefix"])
198
223
 
199
224
    def _add_patterns(self, patterns, translator, prefix=''):
200
225
        while patterns:
201
 
            grouped_rules = ['(%s)' % translator(pat) for pat in patterns[:99]]
 
226
            grouped_rules = [
 
227
                '(%s)' % translator(pat) for pat in patterns[:99]]
202
228
            joined_rule = '%s(?:%s)$' % (prefix, '|'.join(grouped_rules))
203
 
            self._regex_patterns.append((re.compile(joined_rule, re.UNICODE),
 
229
            # Explicitly use lazy_compile here, because we count on its
 
230
            # nicer error reporting.
 
231
            self._regex_patterns.append((
 
232
                lazy_regex.lazy_compile(joined_rule, re.UNICODE),
204
233
                patterns[:99]))
205
234
            patterns = patterns[99:]
206
235
 
209
238
 
210
239
        :return A matching pattern or None if there is no matching pattern.
211
240
        """
212
 
        for regex, patterns in self._regex_patterns:
213
 
            match = regex.match(filename)
214
 
            if match:
215
 
                return patterns[match.lastindex -1]
 
241
        try:
 
242
            for regex, patterns in self._regex_patterns:
 
243
                match = regex.match(filename)
 
244
                if match:
 
245
                    return patterns[match.lastindex - 1]
 
246
        except lazy_regex.InvalidPattern as e:
 
247
            # We can't show the default e.msg to the user as thats for
 
248
            # the combined pattern we sent to regex. Instead we indicate to
 
249
            # the user that an ignore file needs fixing.
 
250
            mutter('Invalid pattern found in regex: %s.', e.msg)
 
251
            e.msg = (
 
252
                "File ~/.config/breezy/ignore or "
 
253
                ".bzrignore contains error(s).")
 
254
            bad_patterns = ''
 
255
            for _, patterns in self._regex_patterns:
 
256
                for p in patterns:
 
257
                    if not Globster.is_pattern_valid(p):
 
258
                        bad_patterns += ('\n  %s' % p)
 
259
            e.msg += bad_patterns
 
260
            raise e
216
261
        return None
217
262
 
 
263
    @staticmethod
 
264
    def identify(pattern):
 
265
        """Returns pattern category.
 
266
 
 
267
        :param pattern: normalized pattern.
 
268
        Identify if a pattern is fullpath, basename or extension
 
269
        and returns the appropriate type.
 
270
        """
 
271
        if pattern.startswith(u'RE:') or u'/' in pattern:
 
272
            return "fullpath"
 
273
        elif pattern.startswith(u'*.'):
 
274
            return "extension"
 
275
        else:
 
276
            return "basename"
 
277
 
 
278
    @staticmethod
 
279
    def is_pattern_valid(pattern):
 
280
        """Returns True if pattern is valid.
 
281
 
 
282
        :param pattern: Normalized pattern.
 
283
        is_pattern_valid() assumes pattern to be normalized.
 
284
        see: globbing.normalize_pattern
 
285
        """
 
286
        result = True
 
287
        translator = Globster.pattern_info[Globster.identify(
 
288
            pattern)]["translator"]
 
289
        tpattern = '(%s)' % translator(pattern)
 
290
        try:
 
291
            re_obj = lazy_regex.lazy_compile(tpattern, re.UNICODE)
 
292
            re_obj.search("")  # force compile
 
293
        except lazy_regex.InvalidPattern:
 
294
            result = False
 
295
        return result
 
296
 
 
297
 
218
298
class ExceptionGlobster(object):
219
299
    """A Globster that supports exception patterns.
220
 
    
 
300
 
221
301
    Exceptions are ignore patterns prefixed with '!'.  Exception
222
 
    patterns take precedence over regular patterns and cause a 
223
 
    matching filename to return None from the match() function.  
224
 
    Patterns using a '!!' prefix are highest precedence, and act 
 
302
    patterns take precedence over regular patterns and cause a
 
303
    matching filename to return None from the match() function.
 
304
    Patterns using a '!!' prefix are highest precedence, and act
225
305
    as regular ignores. '!!' patterns are useful to establish ignores
226
306
    that apply under paths specified by '!' exception patterns.
227
307
    """
228
 
    
229
 
    def __init__(self,patterns):
 
308
 
 
309
    def __init__(self, patterns):
230
310
        ignores = [[], [], []]
231
311
        for p in patterns:
232
312
            if p.startswith(u'!!'):
236
316
            else:
237
317
                ignores[0].append(p)
238
318
        self._ignores = [Globster(i) for i in ignores]
239
 
        
 
319
 
240
320
    def match(self, filename):
241
321
        """Searches for a pattern that matches the given filename.
242
322
 
250
330
        else:
251
331
            return self._ignores[0].match(filename)
252
332
 
 
333
 
253
334
class _OrderedGlobster(Globster):
254
335
    """A Globster that keeps pattern order."""
255
336
 
262
343
        self._regex_patterns = []
263
344
        for pat in patterns:
264
345
            pat = normalize_pattern(pat)
265
 
            if pat.startswith(u'RE:') or u'/' in pat:
266
 
                self._add_patterns([pat], _sub_fullpath)
267
 
            elif pat.startswith(u'*.'):
268
 
                self._add_patterns([pat], _sub_extension,
269
 
                    prefix=r'(?:.*/)?(?!.*/)(?:.*\.)')
270
 
            else:
271
 
                self._add_patterns([pat], _sub_basename,
272
 
                    prefix=r'(?:.*/)?(?!.*/)')
273
 
 
274
 
 
275
 
_slashes = re.compile(r'[\\/]+')
 
346
            t = Globster.identify(pat)
 
347
            self._add_patterns([pat], Globster.pattern_info[t]["translator"],
 
348
                               Globster.pattern_info[t]["prefix"])
 
349
 
 
350
 
 
351
_slashes = lazy_regex.lazy_compile(r'[\\/]+')
 
352
 
 
353
 
276
354
def normalize_pattern(pattern):
277
355
    """Converts backslashes in path patterns to forward slashes.
278
356