← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/globbing.py

  • Committer: Martin
  • Date: 2011-05-21 16:29:38 UTC
  • mto: This revision was merged to the branch mainline in revision 5907.
  • Revision ID: gzlist@googlemail.com-20110521162938-1vrw3hp0197l3vrl
Add tests for non-ascii conflict serialisation

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
22
22
 
23
23
import re
24
24
 
25
 
from bzrlib import (
26
 
    errors,
27
 
    lazy_regex,
28
 
    )
 
25
from bzrlib import errors
29
26
from bzrlib.trace import (
30
27
    mutter,
31
28
    warning,
41
38
    must not contain capturing groups.
42
39
    """
43
40
 
44
 
    _expand = lazy_regex.lazy_compile(ur'\\&')
 
41
    _expand = re.compile(ur'\\&')
45
42
 
46
43
    def __init__(self, source=None):
47
44
        self._pat = None
77
74
 
78
75
    def __call__(self, text):
79
76
        if not self._pat:
80
 
            self._pat = lazy_regex.lazy_compile(
 
77
            self._pat = re.compile(
81
78
                    u'|'.join([u'(%s)' % p for p in self._pats]),
82
79
                    re.UNICODE)
83
80
        return self._pat.sub(self._do_sub, text)
220
217
 
221
218
    def _add_patterns(self, patterns, translator, prefix=''):
222
219
        while patterns:
223
 
            grouped_rules = [
224
 
                '(%s)' % translator(pat) for pat in patterns[:99]]
 
220
            grouped_rules = ['(%s)' % translator(pat) for pat in patterns[:99]]
225
221
            joined_rule = '%s(?:%s)$' % (prefix, '|'.join(grouped_rules))
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),
 
222
            self._regex_patterns.append((re.compile(joined_rule, re.UNICODE),
230
223
                patterns[:99]))
231
224
            patterns = patterns[99:]
232
225
 
282
275
        translator = Globster.pattern_info[Globster.identify(pattern)]["translator"]
283
276
        tpattern = '(%s)' % translator(pattern)
284
277
        try:
285
 
            re_obj = lazy_regex.lazy_compile(tpattern, re.UNICODE)
 
278
            re_obj = re.compile(tpattern, re.UNICODE)
286
279
            re_obj.search("") # force compile
287
280
        except errors.InvalidPattern, e:
288
281
            result = False
341
334
                Globster.pattern_info[t]["prefix"])
342
335
 
343
336
 
344
 
_slashes = lazy_regex.lazy_compile(r'[\\/]+')
 
337
_slashes = re.compile(r'[\\/]+')
345
338
def normalize_pattern(pattern):
346
339
    """Converts backslashes in path patterns to forward slashes.
347
340