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

  • Committer: Jelmer Vernooij
  • Date: 2018-07-08 10:56:06 UTC
  • mto: This revision was merged to the branch mainline in revision 7030.
  • Revision ID: jelmer@jelmer.uk-20180708105606-d53hkks89qq88twu
Use separate .as_bytes method rather than __bytes__.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/urlutils.py
16
16
 
17
17
"""A collection of function for handling URL operations."""
18
18
 
 
19
from __future__ import absolute_import
 
20
 
19
21
import os
20
22
import re
21
23
import sys
22
24
 
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
 
25
try:
 
26
    import urlparse
 
27
except ImportError:
 
28
    from urllib import parse as urlparse
28
29
 
29
 
from bzrlib import (
 
30
from . import (
30
31
    errors,
31
32
    osutils,
32
33
    )
 
34
 
 
35
from .lazy_import import lazy_import
 
36
lazy_import(globals(), """
 
37
from posixpath import split as _posix_split
33
38
""")
34
39
 
 
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
 
35
71
 
36
72
def basename(url, exclude_trailing_slash=True):
37
73
    """Return the last component of a URL.
60
96
    return split(url, exclude_trailing_slash=exclude_trailing_slash)[0]
61
97
 
62
98
 
 
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
 
63
155
def escape(relpath):
64
156
    """Escape relpath to be a valid url."""
65
 
    if isinstance(relpath, unicode):
 
157
    if not isinstance(relpath, str) and sys.version_info[0] == 2:
66
158
        relpath = relpath.encode('utf-8')
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='/~'))
 
159
    return quote(relpath, safe='/~')
70
160
 
71
161
 
72
162
def file_relpath(base, path):
78
168
        raise ValueError('Length of base (%r) must equal or'
79
169
            ' exceed the platform minimum url length (which is %d)' %
80
170
            (base, MIN_ABS_FILEURL_LENGTH))
81
 
    base = local_path_from_url(base)
82
 
    path = local_path_from_url(path)
 
171
    base = osutils.normpath(local_path_from_url(base))
 
172
    path = osutils.normpath(local_path_from_url(path))
83
173
    return escape(osutils.relpath(base, path))
84
174
 
85
175
 
101
191
    first_path_slash = path.find('/')
102
192
    if first_path_slash == -1:
103
193
        return len(scheme), None
104
 
    return len(scheme), first_path_slash+len(scheme)+3
 
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
105
200
 
106
201
 
107
202
def join(base, *args):
118
213
    """
119
214
    if not args:
120
215
        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
 
 
 
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:]
146
222
    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 = []
 
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
166
233
        else:
167
 
            path = '/'.join(path)
168
234
            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)
 
235
    return base[:path_start] + path
182
236
 
183
237
 
184
238
def joinpath(base, *args):
203
257
                continue
204
258
            elif chunk == '..':
205
259
                if path == ['']:
206
 
                    raise errors.InvalidURLJoin('Cannot go above root',
 
260
                    raise InvalidURLJoin('Cannot go above root',
207
261
                            base, args)
208
262
                path.pop()
209
263
            else:
217
271
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
218
272
def _posix_local_path_from_url(url):
219
273
    """Convert a url like file:///path/to/foo into /path/to/foo"""
 
274
    url = split_segment_parameters_raw(url)[0]
220
275
    file_localhost_prefix = 'file://localhost/'
221
276
    if url.startswith(file_localhost_prefix):
222
277
        path = url[len(file_localhost_prefix) - 1:]
223
278
    elif not url.startswith('file:///'):
224
 
        raise errors.InvalidURL(
 
279
        raise InvalidURL(
225
280
            url, 'local urls must start with file:/// or file://localhost/')
226
281
    else:
227
282
        path = url[len('file://'):]
236
291
    """
237
292
    # importing directly from posixpath allows us to test this
238
293
    # on non-posix platforms
239
 
    return 'file://' + escape(_posix_normpath(
240
 
        osutils._posix_abspath(path)))
 
294
    return 'file://' + escape(osutils._posix_abspath(path))
241
295
 
242
296
 
243
297
def _win32_local_path_from_url(url):
244
298
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
245
299
    if not url.startswith('file://'):
246
 
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
 
300
        raise InvalidURL(url, 'local urls must start with file:///, '
247
301
                                     'UNC path urls must start with file://')
 
302
    url = split_segment_parameters_raw(url)[0]
248
303
    # We strip off all 3 slashes
249
304
    win32_url = url[len('file:'):]
250
305
    # check for UNC path: //HOST/path
251
306
    if not win32_url.startswith('///'):
252
307
        if (win32_url[2] == '/'
253
308
            or win32_url[3] in '|:'):
254
 
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
 
309
            raise InvalidURL(url, 'Win32 UNC path urls'
255
310
                ' have form file://HOST/path')
256
311
        return unescape(win32_url)
257
312
 
260
315
        return '/'
261
316
 
262
317
    # usual local path with drive letter
263
 
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
264
 
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
318
    if (len(win32_url) < 6
 
319
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
320
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
265
321
        or win32_url[4] not in  '|:'
266
322
        or win32_url[5] != '/'):
267
 
        raise errors.InvalidURL(url, 'Win32 file urls start with'
 
323
        raise InvalidURL(url, 'Win32 file urls start with'
268
324
                ' file:///x:/, where x is a valid drive letter')
269
325
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
270
326
 
278
334
    # on non-win32 platform
279
335
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
280
336
    #       which actually strips trailing space characters.
281
 
    #       The worst part is that under linux ntpath.abspath has different
 
337
    #       The worst part is that on linux ntpath.abspath has different
282
338
    #       semantics, since 'nt' is not an available module.
283
339
    if path == '/':
284
340
        return 'file:///'
303
359
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
304
360
 
305
361
 
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})')
 
362
_url_scheme_re = re.compile('^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
 
363
_url_hex_escapes_re = re.compile('(%[0-9a-fA-F]{2})')
308
364
 
309
365
 
310
366
def _unescape_safe_chars(matchobj):
339
395
    :param url: Either a hybrid URL or a local path
340
396
    :return: A normalized URL which only includes 7-bit ASCII characters.
341
397
    """
342
 
    m = _url_scheme_re.match(url)
343
 
    if not m:
 
398
    scheme_end, path_start = _find_scheme_and_separator(url)
 
399
    if scheme_end is None:
344
400
        return local_path_to_url(url)
345
 
    scheme = m.group('scheme')
346
 
    path = m.group('path')
347
 
    if not isinstance(url, unicode):
 
401
    prefix = url[:path_start]
 
402
    path = url[path_start:]
 
403
    if not isinstance(url, text_type):
348
404
        for c in url:
349
405
            if c not in _url_safe_characters:
350
 
                raise errors.InvalidURL(url, 'URLs can only contain specific'
 
406
                raise InvalidURL(url, 'URLs can only contain specific'
351
407
                                            ' safe characters (not %r)' % c)
352
408
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
353
 
        return str(scheme + '://' + ''.join(path))
 
409
        return str(prefix + ''.join(path))
354
410
 
355
411
    # We have a unicode (hybrid) url
356
412
    path_chars = list(path)
357
413
 
358
 
    for i in xrange(len(path_chars)):
 
414
    for i in range(len(path_chars)):
359
415
        if path_chars[i] not in _url_safe_characters:
360
416
            chars = path_chars[i].encode('utf-8')
361
417
            path_chars[i] = ''.join(
362
418
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
363
419
    path = ''.join(path_chars)
364
420
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
365
 
    return str(scheme + '://' + path)
 
421
    return str(prefix + path)
366
422
 
367
423
 
368
424
def relative_url(base, other):
421
477
    """On win32 the drive letter needs to be added to the url base."""
422
478
    # Strip off the drive letter
423
479
    # path is currently /C:/foo
424
 
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
425
 
        raise errors.InvalidURL(url_base + path,
 
480
    if len(path) < 4 or path[2] not in ':|' or path[3] != '/':
 
481
        raise InvalidURL(url_base + path,
426
482
            'win32 file:/// paths need a drive letter')
427
483
    url_base += path[0:3] # file:// + /C:
428
484
    path = path[3:] # /foo
469
525
    return url_base + head, tail
470
526
 
471
527
 
 
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
 
472
608
def _win32_strip_local_trailing_slash(url):
473
609
    """Strip slashes after the drive letter"""
474
610
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
524
660
    This returns a Unicode path from a URL
525
661
    """
526
662
    # jam 20060427 URLs are supposed to be ASCII only strings
527
 
    #       If they are passed in as unicode, urllib.unquote
 
663
    #       If they are passed in as unicode, unquote
528
664
    #       will return a UNICODE string, which actually contains
529
665
    #       utf-8 bytes. So we have to ensure that they are
530
666
    #       plain ASCII strings, or the final .decode will
531
667
    #       try to encode the UNICODE => ASCII, and then decode
532
668
    #       it into utf-8.
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)
 
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)
539
678
    try:
540
679
        unicode_path = unquoted.decode('utf-8')
541
 
    except UnicodeError, e:
542
 
        raise errors.InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
 
680
    except UnicodeError as e:
 
681
        raise InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
543
682
    return unicode_path
544
683
 
545
684
 
551
690
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
552
691
                    + [('%02X' % o, chr(o)) for o in range(256)]))
553
692
#These entries get mapped to themselves
554
 
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
 
693
_hex_display_map.update((hex, '%'+hex) for hex in _no_decode_hex)
555
694
 
556
695
# These characters shouldn't be percent-encoded, and it's always safe to
557
696
# unencode them if they are.
599
738
 
600
739
    # Split into sections to try to decode utf-8
601
740
    res = url.split('/')
602
 
    for i in xrange(1, len(res)):
 
741
    for i in range(1, len(res)):
603
742
        escaped_chunks = res[i].split('%')
604
 
        for j in xrange(1, len(escaped_chunks)):
 
743
        for j in range(1, len(escaped_chunks)):
605
744
            item = escaped_chunks[j]
606
745
            try:
607
746
                escaped_chunks[j] = _hex_display_map[item[:2]] + item[2:]
611
750
            except UnicodeDecodeError:
612
751
                escaped_chunks[j] = unichr(int(item[:2], 16)) + item[2:]
613
752
        unescaped = ''.join(escaped_chunks)
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:
 
753
        if sys.version_info[0] == 2:
621
754
            try:
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
 
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
626
759
                pass
627
760
            else:
628
 
                # Otherwise take the url decoded one
629
 
                res[i] = decoded
 
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
630
772
    return u'/'.join(res)
631
773
 
632
774
 
669
811
    old_parsed = urlparse.urlparse(old_base)
670
812
    new_parsed = urlparse.urlparse(new_base)
671
813
    if (old_parsed[:2]) != (new_parsed[:2]):
672
 
        raise errors.InvalidRebaseURLs(old_base, new_base)
 
814
        raise InvalidRebaseURLs(old_base, new_base)
673
815
    return determine_relative_path(new_parsed[2],
674
816
                                   join(old_parsed[2], url))
675
817
 
693
835
    return osutils.pathjoin(*segments)
694
836
 
695
837
 
 
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
 
696
999
 
697
1000
def parse_url(url):
698
1001
    """Extract the server address, the credentials and the path from the url.
701
1004
    chars.
702
1005
 
703
1006
    :param url: an quoted url
704
 
 
705
1007
    :return: (scheme, user, password, host, port, path) tuple, all fields
706
1008
        are unquoted.
707
1009
    """
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)
 
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)