/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 bzrlib/urlutils.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
16
16
 
17
17
"""A collection of function for handling URL operations."""
18
18
 
19
 
from __future__ import absolute_import
20
 
 
21
19
import os
22
20
import re
23
21
import sys
24
22
 
25
 
try:
26
 
    import urlparse
27
 
except ImportError:
28
 
    from urllib import parse as urlparse
 
23
from bzrlib.lazy_import import lazy_import
 
24
lazy_import(globals(), """
 
25
from posixpath import split as _posix_split, normpath as _posix_normpath
 
26
import urllib
 
27
import urlparse
29
28
 
30
 
from . import (
 
29
from bzrlib import (
31
30
    errors,
32
31
    osutils,
33
32
    )
34
 
 
35
 
from .lazy_import import lazy_import
36
 
lazy_import(globals(), """
37
 
from posixpath import split as _posix_split
38
33
""")
39
34
 
40
 
from .sixish import (
41
 
    PY3,
42
 
    text_type,
43
 
    )
44
 
 
45
 
 
46
 
class InvalidURL(errors.PathError):
47
 
 
48
 
    _fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
49
 
 
50
 
 
51
 
class InvalidURLJoin(errors.PathError):
52
 
 
53
 
    _fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"
54
 
 
55
 
    def __init__(self, reason, base, join_args):
56
 
        self.reason = reason
57
 
        self.base = base
58
 
        self.join_args = join_args
59
 
        errors.PathError.__init__(self, base, reason)
60
 
 
61
 
 
62
 
class InvalidRebaseURLs(errors.PathError):
63
 
 
64
 
    _fmt = "URLs differ by more than path: %(from_)r and %(to)r"
65
 
 
66
 
    def __init__(self, from_, to):
67
 
        self.from_ = from_
68
 
        self.to = to
69
 
        errors.PathError.__init__(self, from_, 'URLs differ by more than path.')
70
 
 
71
35
 
72
36
def basename(url, exclude_trailing_slash=True):
73
37
    """Return the last component of a URL.
96
60
    return split(url, exclude_trailing_slash=exclude_trailing_slash)[0]
97
61
 
98
62
 
99
 
# Private copies of quote and unquote, copied from Python's
100
 
# urllib module because urllib unconditionally imports socket, which imports
101
 
# ssl.
102
 
 
103
 
always_safe = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
104
 
               'abcdefghijklmnopqrstuvwxyz'
105
 
               '0123456789' '_.-')
106
 
_safe_map = {}
107
 
for i, c in zip(range(256), ''.join(map(chr, range(256)))):
108
 
    _safe_map[c] = c if (i < 128 and c in always_safe) else '%{0:02X}'.format(i)
109
 
_safe_quoters = {}
110
 
 
111
 
 
112
 
def quote(s, safe='/'):
113
 
    """quote('abc def') -> 'abc%20def'
114
 
 
115
 
    Each part of a URL, e.g. the path info, the query, etc., has a
116
 
    different set of reserved characters that must be quoted.
117
 
 
118
 
    RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
119
 
    the following reserved characters.
120
 
 
121
 
    reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
122
 
                  "$" | ","
123
 
 
124
 
    Each of these characters is reserved in some component of a URL,
125
 
    but not necessarily in all of them.
126
 
 
127
 
    By default, the quote function is intended for quoting the path
128
 
    section of a URL.  Thus, it will not encode '/'.  This character
129
 
    is reserved, but in typical usage the quote function is being
130
 
    called on a path where the existing slash characters are used as
131
 
    reserved characters.
132
 
    """
133
 
    # fastpath
134
 
    if not s:
135
 
        if s is None:
136
 
            raise TypeError('None object cannot be quoted')
137
 
        return s
138
 
    cachekey = (safe, always_safe)
139
 
    try:
140
 
        (quoter, safe) = _safe_quoters[cachekey]
141
 
    except KeyError:
142
 
        safe_map = _safe_map.copy()
143
 
        safe_map.update([(c, c) for c in safe])
144
 
        quoter = safe_map.__getitem__
145
 
        safe = always_safe + safe
146
 
        _safe_quoters[cachekey] = (quoter, safe)
147
 
    if not s.rstrip(safe):
148
 
        return s
149
 
    return ''.join(map(quoter, s))
150
 
 
151
 
 
152
 
unquote = urlparse.unquote
153
 
 
154
 
 
155
63
def escape(relpath):
156
64
    """Escape relpath to be a valid url."""
157
 
    if not isinstance(relpath, str) and sys.version_info[0] == 2:
 
65
    if isinstance(relpath, unicode):
158
66
        relpath = relpath.encode('utf-8')
159
 
    return quote(relpath, safe='/~')
 
67
    # After quoting and encoding, the path should be perfectly
 
68
    # safe as a plain ASCII string, str() just enforces this
 
69
    return str(urllib.quote(relpath, safe='/~'))
160
70
 
161
71
 
162
72
def file_relpath(base, path):
168
78
        raise ValueError('Length of base (%r) must equal or'
169
79
            ' exceed the platform minimum url length (which is %d)' %
170
80
            (base, MIN_ABS_FILEURL_LENGTH))
171
 
    base = osutils.normpath(local_path_from_url(base))
172
 
    path = osutils.normpath(local_path_from_url(path))
 
81
    base = local_path_from_url(base)
 
82
    path = local_path_from_url(path)
173
83
    return escape(osutils.relpath(base, path))
174
84
 
175
85
 
191
101
    first_path_slash = path.find('/')
192
102
    if first_path_slash == -1:
193
103
        return len(scheme), None
194
 
    return len(scheme), first_path_slash+m.start('path')
195
 
 
196
 
 
197
 
def is_url(url):
198
 
    """Tests whether a URL is in actual fact a URL."""
199
 
    return _url_scheme_re.match(url) is not None
 
104
    return len(scheme), first_path_slash+len(scheme)+3
200
105
 
201
106
 
202
107
def join(base, *args):
213
118
    """
214
119
    if not args:
215
120
        return base
216
 
    scheme_end, path_start = _find_scheme_and_separator(base)
217
 
    if scheme_end is None and path_start is None:
218
 
        path_start = 0
219
 
    elif path_start is None:
220
 
        path_start = len(base)
221
 
    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
 
222
146
    for arg in args:
223
 
        arg_scheme_end, arg_path_start = _find_scheme_and_separator(arg)
224
 
        if arg_scheme_end is None and arg_path_start is None:
225
 
            arg_path_start = 0
226
 
        elif arg_path_start is None:
227
 
            arg_path_start = len(arg)
228
 
        if arg_scheme_end is not None:
229
 
            base = arg
230
 
            path = arg[arg_path_start:]
231
 
            scheme_end = arg_scheme_end
232
 
            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 = []
233
166
        else:
 
167
            path = '/'.join(path)
234
168
            path = joinpath(path, arg)
235
 
    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)
236
182
 
237
183
 
238
184
def joinpath(base, *args):
257
203
                continue
258
204
            elif chunk == '..':
259
205
                if path == ['']:
260
 
                    raise InvalidURLJoin('Cannot go above root',
 
206
                    raise errors.InvalidURLJoin('Cannot go above root',
261
207
                            base, args)
262
208
                path.pop()
263
209
            else:
271
217
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
272
218
def _posix_local_path_from_url(url):
273
219
    """Convert a url like file:///path/to/foo into /path/to/foo"""
274
 
    url = split_segment_parameters_raw(url)[0]
275
220
    file_localhost_prefix = 'file://localhost/'
276
221
    if url.startswith(file_localhost_prefix):
277
222
        path = url[len(file_localhost_prefix) - 1:]
278
223
    elif not url.startswith('file:///'):
279
 
        raise InvalidURL(
 
224
        raise errors.InvalidURL(
280
225
            url, 'local urls must start with file:/// or file://localhost/')
281
226
    else:
282
227
        path = url[len('file://'):]
291
236
    """
292
237
    # importing directly from posixpath allows us to test this
293
238
    # on non-posix platforms
294
 
    return 'file://' + escape(osutils._posix_abspath(path))
 
239
    return 'file://' + escape(_posix_normpath(
 
240
        osutils._posix_abspath(path)))
295
241
 
296
242
 
297
243
def _win32_local_path_from_url(url):
298
244
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
299
245
    if not url.startswith('file://'):
300
 
        raise InvalidURL(url, 'local urls must start with file:///, '
 
246
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
301
247
                                     'UNC path urls must start with file://')
302
 
    url = split_segment_parameters_raw(url)[0]
303
248
    # We strip off all 3 slashes
304
249
    win32_url = url[len('file:'):]
305
250
    # check for UNC path: //HOST/path
306
251
    if not win32_url.startswith('///'):
307
252
        if (win32_url[2] == '/'
308
253
            or win32_url[3] in '|:'):
309
 
            raise InvalidURL(url, 'Win32 UNC path urls'
 
254
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
310
255
                ' have form file://HOST/path')
311
256
        return unescape(win32_url)
312
257
 
315
260
        return '/'
316
261
 
317
262
    # usual local path with drive letter
318
 
    if (len(win32_url) < 6
319
 
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
320
 
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
263
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
264
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
321
265
        or win32_url[4] not in  '|:'
322
266
        or win32_url[5] != '/'):
323
 
        raise InvalidURL(url, 'Win32 file urls start with'
 
267
        raise errors.InvalidURL(url, 'Win32 file urls start with'
324
268
                ' file:///x:/, where x is a valid drive letter')
325
269
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
326
270
 
334
278
    # on non-win32 platform
335
279
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
336
280
    #       which actually strips trailing space characters.
337
 
    #       The worst part is that on linux ntpath.abspath has different
 
281
    #       The worst part is that under linux ntpath.abspath has different
338
282
    #       semantics, since 'nt' is not an available module.
339
283
    if path == '/':
340
284
        return 'file:///'
359
303
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
360
304
 
361
305
 
362
 
_url_scheme_re = re.compile('^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
363
 
_url_hex_escapes_re = re.compile('(%[0-9a-fA-F]{2})')
 
306
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
 
307
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
364
308
 
365
309
 
366
310
def _unescape_safe_chars(matchobj):
395
339
    :param url: Either a hybrid URL or a local path
396
340
    :return: A normalized URL which only includes 7-bit ASCII characters.
397
341
    """
398
 
    scheme_end, path_start = _find_scheme_and_separator(url)
399
 
    if scheme_end is None:
 
342
    m = _url_scheme_re.match(url)
 
343
    if not m:
400
344
        return local_path_to_url(url)
401
 
    prefix = url[:path_start]
402
 
    path = url[path_start:]
403
 
    if not isinstance(url, text_type):
 
345
    scheme = m.group('scheme')
 
346
    path = m.group('path')
 
347
    if not isinstance(url, unicode):
404
348
        for c in url:
405
349
            if c not in _url_safe_characters:
406
 
                raise InvalidURL(url, 'URLs can only contain specific'
 
350
                raise errors.InvalidURL(url, 'URLs can only contain specific'
407
351
                                            ' safe characters (not %r)' % c)
408
352
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
409
 
        return str(prefix + ''.join(path))
 
353
        return str(scheme + '://' + ''.join(path))
410
354
 
411
355
    # We have a unicode (hybrid) url
412
356
    path_chars = list(path)
413
357
 
414
 
    for i in range(len(path_chars)):
 
358
    for i in xrange(len(path_chars)):
415
359
        if path_chars[i] not in _url_safe_characters:
416
360
            chars = path_chars[i].encode('utf-8')
417
361
            path_chars[i] = ''.join(
418
362
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
419
363
    path = ''.join(path_chars)
420
364
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
421
 
    return str(prefix + path)
 
365
    return str(scheme + '://' + path)
422
366
 
423
367
 
424
368
def relative_url(base, other):
477
421
    """On win32 the drive letter needs to be added to the url base."""
478
422
    # Strip off the drive letter
479
423
    # path is currently /C:/foo
480
 
    if len(path) < 4 or path[2] not in ':|' or path[3] != '/':
481
 
        raise InvalidURL(url_base + path,
 
424
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
 
425
        raise errors.InvalidURL(url_base + path,
482
426
            'win32 file:/// paths need a drive letter')
483
427
    url_base += path[0:3] # file:// + /C:
484
428
    path = path[3:] # /foo
525
469
    return url_base + head, tail
526
470
 
527
471
 
528
 
def split_segment_parameters_raw(url):
529
 
    """Split the subsegment of the last segment of a URL.
530
 
 
531
 
    :param url: A relative or absolute URL
532
 
    :return: (url, subsegments)
533
 
    """
534
 
    # GZ 2011-11-18: Dodgy removing the terminal slash like this, function
535
 
    #                operates on urls not url+segments, and Transport classes
536
 
    #                should not be blindly adding slashes in the first place. 
537
 
    lurl = strip_trailing_slash(url)
538
 
    # Segments begin at first comma after last forward slash, if one exists
539
 
    segment_start = lurl.find(",", lurl.rfind("/")+1)
540
 
    if segment_start == -1:
541
 
        return (url, [])
542
 
    return (lurl[:segment_start], [str(s) for s in lurl[segment_start+1:].split(",")])
543
 
 
544
 
 
545
 
def split_segment_parameters(url):
546
 
    """Split the segment parameters of the last segment of a URL.
547
 
 
548
 
    :param url: A relative or absolute URL
549
 
    :return: (url, segment_parameters)
550
 
    """
551
 
    (base_url, subsegments) = split_segment_parameters_raw(url)
552
 
    parameters = {}
553
 
    for subsegment in subsegments:
554
 
        (key, value) = subsegment.split("=", 1)
555
 
        if not isinstance(key, str):
556
 
            raise TypeError(key)
557
 
        if not isinstance(value, str):
558
 
            raise TypeError(value)
559
 
        parameters[key] = value
560
 
    return (base_url, parameters)
561
 
 
562
 
 
563
 
def join_segment_parameters_raw(base, *subsegments):
564
 
    """Create a new URL by adding subsegments to an existing one. 
565
 
 
566
 
    This adds the specified subsegments to the last path in the specified
567
 
    base URL. The subsegments should be bytestrings.
568
 
 
569
 
    :note: You probably want to use join_segment_parameters instead.
570
 
    """
571
 
    if not subsegments:
572
 
        return base
573
 
    for subsegment in subsegments:
574
 
        if not isinstance(subsegment, str):
575
 
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
576
 
        if "," in subsegment:
577
 
            raise InvalidURLJoin(", exists in subsegments",
578
 
                                        base, subsegments)
579
 
    return ",".join((base,) + subsegments)
580
 
 
581
 
 
582
 
def join_segment_parameters(url, parameters):
583
 
    """Create a new URL by adding segment parameters to an existing one.
584
 
 
585
 
    The parameters of the last segment in the URL will be updated; if a
586
 
    parameter with the same key already exists it will be overwritten.
587
 
 
588
 
    :param url: A URL, as string
589
 
    :param parameters: Dictionary of parameters, keys and values as bytestrings
590
 
    """
591
 
    (base, existing_parameters) = split_segment_parameters(url)
592
 
    new_parameters = {}
593
 
    new_parameters.update(existing_parameters)
594
 
    for key, value in parameters.items():
595
 
        if not isinstance(key, str):
596
 
            raise TypeError("parameter key %r is not a str" % key)
597
 
        if not isinstance(value, str):
598
 
            raise TypeError("parameter value %r for %s is not a str" %
599
 
                (key, value))
600
 
        if "=" in key:
601
 
            raise InvalidURLJoin("= exists in parameter key", url,
602
 
                parameters)
603
 
        new_parameters[key] = value
604
 
    return join_segment_parameters_raw(base,
605
 
        *["%s=%s" % item for item in sorted(new_parameters.items())])
606
 
 
607
 
 
608
472
def _win32_strip_local_trailing_slash(url):
609
473
    """Strip slashes after the drive letter"""
610
474
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
660
524
    This returns a Unicode path from a URL
661
525
    """
662
526
    # jam 20060427 URLs are supposed to be ASCII only strings
663
 
    #       If they are passed in as unicode, unquote
 
527
    #       If they are passed in as unicode, urllib.unquote
664
528
    #       will return a UNICODE string, which actually contains
665
529
    #       utf-8 bytes. So we have to ensure that they are
666
530
    #       plain ASCII strings, or the final .decode will
667
531
    #       try to encode the UNICODE => ASCII, and then decode
668
532
    #       it into utf-8.
669
 
    if isinstance(url, text_type):
670
 
        try:
671
 
            url = url.encode("ascii")
672
 
        except UnicodeError as e:
673
 
            raise InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
674
 
    if PY3:
675
 
        unquoted = urlparse.unquote_to_bytes(url)
676
 
    else:
677
 
        unquoted = unquote(url)
 
533
    try:
 
534
        url = str(url)
 
535
    except UnicodeError, e:
 
536
        raise errors.InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
 
537
 
 
538
    unquoted = urllib.unquote(url)
678
539
    try:
679
540
        unicode_path = unquoted.decode('utf-8')
680
 
    except UnicodeError as e:
681
 
        raise InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
 
541
    except UnicodeError, e:
 
542
        raise errors.InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
682
543
    return unicode_path
683
544
 
684
545
 
690
551
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
691
552
                    + [('%02X' % o, chr(o)) for o in range(256)]))
692
553
#These entries get mapped to themselves
693
 
_hex_display_map.update((hex, '%'+hex) for hex in _no_decode_hex)
 
554
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
694
555
 
695
556
# These characters shouldn't be percent-encoded, and it's always safe to
696
557
# unencode them if they are.
738
599
 
739
600
    # Split into sections to try to decode utf-8
740
601
    res = url.split('/')
741
 
    for i in range(1, len(res)):
 
602
    for i in xrange(1, len(res)):
742
603
        escaped_chunks = res[i].split('%')
743
 
        for j in range(1, len(escaped_chunks)):
 
604
        for j in xrange(1, len(escaped_chunks)):
744
605
            item = escaped_chunks[j]
745
606
            try:
746
607
                escaped_chunks[j] = _hex_display_map[item[:2]] + item[2:]
750
611
            except UnicodeDecodeError:
751
612
                escaped_chunks[j] = unichr(int(item[:2], 16)) + item[2:]
752
613
        unescaped = ''.join(escaped_chunks)
753
 
        if sys.version_info[0] == 2:
 
614
        try:
 
615
            decoded = unescaped.decode('utf-8')
 
616
        except UnicodeDecodeError:
 
617
            # If this path segment cannot be properly utf-8 decoded
 
618
            # after doing unescaping we will just leave it alone
 
619
            pass
 
620
        else:
754
621
            try:
755
 
                decoded = unescaped.decode('utf-8')
756
 
            except UnicodeDecodeError:
757
 
                # If this path segment cannot be properly utf-8 decoded
758
 
                # after doing unescaping we will just leave it alone
 
622
                decoded.encode(encoding)
 
623
            except UnicodeEncodeError:
 
624
                # If this chunk cannot be encoded in the local
 
625
                # encoding, then we should leave it alone
759
626
                pass
760
627
            else:
761
 
                try:
762
 
                    decoded.encode(encoding)
763
 
                except UnicodeEncodeError:
764
 
                    # If this chunk cannot be encoded in the local
765
 
                    # encoding, then we should leave it alone
766
 
                    pass
767
 
                else:
768
 
                    # Otherwise take the url decoded one
769
 
                    res[i] = decoded
770
 
        else:
771
 
            res[i] = unescaped
 
628
                # Otherwise take the url decoded one
 
629
                res[i] = decoded
772
630
    return u'/'.join(res)
773
631
 
774
632
 
811
669
    old_parsed = urlparse.urlparse(old_base)
812
670
    new_parsed = urlparse.urlparse(new_base)
813
671
    if (old_parsed[:2]) != (new_parsed[:2]):
814
 
        raise InvalidRebaseURLs(old_base, new_base)
 
672
        raise errors.InvalidRebaseURLs(old_base, new_base)
815
673
    return determine_relative_path(new_parsed[2],
816
674
                                   join(old_parsed[2], url))
817
675
 
835
693
    return osutils.pathjoin(*segments)
836
694
 
837
695
 
838
 
class URL(object):
839
 
    """Parsed URL."""
840
 
 
841
 
    def __init__(self, scheme, quoted_user, quoted_password, quoted_host,
842
 
            port, quoted_path):
843
 
        self.scheme = scheme
844
 
        self.quoted_host = quoted_host
845
 
        self.host = unquote(self.quoted_host)
846
 
        self.quoted_user = quoted_user
847
 
        if self.quoted_user is not None:
848
 
            self.user = unquote(self.quoted_user)
849
 
        else:
850
 
            self.user = None
851
 
        self.quoted_password = quoted_password
852
 
        if self.quoted_password is not None:
853
 
            self.password = unquote(self.quoted_password)
854
 
        else:
855
 
            self.password = None
856
 
        self.port = port
857
 
        self.quoted_path = _url_hex_escapes_re.sub(_unescape_safe_chars, quoted_path)
858
 
        self.path = unquote(self.quoted_path)
859
 
 
860
 
    def __eq__(self, other):
861
 
        return (isinstance(other, self.__class__) and
862
 
                self.scheme == other.scheme and
863
 
                self.host == other.host and
864
 
                self.user == other.user and
865
 
                self.password == other.password and
866
 
                self.path == other.path)
867
 
 
868
 
    def __repr__(self):
869
 
        return "<%s(%r, %r, %r, %r, %r, %r)>" % (
870
 
            self.__class__.__name__,
871
 
            self.scheme, self.quoted_user, self.quoted_password,
872
 
            self.quoted_host, self.port, self.quoted_path)
873
 
 
874
 
    @classmethod
875
 
    def from_string(cls, url):
876
 
        """Create a URL object from a string.
877
 
 
878
 
        :param url: URL as bytestring
879
 
        """
880
 
        # GZ 2017-06-09: Actually validate ascii-ness
881
 
        # pad.lv/1696545: For the moment, accept both native strings and unicode.
882
 
        if isinstance(url, str):
883
 
            pass
884
 
        elif isinstance(url, text_type):
885
 
            try:
886
 
                url = url.encode()
887
 
            except UnicodeEncodeError:
888
 
                raise InvalidURL(url)
889
 
        else:
890
 
            raise InvalidURL(url)
891
 
        (scheme, netloc, path, params,
892
 
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
893
 
        user = password = host = port = None
894
 
        if '@' in netloc:
895
 
            user, host = netloc.rsplit('@', 1)
896
 
            if ':' in user:
897
 
                user, password = user.split(':', 1)
898
 
        else:
899
 
            host = netloc
900
 
 
901
 
        if ':' in host and not (host[0] == '[' and host[-1] == ']'):
902
 
            # there *is* port
903
 
            host, port = host.rsplit(':', 1)
904
 
            try:
905
 
                port = int(port)
906
 
            except ValueError:
907
 
                raise InvalidURL('invalid port number %s in url:\n%s' %
908
 
                                 (port, url))
909
 
        if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
910
 
            host = host[1:-1]
911
 
 
912
 
        return cls(scheme, user, password, host, port, path)
913
 
 
914
 
    def __str__(self):
915
 
        netloc = self.quoted_host
916
 
        if ":" in netloc:
917
 
            netloc = "[%s]" % netloc
918
 
        if self.quoted_user is not None:
919
 
            # Note that we don't put the password back even if we
920
 
            # have one so that it doesn't get accidentally
921
 
            # exposed.
922
 
            netloc = '%s@%s' % (self.quoted_user, netloc)
923
 
        if self.port is not None:
924
 
            netloc = '%s:%d' % (netloc, self.port)
925
 
        return urlparse.urlunparse(
926
 
            (self.scheme, netloc, self.quoted_path, None, None, None))
927
 
 
928
 
    @staticmethod
929
 
    def _combine_paths(base_path, relpath):
930
 
        """Transform a Transport-relative path to a remote absolute path.
931
 
 
932
 
        This does not handle substitution of ~ but does handle '..' and '.'
933
 
        components.
934
 
 
935
 
        Examples::
936
 
 
937
 
            t._combine_paths('/home/sarah', 'project/foo')
938
 
                => '/home/sarah/project/foo'
939
 
            t._combine_paths('/home/sarah', '../../etc')
940
 
                => '/etc'
941
 
            t._combine_paths('/home/sarah', '/etc')
942
 
                => '/etc'
943
 
 
944
 
        :param base_path: base path
945
 
        :param relpath: relative url string for relative part of remote path.
946
 
        :return: urlencoded string for final path.
947
 
        """
948
 
        # pad.lv/1696545: For the moment, accept both native strings and unicode.
949
 
        if isinstance(relpath, str):
950
 
            pass
951
 
        elif isinstance(relpath, text_type):
952
 
            try:
953
 
                relpath = relpath.encode()
954
 
            except UnicodeEncodeError:
955
 
                raise InvalidURL(relpath)
956
 
        else:
957
 
            raise InvalidURL(relpath)
958
 
        relpath = _url_hex_escapes_re.sub(_unescape_safe_chars, relpath)
959
 
        if relpath.startswith('/'):
960
 
            base_parts = []
961
 
        else:
962
 
            base_parts = base_path.split('/')
963
 
        if len(base_parts) > 0 and base_parts[-1] == '':
964
 
            base_parts = base_parts[:-1]
965
 
        for p in relpath.split('/'):
966
 
            if p == '..':
967
 
                if len(base_parts) == 0:
968
 
                    # In most filesystems, a request for the parent
969
 
                    # of root, just returns root.
970
 
                    continue
971
 
                base_parts.pop()
972
 
            elif p == '.':
973
 
                continue # No-op
974
 
            elif p != '':
975
 
                base_parts.append(p)
976
 
        path = '/'.join(base_parts)
977
 
        if not path.startswith('/'):
978
 
            path = '/' + path
979
 
        return path
980
 
 
981
 
    def clone(self, offset=None):
982
 
        """Return a new URL for a path relative to this URL.
983
 
 
984
 
        :param offset: A relative path, already urlencoded
985
 
        :return: `URL` instance
986
 
        """
987
 
        if offset is not None:
988
 
            relative = unescape(offset)
989
 
            if sys.version_info[0] == 2:
990
 
                relative = relative.encode('utf-8')
991
 
            path = self._combine_paths(self.path, relative)
992
 
            path = quote(path, safe="/~")
993
 
        else:
994
 
            path = self.quoted_path
995
 
        return self.__class__(self.scheme, self.quoted_user,
996
 
                self.quoted_password, self.quoted_host, self.port,
997
 
                path)
998
 
 
999
696
 
1000
697
def parse_url(url):
1001
698
    """Extract the server address, the credentials and the path from the url.
1004
701
    chars.
1005
702
 
1006
703
    :param url: an quoted url
 
704
 
1007
705
    :return: (scheme, user, password, host, port, path) tuple, all fields
1008
706
        are unquoted.
1009
707
    """
1010
 
    parsed_url = URL.from_string(url)
1011
 
    return (parsed_url.scheme, parsed_url.user, parsed_url.password,
1012
 
        parsed_url.host, parsed_url.port, parsed_url.path)
 
708
    if isinstance(url, unicode):
 
709
        raise errors.InvalidURL('should be ascii:\n%r' % url)
 
710
    url = url.encode('utf-8')
 
711
    (scheme, netloc, path, params,
 
712
     query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
713
    user = password = host = port = None
 
714
    if '@' in netloc:
 
715
        user, host = netloc.rsplit('@', 1)
 
716
        if ':' in user:
 
717
            user, password = user.split(':', 1)
 
718
            password = urllib.unquote(password)
 
719
        user = urllib.unquote(user)
 
720
    else:
 
721
        host = netloc
 
722
 
 
723
    if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port
 
724
        host, port = host.rsplit(':',1)
 
725
        try:
 
726
            port = int(port)
 
727
        except ValueError:
 
728
            raise errors.InvalidURL('invalid port number %s in url:\n%s' %
 
729
                                    (port, url))
 
730
    if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
 
731
        host = host[1:-1]
 
732
 
 
733
    host = urllib.unquote(host)
 
734
    path = urllib.unquote(path)
 
735
 
 
736
    return (scheme, user, password, host, port, path)