/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: John Ferlito
  • Date: 2009-09-02 04:31:45 UTC
  • mto: (4665.7.1 serve-init)
  • mto: This revision was merged to the branch mainline in revision 4913.
  • Revision ID: johnf@inodes.org-20090902043145-gxdsfw03ilcwbyn5
Add a debian init script for bzr --serve

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
20
20
import re
21
21
import sys
22
22
 
23
 
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
24
28
 
25
 
from . import (
 
29
from bzrlib import (
26
30
    errors,
27
31
    osutils,
28
32
    )
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
 
 
64
36
def basename(url, exclude_trailing_slash=True):
65
37
    """Return the last component of a URL.
66
38
 
88
60
    return split(url, exclude_trailing_slash=exclude_trailing_slash)[0]
89
61
 
90
62
 
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='/~'):
 
63
def escape(relpath):
98
64
    """Escape relpath to be a valid url."""
99
 
    return quote(relpath, safe=safe)
 
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='/~'))
100
70
 
101
71
 
102
72
def file_relpath(base, path):
106
76
    """
107
77
    if len(base) < MIN_ABS_FILEURL_LENGTH:
108
78
        raise ValueError('Length of base (%r) must equal or'
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))
 
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)
113
83
    return escape(osutils.relpath(base, path))
114
84
 
115
85
 
131
101
    first_path_slash = path.find('/')
132
102
    if first_path_slash == -1:
133
103
        return len(scheme), None
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
 
104
    return len(scheme), first_path_slash+len(scheme)+3
140
105
 
141
106
 
142
107
def join(base, *args):
153
118
    """
154
119
    if not args:
155
120
        return base
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:]
 
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
 
162
146
    for arg in args:
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
 
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 = []
173
166
        else:
 
167
            path = '/'.join(path)
174
168
            path = joinpath(path, arg)
175
 
    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)
176
182
 
177
183
 
178
184
def joinpath(base, *args):
187
193
    """
188
194
    path = base.split('/')
189
195
    if len(path) > 1 and path[-1] == '':
190
 
        # If the path ends in a trailing /, remove it.
 
196
        #If the path ends in a trailing /, remove it.
191
197
        path.pop()
192
198
    for arg in args:
193
199
        if arg.startswith('/'):
197
203
                continue
198
204
            elif chunk == '..':
199
205
                if path == ['']:
200
 
                    raise InvalidURLJoin('Cannot go above root',
201
 
                                         base, args)
 
206
                    raise errors.InvalidURLJoin('Cannot go above root',
 
207
                            base, args)
202
208
                path.pop()
203
209
            else:
204
210
                path.append(chunk)
211
217
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
212
218
def _posix_local_path_from_url(url):
213
219
    """Convert a url like file:///path/to/foo into /path/to/foo"""
214
 
    url = strip_segment_parameters(url)
215
 
    file_localhost_prefix = 'file://localhost/'
216
 
    if url.startswith(file_localhost_prefix):
217
 
        path = url[len(file_localhost_prefix) - 1:]
218
 
    elif not url.startswith('file:///'):
219
 
        raise InvalidURL(
220
 
            url, 'local urls must start with file:/// or file://localhost/')
221
 
    else:
222
 
        path = url[len('file://'):]
 
220
    if not url.startswith('file:///'):
 
221
        raise errors.InvalidURL(url, 'local urls must start with file:///')
223
222
    # We only strip off 2 slashes
224
 
    return unescape(path)
 
223
    return unescape(url[len('file://'):])
225
224
 
226
225
 
227
226
def _posix_local_path_to_url(path):
231
230
    """
232
231
    # importing directly from posixpath allows us to test this
233
232
    # on non-posix platforms
234
 
    return 'file://' + escape(osutils._posix_abspath(path))
 
233
    return 'file://' + escape(_posix_normpath(
 
234
        osutils._posix_abspath(path)))
235
235
 
236
236
 
237
237
def _win32_local_path_from_url(url):
238
238
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
239
239
    if not url.startswith('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)
 
240
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
 
241
                                     'UNC path urls must start with file://')
243
242
    # We strip off all 3 slashes
244
243
    win32_url = url[len('file:'):]
245
244
    # check for UNC path: //HOST/path
246
245
    if not win32_url.startswith('///'):
247
246
        if (win32_url[2] == '/'
248
 
                or win32_url[3] in '|:'):
249
 
            raise InvalidURL(url, 'Win32 UNC path urls'
250
 
                             ' have form file://HOST/path')
 
247
            or win32_url[3] in '|:'):
 
248
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
 
249
                ' have form file://HOST/path')
251
250
        return unescape(win32_url)
252
251
 
253
252
    # allow empty paths so we can serve all roots
255
254
        return '/'
256
255
 
257
256
    # usual local path with 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')
 
257
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
258
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
259
        or win32_url[4] not in  '|:'
 
260
        or win32_url[5] != '/'):
 
261
        raise errors.InvalidURL(url, 'Win32 file urls start with'
 
262
                ' file:///x:/, where x is a valid drive letter')
265
263
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
266
264
 
267
265
 
274
272
    # on non-win32 platform
275
273
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
276
274
    #       which actually strips trailing space characters.
277
 
    #       The worst part is that on linux ntpath.abspath has different
 
275
    #       The worst part is that under linux ntpath.abspath has different
278
276
    #       semantics, since 'nt' is not an available module.
279
277
    if path == '/':
280
278
        return 'file:///'
284
282
    if win32_path.startswith('//'):
285
283
        return 'file:' + escape(win32_path)
286
284
    return ('file:///' + str(win32_path[0].upper()) + ':' +
287
 
            escape(win32_path[2:]))
 
285
        escape(win32_path[2:]))
288
286
 
289
287
 
290
288
local_path_to_url = _posix_local_path_to_url
299
297
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
300
298
 
301
299
 
302
 
_url_scheme_re = re.compile('^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
303
 
_url_hex_escapes_re = re.compile('(%[0-9a-fA-F]{2})')
 
300
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
 
301
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
304
302
 
305
303
 
306
304
def _unescape_safe_chars(matchobj):
335
333
    :param url: Either a hybrid URL or a local path
336
334
    :return: A normalized URL which only includes 7-bit ASCII characters.
337
335
    """
338
 
    scheme_end, path_start = _find_scheme_and_separator(url)
339
 
    if scheme_end is None:
 
336
    m = _url_scheme_re.match(url)
 
337
    if not m:
340
338
        return local_path_to_url(url)
341
 
    prefix = url[:path_start]
342
 
    path = url[path_start:]
343
 
    if not isinstance(url, str):
 
339
    scheme = m.group('scheme')
 
340
    path = m.group('path')
 
341
    if not isinstance(url, unicode):
344
342
        for c in url:
345
343
            if c not in _url_safe_characters:
346
 
                raise InvalidURL(url, 'URLs can only contain specific'
347
 
                                 ' safe characters (not %r)' % c)
 
344
                raise errors.InvalidURL(url, 'URLs can only contain specific'
 
345
                                            ' safe characters (not %r)' % c)
348
346
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
349
 
        return str(prefix + ''.join(path))
 
347
        return str(scheme + '://' + ''.join(path))
350
348
 
351
349
    # We have a unicode (hybrid) url
352
350
    path_chars = list(path)
353
351
 
354
 
    for i in range(len(path_chars)):
 
352
    for i in xrange(len(path_chars)):
355
353
        if path_chars[i] not in _url_safe_characters:
 
354
            chars = path_chars[i].encode('utf-8')
356
355
            path_chars[i] = ''.join(
357
 
                ['%%%02X' % c for c in bytearray(path_chars[i].encode('utf-8'))])
 
356
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
358
357
    path = ''.join(path_chars)
359
358
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
360
 
    return str(prefix + path)
 
359
    return str(scheme + '://' + path)
361
360
 
362
361
 
363
362
def relative_url(base, other):
380
379
    if base_scheme != other_scheme:
381
380
        return other
382
381
    elif sys.platform == 'win32' and base_scheme == 'file://':
383
 
        base_drive = base[base_first_slash + 1:base_first_slash + 3]
384
 
        other_drive = other[other_first_slash + 1:other_first_slash + 3]
 
382
        base_drive = base[base_first_slash+1:base_first_slash+3]
 
383
        other_drive = other[other_first_slash+1:other_first_slash+3]
385
384
        if base_drive != other_drive:
386
385
            return other
387
386
 
388
 
    base_path = base[base_first_slash + 1:]
389
 
    other_path = other[other_first_slash + 1:]
 
387
    base_path = base[base_first_slash+1:]
 
388
    other_path = other[other_first_slash+1:]
390
389
 
391
390
    if base_path.endswith('/'):
392
391
        base_path = base_path[:-1]
416
415
    """On win32 the drive letter needs to be added to the url base."""
417
416
    # Strip off the drive letter
418
417
    # path is currently /C:/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
 
418
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
 
419
        raise errors.InvalidURL(url_base + path,
 
420
            'win32 file:/// paths need a drive letter')
 
421
    url_base += path[0:3] # file:// + /C:
 
422
    path = path[3:] # /foo
424
423
    return url_base, path
425
424
 
426
425
 
431
430
    :param exclude_trailing_slash: Strip off a final '/' if it is part
432
431
        of the path (but not if it is part of the protocol specification)
433
432
 
434
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if
435
 
        we're at the root.
 
433
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
 
434
        the root.
436
435
    """
437
436
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
438
437
 
448
447
            return url, ''
449
448
 
450
449
    # We have a fully defined path
451
 
    url_base = url[:first_path_slash]  # http://host, file://
452
 
    path = url[first_path_slash:]  # /file/foo
 
450
    url_base = url[:first_path_slash] # http://host, file://
 
451
    path = url[first_path_slash:] # /file/foo
453
452
 
454
453
    if sys.platform == 'win32' and url.startswith('file:///'):
455
454
        # Strip off the drive letter
464
463
    return url_base + head, tail
465
464
 
466
465
 
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
 
 
561
466
def _win32_strip_local_trailing_slash(url):
562
467
    """Strip slashes after the drive letter"""
563
468
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
599
504
        # so just chop off the last character
600
505
        return url[:-1]
601
506
 
602
 
    if first_path_slash is None or first_path_slash == len(url) - 1:
 
507
    if first_path_slash is None or first_path_slash == len(url)-1:
603
508
        # Don't chop off anything if the only slash is the path
604
509
        # separating slash
605
510
        return url
613
518
    This returns a Unicode path from a URL
614
519
    """
615
520
    # jam 20060427 URLs are supposed to be ASCII only strings
616
 
    #       If they are passed in as unicode, unquote
 
521
    #       If they are passed in as unicode, urllib.unquote
617
522
    #       will return a UNICODE string, which actually contains
618
523
    #       utf-8 bytes. So we have to ensure that they are
619
524
    #       plain ASCII strings, or the final .decode will
620
525
    #       try to encode the UNICODE => ASCII, and then decode
621
526
    #       it into utf-8.
 
527
    try:
 
528
        url = str(url)
 
529
    except UnicodeError, e:
 
530
        raise errors.InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
622
531
 
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)
 
532
    unquoted = urllib.unquote(url)
 
533
    try:
 
534
        unicode_path = unquoted.decode('utf-8')
 
535
    except UnicodeError, e:
 
536
        raise errors.InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
 
537
    return unicode_path
630
538
 
631
539
 
632
540
# These are characters that if escaped, should stay that way
633
541
_no_decode_chars = ';/?:@&=+$,#'
634
542
_no_decode_ords = [ord(c) for c in _no_decode_chars]
635
543
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
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)
 
544
                + ['%02X' % o for o in _no_decode_ords])
 
545
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
 
546
                    + [('%02X' % o, chr(o)) for o in range(256)]))
 
547
#These entries get mapped to themselves
 
548
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
642
549
 
643
550
# These characters shouldn't be percent-encoded, and it's always safe to
644
551
# unencode them if they are.
645
552
_url_dont_escape_characters = set(
646
 
    "abcdefghijklmnopqrstuvwxyz"  # Lowercase alpha
647
 
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"  # Uppercase alpha
648
 
    "0123456789"  # Numbers
649
 
    "-._~"  # Unreserved characters
 
553
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
 
554
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
 
555
   "0123456789" # Numbers
 
556
   "-._~"  # Unreserved characters
650
557
)
651
558
 
652
559
# These characters should not be escaped
653
560
_url_safe_characters = set(
654
 
    "abcdefghijklmnopqrstuvwxyz"  # Lowercase alpha
655
 
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"  # Uppercase alpha
656
 
    "0123456789"  # Numbers
657
 
    "_.-!~*'()"  # Unreserved characters
658
 
    "/;?:@&=+$,"  # Reserved characters
659
 
    "%#"         # Extra reserved characters
 
561
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
 
562
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
 
563
   "0123456789" # Numbers
 
564
   "_.-!~*'()"  # Unreserved characters
 
565
   "/;?:@&=+$," # Reserved characters
 
566
   "%#"         # Extra reserved characters
660
567
)
661
568
 
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
 
 
705
569
def unescape_for_display(url, encoding):
706
570
    """Decode what you can for a URL, so that we get a nice looking path.
707
571
 
729
593
 
730
594
    # Split into sections to try to decode utf-8
731
595
    res = url.split('/')
732
 
    for i in range(1, len(res)):
733
 
        res[i] = _unescape_segment_for_display(res[i], encoding)
 
596
    for i in xrange(1, len(res)):
 
597
        escaped_chunks = res[i].split('%')
 
598
        for j in xrange(1, len(escaped_chunks)):
 
599
            item = escaped_chunks[j]
 
600
            try:
 
601
                escaped_chunks[j] = _hex_display_map[item[:2]] + item[2:]
 
602
            except KeyError:
 
603
                # Put back the percent symbol
 
604
                escaped_chunks[j] = '%' + item
 
605
            except UnicodeDecodeError:
 
606
                escaped_chunks[j] = unichr(int(item[:2], 16)) + item[2:]
 
607
        unescaped = ''.join(escaped_chunks)
 
608
        try:
 
609
            decoded = unescaped.decode('utf-8')
 
610
        except UnicodeDecodeError:
 
611
            # If this path segment cannot be properly utf-8 decoded
 
612
            # after doing unescaping we will just leave it alone
 
613
            pass
 
614
        else:
 
615
            try:
 
616
                decoded.encode(encoding)
 
617
            except UnicodeEncodeError:
 
618
                # If this chunk cannot be encoded in the local
 
619
                # encoding, then we should leave it alone
 
620
                pass
 
621
            else:
 
622
                # Otherwise take the url decoded one
 
623
                res[i] = decoded
734
624
    return u'/'.join(res)
735
625
 
736
626
 
745
635
    is used without a path, e.g. c:foo-bar => foo-bar.
746
636
    If no /, path separator or : is found, the from_location is returned.
747
637
    """
748
 
    from_location = strip_segment_parameters(from_location)
749
638
    if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
750
639
        return os.path.basename(from_location.rstrip("/\\"))
751
640
    else:
752
641
        sep = from_location.find(":")
753
642
        if sep > 0:
754
 
            return from_location[sep + 1:]
 
643
            return from_location[sep+1:]
755
644
        else:
756
645
            return from_location
757
646
 
774
663
    old_parsed = urlparse.urlparse(old_base)
775
664
    new_parsed = urlparse.urlparse(new_base)
776
665
    if (old_parsed[:2]) != (new_parsed[:2]):
777
 
        raise InvalidRebaseURLs(old_base, new_base)
 
666
        raise errors.InvalidRebaseURLs(old_base, new_base)
778
667
    return determine_relative_path(new_parsed[2],
779
668
                                   join(old_parsed[2], url))
780
669
 
785
674
    to_segments = osutils.splitpath(to_path)
786
675
    count = -1
787
676
    for count, (from_element, to_element) in enumerate(zip(from_segments,
788
 
                                                           to_segments)):
 
677
                                                       to_segments)):
789
678
        if from_element != to_element:
790
679
            break
791
680
    else:
798
687
    return osutils.pathjoin(*segments)
799
688
 
800
689
 
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
 
 
966
690
 
967
691
def parse_url(url):
968
692
    """Extract the server address, the credentials and the path from the url.
971
695
    chars.
972
696
 
973
697
    :param url: an quoted url
 
698
 
974
699
    :return: (scheme, user, password, host, port, path) tuple, all fields
975
700
        are unquoted.
976
701
    """
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)
 
702
    if isinstance(url, unicode):
 
703
        raise errors.InvalidURL('should be ascii:\n%r' % url)
 
704
    url = url.encode('utf-8')
 
705
    (scheme, netloc, path, params,
 
706
     query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
707
    user = password = host = port = None
 
708
    if '@' in netloc:
 
709
        user, host = netloc.rsplit('@', 1)
 
710
        if ':' in user:
 
711
            user, password = user.split(':', 1)
 
712
            password = urllib.unquote(password)
 
713
        user = urllib.unquote(user)
 
714
    else:
 
715
        host = netloc
 
716
 
 
717
    if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port
 
718
        host, port = host.rsplit(':',1)
 
719
        try:
 
720
            port = int(port)
 
721
        except ValueError:
 
722
            raise errors.InvalidURL('invalid port number %s in url:\n%s' %
 
723
                                    (port, url))
 
724
    if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
 
725
        host = host[1:-1]
 
726
 
 
727
    host = urllib.unquote(host)
 
728
    path = urllib.unquote(path)
 
729
 
 
730
    return (scheme, user, password, host, port, path)