/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-11-16 18:59:44 UTC
  • mfrom: (7143.15.15 more-cleanups)
  • Revision ID: breezy.the.bot@gmail.com-20181116185944-biefv1sub37qfybm
Sprinkle some PEP8iness.

Merged from https://code.launchpad.net/~jelmer/brz/more-cleanups/+merge/358611

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/globbing.py
79
79
    def __call__(self, text):
80
80
        if not self._pat:
81
81
            self._pat = lazy_regex.lazy_compile(
82
 
                    u'|'.join([u'(%s)' % p for p in self._pats]),
83
 
                    re.UNICODE)
 
82
                u'|'.join([u'(%s)' % p for p in self._pats]),
 
83
                re.UNICODE)
84
84
        return self._pat.sub(self._do_sub, text)
85
85
 
86
86
    def _do_sub(self, m):
136
136
 
137
137
 
138
138
_sub_fullpath = Replacer()
139
 
_sub_fullpath.add(r'^RE:.*', _sub_re) # RE:<anything> is a regex
140
 
_sub_fullpath.add(r'\[\^?\]?(?:[^][]|\[:[^]]+:\])+\]', _sub_group) # char group
141
 
_sub_fullpath.add(r'(?:(?<=/)|^)(?:\.?/)+', u'') # canonicalize path
142
 
_sub_fullpath.add(r'\\.', r'\&') # keep anything backslashed
143
 
_sub_fullpath.add(r'[(){}|^$+.]', r'\\&') # escape specials
144
 
_sub_fullpath.add(r'(?:(?<=/)|^)\*\*+/', r'(?:.*/)?') # **/ after ^ or /
145
 
_sub_fullpath.add(r'\*+', r'[^/]*') # * elsewhere
146
 
_sub_fullpath.add(r'\?', r'[^/]') # ? 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
147
148
 
148
149
 
149
150
_sub_basename = Replacer()
150
 
_sub_basename.add(r'\[\^?\]?(?:[^][]|\[:[^]]+:\])+\]', _sub_group) # char group
151
 
_sub_basename.add(r'\\.', r'\&') # keep anything backslashed
152
 
_sub_basename.add(r'[(){}|^$+.]', r'\\&') # escape specials
153
 
_sub_basename.add(r'\*+', r'.*') # * everywhere
154
 
_sub_basename.add(r'\?', r'.') # ? 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
155
157
 
156
158
 
157
159
def _sub_extension(pattern):
187
189
    # starting with the shortest and going to the longest.
188
190
    # As some Python version don't support ordered dicts the list below is
189
191
    # used to select inputs for _add_pattern in a specific order.
190
 
    pattern_types = [ "extension", "basename", "fullpath" ]
 
192
    pattern_types = ["extension", "basename", "fullpath"]
191
193
 
192
194
    pattern_info = {
193
195
        "extension": {
194
 
            "translator" : _sub_extension,
195
 
            "prefix" : r'(?:.*/)?(?!.*/)(?:.*\.)'
 
196
            "translator": _sub_extension,
 
197
            "prefix": r'(?:.*/)?(?!.*/)(?:.*\.)'
196
198
        },
197
199
        "basename": {
198
 
            "translator" : _sub_basename,
199
 
            "prefix" : r'(?:.*/)?(?!.*/)'
 
200
            "translator": _sub_basename,
 
201
            "prefix": r'(?:.*/)?(?!.*/)'
200
202
        },
201
203
        "fullpath": {
202
 
            "translator" : _sub_fullpath,
203
 
            "prefix" : r''
 
204
            "translator": _sub_fullpath,
 
205
            "prefix": r''
204
206
        },
205
207
    }
206
208
 
217
219
        pi = Globster.pattern_info
218
220
        for t in Globster.pattern_types:
219
221
            self._add_patterns(pattern_lists[t], pi[t]["translator"],
220
 
                pi[t]["prefix"])
 
222
                               pi[t]["prefix"])
221
223
 
222
224
    def _add_patterns(self, patterns, translator, prefix=''):
223
225
        while patterns:
240
242
            for regex, patterns in self._regex_patterns:
241
243
                match = regex.match(filename)
242
244
                if match:
243
 
                    return patterns[match.lastindex -1]
 
245
                    return patterns[match.lastindex - 1]
244
246
        except lazy_regex.InvalidPattern as e:
245
247
            # We can't show the default e.msg to the user as thats for
246
248
            # the combined pattern we sent to regex. Instead we indicate to
280
282
        see: globbing.normalize_pattern
281
283
        """
282
284
        result = True
283
 
        translator = Globster.pattern_info[Globster.identify(pattern)]["translator"]
 
285
        translator = Globster.pattern_info[Globster.identify(
 
286
            pattern)]["translator"]
284
287
        tpattern = '(%s)' % translator(pattern)
285
288
        try:
286
289
            re_obj = lazy_regex.lazy_compile(tpattern, re.UNICODE)
287
 
            re_obj.search("") # force compile
288
 
        except lazy_regex.InvalidPattern as e:
 
290
            re_obj.search("")  # force compile
 
291
        except lazy_regex.InvalidPattern:
289
292
            result = False
290
293
        return result
291
294
 
292
295
 
293
296
class ExceptionGlobster(object):
294
297
    """A Globster that supports exception patterns.
295
 
    
 
298
 
296
299
    Exceptions are ignore patterns prefixed with '!'.  Exception
297
300
    patterns take precedence over regular patterns and cause a 
298
301
    matching filename to return None from the match() function.  
300
303
    as regular ignores. '!!' patterns are useful to establish ignores
301
304
    that apply under paths specified by '!' exception patterns.
302
305
    """
303
 
    
 
306
 
304
307
    def __init__(self, patterns):
305
308
        ignores = [[], [], []]
306
309
        for p in patterns:
311
314
            else:
312
315
                ignores[0].append(p)
313
316
        self._ignores = [Globster(i) for i in ignores]
314
 
        
 
317
 
315
318
    def match(self, filename):
316
319
        """Searches for a pattern that matches the given filename.
317
320
 
325
328
        else:
326
329
            return self._ignores[0].match(filename)
327
330
 
 
331
 
328
332
class _OrderedGlobster(Globster):
329
333
    """A Globster that keeps pattern order."""
330
334
 
339
343
            pat = normalize_pattern(pat)
340
344
            t = Globster.identify(pat)
341
345
            self._add_patterns([pat], Globster.pattern_info[t]["translator"],
342
 
                Globster.pattern_info[t]["prefix"])
 
346
                               Globster.pattern_info[t]["prefix"])
343
347
 
344
348
 
345
349
_slashes = lazy_regex.lazy_compile(r'[\\/]+')
 
350
 
 
351
 
346
352
def normalize_pattern(pattern):
347
353
    """Converts backslashes in path patterns to forward slashes.
348
354