← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: Vincent Ladeuil
  • Date: 2010-08-30 07:42:12 UTC
  • mfrom: (5247.2.39 catch-them-all)
  • mto: This revision was merged to the branch mainline in revision 5396.
  • Revision ID: v.ladeuil+lp@free.fr-20100830074212-y0vj6t3sm1zr706y
Fix most of the leaking tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
1
 
# Copyright (C) 2006, 2008 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
101
101
    first_path_slash = path.find('/')
102
102
    if first_path_slash == -1:
103
103
        return len(scheme), None
104
 
    return len(scheme), first_path_slash+len(scheme)+3
 
104
    return len(scheme), first_path_slash+m.start('path')
 
105
 
 
106
 
 
107
def is_url(url):
 
108
    """Tests whether a URL is in actual fact a URL."""
 
109
    return _url_scheme_re.match(url) is not None
105
110
 
106
111
 
107
112
def join(base, *args):
118
123
    """
119
124
    if not args:
120
125
        return base
121
 
    match = _url_scheme_re.match(base)
122
 
    scheme = None
123
 
    if match:
124
 
        scheme = match.group('scheme')
125
 
        path = match.group('path').split('/')
126
 
        if path[-1:] == ['']:
127
 
            # Strip off a trailing slash
128
 
            # This helps both when we are at the root, and when
129
 
            # 'base' has an extra slash at the end
130
 
            path = path[:-1]
131
 
    else:
132
 
        path = base.split('/')
133
 
 
134
 
    if scheme is not None and len(path) >= 1:
135
 
        host = path[:1]
136
 
        # the path should be represented as an abs path.
137
 
        # we know this must be absolute because of the presence of a URL scheme.
138
 
        remove_root = True
139
 
        path = [''] + path[1:]
140
 
    else:
141
 
        # create an empty host, but dont alter the path - this might be a
142
 
        # relative url fragment.
143
 
        host = []
144
 
        remove_root = False
145
 
 
 
126
    scheme_end, path_start = _find_scheme_and_separator(base)
 
127
    if scheme_end is None and path_start is None:
 
128
        path_start = 0
 
129
    elif path_start is None:
 
130
        path_start = len(base)
 
131
    path = base[path_start:]
146
132
    for arg in args:
147
 
        match = _url_scheme_re.match(arg)
148
 
        if match:
149
 
            # Absolute URL
150
 
            scheme = match.group('scheme')
151
 
            # this skips .. normalisation, making http://host/../../..
152
 
            # be rather strange.
153
 
            path = match.group('path').split('/')
154
 
            # set the host and path according to new absolute URL, discarding
155
 
            # any previous values.
156
 
            # XXX: duplicates mess from earlier in this function.  This URL
157
 
            # manipulation code needs some cleaning up.
158
 
            if scheme is not None and len(path) >= 1:
159
 
                host = path[:1]
160
 
                path = path[1:]
161
 
                # url scheme implies absolute path.
162
 
                path = [''] + path
163
 
            else:
164
 
                # no url scheme we take the path as is.
165
 
                host = []
 
133
        arg_scheme_end, arg_path_start = _find_scheme_and_separator(arg)
 
134
        if arg_scheme_end is None and arg_path_start is None:
 
135
            arg_path_start = 0
 
136
        elif arg_path_start is None:
 
137
            arg_path_start = len(arg)
 
138
        if arg_scheme_end is not None:
 
139
            base = arg
 
140
            path = arg[arg_path_start:]
 
141
            scheme_end = arg_scheme_end
 
142
            path_start = arg_path_start
166
143
        else:
167
 
            path = '/'.join(path)
168
144
            path = joinpath(path, arg)
169
 
            path = path.split('/')
170
 
    if remove_root and path[0:1] == ['']:
171
 
        del path[0]
172
 
    if host:
173
 
        # Remove the leading slash from the path, so long as it isn't also the
174
 
        # trailing slash, which we want to keep if present.
175
 
        if path and path[0] == '' and len(path) > 1:
176
 
            del path[0]
177
 
        path = host + path
178
 
 
179
 
    if scheme is None:
180
 
        return '/'.join(path)
181
 
    return scheme + '://' + '/'.join(path)
 
145
    return base[:path_start] + path
182
146
 
183
147
 
184
148
def joinpath(base, *args):
217
181
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
218
182
def _posix_local_path_from_url(url):
219
183
    """Convert a url like file:///path/to/foo into /path/to/foo"""
220
 
    if not url.startswith('file:///'):
221
 
        raise errors.InvalidURL(url, 'local urls must start with file:///')
 
184
    file_localhost_prefix = 'file://localhost/'
 
185
    if url.startswith(file_localhost_prefix):
 
186
        path = url[len(file_localhost_prefix) - 1:]
 
187
    elif not url.startswith('file:///'):
 
188
        raise errors.InvalidURL(
 
189
            url, 'local urls must start with file:/// or file://localhost/')
 
190
    else:
 
191
        path = url[len('file://'):]
222
192
    # We only strip off 2 slashes
223
 
    return unescape(url[len('file://'):])
 
193
    return unescape(path)
224
194
 
225
195
 
226
196
def _posix_local_path_to_url(path):
272
242
    # on non-win32 platform
273
243
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
274
244
    #       which actually strips trailing space characters.
275
 
    #       The worst part is that under linux ntpath.abspath has different
 
245
    #       The worst part is that on linux ntpath.abspath has different
276
246
    #       semantics, since 'nt' is not an available module.
277
247
    if path == '/':
278
248
        return 'file:///'
297
267
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
298
268
 
299
269
 
300
 
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
 
270
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
301
271
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
302
272
 
303
273
 
333
303
    :param url: Either a hybrid URL or a local path
334
304
    :return: A normalized URL which only includes 7-bit ASCII characters.
335
305
    """
336
 
    m = _url_scheme_re.match(url)
337
 
    if not m:
 
306
    scheme_end, path_start = _find_scheme_and_separator(url)
 
307
    if scheme_end is None:
338
308
        return local_path_to_url(url)
339
 
    scheme = m.group('scheme')
340
 
    path = m.group('path')
 
309
    prefix = url[:path_start]
 
310
    path = url[path_start:]
341
311
    if not isinstance(url, unicode):
342
312
        for c in url:
343
313
            if c not in _url_safe_characters:
344
314
                raise errors.InvalidURL(url, 'URLs can only contain specific'
345
315
                                            ' safe characters (not %r)' % c)
346
316
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
347
 
        return str(scheme + '://' + ''.join(path))
 
317
        return str(prefix + ''.join(path))
348
318
 
349
319
    # We have a unicode (hybrid) url
350
320
    path_chars = list(path)
356
326
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
357
327
    path = ''.join(path_chars)
358
328
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
359
 
    return str(scheme + '://' + path)
 
329
    return str(prefix + path)
360
330
 
361
331
 
362
332
def relative_url(base, other):
463
433
    return url_base + head, tail
464
434
 
465
435
 
 
436
def split_segment_parameters_raw(url):
 
437
    """Split the subsegment of the last segment of a URL.
 
438
 
 
439
    :param url: A relative or absolute URL
 
440
    :return: (url, subsegments)
 
441
    """
 
442
    (parent_url, child_dir) = split(url)
 
443
    subsegments = child_dir.split(",")
 
444
    if len(subsegments) == 1:
 
445
        return (url, [])
 
446
    return (join(parent_url, subsegments[0]), subsegments[1:])
 
447
 
 
448
 
 
449
def split_segment_parameters(url):
 
450
    """Split the segment parameters of the last segment of a URL.
 
451
 
 
452
    :param url: A relative or absolute URL
 
453
    :return: (url, segment_parameters)
 
454
    """
 
455
    (base_url, subsegments) = split_segment_parameters_raw(url)
 
456
    parameters = {}
 
457
    for subsegment in subsegments:
 
458
        (key, value) = subsegment.split("=", 1)
 
459
        parameters[key] = value
 
460
    return (base_url, parameters)
 
461
 
 
462
 
 
463
def join_segment_parameters_raw(base, *subsegments):
 
464
    """Create a new URL by adding subsegments to an existing one. 
 
465
 
 
466
    This adds the specified subsegments to the last path in the specified
 
467
    base URL. The subsegments should be bytestrings.
 
468
 
 
469
    :note: You probably want to use join_segment_parameters instead.
 
470
    """
 
471
    if not subsegments:
 
472
        return base
 
473
    for subsegment in subsegments:
 
474
        if type(subsegment) is not str:
 
475
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
 
476
        if "," in subsegment:
 
477
            raise errors.InvalidURLJoin(", exists in subsegments",
 
478
                                        base, subsegments)
 
479
    return ",".join((base,) + subsegments)
 
480
 
 
481
 
 
482
def join_segment_parameters(url, parameters):
 
483
    """Create a new URL by adding segment parameters to an existing one.
 
484
 
 
485
    The parameters of the last segment in the URL will be updated; if a
 
486
    parameter with the same key already exists it will be overwritten.
 
487
 
 
488
    :param url: A URL, as string
 
489
    :param parameters: Dictionary of parameters, keys and values as bytestrings
 
490
    """
 
491
    (base, existing_parameters) = split_segment_parameters(url)
 
492
    new_parameters = {}
 
493
    new_parameters.update(existing_parameters)
 
494
    for key, value in parameters.iteritems():
 
495
        if type(key) is not str:
 
496
            raise TypeError("parameter key %r is not a bytestring" % key)
 
497
        if type(value) is not str:
 
498
            raise TypeError("parameter value %r for %s is not a bytestring" %
 
499
                (key, value))
 
500
        if "=" in key:
 
501
            raise errors.InvalidURLJoin("= exists in parameter key", url,
 
502
                parameters)
 
503
        new_parameters[key] = value
 
504
    return join_segment_parameters_raw(base, 
 
505
        *["%s=%s" % item for item in sorted(new_parameters.items())])
 
506
 
 
507
 
466
508
def _win32_strip_local_trailing_slash(url):
467
509
    """Strip slashes after the drive letter"""
468
510
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH: