/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-02-18 19:18:40 UTC
  • mto: This revision was merged to the branch mainline in revision 6928.
  • Revision ID: jelmer@jelmer.uk-20180218191840-2wezg20u9ffbfmed
Fix more bees, use with rather than try/finally for some files.

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):
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], 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
        parameters[key] = value
 
556
    return (base_url, parameters)
 
557
 
 
558
 
 
559
def join_segment_parameters_raw(base, *subsegments):
 
560
    """Create a new URL by adding subsegments to an existing one. 
 
561
 
 
562
    This adds the specified subsegments to the last path in the specified
 
563
    base URL. The subsegments should be bytestrings.
 
564
 
 
565
    :note: You probably want to use join_segment_parameters instead.
 
566
    """
 
567
    if not subsegments:
 
568
        return base
 
569
    for subsegment in subsegments:
 
570
        if not isinstance(subsegment, str):
 
571
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
 
572
        if "," in subsegment:
 
573
            raise InvalidURLJoin(", exists in subsegments",
 
574
                                        base, subsegments)
 
575
    return ",".join((base,) + subsegments)
 
576
 
 
577
 
 
578
def join_segment_parameters(url, parameters):
 
579
    """Create a new URL by adding segment parameters to an existing one.
 
580
 
 
581
    The parameters of the last segment in the URL will be updated; if a
 
582
    parameter with the same key already exists it will be overwritten.
 
583
 
 
584
    :param url: A URL, as string
 
585
    :param parameters: Dictionary of parameters, keys and values as bytestrings
 
586
    """
 
587
    (base, existing_parameters) = split_segment_parameters(url)
 
588
    new_parameters = {}
 
589
    new_parameters.update(existing_parameters)
 
590
    for key, value in parameters.items():
 
591
        if not isinstance(key, str):
 
592
            raise TypeError("parameter key %r is not a bytestring" % key)
 
593
        if not isinstance(value, str):
 
594
            raise TypeError("parameter value %r for %s is not a bytestring" %
 
595
                (key, value))
 
596
        if "=" in key:
 
597
            raise InvalidURLJoin("= exists in parameter key", url,
 
598
                parameters)
 
599
        new_parameters[key] = value
 
600
    return join_segment_parameters_raw(base, 
 
601
        *["%s=%s" % item for item in sorted(new_parameters.items())])
 
602
 
 
603
 
472
604
def _win32_strip_local_trailing_slash(url):
473
605
    """Strip slashes after the drive letter"""
474
606
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
524
656
    This returns a Unicode path from a URL
525
657
    """
526
658
    # jam 20060427 URLs are supposed to be ASCII only strings
527
 
    #       If they are passed in as unicode, urllib.unquote
 
659
    #       If they are passed in as unicode, unquote
528
660
    #       will return a UNICODE string, which actually contains
529
661
    #       utf-8 bytes. So we have to ensure that they are
530
662
    #       plain ASCII strings, or the final .decode will
531
663
    #       try to encode the UNICODE => ASCII, and then decode
532
664
    #       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)
 
665
    if isinstance(url, text_type):
 
666
        try:
 
667
            url = url.encode("ascii")
 
668
        except UnicodeError as e:
 
669
            raise InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
 
670
    if PY3:
 
671
        unquoted = urlparse.unquote_to_bytes(url)
 
672
    else:
 
673
        unquoted = unquote(url)
539
674
    try:
540
675
        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,))
 
676
    except UnicodeError as e:
 
677
        raise InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
543
678
    return unicode_path
544
679
 
545
680
 
551
686
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
552
687
                    + [('%02X' % o, chr(o)) for o in range(256)]))
553
688
#These entries get mapped to themselves
554
 
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
 
689
_hex_display_map.update((hex, '%'+hex) for hex in _no_decode_hex)
555
690
 
556
691
# These characters shouldn't be percent-encoded, and it's always safe to
557
692
# unencode them if they are.
599
734
 
600
735
    # Split into sections to try to decode utf-8
601
736
    res = url.split('/')
602
 
    for i in xrange(1, len(res)):
 
737
    for i in range(1, len(res)):
603
738
        escaped_chunks = res[i].split('%')
604
 
        for j in xrange(1, len(escaped_chunks)):
 
739
        for j in range(1, len(escaped_chunks)):
605
740
            item = escaped_chunks[j]
606
741
            try:
607
742
                escaped_chunks[j] = _hex_display_map[item[:2]] + item[2:]
669
804
    old_parsed = urlparse.urlparse(old_base)
670
805
    new_parsed = urlparse.urlparse(new_base)
671
806
    if (old_parsed[:2]) != (new_parsed[:2]):
672
 
        raise errors.InvalidRebaseURLs(old_base, new_base)
 
807
        raise InvalidRebaseURLs(old_base, new_base)
673
808
    return determine_relative_path(new_parsed[2],
674
809
                                   join(old_parsed[2], url))
675
810
 
693
828
    return osutils.pathjoin(*segments)
694
829
 
695
830
 
 
831
class URL(object):
 
832
    """Parsed URL."""
 
833
 
 
834
    def __init__(self, scheme, quoted_user, quoted_password, quoted_host,
 
835
            port, quoted_path):
 
836
        self.scheme = scheme
 
837
        self.quoted_host = quoted_host
 
838
        self.host = unquote(self.quoted_host)
 
839
        self.quoted_user = quoted_user
 
840
        if self.quoted_user is not None:
 
841
            self.user = unquote(self.quoted_user)
 
842
        else:
 
843
            self.user = None
 
844
        self.quoted_password = quoted_password
 
845
        if self.quoted_password is not None:
 
846
            self.password = unquote(self.quoted_password)
 
847
        else:
 
848
            self.password = None
 
849
        self.port = port
 
850
        self.quoted_path = _url_hex_escapes_re.sub(_unescape_safe_chars, quoted_path)
 
851
        self.path = unquote(self.quoted_path)
 
852
 
 
853
    def __eq__(self, other):
 
854
        return (isinstance(other, self.__class__) and
 
855
                self.scheme == other.scheme and
 
856
                self.host == other.host and
 
857
                self.user == other.user and
 
858
                self.password == other.password and
 
859
                self.path == other.path)
 
860
 
 
861
    def __repr__(self):
 
862
        return "<%s(%r, %r, %r, %r, %r, %r)>" % (
 
863
            self.__class__.__name__,
 
864
            self.scheme, self.quoted_user, self.quoted_password,
 
865
            self.quoted_host, self.port, self.quoted_path)
 
866
 
 
867
    @classmethod
 
868
    def from_string(cls, url):
 
869
        """Create a URL object from a string.
 
870
 
 
871
        :param url: URL as bytestring
 
872
        """
 
873
        # GZ 2017-06-09: Actually validate ascii-ness
 
874
        if not isinstance(url, str):
 
875
            raise InvalidURL('should be ascii:\n%r' % url)
 
876
        (scheme, netloc, path, params,
 
877
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
878
        user = password = host = port = None
 
879
        if '@' in netloc:
 
880
            user, host = netloc.rsplit('@', 1)
 
881
            if ':' in user:
 
882
                user, password = user.split(':', 1)
 
883
        else:
 
884
            host = netloc
 
885
 
 
886
        if ':' in host and not (host[0] == '[' and host[-1] == ']'):
 
887
            # there *is* port
 
888
            host, port = host.rsplit(':', 1)
 
889
            try:
 
890
                port = int(port)
 
891
            except ValueError:
 
892
                raise InvalidURL('invalid port number %s in url:\n%s' %
 
893
                                 (port, url))
 
894
        if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
 
895
            host = host[1:-1]
 
896
 
 
897
        return cls(scheme, user, password, host, port, path)
 
898
 
 
899
    def __str__(self):
 
900
        netloc = self.quoted_host
 
901
        if ":" in netloc:
 
902
            netloc = "[%s]" % netloc
 
903
        if self.quoted_user is not None:
 
904
            # Note that we don't put the password back even if we
 
905
            # have one so that it doesn't get accidentally
 
906
            # exposed.
 
907
            netloc = '%s@%s' % (self.quoted_user, netloc)
 
908
        if self.port is not None:
 
909
            netloc = '%s:%d' % (netloc, self.port)
 
910
        return urlparse.urlunparse(
 
911
            (self.scheme, netloc, self.quoted_path, None, None, None))
 
912
 
 
913
    @staticmethod
 
914
    def _combine_paths(base_path, relpath):
 
915
        """Transform a Transport-relative path to a remote absolute path.
 
916
 
 
917
        This does not handle substitution of ~ but does handle '..' and '.'
 
918
        components.
 
919
 
 
920
        Examples::
 
921
 
 
922
            t._combine_paths('/home/sarah', 'project/foo')
 
923
                => '/home/sarah/project/foo'
 
924
            t._combine_paths('/home/sarah', '../../etc')
 
925
                => '/etc'
 
926
            t._combine_paths('/home/sarah', '/etc')
 
927
                => '/etc'
 
928
 
 
929
        :param base_path: base path
 
930
        :param relpath: relative url string for relative part of remote path.
 
931
        :return: urlencoded string for final path.
 
932
        """
 
933
        if not isinstance(relpath, str):
 
934
            raise InvalidURL(relpath)
 
935
        relpath = _url_hex_escapes_re.sub(_unescape_safe_chars, relpath)
 
936
        if relpath.startswith('/'):
 
937
            base_parts = []
 
938
        else:
 
939
            base_parts = base_path.split('/')
 
940
        if len(base_parts) > 0 and base_parts[-1] == '':
 
941
            base_parts = base_parts[:-1]
 
942
        for p in relpath.split('/'):
 
943
            if p == '..':
 
944
                if len(base_parts) == 0:
 
945
                    # In most filesystems, a request for the parent
 
946
                    # of root, just returns root.
 
947
                    continue
 
948
                base_parts.pop()
 
949
            elif p == '.':
 
950
                continue # No-op
 
951
            elif p != '':
 
952
                base_parts.append(p)
 
953
        path = '/'.join(base_parts)
 
954
        if not path.startswith('/'):
 
955
            path = '/' + path
 
956
        return path
 
957
 
 
958
    def clone(self, offset=None):
 
959
        """Return a new URL for a path relative to this URL.
 
960
 
 
961
        :param offset: A relative path, already urlencoded
 
962
        :return: `URL` instance
 
963
        """
 
964
        if offset is not None:
 
965
            relative = unescape(offset).encode('utf-8')
 
966
            path = self._combine_paths(self.path, relative)
 
967
            path = quote(path, safe="/~")
 
968
        else:
 
969
            path = self.quoted_path
 
970
        return self.__class__(self.scheme, self.quoted_user,
 
971
                self.quoted_password, self.quoted_host, self.port,
 
972
                path)
 
973
 
696
974
 
697
975
def parse_url(url):
698
976
    """Extract the server address, the credentials and the path from the url.
701
979
    chars.
702
980
 
703
981
    :param url: an quoted url
704
 
 
705
982
    :return: (scheme, user, password, host, port, path) tuple, all fields
706
983
        are unquoted.
707
984
    """
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)
 
985
    parsed_url = URL.from_string(url)
 
986
    return (parsed_url.scheme, parsed_url.user, parsed_url.password,
 
987
        parsed_url.host, parsed_url.port, parsed_url.path)