/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: 2019-02-04 01:01:24 UTC
  • mto: This revision was merged to the branch mainline in revision 7268.
  • Revision ID: jelmer@jelmer.uk-20190204010124-ni0i4qc6f5tnbvux
Fix source tests.

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 = "File ~/.bazaar/ignore or .bzrignore contains error(s)."
 
252
            bad_patterns = ''
 
253
            for _, patterns in self._regex_patterns:
 
254
                for p in patterns:
 
255
                    if not Globster.is_pattern_valid(p):
 
256
                        bad_patterns += ('\n  %s' % p)
 
257
            e.msg += bad_patterns
 
258
            raise e
216
259
        return None
217
260
 
 
261
    @staticmethod
 
262
    def identify(pattern):
 
263
        """Returns pattern category.
 
264
 
 
265
        :param pattern: normalized pattern.
 
266
        Identify if a pattern is fullpath, basename or extension
 
267
        and returns the appropriate type.
 
268
        """
 
269
        if pattern.startswith(u'RE:') or u'/' in pattern:
 
270
            return "fullpath"
 
271
        elif pattern.startswith(u'*.'):
 
272
            return "extension"
 
273
        else:
 
274
            return "basename"
 
275
 
 
276
    @staticmethod
 
277
    def is_pattern_valid(pattern):
 
278
        """Returns True if pattern is valid.
 
279
 
 
280
        :param pattern: Normalized pattern.
 
281
        is_pattern_valid() assumes pattern to be normalized.
 
282
        see: globbing.normalize_pattern
 
283
        """
 
284
        result = True
 
285
        translator = Globster.pattern_info[Globster.identify(
 
286
            pattern)]["translator"]
 
287
        tpattern = '(%s)' % translator(pattern)
 
288
        try:
 
289
            re_obj = lazy_regex.lazy_compile(tpattern, re.UNICODE)
 
290
            re_obj.search("")  # force compile
 
291
        except lazy_regex.InvalidPattern:
 
292
            result = False
 
293
        return result
 
294
 
 
295
 
218
296
class ExceptionGlobster(object):
219
297
    """A Globster that supports exception patterns.
220
 
    
 
298
 
221
299
    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 
 
300
    patterns take precedence over regular patterns and cause a
 
301
    matching filename to return None from the match() function.
 
302
    Patterns using a '!!' prefix are highest precedence, and act
225
303
    as regular ignores. '!!' patterns are useful to establish ignores
226
304
    that apply under paths specified by '!' exception patterns.
227
305
    """
228
 
    
229
 
    def __init__(self,patterns):
 
306
 
 
307
    def __init__(self, patterns):
230
308
        ignores = [[], [], []]
231
309
        for p in patterns:
232
310
            if p.startswith(u'!!'):
236
314
            else:
237
315
                ignores[0].append(p)
238
316
        self._ignores = [Globster(i) for i in ignores]
239
 
        
 
317
 
240
318
    def match(self, filename):
241
319
        """Searches for a pattern that matches the given filename.
242
320
 
250
328
        else:
251
329
            return self._ignores[0].match(filename)
252
330
 
 
331
 
253
332
class _OrderedGlobster(Globster):
254
333
    """A Globster that keeps pattern order."""
255
334
 
262
341
        self._regex_patterns = []
263
342
        for pat in patterns:
264
343
            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'[\\/]+')
 
344
            t = Globster.identify(pat)
 
345
            self._add_patterns([pat], Globster.pattern_info[t]["translator"],
 
346
                               Globster.pattern_info[t]["prefix"])
 
347
 
 
348
 
 
349
_slashes = lazy_regex.lazy_compile(r'[\\/]+')
 
350
 
 
351
 
276
352
def normalize_pattern(pattern):
277
353
    """Converts backslashes in path patterns to forward slashes.
278
354