/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2020-08-23 01:15:41 UTC
  • mfrom: (7520.1.4 merge-3.1)
  • Revision ID: breezy.the.bot@gmail.com-20200823011541-nv0oh7nzaganx2qy
Merge lp:brz/3.1.

Merged from https://code.launchpad.net/~jelmer/brz/merge-3.1/+merge/389690

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/urlutils.py
20
20
import re
21
21
import sys
22
22
 
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
 
23
from urllib import parse as urlparse
28
24
 
29
 
from bzrlib import (
 
25
from . import (
30
26
    errors,
31
27
    osutils,
32
28
    )
 
29
 
 
30
from .lazy_import import lazy_import
 
31
lazy_import(globals(), """
 
32
from posixpath import split as _posix_split
33
33
""")
34
34
 
35
35
 
 
36
 
 
37
class InvalidURL(errors.PathError):
 
38
 
 
39
    _fmt = 'Invalid url supplied to transport: "%(path)s"%(extra)s'
 
40
 
 
41
 
 
42
class InvalidURLJoin(errors.PathError):
 
43
 
 
44
    _fmt = "Invalid URL join request: %(reason)s: %(base)r + %(join_args)r"
 
45
 
 
46
    def __init__(self, reason, base, join_args):
 
47
        self.reason = reason
 
48
        self.base = base
 
49
        self.join_args = join_args
 
50
        errors.PathError.__init__(self, base, reason)
 
51
 
 
52
 
 
53
class InvalidRebaseURLs(errors.PathError):
 
54
 
 
55
    _fmt = "URLs differ by more than path: %(from_)r and %(to)r"
 
56
 
 
57
    def __init__(self, from_, to):
 
58
        self.from_ = from_
 
59
        self.to = to
 
60
        errors.PathError.__init__(
 
61
            self, from_, 'URLs differ by more than path.')
 
62
 
 
63
 
36
64
def basename(url, exclude_trailing_slash=True):
37
65
    """Return the last component of a URL.
38
66
 
60
88
    return split(url, exclude_trailing_slash=exclude_trailing_slash)[0]
61
89
 
62
90
 
63
 
def escape(relpath):
 
91
quote_from_bytes = urlparse.quote_from_bytes
 
92
quote = urlparse.quote
 
93
unquote_to_bytes = urlparse.unquote_to_bytes
 
94
unquote = urlparse.unquote
 
95
 
 
96
 
 
97
def escape(relpath, safe='/~'):
64
98
    """Escape relpath to be a valid url."""
65
 
    if isinstance(relpath, unicode):
66
 
        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='/~'))
 
99
    return quote(relpath, safe=safe)
70
100
 
71
101
 
72
102
def file_relpath(base, path):
76
106
    """
77
107
    if len(base) < MIN_ABS_FILEURL_LENGTH:
78
108
        raise ValueError('Length of base (%r) must equal or'
79
 
            ' exceed the platform minimum url length (which is %d)' %
80
 
            (base, MIN_ABS_FILEURL_LENGTH))
81
 
    base = local_path_from_url(base)
82
 
    path = local_path_from_url(path)
 
109
                         ' exceed the platform minimum url length (which is %d)' %
 
110
                         (base, MIN_ABS_FILEURL_LENGTH))
 
111
    base = osutils.normpath(local_path_from_url(base))
 
112
    path = osutils.normpath(local_path_from_url(path))
83
113
    return escape(osutils.relpath(base, path))
84
114
 
85
115
 
101
131
    first_path_slash = path.find('/')
102
132
    if first_path_slash == -1:
103
133
        return len(scheme), None
104
 
    return len(scheme), first_path_slash+len(scheme)+3
 
134
    return len(scheme), first_path_slash + m.start('path')
 
135
 
 
136
 
 
137
def is_url(url):
 
138
    """Tests whether a URL is in actual fact a URL."""
 
139
    return _url_scheme_re.match(url) is not None
105
140
 
106
141
 
107
142
def join(base, *args):
118
153
    """
119
154
    if not args:
120
155
        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
 
 
 
156
    scheme_end, path_start = _find_scheme_and_separator(base)
 
157
    if scheme_end is None and path_start is None:
 
158
        path_start = 0
 
159
    elif path_start is None:
 
160
        path_start = len(base)
 
161
    path = base[path_start:]
146
162
    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 = []
 
163
        arg_scheme_end, arg_path_start = _find_scheme_and_separator(arg)
 
164
        if arg_scheme_end is None and arg_path_start is None:
 
165
            arg_path_start = 0
 
166
        elif arg_path_start is None:
 
167
            arg_path_start = len(arg)
 
168
        if arg_scheme_end is not None:
 
169
            base = arg
 
170
            path = arg[arg_path_start:]
 
171
            scheme_end = arg_scheme_end
 
172
            path_start = arg_path_start
166
173
        else:
167
 
            path = '/'.join(path)
168
174
            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)
 
175
    return base[:path_start] + path
182
176
 
183
177
 
184
178
def joinpath(base, *args):
193
187
    """
194
188
    path = base.split('/')
195
189
    if len(path) > 1 and path[-1] == '':
196
 
        #If the path ends in a trailing /, remove it.
 
190
        # If the path ends in a trailing /, remove it.
197
191
        path.pop()
198
192
    for arg in args:
199
193
        if arg.startswith('/'):
203
197
                continue
204
198
            elif chunk == '..':
205
199
                if path == ['']:
206
 
                    raise errors.InvalidURLJoin('Cannot go above root',
207
 
                            base, args)
 
200
                    raise InvalidURLJoin('Cannot go above root',
 
201
                                         base, args)
208
202
                path.pop()
209
203
            else:
210
204
                path.append(chunk)
217
211
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
218
212
def _posix_local_path_from_url(url):
219
213
    """Convert a url like file:///path/to/foo into /path/to/foo"""
 
214
    url = strip_segment_parameters(url)
220
215
    file_localhost_prefix = 'file://localhost/'
221
216
    if url.startswith(file_localhost_prefix):
222
217
        path = url[len(file_localhost_prefix) - 1:]
223
218
    elif not url.startswith('file:///'):
224
 
        raise errors.InvalidURL(
 
219
        raise InvalidURL(
225
220
            url, 'local urls must start with file:/// or file://localhost/')
226
221
    else:
227
222
        path = url[len('file://'):]
236
231
    """
237
232
    # importing directly from posixpath allows us to test this
238
233
    # on non-posix platforms
239
 
    return 'file://' + escape(_posix_normpath(
240
 
        osutils._posix_abspath(path)))
 
234
    return 'file://' + escape(osutils._posix_abspath(path))
241
235
 
242
236
 
243
237
def _win32_local_path_from_url(url):
244
238
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
245
239
    if not url.startswith('file://'):
246
 
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
247
 
                                     'UNC path urls must start with file://')
 
240
        raise InvalidURL(url, 'local urls must start with file:///, '
 
241
                         'UNC path urls must start with file://')
 
242
    url = strip_segment_parameters(url)
248
243
    # We strip off all 3 slashes
249
244
    win32_url = url[len('file:'):]
250
245
    # check for UNC path: //HOST/path
251
246
    if not win32_url.startswith('///'):
252
247
        if (win32_url[2] == '/'
253
 
            or win32_url[3] in '|:'):
254
 
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
255
 
                ' have form file://HOST/path')
 
248
                or win32_url[3] in '|:'):
 
249
            raise InvalidURL(url, 'Win32 UNC path urls'
 
250
                             ' have form file://HOST/path')
256
251
        return unescape(win32_url)
257
252
 
258
253
    # allow empty paths so we can serve all roots
260
255
        return '/'
261
256
 
262
257
    # usual local path with drive letter
263
 
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
264
 
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
265
 
        or win32_url[4] not in  '|:'
266
 
        or win32_url[5] != '/'):
267
 
        raise errors.InvalidURL(url, 'Win32 file urls start with'
268
 
                ' file:///x:/, where x is a valid drive letter')
 
258
    if (len(win32_url) < 6
 
259
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
260
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ') or
 
261
        win32_url[4] not in '|:'
 
262
            or win32_url[5] != '/'):
 
263
        raise InvalidURL(url, 'Win32 file urls start with'
 
264
                         ' file:///x:/, where x is a valid drive letter')
269
265
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
270
266
 
271
267
 
278
274
    # on non-win32 platform
279
275
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
280
276
    #       which actually strips trailing space characters.
281
 
    #       The worst part is that under linux ntpath.abspath has different
 
277
    #       The worst part is that on linux ntpath.abspath has different
282
278
    #       semantics, since 'nt' is not an available module.
283
279
    if path == '/':
284
280
        return 'file:///'
288
284
    if win32_path.startswith('//'):
289
285
        return 'file:' + escape(win32_path)
290
286
    return ('file:///' + str(win32_path[0].upper()) + ':' +
291
 
        escape(win32_path[2:]))
 
287
            escape(win32_path[2:]))
292
288
 
293
289
 
294
290
local_path_to_url = _posix_local_path_to_url
303
299
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
304
300
 
305
301
 
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})')
 
302
_url_scheme_re = re.compile('^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
 
303
_url_hex_escapes_re = re.compile('(%[0-9a-fA-F]{2})')
308
304
 
309
305
 
310
306
def _unescape_safe_chars(matchobj):
339
335
    :param url: Either a hybrid URL or a local path
340
336
    :return: A normalized URL which only includes 7-bit ASCII characters.
341
337
    """
342
 
    m = _url_scheme_re.match(url)
343
 
    if not m:
 
338
    scheme_end, path_start = _find_scheme_and_separator(url)
 
339
    if scheme_end is None:
344
340
        return local_path_to_url(url)
345
 
    scheme = m.group('scheme')
346
 
    path = m.group('path')
347
 
    if not isinstance(url, unicode):
 
341
    prefix = url[:path_start]
 
342
    path = url[path_start:]
 
343
    if not isinstance(url, str):
348
344
        for c in url:
349
345
            if c not in _url_safe_characters:
350
 
                raise errors.InvalidURL(url, 'URLs can only contain specific'
351
 
                                            ' safe characters (not %r)' % c)
 
346
                raise InvalidURL(url, 'URLs can only contain specific'
 
347
                                 ' safe characters (not %r)' % c)
352
348
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
353
 
        return str(scheme + '://' + ''.join(path))
 
349
        return str(prefix + ''.join(path))
354
350
 
355
351
    # We have a unicode (hybrid) url
356
352
    path_chars = list(path)
357
353
 
358
 
    for i in xrange(len(path_chars)):
 
354
    for i in range(len(path_chars)):
359
355
        if path_chars[i] not in _url_safe_characters:
360
 
            chars = path_chars[i].encode('utf-8')
361
356
            path_chars[i] = ''.join(
362
 
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
 
357
                ['%%%02X' % c for c in bytearray(path_chars[i].encode('utf-8'))])
363
358
    path = ''.join(path_chars)
364
359
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
365
 
    return str(scheme + '://' + path)
 
360
    return str(prefix + path)
366
361
 
367
362
 
368
363
def relative_url(base, other):
385
380
    if base_scheme != other_scheme:
386
381
        return other
387
382
    elif sys.platform == 'win32' and base_scheme == 'file://':
388
 
        base_drive = base[base_first_slash+1:base_first_slash+3]
389
 
        other_drive = other[other_first_slash+1:other_first_slash+3]
 
383
        base_drive = base[base_first_slash + 1:base_first_slash + 3]
 
384
        other_drive = other[other_first_slash + 1:other_first_slash + 3]
390
385
        if base_drive != other_drive:
391
386
            return other
392
387
 
393
 
    base_path = base[base_first_slash+1:]
394
 
    other_path = other[other_first_slash+1:]
 
388
    base_path = base[base_first_slash + 1:]
 
389
    other_path = other[other_first_slash + 1:]
395
390
 
396
391
    if base_path.endswith('/'):
397
392
        base_path = base_path[:-1]
421
416
    """On win32 the drive letter needs to be added to the url base."""
422
417
    # Strip off the drive letter
423
418
    # 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,
426
 
            'win32 file:/// paths need a drive letter')
427
 
    url_base += path[0:3] # file:// + /C:
428
 
    path = path[3:] # /foo
 
419
    if len(path) < 4 or path[2] not in ':|' or path[3] != '/':
 
420
        raise InvalidURL(url_base + path,
 
421
                         'win32 file:/// paths need a drive letter')
 
422
    url_base += path[0:3]  # file:// + /C:
 
423
    path = path[3:]  # /foo
429
424
    return url_base, path
430
425
 
431
426
 
436
431
    :param exclude_trailing_slash: Strip off a final '/' if it is part
437
432
        of the path (but not if it is part of the protocol specification)
438
433
 
439
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
440
 
        the root.
 
434
    :return: (parent_url, child_dir).  child_dir may be the empty string if
 
435
        we're at the root.
441
436
    """
442
437
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
443
438
 
453
448
            return url, ''
454
449
 
455
450
    # We have a fully defined path
456
 
    url_base = url[:first_path_slash] # http://host, file://
457
 
    path = url[first_path_slash:] # /file/foo
 
451
    url_base = url[:first_path_slash]  # http://host, file://
 
452
    path = url[first_path_slash:]  # /file/foo
458
453
 
459
454
    if sys.platform == 'win32' and url.startswith('file:///'):
460
455
        # Strip off the drive letter
469
464
    return url_base + head, tail
470
465
 
471
466
 
 
467
def split_segment_parameters_raw(url):
 
468
    """Split the subsegment of the last segment of a URL.
 
469
 
 
470
    :param url: A relative or absolute URL
 
471
    :return: (url, subsegments)
 
472
    """
 
473
    # GZ 2011-11-18: Dodgy removing the terminal slash like this, function
 
474
    #                operates on urls not url+segments, and Transport classes
 
475
    #                should not be blindly adding slashes in the first place.
 
476
    lurl = strip_trailing_slash(url)
 
477
    # Segments begin at first comma after last forward slash, if one exists
 
478
    segment_start = lurl.find(",", lurl.rfind("/") + 1)
 
479
    if segment_start == -1:
 
480
        return (url, [])
 
481
    return (lurl[:segment_start],
 
482
            [str(s) for s in lurl[segment_start + 1:].split(",")])
 
483
 
 
484
 
 
485
def split_segment_parameters(url):
 
486
    """Split the segment parameters of the last segment of a URL.
 
487
 
 
488
    :param url: A relative or absolute URL
 
489
    :return: (url, segment_parameters)
 
490
    """
 
491
    (base_url, subsegments) = split_segment_parameters_raw(url)
 
492
    parameters = {}
 
493
    for subsegment in subsegments:
 
494
        try:
 
495
            (key, value) = subsegment.split("=", 1)
 
496
        except ValueError:
 
497
            raise InvalidURL(url, "missing = in subsegment")
 
498
        if not isinstance(key, str):
 
499
            raise TypeError(key)
 
500
        if not isinstance(value, str):
 
501
            raise TypeError(value)
 
502
        parameters[key] = value
 
503
    return (base_url, parameters)
 
504
 
 
505
 
 
506
def strip_segment_parameters(url):
 
507
    """Strip the segment parameters from a URL.
 
508
 
 
509
    :param url: A relative or absolute URL
 
510
    :return: url
 
511
    """
 
512
    base_url, subsegments = split_segment_parameters_raw(url)
 
513
    return base_url
 
514
 
 
515
 
 
516
def join_segment_parameters_raw(base, *subsegments):
 
517
    """Create a new URL by adding subsegments to an existing one.
 
518
 
 
519
    This adds the specified subsegments to the last path in the specified
 
520
    base URL. The subsegments should be bytestrings.
 
521
 
 
522
    :note: You probably want to use join_segment_parameters instead.
 
523
    """
 
524
    if not subsegments:
 
525
        return base
 
526
    for subsegment in subsegments:
 
527
        if not isinstance(subsegment, str):
 
528
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
 
529
        if "," in subsegment:
 
530
            raise InvalidURLJoin(", exists in subsegments",
 
531
                                 base, subsegments)
 
532
    return ",".join((base,) + subsegments)
 
533
 
 
534
 
 
535
def join_segment_parameters(url, parameters):
 
536
    """Create a new URL by adding segment parameters to an existing one.
 
537
 
 
538
    The parameters of the last segment in the URL will be updated; if a
 
539
    parameter with the same key already exists it will be overwritten.
 
540
 
 
541
    :param url: A URL, as string
 
542
    :param parameters: Dictionary of parameters, keys and values as bytestrings
 
543
    """
 
544
    (base, existing_parameters) = split_segment_parameters(url)
 
545
    new_parameters = {}
 
546
    new_parameters.update(existing_parameters)
 
547
    for key, value in parameters.items():
 
548
        if not isinstance(key, str):
 
549
            raise TypeError("parameter key %r is not a str" % key)
 
550
        if not isinstance(value, str):
 
551
            raise TypeError("parameter value %r for %r is not a str" %
 
552
                            (value, key))
 
553
        if "=" in key:
 
554
            raise InvalidURLJoin("= exists in parameter key", url,
 
555
                                 parameters)
 
556
        new_parameters[key] = value
 
557
    return join_segment_parameters_raw(
 
558
        base, *["%s=%s" % item for item in sorted(new_parameters.items())])
 
559
 
 
560
 
472
561
def _win32_strip_local_trailing_slash(url):
473
562
    """Strip slashes after the drive letter"""
474
563
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
510
599
        # so just chop off the last character
511
600
        return url[:-1]
512
601
 
513
 
    if first_path_slash is None or first_path_slash == len(url)-1:
 
602
    if first_path_slash is None or first_path_slash == len(url) - 1:
514
603
        # Don't chop off anything if the only slash is the path
515
604
        # separating slash
516
605
        return url
524
613
    This returns a Unicode path from a URL
525
614
    """
526
615
    # jam 20060427 URLs are supposed to be ASCII only strings
527
 
    #       If they are passed in as unicode, urllib.unquote
 
616
    #       If they are passed in as unicode, unquote
528
617
    #       will return a UNICODE string, which actually contains
529
618
    #       utf-8 bytes. So we have to ensure that they are
530
619
    #       plain ASCII strings, or the final .decode will
531
620
    #       try to encode the UNICODE => ASCII, and then decode
532
621
    #       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
622
 
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
 
623
    if isinstance(url, str):
 
624
        try:
 
625
            url.encode("ascii")
 
626
        except UnicodeError as e:
 
627
            raise InvalidURL(
 
628
                url, 'URL was not a plain ASCII url: %s' % (e,))
 
629
    return urlparse.unquote(url)
544
630
 
545
631
 
546
632
# These are characters that if escaped, should stay that way
547
633
_no_decode_chars = ';/?:@&=+$,#'
548
634
_no_decode_ords = [ord(c) for c in _no_decode_chars]
549
635
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
550
 
                + ['%02X' % o for o in _no_decode_ords])
551
 
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
552
 
                    + [('%02X' % o, chr(o)) for o in range(256)]))
553
 
#These entries get mapped to themselves
554
 
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
 
636
                  + ['%02X' % o for o in _no_decode_ords])
 
637
_hex_display_map = dict(([('%02x' % o, bytes([o])) for o in range(256)]
 
638
                         + [('%02X' % o, bytes([o])) for o in range(256)]))
 
639
# These entries get mapped to themselves
 
640
_hex_display_map.update((hex, b'%' + hex.encode('ascii'))
 
641
                        for hex in _no_decode_hex)
555
642
 
556
643
# These characters shouldn't be percent-encoded, and it's always safe to
557
644
# unencode them if they are.
558
645
_url_dont_escape_characters = set(
559
 
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
560
 
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
561
 
   "0123456789" # Numbers
562
 
   "-._~"  # Unreserved characters
 
646
    "abcdefghijklmnopqrstuvwxyz"  # Lowercase alpha
 
647
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"  # Uppercase alpha
 
648
    "0123456789"  # Numbers
 
649
    "-._~"  # Unreserved characters
563
650
)
564
651
 
565
652
# These characters should not be escaped
566
653
_url_safe_characters = set(
567
 
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
568
 
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
569
 
   "0123456789" # Numbers
570
 
   "_.-!~*'()"  # Unreserved characters
571
 
   "/;?:@&=+$," # Reserved characters
572
 
   "%#"         # Extra reserved characters
 
654
    "abcdefghijklmnopqrstuvwxyz"  # Lowercase alpha
 
655
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"  # Uppercase alpha
 
656
    "0123456789"  # Numbers
 
657
    "_.-!~*'()"  # Unreserved characters
 
658
    "/;?:@&=+$,"  # Reserved characters
 
659
    "%#"         # Extra reserved characters
573
660
)
574
661
 
 
662
 
 
663
def _unescape_segment_for_display(segment, encoding):
 
664
    """Unescape a segment for display.
 
665
 
 
666
    Helper for unescape_for_display
 
667
 
 
668
    :param url: A 7-bit ASCII URL
 
669
    :param encoding: The final output encoding
 
670
 
 
671
    :return: A unicode string which can be safely encoded into the
 
672
         specified encoding.
 
673
    """
 
674
    escaped_chunks = segment.split('%')
 
675
    escaped_chunks[0] = escaped_chunks[0].encode('utf-8')
 
676
    for j in range(1, len(escaped_chunks)):
 
677
        item = escaped_chunks[j]
 
678
        try:
 
679
            escaped_chunks[j] = _hex_display_map[item[:2]]
 
680
        except KeyError:
 
681
            # Put back the percent symbol
 
682
            escaped_chunks[j] = b'%' + (item[:2].encode('utf-8'))
 
683
        except UnicodeDecodeError:
 
684
            escaped_chunks[j] = chr(int(item[:2], 16)).encode('utf-8')
 
685
        escaped_chunks[j] += (item[2:].encode('utf-8'))
 
686
    unescaped = b''.join(escaped_chunks)
 
687
    try:
 
688
        decoded = unescaped.decode('utf-8')
 
689
    except UnicodeDecodeError:
 
690
        # If this path segment cannot be properly utf-8 decoded
 
691
        # after doing unescaping we will just leave it alone
 
692
        return segment
 
693
    else:
 
694
        try:
 
695
            decoded.encode(encoding)
 
696
        except UnicodeEncodeError:
 
697
            # If this chunk cannot be encoded in the local
 
698
            # encoding, then we should leave it alone
 
699
            return segment
 
700
        else:
 
701
            # Otherwise take the url decoded one
 
702
            return decoded
 
703
 
 
704
 
575
705
def unescape_for_display(url, encoding):
576
706
    """Decode what you can for a URL, so that we get a nice looking path.
577
707
 
599
729
 
600
730
    # Split into sections to try to decode utf-8
601
731
    res = url.split('/')
602
 
    for i in xrange(1, len(res)):
603
 
        escaped_chunks = res[i].split('%')
604
 
        for j in xrange(1, len(escaped_chunks)):
605
 
            item = escaped_chunks[j]
606
 
            try:
607
 
                escaped_chunks[j] = _hex_display_map[item[:2]] + item[2:]
608
 
            except KeyError:
609
 
                # Put back the percent symbol
610
 
                escaped_chunks[j] = '%' + item
611
 
            except UnicodeDecodeError:
612
 
                escaped_chunks[j] = unichr(int(item[:2], 16)) + item[2:]
613
 
        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:
621
 
            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
626
 
                pass
627
 
            else:
628
 
                # Otherwise take the url decoded one
629
 
                res[i] = decoded
 
732
    for i in range(1, len(res)):
 
733
        res[i] = _unescape_segment_for_display(res[i], encoding)
630
734
    return u'/'.join(res)
631
735
 
632
736
 
641
745
    is used without a path, e.g. c:foo-bar => foo-bar.
642
746
    If no /, path separator or : is found, the from_location is returned.
643
747
    """
 
748
    from_location = strip_segment_parameters(from_location)
644
749
    if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
645
750
        return os.path.basename(from_location.rstrip("/\\"))
646
751
    else:
647
752
        sep = from_location.find(":")
648
753
        if sep > 0:
649
 
            return from_location[sep+1:]
 
754
            return from_location[sep + 1:]
650
755
        else:
651
756
            return from_location
652
757
 
669
774
    old_parsed = urlparse.urlparse(old_base)
670
775
    new_parsed = urlparse.urlparse(new_base)
671
776
    if (old_parsed[:2]) != (new_parsed[:2]):
672
 
        raise errors.InvalidRebaseURLs(old_base, new_base)
 
777
        raise InvalidRebaseURLs(old_base, new_base)
673
778
    return determine_relative_path(new_parsed[2],
674
779
                                   join(old_parsed[2], url))
675
780
 
680
785
    to_segments = osutils.splitpath(to_path)
681
786
    count = -1
682
787
    for count, (from_element, to_element) in enumerate(zip(from_segments,
683
 
                                                       to_segments)):
 
788
                                                           to_segments)):
684
789
        if from_element != to_element:
685
790
            break
686
791
    else:
693
798
    return osutils.pathjoin(*segments)
694
799
 
695
800
 
 
801
class URL(object):
 
802
    """Parsed URL."""
 
803
 
 
804
    def __init__(self, scheme, quoted_user, quoted_password, quoted_host,
 
805
                 port, quoted_path):
 
806
        self.scheme = scheme
 
807
        self.quoted_host = quoted_host
 
808
        self.host = unquote(self.quoted_host)
 
809
        self.quoted_user = quoted_user
 
810
        if self.quoted_user is not None:
 
811
            self.user = unquote(self.quoted_user)
 
812
        else:
 
813
            self.user = None
 
814
        self.quoted_password = quoted_password
 
815
        if self.quoted_password is not None:
 
816
            self.password = unquote(self.quoted_password)
 
817
        else:
 
818
            self.password = None
 
819
        self.port = port
 
820
        self.quoted_path = _url_hex_escapes_re.sub(
 
821
            _unescape_safe_chars, quoted_path)
 
822
        self.path = unquote(self.quoted_path)
 
823
 
 
824
    def __eq__(self, other):
 
825
        return (isinstance(other, self.__class__) and
 
826
                self.scheme == other.scheme and
 
827
                self.host == other.host and
 
828
                self.user == other.user and
 
829
                self.password == other.password and
 
830
                self.path == other.path)
 
831
 
 
832
    def __repr__(self):
 
833
        return "<%s(%r, %r, %r, %r, %r, %r)>" % (
 
834
            self.__class__.__name__,
 
835
            self.scheme, self.quoted_user, self.quoted_password,
 
836
            self.quoted_host, self.port, self.quoted_path)
 
837
 
 
838
    @classmethod
 
839
    def from_string(cls, url):
 
840
        """Create a URL object from a string.
 
841
 
 
842
        :param url: URL as bytestring
 
843
        """
 
844
        # GZ 2017-06-09: Actually validate ascii-ness
 
845
        # pad.lv/1696545: For the moment, accept both native strings and
 
846
        # unicode.
 
847
        if isinstance(url, str):
 
848
            pass
 
849
        elif isinstance(url, str):
 
850
            try:
 
851
                url = url.encode()
 
852
            except UnicodeEncodeError:
 
853
                raise InvalidURL(url)
 
854
        else:
 
855
            raise InvalidURL(url)
 
856
        (scheme, netloc, path, params,
 
857
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
858
        user = password = host = port = None
 
859
        if '@' in netloc:
 
860
            user, host = netloc.rsplit('@', 1)
 
861
            if ':' in user:
 
862
                user, password = user.split(':', 1)
 
863
        else:
 
864
            host = netloc
 
865
 
 
866
        if ':' in host and not (host[0] == '[' and host[-1] == ']'):
 
867
            # there *is* port
 
868
            host, port = host.rsplit(':', 1)
 
869
            if port:
 
870
                try:
 
871
                    port = int(port)
 
872
                except ValueError:
 
873
                    raise InvalidURL('invalid port number %s in url:\n%s' %
 
874
                                     (port, url))
 
875
            else:
 
876
                port = None
 
877
        if host != "" and host[0] == '[' and host[-1] == ']':  # IPv6
 
878
            host = host[1:-1]
 
879
 
 
880
        return cls(scheme, user, password, host, port, path)
 
881
 
 
882
    def __str__(self):
 
883
        netloc = self.quoted_host
 
884
        if ":" in netloc:
 
885
            netloc = "[%s]" % netloc
 
886
        if self.quoted_user is not None:
 
887
            # Note that we don't put the password back even if we
 
888
            # have one so that it doesn't get accidentally
 
889
            # exposed.
 
890
            netloc = '%s@%s' % (self.quoted_user, netloc)
 
891
        if self.port is not None:
 
892
            netloc = '%s:%d' % (netloc, self.port)
 
893
        return urlparse.urlunparse(
 
894
            (self.scheme, netloc, self.quoted_path, None, None, None))
 
895
 
 
896
    @staticmethod
 
897
    def _combine_paths(base_path, relpath):
 
898
        """Transform a Transport-relative path to a remote absolute path.
 
899
 
 
900
        This does not handle substitution of ~ but does handle '..' and '.'
 
901
        components.
 
902
 
 
903
        Examples::
 
904
 
 
905
            t._combine_paths('/home/sarah', 'project/foo')
 
906
                => '/home/sarah/project/foo'
 
907
            t._combine_paths('/home/sarah', '../../etc')
 
908
                => '/etc'
 
909
            t._combine_paths('/home/sarah', '/etc')
 
910
                => '/etc'
 
911
 
 
912
        :param base_path: base path
 
913
        :param relpath: relative url string for relative part of remote path.
 
914
        :return: urlencoded string for final path.
 
915
        """
 
916
        # pad.lv/1696545: For the moment, accept both native strings and
 
917
        # unicode.
 
918
        if isinstance(relpath, str):
 
919
            pass
 
920
        elif isinstance(relpath, str):
 
921
            try:
 
922
                relpath = relpath.encode()
 
923
            except UnicodeEncodeError:
 
924
                raise InvalidURL(relpath)
 
925
        else:
 
926
            raise InvalidURL(relpath)
 
927
        relpath = _url_hex_escapes_re.sub(_unescape_safe_chars, relpath)
 
928
        if relpath.startswith('/'):
 
929
            base_parts = []
 
930
        else:
 
931
            base_parts = base_path.split('/')
 
932
        if len(base_parts) > 0 and base_parts[-1] == '':
 
933
            base_parts = base_parts[:-1]
 
934
        for p in relpath.split('/'):
 
935
            if p == '..':
 
936
                if len(base_parts) == 0:
 
937
                    # In most filesystems, a request for the parent
 
938
                    # of root, just returns root.
 
939
                    continue
 
940
                base_parts.pop()
 
941
            elif p == '.':
 
942
                continue  # No-op
 
943
            elif p != '':
 
944
                base_parts.append(p)
 
945
        path = '/'.join(base_parts)
 
946
        if not path.startswith('/'):
 
947
            path = '/' + path
 
948
        return path
 
949
 
 
950
    def clone(self, offset=None):
 
951
        """Return a new URL for a path relative to this URL.
 
952
 
 
953
        :param offset: A relative path, already urlencoded
 
954
        :return: `URL` instance
 
955
        """
 
956
        if offset is not None:
 
957
            relative = unescape(offset)
 
958
            path = self._combine_paths(self.path, relative)
 
959
            path = quote(path, safe="/~")
 
960
        else:
 
961
            path = self.quoted_path
 
962
        return self.__class__(self.scheme, self.quoted_user,
 
963
                              self.quoted_password, self.quoted_host, self.port,
 
964
                              path)
 
965
 
696
966
 
697
967
def parse_url(url):
698
968
    """Extract the server address, the credentials and the path from the url.
701
971
    chars.
702
972
 
703
973
    :param url: an quoted url
704
 
 
705
974
    :return: (scheme, user, password, host, port, path) tuple, all fields
706
975
        are unquoted.
707
976
    """
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)
 
977
    parsed_url = URL.from_string(url)
 
978
    return (parsed_url.scheme, parsed_url.user, parsed_url.password,
 
979
            parsed_url.host, parsed_url.port, parsed_url.path)