~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: John Arbash Meinel
  • Date: 2009-09-22 02:18:24 UTC
  • mto: This revision was merged to the branch mainline in revision 4709.
  • Revision ID: john@arbash-meinel.com-20090922021824-j3en52uqoof7ym89
Remove some assert statements.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2008 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+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
 
104
    return len(scheme), first_path_slash+len(scheme)+3
110
105
 
111
106
 
112
107
def join(base, *args):
123
118
    """
124
119
    if not args:
125
120
        return base
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:]
 
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
 
132
146
    for arg in args:
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
 
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 = []
143
166
        else:
 
167
            path = '/'.join(path)
144
168
            path = joinpath(path, arg)
145
 
    return base[:path_start] + path
 
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)
146
182
 
147
183
 
148
184
def joinpath(base, *args):
181
217
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
182
218
def _posix_local_path_from_url(url):
183
219
    """Convert a url like file:///path/to/foo into /path/to/foo"""
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://'):]
 
220
    if not url.startswith('file:///'):
 
221
        raise errors.InvalidURL(url, 'local urls must start with file:///')
192
222
    # We only strip off 2 slashes
193
 
    return unescape(path)
 
223
    return unescape(url[len('file://'):])
194
224
 
195
225
 
196
226
def _posix_local_path_to_url(path):
242
272
    # on non-win32 platform
243
273
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
244
274
    #       which actually strips trailing space characters.
245
 
    #       The worst part is that on linux ntpath.abspath has different
 
275
    #       The worst part is that under linux ntpath.abspath has different
246
276
    #       semantics, since 'nt' is not an available module.
247
277
    if path == '/':
248
278
        return 'file:///'
267
297
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
268
298
 
269
299
 
270
 
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
 
300
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
271
301
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
272
302
 
273
303
 
303
333
    :param url: Either a hybrid URL or a local path
304
334
    :return: A normalized URL which only includes 7-bit ASCII characters.
305
335
    """
306
 
    scheme_end, path_start = _find_scheme_and_separator(url)
307
 
    if scheme_end is None:
 
336
    m = _url_scheme_re.match(url)
 
337
    if not m:
308
338
        return local_path_to_url(url)
309
 
    prefix = url[:path_start]
310
 
    path = url[path_start:]
 
339
    scheme = m.group('scheme')
 
340
    path = m.group('path')
311
341
    if not isinstance(url, unicode):
312
342
        for c in url:
313
343
            if c not in _url_safe_characters:
314
344
                raise errors.InvalidURL(url, 'URLs can only contain specific'
315
345
                                            ' safe characters (not %r)' % c)
316
346
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
317
 
        return str(prefix + ''.join(path))
 
347
        return str(scheme + '://' + ''.join(path))
318
348
 
319
349
    # We have a unicode (hybrid) url
320
350
    path_chars = list(path)
326
356
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
327
357
    path = ''.join(path_chars)
328
358
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
329
 
    return str(prefix + path)
 
359
    return str(scheme + '://' + path)
330
360
 
331
361
 
332
362
def relative_url(base, other):
433
463
    return url_base + head, tail
434
464
 
435
465
 
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
 
 
508
466
def _win32_strip_local_trailing_slash(url):
509
467
    """Strip slashes after the drive letter"""
510
468
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH: