/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-08-18 17:40:49 UTC
  • mto: This revision was merged to the branch mainline in revision 7093.
  • Revision ID: jelmer@jelmer.uk-20180818174049-w25ym3mkqjthccqb
Fix bytes test.

Show diffs side-by-side

added added

removed removed

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