← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/globbing.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-08-17 18:13:57 UTC
  • mfrom: (5268.7.29 transport-segments)
  • Revision ID: pqm@pqm.ubuntu.com-20110817181357-y5q5eth1hk8bl3om
(jelmer) Allow specifying the colocated branch to use in the branch URL,
 and retrieving the branch name using ControlDir._get_selected_branch.
 (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/globbing.py
1
 
# Copyright (C) 2006, 2008 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tools for converting globs to regular expressions.
18
18
 
22
22
 
23
23
import re
24
24
 
 
25
from bzrlib import (
 
26
    errors,
 
27
    lazy_regex,
 
28
    )
25
29
from bzrlib.trace import (
26
 
    warning
 
30
    mutter,
 
31
    warning,
27
32
    )
28
33
 
29
34
 
36
41
    must not contain capturing groups.
37
42
    """
38
43
 
39
 
    _expand = re.compile(ur'\\&')
 
44
    _expand = lazy_regex.lazy_compile(ur'\\&')
40
45
 
41
46
    def __init__(self, source=None):
42
47
        self._pat = None
52
57
 
53
58
        The pattern must not contain capturing groups.
54
59
        The replacement might be either a string template in which \& will be
55
 
        replaced with the match, or a function that will get the matching text  
56
 
        as argument. It does not get match object, because capturing is 
 
60
        replaced with the match, or a function that will get the matching text
 
61
        as argument. It does not get match object, because capturing is
57
62
        forbidden anyway.
58
63
        """
59
64
        self._pat = None
72
77
 
73
78
    def __call__(self, text):
74
79
        if not self._pat:
75
 
            self._pat = re.compile(
 
80
            self._pat = lazy_regex.lazy_compile(
76
81
                    u'|'.join([u'(%s)' % p for p in self._pats]),
77
82
                    re.UNICODE)
78
83
        return self._pat.sub(self._do_sub, text)
160
165
 
161
166
    Patterns are translated to regular expressions to expidite matching.
162
167
 
163
 
    The regular expressions for multiple patterns are aggregated into 
164
 
    a super-regex containing groups of up to 99 patterns.  
 
168
    The regular expressions for multiple patterns are aggregated into
 
169
    a super-regex containing groups of up to 99 patterns.
165
170
    The 99 limitation is due to the grouping limit of the Python re module.
166
171
    The resulting super-regex and associated patterns are stored as a list of
167
172
    (regex,[patterns]) in _regex_patterns.
168
 
    
 
173
 
169
174
    For performance reasons the patterns are categorised as extension patterns
170
175
    (those that match against a file extension), basename patterns
171
176
    (those that match against the basename of the filename),
172
177
    and fullpath patterns (those that match against the full path).
173
 
    The translations used for extensions and basenames are relatively simpler 
 
178
    The translations used for extensions and basenames are relatively simpler
174
179
    and therefore faster to perform than the fullpath patterns.
175
180
 
176
 
    Also, the extension patterns are more likely to find a match and 
 
181
    Also, the extension patterns are more likely to find a match and
177
182
    so are matched first, then the basename patterns, then the fullpath
178
183
    patterns.
179
184
    """
 
185
    # We want to _add_patterns in a specific order (as per type_list below)
 
186
    # starting with the shortest and going to the longest.
 
187
    # As some Python version don't support ordered dicts the list below is
 
188
    # used to select inputs for _add_pattern in a specific order.
 
189
    pattern_types = [ "extension", "basename", "fullpath" ]
 
190
 
 
191
    pattern_info = {
 
192
        "extension" : {
 
193
            "translator" : _sub_extension,
 
194
            "prefix" : r'(?:.*/)?(?!.*/)(?:.*\.)'
 
195
        },
 
196
        "basename" : {
 
197
            "translator" : _sub_basename,
 
198
            "prefix" : r'(?:.*/)?(?!.*/)'
 
199
        },
 
200
        "fullpath" : {
 
201
            "translator" : _sub_fullpath,
 
202
            "prefix" : r''
 
203
        },
 
204
    }
 
205
 
180
206
    def __init__(self, patterns):
181
207
        self._regex_patterns = []
182
 
        path_patterns = []
183
 
        base_patterns = []
184
 
        ext_patterns = []
 
208
        pattern_lists = {
 
209
            "extension" : [],
 
210
            "basename" : [],
 
211
            "fullpath" : [],
 
212
        }
185
213
        for pat in patterns:
186
214
            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) 
 
215
            pattern_lists[Globster.identify(pat)].append(pat)
 
216
        pi = Globster.pattern_info
 
217
        for t in Globster.pattern_types:
 
218
            self._add_patterns(pattern_lists[t], pi[t]["translator"],
 
219
                pi[t]["prefix"])
198
220
 
199
221
    def _add_patterns(self, patterns, translator, prefix=''):
200
222
        while patterns:
201
 
            grouped_rules = ['(%s)' % translator(pat) for pat in patterns[:99]]
 
223
            grouped_rules = [
 
224
                '(%s)' % translator(pat) for pat in patterns[:99]]
202
225
            joined_rule = '%s(?:%s)$' % (prefix, '|'.join(grouped_rules))
203
 
            self._regex_patterns.append((re.compile(joined_rule, re.UNICODE), 
 
226
            # Explicitly use lazy_compile here, because we count on its
 
227
            # nicer error reporting.
 
228
            self._regex_patterns.append((
 
229
                lazy_regex.lazy_compile(joined_rule, re.UNICODE),
204
230
                patterns[:99]))
205
231
            patterns = patterns[99:]
206
232
 
207
233
    def match(self, filename):
208
234
        """Searches for a pattern that matches the given filename.
 
235
 
 
236
        :return A matching pattern or None if there is no matching pattern.
 
237
        """
 
238
        try:
 
239
            for regex, patterns in self._regex_patterns:
 
240
                match = regex.match(filename)
 
241
                if match:
 
242
                    return patterns[match.lastindex -1]
 
243
        except errors.InvalidPattern, e:
 
244
            # We can't show the default e.msg to the user as thats for
 
245
            # the combined pattern we sent to regex. Instead we indicate to
 
246
            # the user that an ignore file needs fixing.
 
247
            mutter('Invalid pattern found in regex: %s.', e.msg)
 
248
            e.msg = "File ~/.bazaar/ignore or .bzrignore contains error(s)."
 
249
            bad_patterns = ''
 
250
            for _, patterns in self._regex_patterns:
 
251
                for p in patterns:
 
252
                    if not Globster.is_pattern_valid(p):
 
253
                        bad_patterns += ('\n  %s' % p)
 
254
            e.msg += bad_patterns
 
255
            raise e
 
256
        return None
 
257
 
 
258
    @staticmethod
 
259
    def identify(pattern):
 
260
        """Returns pattern category.
 
261
 
 
262
        :param pattern: normalized pattern.
 
263
        Identify if a pattern is fullpath, basename or extension
 
264
        and returns the appropriate type.
 
265
        """
 
266
        if pattern.startswith(u'RE:') or u'/' in pattern:
 
267
            return "fullpath"
 
268
        elif pattern.startswith(u'*.'):
 
269
            return "extension"
 
270
        else:
 
271
            return "basename"
 
272
 
 
273
    @staticmethod
 
274
    def is_pattern_valid(pattern):
 
275
        """Returns True if pattern is valid.
 
276
 
 
277
        :param pattern: Normalized pattern.
 
278
        is_pattern_valid() assumes pattern to be normalized.
 
279
        see: globbing.normalize_pattern
 
280
        """
 
281
        result = True
 
282
        translator = Globster.pattern_info[Globster.identify(pattern)]["translator"]
 
283
        tpattern = '(%s)' % translator(pattern)
 
284
        try:
 
285
            re_obj = lazy_regex.lazy_compile(tpattern, re.UNICODE)
 
286
            re_obj.search("") # force compile
 
287
        except errors.InvalidPattern, e:
 
288
            result = False
 
289
        return result
 
290
 
 
291
 
 
292
class ExceptionGlobster(object):
 
293
    """A Globster that supports exception patterns.
 
294
    
 
295
    Exceptions are ignore patterns prefixed with '!'.  Exception
 
296
    patterns take precedence over regular patterns and cause a 
 
297
    matching filename to return None from the match() function.  
 
298
    Patterns using a '!!' prefix are highest precedence, and act 
 
299
    as regular ignores. '!!' patterns are useful to establish ignores
 
300
    that apply under paths specified by '!' exception patterns.
 
301
    """
 
302
    
 
303
    def __init__(self,patterns):
 
304
        ignores = [[], [], []]
 
305
        for p in patterns:
 
306
            if p.startswith(u'!!'):
 
307
                ignores[2].append(p[2:])
 
308
            elif p.startswith(u'!'):
 
309
                ignores[1].append(p[1:])
 
310
            else:
 
311
                ignores[0].append(p)
 
312
        self._ignores = [Globster(i) for i in ignores]
209
313
        
 
314
    def match(self, filename):
 
315
        """Searches for a pattern that matches the given filename.
 
316
 
210
317
        :return A matching pattern or None if there is no matching pattern.
211
318
        """
212
 
        for regex, patterns in self._regex_patterns:
213
 
            match = regex.match(filename)
214
 
            if match:
215
 
                return patterns[match.lastindex -1]
216
 
        return None
217
 
 
 
319
        double_neg = self._ignores[2].match(filename)
 
320
        if double_neg:
 
321
            return "!!%s" % double_neg
 
322
        elif self._ignores[1].match(filename):
 
323
            return None
 
324
        else:
 
325
            return self._ignores[0].match(filename)
218
326
 
219
327
class _OrderedGlobster(Globster):
220
328
    """A Globster that keeps pattern order."""
228
336
        self._regex_patterns = []
229
337
        for pat in patterns:
230
338
            pat = normalize_pattern(pat)
231
 
            if pat.startswith(u'RE:') or u'/' in pat:
232
 
                self._add_patterns([pat], _sub_fullpath) 
233
 
            elif pat.startswith(u'*.'):
234
 
                self._add_patterns([pat], _sub_extension,
235
 
                    prefix=r'(?:.*/)?(?!.*/)(?:.*\.)')
236
 
            else:
237
 
                self._add_patterns([pat], _sub_basename, 
238
 
                    prefix=r'(?:.*/)?(?!.*/)')
239
 
 
240
 
 
 
339
            t = Globster.identify(pat)
 
340
            self._add_patterns([pat], Globster.pattern_info[t]["translator"],
 
341
                Globster.pattern_info[t]["prefix"])
 
342
 
 
343
 
 
344
_slashes = lazy_regex.lazy_compile(r'[\\/]+')
241
345
def normalize_pattern(pattern):
242
346
    """Converts backslashes in path patterns to forward slashes.
243
 
    
 
347
 
244
348
    Doesn't normalize regular expressions - they may contain escapes.
245
349
    """
246
 
    if not pattern.startswith('RE:'):
247
 
        pattern = pattern.replace('\\','/')
248
 
    return pattern.rstrip('/')
 
350
    if not (pattern.startswith('RE:') or pattern.startswith('!RE:')):
 
351
        pattern = _slashes.sub('/', pattern)
 
352
    if len(pattern) > 1:
 
353
        pattern = pattern.rstrip('/')
 
354
    return pattern