/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
16
16
 
17
17
"""A collection of function for handling URL operations."""
18
18
 
19
 
from __future__ import absolute_import
20
 
 
21
19
import os
22
20
import re
23
21
import sys
24
22
 
25
 
try:
26
 
    import urlparse
27
 
except ImportError:
28
 
    from urllib import parse as urlparse
 
23
from bzrlib.lazy_import import lazy_import
 
24
lazy_import(globals(), """
 
25
from posixpath import split as _posix_split, normpath as _posix_normpath
 
26
import urllib
 
27
import urlparse
29
28
 
30
 
from . import (
 
29
from bzrlib import (
31
30
    errors,
32
31
    osutils,
33
32
    )
34
 
 
35
 
from .lazy_import import lazy_import
36
 
lazy_import(globals(), """
37
 
from posixpath import split as _posix_split
38
33
""")
39
34
 
40
 
from .sixish import (
41
 
    PY3,
42
 
    text_type,
43
 
    )
44
 
 
45
 
 
46
 
class InvalidURL(errors.PathError):
47
 
 
48
 
    _fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
49
 
 
50
 
 
51
 
class InvalidURLJoin(errors.PathError):
52
 
 
53
 
    _fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"
54
 
 
55
 
    def __init__(self, reason, base, join_args):
56
 
        self.reason = reason
57
 
        self.base = base
58
 
        self.join_args = join_args
59
 
        errors.PathError.__init__(self, base, reason)
60
 
 
61
 
 
62
 
class InvalidRebaseURLs(errors.PathError):
63
 
 
64
 
    _fmt = "URLs differ by more than path: %(from_)r and %(to)r"
65
 
 
66
 
    def __init__(self, from_, to):
67
 
        self.from_ = from_
68
 
        self.to = to
69
 
        errors.PathError.__init__(self, from_, 'URLs differ by more than path.')
70
 
 
71
35
 
72
36
def basename(url, exclude_trailing_slash=True):
73
37
    """Return the last component of a URL.
96
60
    return split(url, exclude_trailing_slash=exclude_trailing_slash)[0]
97
61
 
98
62
 
99
 
# Private copies of quote and unquote, copied from Python's
100
 
# urllib module because urllib unconditionally imports socket, which imports
101
 
# ssl.
102
 
 
103
 
always_safe = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
104
 
               'abcdefghijklmnopqrstuvwxyz'
105
 
               '0123456789' '_.-')
106
 
_safe_map = {}
107
 
for i, c in zip(range(256), ''.join(map(chr, range(256)))):
108
 
    _safe_map[c] = c if (i < 128 and c in always_safe) else '%{0:02X}'.format(i)
109
 
_safe_quoters = {}
110
 
 
111
 
 
112
 
def quote(s, safe='/'):
113
 
    """quote('abc def') -> 'abc%20def'
114
 
 
115
 
    Each part of a URL, e.g. the path info, the query, etc., has a
116
 
    different set of reserved characters that must be quoted.
117
 
 
118
 
    RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
119
 
    the following reserved characters.
120
 
 
121
 
    reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
122
 
                  "$" | ","
123
 
 
124
 
    Each of these characters is reserved in some component of a URL,
125
 
    but not necessarily in all of them.
126
 
 
127
 
    By default, the quote function is intended for quoting the path
128
 
    section of a URL.  Thus, it will not encode '/'.  This character
129
 
    is reserved, but in typical usage the quote function is being
130
 
    called on a path where the existing slash characters are used as
131
 
    reserved characters.
132
 
    """
133
 
    # fastpath
134
 
    if not s:
135
 
        if s is None:
136
 
            raise TypeError('None object cannot be quoted')
137
 
        return s
138
 
    cachekey = (safe, always_safe)
139
 
    try:
140
 
        (quoter, safe) = _safe_quoters[cachekey]
141
 
    except KeyError:
142
 
        safe_map = _safe_map.copy()
143
 
        safe_map.update([(c, c) for c in safe])
144
 
        quoter = safe_map.__getitem__
145
 
        safe = always_safe + safe
146
 
        _safe_quoters[cachekey] = (quoter, safe)
147
 
    if not s.rstrip(safe):
148
 
        return s
149
 
    return ''.join(map(quoter, s))
150
 
 
151
 
 
152
 
unquote = urlparse.unquote
153
 
 
154
 
 
155
63
def escape(relpath):
156
64
    """Escape relpath to be a valid url."""
157
 
    if not isinstance(relpath, str):
 
65
    if isinstance(relpath, unicode):
158
66
        relpath = relpath.encode('utf-8')
159
 
    return quote(relpath, safe='/~')
 
67
    # After quoting and encoding, the path should be perfectly
 
68
    # safe as a plain ASCII string, str() just enforces this
 
69
    return str(urllib.quote(relpath, safe='/~'))
160
70
 
161
71
 
162
72
def file_relpath(base, path):
168
78
        raise ValueError('Length of base (%r) must equal or'
169
79
            ' exceed the platform minimum url length (which is %d)' %
170
80
            (base, MIN_ABS_FILEURL_LENGTH))
171
 
    base = osutils.normpath(local_path_from_url(base))
172
 
    path = osutils.normpath(local_path_from_url(path))
 
81
    base = local_path_from_url(base)
 
82
    path = local_path_from_url(path)
173
83
    return escape(osutils.relpath(base, path))
174
84
 
175
85
 
191
101
    first_path_slash = path.find('/')
192
102
    if first_path_slash == -1:
193
103
        return len(scheme), None
194
 
    return len(scheme), first_path_slash+m.start('path')
195
 
 
196
 
 
197
 
def is_url(url):
198
 
    """Tests whether a URL is in actual fact a URL."""
199
 
    return _url_scheme_re.match(url) is not None
 
104
    return len(scheme), first_path_slash+len(scheme)+3
200
105
 
201
106
 
202
107
def join(base, *args):
213
118
    """
214
119
    if not args:
215
120
        return base
216
 
    scheme_end, path_start = _find_scheme_and_separator(base)
217
 
    if scheme_end is None and path_start is None:
218
 
        path_start = 0
219
 
    elif path_start is None:
220
 
        path_start = len(base)
221
 
    path = base[path_start:]
 
121
    match = _url_scheme_re.match(base)
 
122
    scheme = None
 
123
    if match:
 
124
        scheme = match.group('scheme')
 
125
        path = match.group('path').split('/')
 
126
        if path[-1:] == ['']:
 
127
            # Strip off a trailing slash
 
128
            # This helps both when we are at the root, and when
 
129
            # 'base' has an extra slash at the end
 
130
            path = path[:-1]
 
131
    else:
 
132
        path = base.split('/')
 
133
 
 
134
    if scheme is not None and len(path) >= 1:
 
135
        host = path[:1]
 
136
        # the path should be represented as an abs path.
 
137
        # we know this must be absolute because of the presence of a URL scheme.
 
138
        remove_root = True
 
139
        path = [''] + path[1:]
 
140
    else:
 
141
        # create an empty host, but dont alter the path - this might be a
 
142
        # relative url fragment.
 
143
        host = []
 
144
        remove_root = False
 
145
 
222
146
    for arg in args:
223
 
        arg_scheme_end, arg_path_start = _find_scheme_and_separator(arg)
224
 
        if arg_scheme_end is None and arg_path_start is None:
225
 
            arg_path_start = 0
226
 
        elif arg_path_start is None:
227
 
            arg_path_start = len(arg)
228
 
        if arg_scheme_end is not None:
229
 
            base = arg
230
 
            path = arg[arg_path_start:]
231
 
            scheme_end = arg_scheme_end
232
 
            path_start = arg_path_start
 
147
        match = _url_scheme_re.match(arg)
 
148
        if match:
 
149
            # Absolute URL
 
150
            scheme = match.group('scheme')
 
151
            # this skips .. normalisation, making http://host/../../..
 
152
            # be rather strange.
 
153
            path = match.group('path').split('/')
 
154
            # set the host and path according to new absolute URL, discarding
 
155
            # any previous values.
 
156
            # XXX: duplicates mess from earlier in this function.  This URL
 
157
            # manipulation code needs some cleaning up.
 
158
            if scheme is not None and len(path) >= 1:
 
159
                host = path[:1]
 
160
                path = path[1:]
 
161
                # url scheme implies absolute path.
 
162
                path = [''] + path
 
163
            else:
 
164
                # no url scheme we take the path as is.
 
165
                host = []
233
166
        else:
 
167
            path = '/'.join(path)
234
168
            path = joinpath(path, arg)
235
 
    return base[:path_start] + path
 
169
            path = path.split('/')
 
170
    if remove_root and path[0:1] == ['']:
 
171
        del path[0]
 
172
    if host:
 
173
        # Remove the leading slash from the path, so long as it isn't also the
 
174
        # trailing slash, which we want to keep if present.
 
175
        if path and path[0] == '' and len(path) > 1:
 
176
            del path[0]
 
177
        path = host + path
 
178
 
 
179
    if scheme is None:
 
180
        return '/'.join(path)
 
181
    return scheme + '://' + '/'.join(path)
236
182
 
237
183
 
238
184
def joinpath(base, *args):
257
203
                continue
258
204
            elif chunk == '..':
259
205
                if path == ['']:
260
 
                    raise InvalidURLJoin('Cannot go above root',
 
206
                    raise errors.InvalidURLJoin('Cannot go above root',
261
207
                            base, args)
262
208
                path.pop()
263
209
            else:
271
217
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
272
218
def _posix_local_path_from_url(url):
273
219
    """Convert a url like file:///path/to/foo into /path/to/foo"""
274
 
    url = split_segment_parameters_raw(url)[0]
275
220
    file_localhost_prefix = 'file://localhost/'
276
221
    if url.startswith(file_localhost_prefix):
277
222
        path = url[len(file_localhost_prefix) - 1:]
278
223
    elif not url.startswith('file:///'):
279
 
        raise InvalidURL(
 
224
        raise errors.InvalidURL(
280
225
            url, 'local urls must start with file:/// or file://localhost/')
281
226
    else:
282
227
        path = url[len('file://'):]
291
236
    """
292
237
    # importing directly from posixpath allows us to test this
293
238
    # on non-posix platforms
294
 
    return 'file://' + escape(osutils._posix_abspath(path))
 
239
    return 'file://' + escape(_posix_normpath(
 
240
        osutils._posix_abspath(path)))
295
241
 
296
242
 
297
243
def _win32_local_path_from_url(url):
298
244
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
299
245
    if not url.startswith('file://'):
300
 
        raise InvalidURL(url, 'local urls must start with file:///, '
 
246
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
301
247
                                     'UNC path urls must start with file://')
302
 
    url = split_segment_parameters_raw(url)[0]
303
248
    # We strip off all 3 slashes
304
249
    win32_url = url[len('file:'):]
305
250
    # check for UNC path: //HOST/path
306
251
    if not win32_url.startswith('///'):
307
252
        if (win32_url[2] == '/'
308
253
            or win32_url[3] in '|:'):
309
 
            raise InvalidURL(url, 'Win32 UNC path urls'
 
254
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
310
255
                ' have form file://HOST/path')
311
256
        return unescape(win32_url)
312
257
 
315
260
        return '/'
316
261
 
317
262
    # usual local path with drive letter
318
 
    if (len(win32_url) < 6
319
 
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
320
 
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
263
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
264
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
321
265
        or win32_url[4] not in  '|:'
322
266
        or win32_url[5] != '/'):
323
 
        raise InvalidURL(url, 'Win32 file urls start with'
 
267
        raise errors.InvalidURL(url, 'Win32 file urls start with'
324
268
                ' file:///x:/, where x is a valid drive letter')
325
269
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
326
270
 
334
278
    # on non-win32 platform
335
279
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
336
280
    #       which actually strips trailing space characters.
337
 
    #       The worst part is that on linux ntpath.abspath has different
 
281
    #       The worst part is that under linux ntpath.abspath has different
338
282
    #       semantics, since 'nt' is not an available module.
339
283
    if path == '/':
340
284
        return 'file:///'
359
303
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
360
304
 
361
305
 
362
 
_url_scheme_re = re.compile('^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
363
 
_url_hex_escapes_re = re.compile('(%[0-9a-fA-F]{2})')
 
306
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
 
307
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
364
308
 
365
309
 
366
310
def _unescape_safe_chars(matchobj):
395
339
    :param url: Either a hybrid URL or a local path
396
340
    :return: A normalized URL which only includes 7-bit ASCII characters.
397
341
    """
398
 
    scheme_end, path_start = _find_scheme_and_separator(url)
399
 
    if scheme_end is None:
 
342
    m = _url_scheme_re.match(url)
 
343
    if not m:
400
344
        return local_path_to_url(url)
401
 
    prefix = url[:path_start]
402
 
    path = url[path_start:]
403
 
    if not isinstance(url, text_type):
 
345
    scheme = m.group('scheme')
 
346
    path = m.group('path')
 
347
    if not isinstance(url, unicode):
404
348
        for c in url:
405
349
            if c not in _url_safe_characters:
406
 
                raise InvalidURL(url, 'URLs can only contain specific'
 
350
                raise errors.InvalidURL(url, 'URLs can only contain specific'
407
351
                                            ' safe characters (not %r)' % c)
408
352
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
409
 
        return str(prefix + ''.join(path))
 
353
        return str(scheme + '://' + ''.join(path))
410
354
 
411
355
    # We have a unicode (hybrid) url
412
356
    path_chars = list(path)
413
357
 
414
 
    for i in range(len(path_chars)):
 
358
    for i in xrange(len(path_chars)):
415
359
        if path_chars[i] not in _url_safe_characters:
416
360
            chars = path_chars[i].encode('utf-8')
417
361
            path_chars[i] = ''.join(
418
362
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
419
363
    path = ''.join(path_chars)
420
364
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
421
 
    return str(prefix + path)
 
365
    return str(scheme + '://' + path)
422
366
 
423
367
 
424
368
def relative_url(base, other):
477
421
    """On win32 the drive letter needs to be added to the url base."""
478
422
    # Strip off the drive letter
479
423
    # path is currently /C:/foo
480
 
    if len(path) < 4 or path[2] not in ':|' or path[3] != '/':
481
 
        raise InvalidURL(url_base + path,
 
424
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
 
425
        raise errors.InvalidURL(url_base + path,
482
426
            'win32 file:/// paths need a drive letter')
483
427
    url_base += path[0:3] # file:// + /C:
484
428
    path = path[3:] # /foo
525
469
    return url_base + head, tail
526
470
 
527
471
 
528
 
def split_segment_parameters_raw(url):
529
 
    """Split the subsegment of the last segment of a URL.
530
 
 
531
 
    :param url: A relative or absolute URL
532
 
    :return: (url, subsegments)
533
 
    """
534
 
    # GZ 2011-11-18: Dodgy removing the terminal slash like this, function
535
 
    #                operates on urls not url+segments, and Transport classes
536
 
    #                should not be blindly adding slashes in the first place. 
537
 
    lurl = strip_trailing_slash(url)
538
 
    # Segments begin at first comma after last forward slash, if one exists
539
 
    segment_start = lurl.find(",", lurl.rfind("/")+1)
540
 
    if segment_start == -1:
541
 
        return (url, [])
542
 
    return (lurl[:segment_start], 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
 
 
604
472
def _win32_strip_local_trailing_slash(url):
605
473
    """Strip slashes after the drive letter"""
606
474
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
656
524
    This returns a Unicode path from a URL
657
525
    """
658
526
    # jam 20060427 URLs are supposed to be ASCII only strings
659
 
    #       If they are passed in as unicode, unquote
 
527
    #       If they are passed in as unicode, urllib.unquote
660
528
    #       will return a UNICODE string, which actually contains
661
529
    #       utf-8 bytes. So we have to ensure that they are
662
530
    #       plain ASCII strings, or the final .decode will
663
531
    #       try to encode the UNICODE => ASCII, and then decode
664
532
    #       it into utf-8.
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)
 
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)
674
539
    try:
675
540
        unicode_path = unquoted.decode('utf-8')
676
 
    except UnicodeError as e:
677
 
        raise InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
 
541
    except UnicodeError, e:
 
542
        raise errors.InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
678
543
    return unicode_path
679
544
 
680
545
 
686
551
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
687
552
                    + [('%02X' % o, chr(o)) for o in range(256)]))
688
553
#These entries get mapped to themselves
689
 
_hex_display_map.update((hex, '%'+hex) for hex in _no_decode_hex)
 
554
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
690
555
 
691
556
# These characters shouldn't be percent-encoded, and it's always safe to
692
557
# unencode them if they are.
734
599
 
735
600
    # Split into sections to try to decode utf-8
736
601
    res = url.split('/')
737
 
    for i in range(1, len(res)):
 
602
    for i in xrange(1, len(res)):
738
603
        escaped_chunks = res[i].split('%')
739
 
        for j in range(1, len(escaped_chunks)):
 
604
        for j in xrange(1, len(escaped_chunks)):
740
605
            item = escaped_chunks[j]
741
606
            try:
742
607
                escaped_chunks[j] = _hex_display_map[item[:2]] + item[2:]
804
669
    old_parsed = urlparse.urlparse(old_base)
805
670
    new_parsed = urlparse.urlparse(new_base)
806
671
    if (old_parsed[:2]) != (new_parsed[:2]):
807
 
        raise InvalidRebaseURLs(old_base, new_base)
 
672
        raise errors.InvalidRebaseURLs(old_base, new_base)
808
673
    return determine_relative_path(new_parsed[2],
809
674
                                   join(old_parsed[2], url))
810
675
 
828
693
    return osutils.pathjoin(*segments)
829
694
 
830
695
 
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
 
 
974
696
 
975
697
def parse_url(url):
976
698
    """Extract the server address, the credentials and the path from the url.
979
701
    chars.
980
702
 
981
703
    :param url: an quoted url
 
704
 
982
705
    :return: (scheme, user, password, host, port, path) tuple, all fields
983
706
        are unquoted.
984
707
    """
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)
 
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)