/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 bzrlib/globbing.py

  • Committer: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/globbing.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
 
 
25
23
import re
26
24
 
27
 
from . import (
28
 
    lazy_regex,
29
 
    )
30
 
from .trace import (
 
25
from bzrlib import errors
 
26
from bzrlib.trace import (
31
27
    mutter,
32
28
    warning,
33
29
    )
42
38
    must not contain capturing groups.
43
39
    """
44
40
 
45
 
    _expand = lazy_regex.lazy_compile(u'\\\\&')
 
41
    _expand = re.compile(ur'\\&')
46
42
 
47
43
    def __init__(self, source=None):
48
44
        self._pat = None
78
74
 
79
75
    def __call__(self, text):
80
76
        if not self._pat:
81
 
            self._pat = lazy_regex.lazy_compile(
82
 
                u'|'.join([u'(%s)' % p for p in self._pats]),
83
 
                re.UNICODE)
 
77
            self._pat = re.compile(
 
78
                    u'|'.join([u'(%s)' % p for p in self._pats]),
 
79
                    re.UNICODE)
84
80
        return self._pat.sub(self._do_sub, text)
85
81
 
86
82
    def _do_sub(self, m):
92
88
 
93
89
 
94
90
_sub_named = Replacer()
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')
 
91
_sub_named.add(ur'\[:digit:\]', ur'\d')
 
92
_sub_named.add(ur'\[:space:\]', ur'\s')
 
93
_sub_named.add(ur'\[:alnum:\]', ur'\w')
 
94
_sub_named.add(ur'\[:ascii:\]', ur'\0-\x7f')
 
95
_sub_named.add(ur'\[:blank:\]', ur' \t')
 
96
_sub_named.add(ur'\[:cntrl:\]', ur'\0-\x1f\x7f-\x9f')
101
97
 
102
98
 
103
99
def _sub_group(m):
129
125
 
130
126
_sub_re = Replacer()
131
127
_sub_re.add(u'^RE:', u'')
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)
 
128
_sub_re.add(u'\((?!\?)', u'(?:')
 
129
_sub_re.add(u'\(\?P<.*>', _invalid_regex(u'(?:'))
 
130
_sub_re.add(u'\(\?P=[^)]*\)', _invalid_regex(u''))
 
131
_sub_re.add(ur'\\+$', _trailing_backslashes_regex)
136
132
 
137
133
 
138
134
_sub_fullpath = Replacer()
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
 
135
_sub_fullpath.add(ur'^RE:.*', _sub_re) # RE:<anything> is a regex
 
136
_sub_fullpath.add(ur'\[\^?\]?(?:[^][]|\[:[^]]+:\])+\]', _sub_group) # char group
 
137
_sub_fullpath.add(ur'(?:(?<=/)|^)(?:\.?/)+', u'') # canonicalize path
 
138
_sub_fullpath.add(ur'\\.', ur'\&') # keep anything backslashed
 
139
_sub_fullpath.add(ur'[(){}|^$+.]', ur'\\&') # escape specials
 
140
_sub_fullpath.add(ur'(?:(?<=/)|^)\*\*+/', ur'(?:.*/)?') # **/ after ^ or /
 
141
_sub_fullpath.add(ur'\*+', ur'[^/]*') # * elsewhere
 
142
_sub_fullpath.add(ur'\?', ur'[^/]') # ? everywhere
148
143
 
149
144
 
150
145
_sub_basename = Replacer()
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
 
146
_sub_basename.add(ur'\[\^?\]?(?:[^][]|\[:[^]]+:\])+\]', _sub_group) # char group
 
147
_sub_basename.add(ur'\\.', ur'\&') # keep anything backslashed
 
148
_sub_basename.add(ur'[(){}|^$+.]', ur'\\&') # escape specials
 
149
_sub_basename.add(ur'\*+', ur'.*') # * everywhere
 
150
_sub_basename.add(ur'\?', ur'.') # ? everywhere
157
151
 
158
152
 
159
153
def _sub_extension(pattern):
185
179
    so are matched first, then the basename patterns, then the fullpath
186
180
    patterns.
187
181
    """
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
 
 
209
182
    def __init__(self, patterns):
210
183
        self._regex_patterns = []
211
 
        pattern_lists = {
212
 
            "extension": [],
213
 
            "basename": [],
214
 
            "fullpath": [],
215
 
        }
 
184
        path_patterns = []
 
185
        base_patterns = []
 
186
        ext_patterns = []
216
187
        for pat in patterns:
217
188
            pat = normalize_pattern(pat)
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"])
 
189
            if pat.startswith(u'RE:') or u'/' in pat:
 
190
                path_patterns.append(pat)
 
191
            elif pat.startswith(u'*.'):
 
192
                ext_patterns.append(pat)
 
193
            else:
 
194
                base_patterns.append(pat)
 
195
        self._add_patterns(ext_patterns,_sub_extension,
 
196
            prefix=r'(?:.*/)?(?!.*/)(?:.*\.)')
 
197
        self._add_patterns(base_patterns,_sub_basename,
 
198
            prefix=r'(?:.*/)?(?!.*/)')
 
199
        self._add_patterns(path_patterns,_sub_fullpath)
223
200
 
224
201
    def _add_patterns(self, patterns, translator, prefix=''):
225
202
        while patterns:
226
 
            grouped_rules = [
227
 
                '(%s)' % translator(pat) for pat in patterns[:99]]
 
203
            grouped_rules = ['(%s)' % translator(pat) for pat in patterns[:99]]
228
204
            joined_rule = '%s(?:%s)$' % (prefix, '|'.join(grouped_rules))
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),
 
205
            self._regex_patterns.append((re.compile(joined_rule, re.UNICODE),
233
206
                patterns[:99]))
234
207
            patterns = patterns[99:]
235
208
 
242
215
            for regex, patterns in self._regex_patterns:
243
216
                match = regex.match(filename)
244
217
                if match:
245
 
                    return patterns[match.lastindex - 1]
246
 
        except lazy_regex.InvalidPattern as e:
 
218
                    return patterns[match.lastindex -1]
 
219
        except errors.InvalidPattern, e:
247
220
            # We can't show the default e.msg to the user as thats for
248
221
            # the combined pattern we sent to regex. Instead we indicate to
249
222
            # the user that an ignore file needs fixing.
250
223
            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
 
224
            e.msg = "File ~/.bazaar/ignore or .bzrignore contains errors."
260
225
            raise e
261
226
        return None
262
227
 
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
 
 
298
228
class ExceptionGlobster(object):
299
229
    """A Globster that supports exception patterns.
300
 
 
 
230
    
301
231
    Exceptions are ignore patterns prefixed with '!'.  Exception
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
 
232
    patterns take precedence over regular patterns and cause a 
 
233
    matching filename to return None from the match() function.  
 
234
    Patterns using a '!!' prefix are highest precedence, and act 
305
235
    as regular ignores. '!!' patterns are useful to establish ignores
306
236
    that apply under paths specified by '!' exception patterns.
307
237
    """
308
 
 
309
 
    def __init__(self, patterns):
 
238
    
 
239
    def __init__(self,patterns):
310
240
        ignores = [[], [], []]
311
241
        for p in patterns:
312
242
            if p.startswith(u'!!'):
316
246
            else:
317
247
                ignores[0].append(p)
318
248
        self._ignores = [Globster(i) for i in ignores]
319
 
 
 
249
        
320
250
    def match(self, filename):
321
251
        """Searches for a pattern that matches the given filename.
322
252
 
330
260
        else:
331
261
            return self._ignores[0].match(filename)
332
262
 
333
 
 
334
263
class _OrderedGlobster(Globster):
335
264
    """A Globster that keeps pattern order."""
336
265
 
343
272
        self._regex_patterns = []
344
273
        for pat in patterns:
345
274
            pat = normalize_pattern(pat)
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
 
 
 
275
            if pat.startswith(u'RE:') or u'/' in pat:
 
276
                self._add_patterns([pat], _sub_fullpath)
 
277
            elif pat.startswith(u'*.'):
 
278
                self._add_patterns([pat], _sub_extension,
 
279
                    prefix=r'(?:.*/)?(?!.*/)(?:.*\.)')
 
280
            else:
 
281
                self._add_patterns([pat], _sub_basename,
 
282
                    prefix=r'(?:.*/)?(?!.*/)')
 
283
 
 
284
 
 
285
_slashes = re.compile(r'[\\/]+')
354
286
def normalize_pattern(pattern):
355
287
    """Converts backslashes in path patterns to forward slashes.
356
288