← 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: 2010-10-05 21:15:13 UTC
  • mfrom: (5448.3.5 374700-Add-gnu-lsh-support)
  • Revision ID: pqm@pqm.ubuntu.com-20101005211513-whouyj5t7oo92gmq
(gz) Add support for GNU lsh as a secure shell client (Matthew Gordon)

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