← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: Robert Collins
  • Author(s): Vincent Ladeuil
  • Date: 2009-04-07 07:20:17 UTC
  • mto: This revision was merged to the branch mainline in revision 4262.
  • Revision ID: robertc@robertcollins.net-20090407072017-rxvtpahno3yfb52e
Add InterCHKRevisionTree

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Bazaar -- distributed version control
 
2
#
 
3
# Copyright (C) 2006 Canonical Ltd
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
75
77
    This assumes that both paths are already fully specified file:// URLs.
76
78
    """
77
79
    if len(base) < MIN_ABS_FILEURL_LENGTH:
78
 
        raise ValueError('Length of base (%r) must equal or'
 
80
        raise ValueError('Length of base must be equal or'
79
81
            ' exceed the platform minimum url length (which is %d)' %
80
 
            (base, MIN_ABS_FILEURL_LENGTH))
 
82
            MIN_ABS_FILEURL_LENGTH)
81
83
    base = local_path_from_url(base)
82
84
    path = local_path_from_url(path)
83
85
    return escape(osutils.relpath(base, path))
101
103
    first_path_slash = path.find('/')
102
104
    if first_path_slash == -1:
103
105
        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
 
106
    return len(scheme), first_path_slash+len(scheme)+3
110
107
 
111
108
 
112
109
def join(base, *args):
123
120
    """
124
121
    if not args:
125
122
        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:]
 
123
    match = _url_scheme_re.match(base)
 
124
    scheme = None
 
125
    if match:
 
126
        scheme = match.group('scheme')
 
127
        path = match.group('path').split('/')
 
128
        if path[-1:] == ['']:
 
129
            # Strip off a trailing slash
 
130
            # This helps both when we are at the root, and when
 
131
            # 'base' has an extra slash at the end
 
132
            path = path[:-1]
 
133
    else:
 
134
        path = base.split('/')
 
135
 
 
136
    if scheme is not None and len(path) >= 1:
 
137
        host = path[:1]
 
138
        # the path should be represented as an abs path.
 
139
        # we know this must be absolute because of the presence of a URL scheme.
 
140
        remove_root = True
 
141
        path = [''] + path[1:]
 
142
    else:
 
143
        # create an empty host, but dont alter the path - this might be a
 
144
        # relative url fragment.
 
145
        host = []
 
146
        remove_root = False
 
147
 
132
148
    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
 
149
        match = _url_scheme_re.match(arg)
 
150
        if match:
 
151
            # Absolute URL
 
152
            scheme = match.group('scheme')
 
153
            # this skips .. normalisation, making http://host/../../..
 
154
            # be rather strange.
 
155
            path = match.group('path').split('/')
 
156
            # set the host and path according to new absolute URL, discarding
 
157
            # any previous values.
 
158
            # XXX: duplicates mess from earlier in this function.  This URL
 
159
            # manipulation code needs some cleaning up.
 
160
            if scheme is not None and len(path) >= 1:
 
161
                host = path[:1]
 
162
                path = path[1:]
 
163
                # url scheme implies absolute path.
 
164
                path = [''] + path
 
165
            else:
 
166
                # no url scheme we take the path as is.
 
167
                host = []
143
168
        else:
 
169
            path = '/'.join(path)
144
170
            path = joinpath(path, arg)
145
 
    return base[:path_start] + path
 
171
            path = path.split('/')
 
172
    if remove_root and path[0:1] == ['']:
 
173
        del path[0]
 
174
    if host:
 
175
        # Remove the leading slash from the path, so long as it isn't also the
 
176
        # trailing slash, which we want to keep if present.
 
177
        if path and path[0] == '' and len(path) > 1:
 
178
            del path[0]
 
179
        path = host + path
 
180
 
 
181
    if scheme is None:
 
182
        return '/'.join(path)
 
183
    return scheme + '://' + '/'.join(path)
146
184
 
147
185
 
148
186
def joinpath(base, *args):
181
219
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
182
220
def _posix_local_path_from_url(url):
183
221
    """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://'):]
 
222
    if not url.startswith('file:///'):
 
223
        raise errors.InvalidURL(url, 'local urls must start with file:///')
192
224
    # We only strip off 2 slashes
193
 
    return unescape(path)
 
225
    return unescape(url[len('file://'):])
194
226
 
195
227
 
196
228
def _posix_local_path_to_url(path):
224
256
        return '/'
225
257
 
226
258
    # usual local path with drive letter
227
 
    if (len(win32_url) < 6
228
 
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
229
 
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
259
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
260
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
230
261
        or win32_url[4] not in  '|:'
231
262
        or win32_url[5] != '/'):
232
263
        raise errors.InvalidURL(url, 'Win32 file urls start with'
243
274
    # on non-win32 platform
244
275
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
245
276
    #       which actually strips trailing space characters.
246
 
    #       The worst part is that on linux ntpath.abspath has different
 
277
    #       The worst part is that under linux ntpath.abspath has different
247
278
    #       semantics, since 'nt' is not an available module.
248
279
    if path == '/':
249
280
        return 'file:///'
268
299
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
269
300
 
270
301
 
271
 
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
 
302
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
272
303
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
273
304
 
274
305
 
304
335
    :param url: Either a hybrid URL or a local path
305
336
    :return: A normalized URL which only includes 7-bit ASCII characters.
306
337
    """
307
 
    scheme_end, path_start = _find_scheme_and_separator(url)
308
 
    if scheme_end is None:
 
338
    m = _url_scheme_re.match(url)
 
339
    if not m:
309
340
        return local_path_to_url(url)
310
 
    prefix = url[:path_start]
311
 
    path = url[path_start:]
 
341
    scheme = m.group('scheme')
 
342
    path = m.group('path')
312
343
    if not isinstance(url, unicode):
313
344
        for c in url:
314
345
            if c not in _url_safe_characters:
315
346
                raise errors.InvalidURL(url, 'URLs can only contain specific'
316
347
                                            ' safe characters (not %r)' % c)
317
348
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
318
 
        return str(prefix + ''.join(path))
 
349
        return str(scheme + '://' + ''.join(path))
319
350
 
320
351
    # We have a unicode (hybrid) url
321
352
    path_chars = list(path)
327
358
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
328
359
    path = ''.join(path_chars)
329
360
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
330
 
    return str(prefix + path)
 
361
    return str(scheme + '://' + path)
331
362
 
332
363
 
333
364
def relative_url(base, other):
434
465
    return url_base + head, tail
435
466
 
436
467
 
437
 
def split_segment_parameters_raw(url):
438
 
    """Split the subsegment of the last segment of a URL.
439
 
 
440
 
    :param url: A relative or absolute URL
441
 
    :return: (url, subsegments)
442
 
    """
443
 
    (parent_url, child_dir) = split(url)
444
 
    subsegments = child_dir.split(",")
445
 
    if len(subsegments) == 1:
446
 
        return (url, [])
447
 
    return (join(parent_url, subsegments[0]), subsegments[1:])
448
 
 
449
 
 
450
 
def split_segment_parameters(url):
451
 
    """Split the segment parameters of the last segment of a URL.
452
 
 
453
 
    :param url: A relative or absolute URL
454
 
    :return: (url, segment_parameters)
455
 
    """
456
 
    (base_url, subsegments) = split_segment_parameters_raw(url)
457
 
    parameters = {}
458
 
    for subsegment in subsegments:
459
 
        (key, value) = subsegment.split("=", 1)
460
 
        parameters[key] = value
461
 
    return (base_url, parameters)
462
 
 
463
 
 
464
 
def join_segment_parameters_raw(base, *subsegments):
465
 
    """Create a new URL by adding subsegments to an existing one. 
466
 
 
467
 
    This adds the specified subsegments to the last path in the specified
468
 
    base URL. The subsegments should be bytestrings.
469
 
 
470
 
    :note: You probably want to use join_segment_parameters instead.
471
 
    """
472
 
    if not subsegments:
473
 
        return base
474
 
    for subsegment in subsegments:
475
 
        if type(subsegment) is not str:
476
 
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
477
 
        if "," in subsegment:
478
 
            raise errors.InvalidURLJoin(", exists in subsegments",
479
 
                                        base, subsegments)
480
 
    return ",".join((base,) + subsegments)
481
 
 
482
 
 
483
 
def join_segment_parameters(url, parameters):
484
 
    """Create a new URL by adding segment parameters to an existing one.
485
 
 
486
 
    The parameters of the last segment in the URL will be updated; if a
487
 
    parameter with the same key already exists it will be overwritten.
488
 
 
489
 
    :param url: A URL, as string
490
 
    :param parameters: Dictionary of parameters, keys and values as bytestrings
491
 
    """
492
 
    (base, existing_parameters) = split_segment_parameters(url)
493
 
    new_parameters = {}
494
 
    new_parameters.update(existing_parameters)
495
 
    for key, value in parameters.iteritems():
496
 
        if type(key) is not str:
497
 
            raise TypeError("parameter key %r is not a bytestring" % key)
498
 
        if type(value) is not str:
499
 
            raise TypeError("parameter value %r for %s is not a bytestring" %
500
 
                (key, value))
501
 
        if "=" in key:
502
 
            raise errors.InvalidURLJoin("= exists in parameter key", url,
503
 
                parameters)
504
 
        new_parameters[key] = value
505
 
    return join_segment_parameters_raw(base, 
506
 
        *["%s=%s" % item for item in sorted(new_parameters.items())])
507
 
 
508
 
 
509
468
def _win32_strip_local_trailing_slash(url):
510
469
    """Strip slashes after the drive letter"""
511
470
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
728
687
    if len(segments) == 0:
729
688
        return '.'
730
689
    return osutils.pathjoin(*segments)
731
 
 
732
 
 
733
 
 
734
 
def parse_url(url):
735
 
    """Extract the server address, the credentials and the path from the url.
736
 
 
737
 
    user, password, host and path should be quoted if they contain reserved
738
 
    chars.
739
 
 
740
 
    :param url: an quoted url
741
 
 
742
 
    :return: (scheme, user, password, host, port, path) tuple, all fields
743
 
        are unquoted.
744
 
    """
745
 
    if isinstance(url, unicode):
746
 
        raise errors.InvalidURL('should be ascii:\n%r' % url)
747
 
    url = url.encode('utf-8')
748
 
    (scheme, netloc, path, params,
749
 
     query, fragment) = urlparse.urlparse(url, allow_fragments=False)
750
 
    user = password = host = port = None
751
 
    if '@' in netloc:
752
 
        user, host = netloc.rsplit('@', 1)
753
 
        if ':' in user:
754
 
            user, password = user.split(':', 1)
755
 
            password = urllib.unquote(password)
756
 
        user = urllib.unquote(user)
757
 
    else:
758
 
        host = netloc
759
 
 
760
 
    if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port
761
 
        host, port = host.rsplit(':',1)
762
 
        try:
763
 
            port = int(port)
764
 
        except ValueError:
765
 
            raise errors.InvalidURL('invalid port number %s in url:\n%s' %
766
 
                                    (port, url))
767
 
    if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
768
 
        host = host[1:-1]
769
 
 
770
 
    host = urllib.unquote(host)
771
 
    path = urllib.unquote(path)
772
 
 
773
 
    return (scheme, user, password, host, port, path)