← 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-10-26 08:08:23 UTC
  • mfrom: (5514.1.1 665100-content-type)
  • mto: This revision was merged to the branch mainline in revision 5516.
  • Revision ID: v.ladeuil+lp@free.fr-20101026080823-3wggo03b7cpn9908
Correctly set the Content-Type header when POSTing http requests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
1
 
# Bazaar-NG -- distributed version control
2
 
#
3
 
# Copyright (C) 2006 by Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
4
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
14
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
16
 
19
17
"""A collection of function for handling URL operations."""
20
18
 
21
19
import os
22
 
from posixpath import split as _posix_split, normpath as _posix_normpath
23
20
import re
24
21
import sys
 
22
 
 
23
from bzrlib.lazy_import import lazy_import
 
24
lazy_import(globals(), """
 
25
from posixpath import split as _posix_split, normpath as _posix_normpath
25
26
import urllib
 
27
import urlparse
26
28
 
27
 
import bzrlib.errors as errors
28
 
import bzrlib.osutils
 
29
from bzrlib import (
 
30
    errors,
 
31
    osutils,
 
32
    )
 
33
""")
29
34
 
30
35
 
31
36
def basename(url, exclude_trailing_slash=True):
61
66
        relpath = relpath.encode('utf-8')
62
67
    # After quoting and encoding, the path should be perfectly
63
68
    # safe as a plain ASCII string, str() just enforces this
64
 
    return str(urllib.quote(relpath))
 
69
    return str(urllib.quote(relpath, safe='/~'))
65
70
 
66
71
 
67
72
def file_relpath(base, path):
68
73
    """Compute just the relative sub-portion of a url
69
 
    
 
74
 
70
75
    This assumes that both paths are already fully specified file:// URLs.
71
76
    """
72
 
    assert len(base) >= MIN_ABS_FILEURL_LENGTH, ('Length of base must be equal or'
73
 
        ' exceed the platform minimum url length (which is %d)' % 
74
 
        MIN_ABS_FILEURL_LENGTH)
75
 
 
 
77
    if len(base) < MIN_ABS_FILEURL_LENGTH:
 
78
        raise ValueError('Length of base (%r) must equal or'
 
79
            ' exceed the platform minimum url length (which is %d)' %
 
80
            (base, MIN_ABS_FILEURL_LENGTH))
76
81
    base = local_path_from_url(base)
77
82
    path = local_path_from_url(path)
78
 
    return escape(bzrlib.osutils.relpath(base, path))
 
83
    return escape(osutils.relpath(base, path))
79
84
 
80
85
 
81
86
def _find_scheme_and_separator(url):
96
101
    first_path_slash = path.find('/')
97
102
    if first_path_slash == -1:
98
103
        return len(scheme), None
99
 
    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
100
110
 
101
111
 
102
112
def join(base, *args):
111
121
        join('http://foo', 'bar') => 'http://foo/bar'
112
122
        join('http://foo', 'bar', '../baz') => 'http://foo/baz'
113
123
    """
114
 
    m = _url_scheme_re.match(base)
115
 
    scheme = None
116
 
    if m:
117
 
        scheme = m.group('scheme')
118
 
        path = m.group('path').split('/')
119
 
        if path[-1:] == ['']:
120
 
            # Strip off a trailing slash
121
 
            # This helps both when we are at the root, and when
122
 
            # 'base' has an extra slash at the end
123
 
            path = path[:-1]
 
124
    if not args:
 
125
        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:]
 
132
    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
 
143
        else:
 
144
            path = joinpath(path, arg)
 
145
    return base[:path_start] + path
 
146
 
 
147
 
 
148
def joinpath(base, *args):
 
149
    """Join URL path segments to a URL path segment.
 
150
 
 
151
    This is somewhat like osutils.joinpath, but intended for URLs.
 
152
 
 
153
    XXX: this duplicates some normalisation logic, and also duplicates a lot of
 
154
    path handling logic that already exists in some Transport implementations.
 
155
    We really should try to have exactly one place in the code base responsible
 
156
    for combining paths of URLs.
 
157
    """
 
158
    path = base.split('/')
 
159
    if len(path) > 1 and path[-1] == '':
 
160
        #If the path ends in a trailing /, remove it.
 
161
        path.pop()
 
162
    for arg in args:
 
163
        if arg.startswith('/'):
 
164
            path = []
 
165
        for chunk in arg.split('/'):
 
166
            if chunk == '.':
 
167
                continue
 
168
            elif chunk == '..':
 
169
                if path == ['']:
 
170
                    raise errors.InvalidURLJoin('Cannot go above root',
 
171
                            base, args)
 
172
                path.pop()
 
173
            else:
 
174
                path.append(chunk)
 
175
    if path == ['']:
 
176
        return '/'
124
177
    else:
125
 
        path = base.split('/')
126
 
 
127
 
    for arg in args:
128
 
        m = _url_scheme_re.match(arg)
129
 
        if m:
130
 
            # Absolute URL
131
 
            scheme = m.group('scheme')
132
 
            path = m.group('path').split('/')
133
 
        else:
134
 
            for chunk in arg.split('/'):
135
 
                if chunk == '.':
136
 
                    continue
137
 
                elif chunk == '..':
138
 
                    if len(path) >= 2:
139
 
                        # Don't pop off the host portion
140
 
                        path.pop()
141
 
                    else:
142
 
                        raise errors.InvalidURLJoin('Cannot go above root',
143
 
                                base, args)
144
 
                else:
145
 
                    path.append(chunk)
146
 
 
147
 
    if scheme is None:
148
178
        return '/'.join(path)
149
 
    return scheme + '://' + '/'.join(path)
150
179
 
151
180
 
152
181
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
153
182
def _posix_local_path_from_url(url):
154
183
    """Convert a url like file:///path/to/foo into /path/to/foo"""
155
 
    if not url.startswith('file:///'):
156
 
        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://'):]
157
192
    # We only strip off 2 slashes
158
 
    return unescape(url[len('file://'):])
 
193
    return unescape(path)
159
194
 
160
195
 
161
196
def _posix_local_path_to_url(path):
163
198
 
164
199
    This also handles transforming escaping unicode characters, etc.
165
200
    """
166
 
    # importing directly from posixpath allows us to test this 
 
201
    # importing directly from posixpath allows us to test this
167
202
    # on non-posix platforms
168
203
    return 'file://' + escape(_posix_normpath(
169
 
        bzrlib.osutils._posix_abspath(path)))
 
204
        osutils._posix_abspath(path)))
170
205
 
171
206
 
172
207
def _win32_local_path_from_url(url):
173
208
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
174
 
    if not url.startswith('file:///'):
175
 
        raise errors.InvalidURL(url, 'local urls must start with file:///')
 
209
    if not url.startswith('file://'):
 
210
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
 
211
                                     'UNC path urls must start with file://')
176
212
    # We strip off all 3 slashes
177
 
    win32_url = url[len('file:///'):]
178
 
    if (win32_url[0] not in ('abcdefghijklmnopqrstuvwxyz'
179
 
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
180
 
        or win32_url[1] not in  '|:'
181
 
        or win32_url[2] != '/'):
 
213
    win32_url = url[len('file:'):]
 
214
    # check for UNC path: //HOST/path
 
215
    if not win32_url.startswith('///'):
 
216
        if (win32_url[2] == '/'
 
217
            or win32_url[3] in '|:'):
 
218
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
 
219
                ' have form file://HOST/path')
 
220
        return unescape(win32_url)
 
221
 
 
222
    # allow empty paths so we can serve all roots
 
223
    if win32_url == '///':
 
224
        return '/'
 
225
 
 
226
    # usual local path with drive letter
 
227
    if (len(win32_url) < 6
 
228
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
229
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
230
        or win32_url[4] not in  '|:'
 
231
        or win32_url[5] != '/'):
182
232
        raise errors.InvalidURL(url, 'Win32 file urls start with'
183
233
                ' file:///x:/, where x is a valid drive letter')
184
 
    return win32_url[0].upper() + u':' + unescape(win32_url[2:])
 
234
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
185
235
 
186
236
 
187
237
def _win32_local_path_to_url(path):
189
239
 
190
240
    This also handles transforming escaping unicode characters, etc.
191
241
    """
192
 
    # importing directly from ntpath allows us to test this 
 
242
    # importing directly from ntpath allows us to test this
193
243
    # on non-win32 platform
194
244
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
195
245
    #       which actually strips trailing space characters.
196
 
    #       The worst part is that under linux ntpath.abspath has different
 
246
    #       The worst part is that on linux ntpath.abspath has different
197
247
    #       semantics, since 'nt' is not an available module.
198
 
    win32_path = bzrlib.osutils._nt_normpath(
199
 
        bzrlib.osutils._win32_abspath(path)).replace('\\', '/')
200
 
    return 'file:///' + win32_path[0].upper() + ':' + escape(win32_path[2:])
 
248
    if path == '/':
 
249
        return 'file:///'
 
250
 
 
251
    win32_path = osutils._win32_abspath(path)
 
252
    # check for UNC path \\HOST\path
 
253
    if win32_path.startswith('//'):
 
254
        return 'file:' + escape(win32_path)
 
255
    return ('file:///' + str(win32_path[0].upper()) + ':' +
 
256
        escape(win32_path[2:]))
201
257
 
202
258
 
203
259
local_path_to_url = _posix_local_path_to_url
212
268
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
213
269
 
214
270
 
215
 
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
 
271
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
 
272
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
 
273
 
 
274
 
 
275
def _unescape_safe_chars(matchobj):
 
276
    """re.sub callback to convert hex-escapes to plain characters (if safe).
 
277
 
 
278
    e.g. '%7E' will be converted to '~'.
 
279
    """
 
280
    hex_digits = matchobj.group(0)[1:]
 
281
    char = chr(int(hex_digits, 16))
 
282
    if char in _url_dont_escape_characters:
 
283
        return char
 
284
    else:
 
285
        return matchobj.group(0).upper()
216
286
 
217
287
 
218
288
def normalize_url(url):
219
289
    """Make sure that a path string is in fully normalized URL form.
220
 
    
221
 
    This handles URLs which have unicode characters, spaces, 
 
290
 
 
291
    This handles URLs which have unicode characters, spaces,
222
292
    special characters, etc.
223
293
 
224
294
    It has two basic modes of operation, depending on whether the
234
304
    :param url: Either a hybrid URL or a local path
235
305
    :return: A normalized URL which only includes 7-bit ASCII characters.
236
306
    """
237
 
    m = _url_scheme_re.match(url)
238
 
    if not m:
 
307
    scheme_end, path_start = _find_scheme_and_separator(url)
 
308
    if scheme_end is None:
239
309
        return local_path_to_url(url)
 
310
    prefix = url[:path_start]
 
311
    path = url[path_start:]
240
312
    if not isinstance(url, unicode):
241
313
        for c in url:
242
314
            if c not in _url_safe_characters:
243
315
                raise errors.InvalidURL(url, 'URLs can only contain specific'
244
316
                                            ' safe characters (not %r)' % c)
245
 
        return url
 
317
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
 
318
        return str(prefix + ''.join(path))
 
319
 
246
320
    # We have a unicode (hybrid) url
247
 
    scheme = m.group('scheme')
248
 
    path = list(m.group('path'))
 
321
    path_chars = list(path)
249
322
 
250
 
    for i in xrange(len(path)):
251
 
        if path[i] not in _url_safe_characters:
252
 
            chars = path[i].encode('utf-8')
253
 
            path[i] = ''.join(['%%%02X' % ord(c) for c in path[i].encode('utf-8')])
254
 
    return scheme + '://' + ''.join(path)
 
323
    for i in xrange(len(path_chars)):
 
324
        if path_chars[i] not in _url_safe_characters:
 
325
            chars = path_chars[i].encode('utf-8')
 
326
            path_chars[i] = ''.join(
 
327
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
 
328
    path = ''.join(path_chars)
 
329
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
 
330
    return str(prefix + path)
255
331
 
256
332
 
257
333
def relative_url(base, other):
263
339
    dummy, base_first_slash = _find_scheme_and_separator(base)
264
340
    if base_first_slash is None:
265
341
        return other
266
 
    
 
342
 
267
343
    dummy, other_first_slash = _find_scheme_and_separator(other)
268
344
    if other_first_slash is None:
269
345
        return other
273
349
    other_scheme = other[:other_first_slash]
274
350
    if base_scheme != other_scheme:
275
351
        return other
 
352
    elif sys.platform == 'win32' and base_scheme == 'file://':
 
353
        base_drive = base[base_first_slash+1:base_first_slash+3]
 
354
        other_drive = other[other_first_slash+1:other_first_slash+3]
 
355
        if base_drive != other_drive:
 
356
            return other
276
357
 
277
358
    base_path = base[base_first_slash+1:]
278
359
    other_path = other[other_first_slash+1:]
306
387
    # Strip off the drive letter
307
388
    # path is currently /C:/foo
308
389
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
309
 
        raise errors.InvalidURL(url_base + path, 
 
390
        raise errors.InvalidURL(url_base + path,
310
391
            'win32 file:/// paths need a drive letter')
311
392
    url_base += path[0:3] # file:// + /C:
312
393
    path = path[3:] # /foo
320
401
    :param exclude_trailing_slash: Strip off a final '/' if it is part
321
402
        of the path (but not if it is part of the protocol specification)
322
403
 
323
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at 
 
404
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
324
405
        the root.
325
406
    """
326
407
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
353
434
    return url_base + head, tail
354
435
 
355
436
 
 
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
 
356
509
def _win32_strip_local_trailing_slash(url):
357
510
    """Strip slashes after the drive letter"""
358
511
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
385
538
    if not url.endswith('/'):
386
539
        # Nothing to do
387
540
        return url
388
 
    if sys.platform == 'win32' and url.startswith('file:///'):
 
541
    if sys.platform == 'win32' and url.startswith('file://'):
389
542
        return _win32_strip_local_trailing_slash(url)
390
543
 
391
544
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
430
583
# These are characters that if escaped, should stay that way
431
584
_no_decode_chars = ';/?:@&=+$,#'
432
585
_no_decode_ords = [ord(c) for c in _no_decode_chars]
433
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
 
586
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
434
587
                + ['%02X' % o for o in _no_decode_ords])
435
588
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
436
589
                    + [('%02X' % o, chr(o)) for o in range(256)]))
437
590
#These entries get mapped to themselves
438
591
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
439
592
 
 
593
# These characters shouldn't be percent-encoded, and it's always safe to
 
594
# unencode them if they are.
 
595
_url_dont_escape_characters = set(
 
596
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
 
597
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
 
598
   "0123456789" # Numbers
 
599
   "-._~"  # Unreserved characters
 
600
)
 
601
 
440
602
# These characters should not be escaped
441
 
_url_safe_characters = set('abcdefghijklmnopqrstuvwxyz'
442
 
                        'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
443
 
                        '0123456789' '_.-/'
444
 
                        ';?:@&=+$,%#')
445
 
 
 
603
_url_safe_characters = set(
 
604
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
 
605
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
 
606
   "0123456789" # Numbers
 
607
   "_.-!~*'()"  # Unreserved characters
 
608
   "/;?:@&=+$," # Reserved characters
 
609
   "%#"         # Extra reserved characters
 
610
)
446
611
 
447
612
def unescape_for_display(url, encoding):
448
613
    """Decode what you can for a URL, so that we get a nice looking path.
450
615
    This will turn file:// urls into local paths, and try to decode
451
616
    any portions of a http:// style url that it can.
452
617
 
453
 
    Any sections of the URL which can't be represented in the encoding or 
 
618
    Any sections of the URL which can't be represented in the encoding or
454
619
    need to stay as escapes are left alone.
455
620
 
456
621
    :param url: A 7-bit ASCII URL
457
622
    :param encoding: The final output encoding
458
623
 
459
 
    :return: A unicode string which can be safely encoded into the 
 
624
    :return: A unicode string which can be safely encoded into the
460
625
         specified encoding.
461
626
    """
462
 
    assert encoding is not None, 'you cannot specify None for the display encoding.'
 
627
    if encoding is None:
 
628
        raise ValueError('you cannot specify None for the display encoding')
463
629
    if url.startswith('file://'):
464
630
        try:
465
631
            path = local_path_from_url(url)
499
665
                # Otherwise take the url decoded one
500
666
                res[i] = decoded
501
667
    return u'/'.join(res)
 
668
 
 
669
 
 
670
def derive_to_location(from_location):
 
671
    """Derive a TO_LOCATION given a FROM_LOCATION.
 
672
 
 
673
    The normal case is a FROM_LOCATION of http://foo/bar => bar.
 
674
    The Right Thing for some logical destinations may differ though
 
675
    because no / may be present at all. In that case, the result is
 
676
    the full name without the scheme indicator, e.g. lp:foo-bar => foo-bar.
 
677
    This latter case also applies when a Windows drive
 
678
    is used without a path, e.g. c:foo-bar => foo-bar.
 
679
    If no /, path separator or : is found, the from_location is returned.
 
680
    """
 
681
    if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
 
682
        return os.path.basename(from_location.rstrip("/\\"))
 
683
    else:
 
684
        sep = from_location.find(":")
 
685
        if sep > 0:
 
686
            return from_location[sep+1:]
 
687
        else:
 
688
            return from_location
 
689
 
 
690
 
 
691
def _is_absolute(url):
 
692
    return (osutils.pathjoin('/foo', url) == url)
 
693
 
 
694
 
 
695
def rebase_url(url, old_base, new_base):
 
696
    """Convert a relative path from an old base URL to a new base URL.
 
697
 
 
698
    The result will be a relative path.
 
699
    Absolute paths and full URLs are returned unaltered.
 
700
    """
 
701
    scheme, separator = _find_scheme_and_separator(url)
 
702
    if scheme is not None:
 
703
        return url
 
704
    if _is_absolute(url):
 
705
        return url
 
706
    old_parsed = urlparse.urlparse(old_base)
 
707
    new_parsed = urlparse.urlparse(new_base)
 
708
    if (old_parsed[:2]) != (new_parsed[:2]):
 
709
        raise errors.InvalidRebaseURLs(old_base, new_base)
 
710
    return determine_relative_path(new_parsed[2],
 
711
                                   join(old_parsed[2], url))
 
712
 
 
713
 
 
714
def determine_relative_path(from_path, to_path):
 
715
    """Determine a relative path from from_path to to_path."""
 
716
    from_segments = osutils.splitpath(from_path)
 
717
    to_segments = osutils.splitpath(to_path)
 
718
    count = -1
 
719
    for count, (from_element, to_element) in enumerate(zip(from_segments,
 
720
                                                       to_segments)):
 
721
        if from_element != to_element:
 
722
            break
 
723
    else:
 
724
        count += 1
 
725
    unique_from = from_segments[count:]
 
726
    unique_to = to_segments[count:]
 
727
    segments = (['..'] * len(unique_from) + unique_to)
 
728
    if len(segments) == 0:
 
729
        return '.'
 
730
    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)