/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

Merge from bzr.dev, resolving conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Bazaar -- distributed version control
 
2
#
 
3
# Copyright (C) 2006 Canonical Ltd
2
4
#
3
5
# This program is free software; you can redistribute it and/or modify
4
6
# it under the terms of the GNU General Public License as published by
12
14
#
13
15
# You should have received a copy of the GNU General Public License
14
16
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
18
 
17
19
"""A collection of function for handling URL operations."""
18
20
 
19
 
from __future__ import absolute_import
20
 
 
21
21
import os
22
22
import re
23
23
import sys
24
24
 
25
 
try:
26
 
    import urlparse
27
 
except ImportError:
28
 
    from urllib import parse as urlparse
 
25
from bzrlib.lazy_import import lazy_import
 
26
lazy_import(globals(), """
 
27
from posixpath import split as _posix_split, normpath as _posix_normpath
 
28
import urllib
29
29
 
30
 
from . import (
 
30
from bzrlib import (
31
31
    errors,
32
32
    osutils,
33
33
    )
34
 
 
35
 
from .lazy_import import lazy_import
36
 
lazy_import(globals(), """
37
 
from posixpath import split as _posix_split
38
34
""")
39
35
 
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
36
 
72
37
def basename(url, exclude_trailing_slash=True):
73
38
    """Return the last component of a URL.
96
61
    return split(url, exclude_trailing_slash=exclude_trailing_slash)[0]
97
62
 
98
63
 
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
64
def escape(relpath):
156
65
    """Escape relpath to be a valid url."""
157
 
    if not isinstance(relpath, str) and sys.version_info[0] == 2:
 
66
    if isinstance(relpath, unicode):
158
67
        relpath = relpath.encode('utf-8')
159
 
    return quote(relpath, safe='/~')
 
68
    # After quoting and encoding, the path should be perfectly
 
69
    # safe as a plain ASCII string, str() just enforces this
 
70
    return str(urllib.quote(relpath))
160
71
 
161
72
 
162
73
def file_relpath(base, path):
163
74
    """Compute just the relative sub-portion of a url
164
 
 
 
75
    
165
76
    This assumes that both paths are already fully specified file:// URLs.
166
77
    """
167
 
    if len(base) < MIN_ABS_FILEURL_LENGTH:
168
 
        raise ValueError('Length of base (%r) must equal or'
169
 
            ' exceed the platform minimum url length (which is %d)' %
170
 
            (base, MIN_ABS_FILEURL_LENGTH))
171
 
    base = osutils.normpath(local_path_from_url(base))
172
 
    path = osutils.normpath(local_path_from_url(path))
 
78
    assert len(base) >= MIN_ABS_FILEURL_LENGTH, ('Length of base must be equal or'
 
79
        ' exceed the platform minimum url length (which is %d)' % 
 
80
        MIN_ABS_FILEURL_LENGTH)
 
81
 
 
82
    base = local_path_from_url(base)
 
83
    path = local_path_from_url(path)
173
84
    return escape(osutils.relpath(base, path))
174
85
 
175
86
 
191
102
    first_path_slash = path.find('/')
192
103
    if first_path_slash == -1:
193
104
        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
 
105
    return len(scheme), first_path_slash+len(scheme)+3
200
106
 
201
107
 
202
108
def join(base, *args):
213
119
    """
214
120
    if not args:
215
121
        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:]
 
122
    match = _url_scheme_re.match(base)
 
123
    scheme = None
 
124
    if match:
 
125
        scheme = match.group('scheme')
 
126
        path = match.group('path').split('/')
 
127
        if path[-1:] == ['']:
 
128
            # Strip off a trailing slash
 
129
            # This helps both when we are at the root, and when
 
130
            # 'base' has an extra slash at the end
 
131
            path = path[:-1]
 
132
    else:
 
133
        path = base.split('/')
 
134
 
 
135
    if scheme is not None and len(path) >= 1:
 
136
        host = path[:1]
 
137
        # the path should be represented as an abs path.
 
138
        # we know this must be absolute because of the presence of a URL scheme.
 
139
        remove_root = True
 
140
        path = [''] + path[1:]
 
141
    else:
 
142
        # create an empty host, but dont alter the path - this might be a
 
143
        # relative url fragment.
 
144
        host = []
 
145
        remove_root = False
 
146
 
222
147
    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
 
148
        match = _url_scheme_re.match(arg)
 
149
        if match:
 
150
            # Absolute URL
 
151
            scheme = match.group('scheme')
 
152
            # this skips .. normalisation, making http://host/../../..
 
153
            # be rather strange.
 
154
            path = match.group('path').split('/')
 
155
            # set the host and path according to new absolute URL, discarding
 
156
            # any previous values.
 
157
            # XXX: duplicates mess from earlier in this function.  This URL
 
158
            # manipulation code needs some cleaning up.
 
159
            if scheme is not None and len(path) >= 1:
 
160
                host = path[:1]
 
161
                path = path[1:]
 
162
                # url scheme implies absolute path.
 
163
                path = [''] + path
 
164
            else:
 
165
                # no url scheme we take the path as is.
 
166
                host = []
233
167
        else:
 
168
            path = '/'.join(path)
234
169
            path = joinpath(path, arg)
235
 
    return base[:path_start] + path
 
170
            path = path.split('/')
 
171
    if remove_root and path[0:1] == ['']:
 
172
        del path[0]
 
173
    if host:
 
174
        # Remove the leading slash from the path, so long as it isn't also the
 
175
        # trailing slash, which we want to keep if present.
 
176
        if path and path[0] == '' and len(path) > 1:
 
177
            del path[0]
 
178
        path = host + path
 
179
 
 
180
    if scheme is None:
 
181
        return '/'.join(path)
 
182
    return scheme + '://' + '/'.join(path)
236
183
 
237
184
 
238
185
def joinpath(base, *args):
239
186
    """Join URL path segments to a URL path segment.
240
 
 
 
187
    
241
188
    This is somewhat like osutils.joinpath, but intended for URLs.
242
189
 
243
190
    XXX: this duplicates some normalisation logic, and also duplicates a lot of
257
204
                continue
258
205
            elif chunk == '..':
259
206
                if path == ['']:
260
 
                    raise InvalidURLJoin('Cannot go above root',
 
207
                    raise errors.InvalidURLJoin('Cannot go above root',
261
208
                            base, args)
262
209
                path.pop()
263
210
            else:
271
218
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
272
219
def _posix_local_path_from_url(url):
273
220
    """Convert a url like file:///path/to/foo into /path/to/foo"""
274
 
    url = split_segment_parameters_raw(url)[0]
275
 
    file_localhost_prefix = 'file://localhost/'
276
 
    if url.startswith(file_localhost_prefix):
277
 
        path = url[len(file_localhost_prefix) - 1:]
278
 
    elif not url.startswith('file:///'):
279
 
        raise InvalidURL(
280
 
            url, 'local urls must start with file:/// or file://localhost/')
281
 
    else:
282
 
        path = url[len('file://'):]
 
221
    if not url.startswith('file:///'):
 
222
        raise errors.InvalidURL(url, 'local urls must start with file:///')
283
223
    # We only strip off 2 slashes
284
 
    return unescape(path)
 
224
    return unescape(url[len('file://'):])
285
225
 
286
226
 
287
227
def _posix_local_path_to_url(path):
289
229
 
290
230
    This also handles transforming escaping unicode characters, etc.
291
231
    """
292
 
    # importing directly from posixpath allows us to test this
 
232
    # importing directly from posixpath allows us to test this 
293
233
    # on non-posix platforms
294
 
    return 'file://' + escape(osutils._posix_abspath(path))
 
234
    return 'file://' + escape(_posix_normpath(
 
235
        osutils._posix_abspath(path)))
295
236
 
296
237
 
297
238
def _win32_local_path_from_url(url):
298
239
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
299
240
    if not url.startswith('file://'):
300
 
        raise InvalidURL(url, 'local urls must start with file:///, '
 
241
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
301
242
                                     'UNC path urls must start with file://')
302
 
    url = split_segment_parameters_raw(url)[0]
303
243
    # We strip off all 3 slashes
304
244
    win32_url = url[len('file:'):]
305
245
    # check for UNC path: //HOST/path
306
246
    if not win32_url.startswith('///'):
307
247
        if (win32_url[2] == '/'
308
248
            or win32_url[3] in '|:'):
309
 
            raise InvalidURL(url, 'Win32 UNC path urls'
 
249
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
310
250
                ' have form file://HOST/path')
311
251
        return unescape(win32_url)
312
 
 
313
 
    # allow empty paths so we can serve all roots
314
 
    if win32_url == '///':
315
 
        return '/'
316
 
 
317
252
    # usual local path with drive letter
318
 
    if (len(win32_url) < 6
319
 
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
320
 
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
253
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
254
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
321
255
        or win32_url[4] not in  '|:'
322
256
        or win32_url[5] != '/'):
323
 
        raise InvalidURL(url, 'Win32 file urls start with'
 
257
        raise errors.InvalidURL(url, 'Win32 file urls start with'
324
258
                ' file:///x:/, where x is a valid drive letter')
325
259
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
326
260
 
330
264
 
331
265
    This also handles transforming escaping unicode characters, etc.
332
266
    """
333
 
    # importing directly from ntpath allows us to test this
 
267
    # importing directly from ntpath allows us to test this 
334
268
    # on non-win32 platform
335
269
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
336
270
    #       which actually strips trailing space characters.
337
 
    #       The worst part is that on linux ntpath.abspath has different
 
271
    #       The worst part is that under linux ntpath.abspath has different
338
272
    #       semantics, since 'nt' is not an available module.
339
 
    if path == '/':
340
 
        return 'file:///'
341
 
 
342
273
    win32_path = osutils._win32_abspath(path)
343
274
    # check for UNC path \\HOST\path
344
275
    if win32_path.startswith('//'):
345
276
        return 'file:' + escape(win32_path)
346
 
    return ('file:///' + str(win32_path[0].upper()) + ':' +
347
 
        escape(win32_path[2:]))
 
277
    return 'file:///' + win32_path[0].upper() + ':' + escape(win32_path[2:])
348
278
 
349
279
 
350
280
local_path_to_url = _posix_local_path_to_url
359
289
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
360
290
 
361
291
 
362
 
_url_scheme_re = re.compile('^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
363
 
_url_hex_escapes_re = re.compile('(%[0-9a-fA-F]{2})')
364
 
 
365
 
 
366
 
def _unescape_safe_chars(matchobj):
367
 
    """re.sub callback to convert hex-escapes to plain characters (if safe).
368
 
 
369
 
    e.g. '%7E' will be converted to '~'.
370
 
    """
371
 
    hex_digits = matchobj.group(0)[1:]
372
 
    char = chr(int(hex_digits, 16))
373
 
    if char in _url_dont_escape_characters:
374
 
        return char
375
 
    else:
376
 
        return matchobj.group(0).upper()
 
292
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
377
293
 
378
294
 
379
295
def normalize_url(url):
380
296
    """Make sure that a path string is in fully normalized URL form.
381
 
 
382
 
    This handles URLs which have unicode characters, spaces,
 
297
    
 
298
    This handles URLs which have unicode characters, spaces, 
383
299
    special characters, etc.
384
300
 
385
301
    It has two basic modes of operation, depending on whether the
395
311
    :param url: Either a hybrid URL or a local path
396
312
    :return: A normalized URL which only includes 7-bit ASCII characters.
397
313
    """
398
 
    scheme_end, path_start = _find_scheme_and_separator(url)
399
 
    if scheme_end is None:
 
314
    m = _url_scheme_re.match(url)
 
315
    if not m:
400
316
        return local_path_to_url(url)
401
 
    prefix = url[:path_start]
402
 
    path = url[path_start:]
403
 
    if not isinstance(url, text_type):
 
317
    if not isinstance(url, unicode):
404
318
        for c in url:
405
319
            if c not in _url_safe_characters:
406
 
                raise InvalidURL(url, 'URLs can only contain specific'
 
320
                raise errors.InvalidURL(url, 'URLs can only contain specific'
407
321
                                            ' safe characters (not %r)' % c)
408
 
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
409
 
        return str(prefix + ''.join(path))
410
 
 
 
322
        return url
411
323
    # We have a unicode (hybrid) url
412
 
    path_chars = list(path)
 
324
    scheme = m.group('scheme')
 
325
    path = list(m.group('path'))
413
326
 
414
 
    for i in range(len(path_chars)):
415
 
        if path_chars[i] not in _url_safe_characters:
416
 
            chars = path_chars[i].encode('utf-8')
417
 
            path_chars[i] = ''.join(
418
 
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
419
 
    path = ''.join(path_chars)
420
 
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
421
 
    return str(prefix + path)
 
327
    for i in xrange(len(path)):
 
328
        if path[i] not in _url_safe_characters:
 
329
            chars = path[i].encode('utf-8')
 
330
            path[i] = ''.join(['%%%02X' % ord(c) for c in path[i].encode('utf-8')])
 
331
    return str(scheme + '://' + ''.join(path))
422
332
 
423
333
 
424
334
def relative_url(base, other):
430
340
    dummy, base_first_slash = _find_scheme_and_separator(base)
431
341
    if base_first_slash is None:
432
342
        return other
433
 
 
 
343
    
434
344
    dummy, other_first_slash = _find_scheme_and_separator(other)
435
345
    if other_first_slash is None:
436
346
        return other
440
350
    other_scheme = other[:other_first_slash]
441
351
    if base_scheme != other_scheme:
442
352
        return other
443
 
    elif sys.platform == 'win32' and base_scheme == 'file://':
444
 
        base_drive = base[base_first_slash+1:base_first_slash+3]
445
 
        other_drive = other[other_first_slash+1:other_first_slash+3]
446
 
        if base_drive != other_drive:
447
 
            return other
448
353
 
449
354
    base_path = base[base_first_slash+1:]
450
355
    other_path = other[other_first_slash+1:]
477
382
    """On win32 the drive letter needs to be added to the url base."""
478
383
    # Strip off the drive letter
479
384
    # path is currently /C:/foo
480
 
    if len(path) < 4 or path[2] not in ':|' or path[3] != '/':
481
 
        raise InvalidURL(url_base + path,
 
385
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
 
386
        raise errors.InvalidURL(url_base + path, 
482
387
            'win32 file:/// paths need a drive letter')
483
388
    url_base += path[0:3] # file:// + /C:
484
389
    path = path[3:] # /foo
492
397
    :param exclude_trailing_slash: Strip off a final '/' if it is part
493
398
        of the path (but not if it is part of the protocol specification)
494
399
 
495
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
 
400
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at 
496
401
        the root.
497
402
    """
498
403
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
525
430
    return url_base + head, tail
526
431
 
527
432
 
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], [str(s) for s in 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
 
        if not isinstance(key, str):
556
 
            raise TypeError(key)
557
 
        if not isinstance(value, str):
558
 
            raise TypeError(value)
559
 
        parameters[key] = value
560
 
    return (base_url, parameters)
561
 
 
562
 
 
563
 
def join_segment_parameters_raw(base, *subsegments):
564
 
    """Create a new URL by adding subsegments to an existing one. 
565
 
 
566
 
    This adds the specified subsegments to the last path in the specified
567
 
    base URL. The subsegments should be bytestrings.
568
 
 
569
 
    :note: You probably want to use join_segment_parameters instead.
570
 
    """
571
 
    if not subsegments:
572
 
        return base
573
 
    for subsegment in subsegments:
574
 
        if not isinstance(subsegment, str):
575
 
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
576
 
        if "," in subsegment:
577
 
            raise InvalidURLJoin(", exists in subsegments",
578
 
                                        base, subsegments)
579
 
    return ",".join((base,) + subsegments)
580
 
 
581
 
 
582
 
def join_segment_parameters(url, parameters):
583
 
    """Create a new URL by adding segment parameters to an existing one.
584
 
 
585
 
    The parameters of the last segment in the URL will be updated; if a
586
 
    parameter with the same key already exists it will be overwritten.
587
 
 
588
 
    :param url: A URL, as string
589
 
    :param parameters: Dictionary of parameters, keys and values as bytestrings
590
 
    """
591
 
    (base, existing_parameters) = split_segment_parameters(url)
592
 
    new_parameters = {}
593
 
    new_parameters.update(existing_parameters)
594
 
    for key, value in parameters.items():
595
 
        if not isinstance(key, str):
596
 
            raise TypeError("parameter key %r is not a str" % key)
597
 
        if not isinstance(value, str):
598
 
            raise TypeError("parameter value %r for %s is not a str" %
599
 
                (key, value))
600
 
        if "=" in key:
601
 
            raise InvalidURLJoin("= exists in parameter key", url,
602
 
                parameters)
603
 
        new_parameters[key] = value
604
 
    return join_segment_parameters_raw(base,
605
 
        *["%s=%s" % item for item in sorted(new_parameters.items())])
606
 
 
607
 
 
608
433
def _win32_strip_local_trailing_slash(url):
609
434
    """Strip slashes after the drive letter"""
610
435
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
660
485
    This returns a Unicode path from a URL
661
486
    """
662
487
    # jam 20060427 URLs are supposed to be ASCII only strings
663
 
    #       If they are passed in as unicode, unquote
 
488
    #       If they are passed in as unicode, urllib.unquote
664
489
    #       will return a UNICODE string, which actually contains
665
490
    #       utf-8 bytes. So we have to ensure that they are
666
491
    #       plain ASCII strings, or the final .decode will
667
492
    #       try to encode the UNICODE => ASCII, and then decode
668
493
    #       it into utf-8.
669
 
    if isinstance(url, text_type):
670
 
        try:
671
 
            url = url.encode("ascii")
672
 
        except UnicodeError as e:
673
 
            raise InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
674
 
    if PY3:
675
 
        unquoted = urlparse.unquote_to_bytes(url)
676
 
    else:
677
 
        unquoted = unquote(url)
 
494
    try:
 
495
        url = str(url)
 
496
    except UnicodeError, e:
 
497
        raise errors.InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
 
498
 
 
499
    unquoted = urllib.unquote(url)
678
500
    try:
679
501
        unicode_path = unquoted.decode('utf-8')
680
 
    except UnicodeError as e:
681
 
        raise InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
 
502
    except UnicodeError, e:
 
503
        raise errors.InvalidURL(url, 'Unable to encode the URL as utf-8: %s' % (e,))
682
504
    return unicode_path
683
505
 
684
506
 
685
507
# These are characters that if escaped, should stay that way
686
508
_no_decode_chars = ';/?:@&=+$,#'
687
509
_no_decode_ords = [ord(c) for c in _no_decode_chars]
688
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
 
510
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
689
511
                + ['%02X' % o for o in _no_decode_ords])
690
512
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
691
513
                    + [('%02X' % o, chr(o)) for o in range(256)]))
692
514
#These entries get mapped to themselves
693
 
_hex_display_map.update((hex, '%'+hex) for hex in _no_decode_hex)
694
 
 
695
 
# These characters shouldn't be percent-encoded, and it's always safe to
696
 
# unencode them if they are.
697
 
_url_dont_escape_characters = set(
698
 
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
699
 
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
700
 
   "0123456789" # Numbers
701
 
   "-._~"  # Unreserved characters
702
 
)
 
515
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
703
516
 
704
517
# These characters should not be escaped
705
518
_url_safe_characters = set(
717
530
    This will turn file:// urls into local paths, and try to decode
718
531
    any portions of a http:// style url that it can.
719
532
 
720
 
    Any sections of the URL which can't be represented in the encoding or
 
533
    Any sections of the URL which can't be represented in the encoding or 
721
534
    need to stay as escapes are left alone.
722
535
 
723
536
    :param url: A 7-bit ASCII URL
724
537
    :param encoding: The final output encoding
725
538
 
726
 
    :return: A unicode string which can be safely encoded into the
 
539
    :return: A unicode string which can be safely encoded into the 
727
540
         specified encoding.
728
541
    """
729
 
    if encoding is None:
730
 
        raise ValueError('you cannot specify None for the display encoding')
 
542
    assert encoding is not None, 'you cannot specify None for the display encoding.'
731
543
    if url.startswith('file://'):
732
544
        try:
733
545
            path = local_path_from_url(url)
738
550
 
739
551
    # Split into sections to try to decode utf-8
740
552
    res = url.split('/')
741
 
    for i in range(1, len(res)):
 
553
    for i in xrange(1, len(res)):
742
554
        escaped_chunks = res[i].split('%')
743
 
        for j in range(1, len(escaped_chunks)):
 
555
        for j in xrange(1, len(escaped_chunks)):
744
556
            item = escaped_chunks[j]
745
557
            try:
746
558
                escaped_chunks[j] = _hex_display_map[item[:2]] + item[2:]
750
562
            except UnicodeDecodeError:
751
563
                escaped_chunks[j] = unichr(int(item[:2], 16)) + item[2:]
752
564
        unescaped = ''.join(escaped_chunks)
753
 
        if sys.version_info[0] == 2:
 
565
        try:
 
566
            decoded = unescaped.decode('utf-8')
 
567
        except UnicodeDecodeError:
 
568
            # If this path segment cannot be properly utf-8 decoded
 
569
            # after doing unescaping we will just leave it alone
 
570
            pass
 
571
        else:
754
572
            try:
755
 
                decoded = unescaped.decode('utf-8')
756
 
            except UnicodeDecodeError:
757
 
                # If this path segment cannot be properly utf-8 decoded
758
 
                # after doing unescaping we will just leave it alone
 
573
                decoded.encode(encoding)
 
574
            except UnicodeEncodeError:
 
575
                # If this chunk cannot be encoded in the local
 
576
                # encoding, then we should leave it alone
759
577
                pass
760
578
            else:
761
 
                try:
762
 
                    decoded.encode(encoding)
763
 
                except UnicodeEncodeError:
764
 
                    # If this chunk cannot be encoded in the local
765
 
                    # encoding, then we should leave it alone
766
 
                    pass
767
 
                else:
768
 
                    # Otherwise take the url decoded one
769
 
                    res[i] = decoded
770
 
        else:
771
 
            res[i] = unescaped
 
579
                # Otherwise take the url decoded one
 
580
                res[i] = decoded
772
581
    return u'/'.join(res)
773
 
 
774
 
 
775
 
def derive_to_location(from_location):
776
 
    """Derive a TO_LOCATION given a FROM_LOCATION.
777
 
 
778
 
    The normal case is a FROM_LOCATION of http://foo/bar => bar.
779
 
    The Right Thing for some logical destinations may differ though
780
 
    because no / may be present at all. In that case, the result is
781
 
    the full name without the scheme indicator, e.g. lp:foo-bar => foo-bar.
782
 
    This latter case also applies when a Windows drive
783
 
    is used without a path, e.g. c:foo-bar => foo-bar.
784
 
    If no /, path separator or : is found, the from_location is returned.
785
 
    """
786
 
    if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
787
 
        return os.path.basename(from_location.rstrip("/\\"))
788
 
    else:
789
 
        sep = from_location.find(":")
790
 
        if sep > 0:
791
 
            return from_location[sep+1:]
792
 
        else:
793
 
            return from_location
794
 
 
795
 
 
796
 
def _is_absolute(url):
797
 
    return (osutils.pathjoin('/foo', url) == url)
798
 
 
799
 
 
800
 
def rebase_url(url, old_base, new_base):
801
 
    """Convert a relative path from an old base URL to a new base URL.
802
 
 
803
 
    The result will be a relative path.
804
 
    Absolute paths and full URLs are returned unaltered.
805
 
    """
806
 
    scheme, separator = _find_scheme_and_separator(url)
807
 
    if scheme is not None:
808
 
        return url
809
 
    if _is_absolute(url):
810
 
        return url
811
 
    old_parsed = urlparse.urlparse(old_base)
812
 
    new_parsed = urlparse.urlparse(new_base)
813
 
    if (old_parsed[:2]) != (new_parsed[:2]):
814
 
        raise InvalidRebaseURLs(old_base, new_base)
815
 
    return determine_relative_path(new_parsed[2],
816
 
                                   join(old_parsed[2], url))
817
 
 
818
 
 
819
 
def determine_relative_path(from_path, to_path):
820
 
    """Determine a relative path from from_path to to_path."""
821
 
    from_segments = osutils.splitpath(from_path)
822
 
    to_segments = osutils.splitpath(to_path)
823
 
    count = -1
824
 
    for count, (from_element, to_element) in enumerate(zip(from_segments,
825
 
                                                       to_segments)):
826
 
        if from_element != to_element:
827
 
            break
828
 
    else:
829
 
        count += 1
830
 
    unique_from = from_segments[count:]
831
 
    unique_to = to_segments[count:]
832
 
    segments = (['..'] * len(unique_from) + unique_to)
833
 
    if len(segments) == 0:
834
 
        return '.'
835
 
    return osutils.pathjoin(*segments)
836
 
 
837
 
 
838
 
class URL(object):
839
 
    """Parsed URL."""
840
 
 
841
 
    def __init__(self, scheme, quoted_user, quoted_password, quoted_host,
842
 
            port, quoted_path):
843
 
        self.scheme = scheme
844
 
        self.quoted_host = quoted_host
845
 
        self.host = unquote(self.quoted_host)
846
 
        self.quoted_user = quoted_user
847
 
        if self.quoted_user is not None:
848
 
            self.user = unquote(self.quoted_user)
849
 
        else:
850
 
            self.user = None
851
 
        self.quoted_password = quoted_password
852
 
        if self.quoted_password is not None:
853
 
            self.password = unquote(self.quoted_password)
854
 
        else:
855
 
            self.password = None
856
 
        self.port = port
857
 
        self.quoted_path = _url_hex_escapes_re.sub(_unescape_safe_chars, quoted_path)
858
 
        self.path = unquote(self.quoted_path)
859
 
 
860
 
    def __eq__(self, other):
861
 
        return (isinstance(other, self.__class__) and
862
 
                self.scheme == other.scheme and
863
 
                self.host == other.host and
864
 
                self.user == other.user and
865
 
                self.password == other.password and
866
 
                self.path == other.path)
867
 
 
868
 
    def __repr__(self):
869
 
        return "<%s(%r, %r, %r, %r, %r, %r)>" % (
870
 
            self.__class__.__name__,
871
 
            self.scheme, self.quoted_user, self.quoted_password,
872
 
            self.quoted_host, self.port, self.quoted_path)
873
 
 
874
 
    @classmethod
875
 
    def from_string(cls, url):
876
 
        """Create a URL object from a string.
877
 
 
878
 
        :param url: URL as bytestring
879
 
        """
880
 
        # GZ 2017-06-09: Actually validate ascii-ness
881
 
        # pad.lv/1696545: For the moment, accept both native strings and unicode.
882
 
        if isinstance(url, str):
883
 
            pass
884
 
        elif isinstance(url, text_type):
885
 
            try:
886
 
                url = url.encode()
887
 
            except UnicodeEncodeError:
888
 
                raise InvalidURL(url)
889
 
        else:
890
 
            raise InvalidURL(url)
891
 
        (scheme, netloc, path, params,
892
 
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
893
 
        user = password = host = port = None
894
 
        if '@' in netloc:
895
 
            user, host = netloc.rsplit('@', 1)
896
 
            if ':' in user:
897
 
                user, password = user.split(':', 1)
898
 
        else:
899
 
            host = netloc
900
 
 
901
 
        if ':' in host and not (host[0] == '[' and host[-1] == ']'):
902
 
            # there *is* port
903
 
            host, port = host.rsplit(':', 1)
904
 
            try:
905
 
                port = int(port)
906
 
            except ValueError:
907
 
                raise InvalidURL('invalid port number %s in url:\n%s' %
908
 
                                 (port, url))
909
 
        if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
910
 
            host = host[1:-1]
911
 
 
912
 
        return cls(scheme, user, password, host, port, path)
913
 
 
914
 
    def __str__(self):
915
 
        netloc = self.quoted_host
916
 
        if ":" in netloc:
917
 
            netloc = "[%s]" % netloc
918
 
        if self.quoted_user is not None:
919
 
            # Note that we don't put the password back even if we
920
 
            # have one so that it doesn't get accidentally
921
 
            # exposed.
922
 
            netloc = '%s@%s' % (self.quoted_user, netloc)
923
 
        if self.port is not None:
924
 
            netloc = '%s:%d' % (netloc, self.port)
925
 
        return urlparse.urlunparse(
926
 
            (self.scheme, netloc, self.quoted_path, None, None, None))
927
 
 
928
 
    @staticmethod
929
 
    def _combine_paths(base_path, relpath):
930
 
        """Transform a Transport-relative path to a remote absolute path.
931
 
 
932
 
        This does not handle substitution of ~ but does handle '..' and '.'
933
 
        components.
934
 
 
935
 
        Examples::
936
 
 
937
 
            t._combine_paths('/home/sarah', 'project/foo')
938
 
                => '/home/sarah/project/foo'
939
 
            t._combine_paths('/home/sarah', '../../etc')
940
 
                => '/etc'
941
 
            t._combine_paths('/home/sarah', '/etc')
942
 
                => '/etc'
943
 
 
944
 
        :param base_path: base path
945
 
        :param relpath: relative url string for relative part of remote path.
946
 
        :return: urlencoded string for final path.
947
 
        """
948
 
        # pad.lv/1696545: For the moment, accept both native strings and unicode.
949
 
        if isinstance(relpath, str):
950
 
            pass
951
 
        elif isinstance(relpath, text_type):
952
 
            try:
953
 
                relpath = relpath.encode()
954
 
            except UnicodeEncodeError:
955
 
                raise InvalidURL(relpath)
956
 
        else:
957
 
            raise InvalidURL(relpath)
958
 
        relpath = _url_hex_escapes_re.sub(_unescape_safe_chars, relpath)
959
 
        if relpath.startswith('/'):
960
 
            base_parts = []
961
 
        else:
962
 
            base_parts = base_path.split('/')
963
 
        if len(base_parts) > 0 and base_parts[-1] == '':
964
 
            base_parts = base_parts[:-1]
965
 
        for p in relpath.split('/'):
966
 
            if p == '..':
967
 
                if len(base_parts) == 0:
968
 
                    # In most filesystems, a request for the parent
969
 
                    # of root, just returns root.
970
 
                    continue
971
 
                base_parts.pop()
972
 
            elif p == '.':
973
 
                continue # No-op
974
 
            elif p != '':
975
 
                base_parts.append(p)
976
 
        path = '/'.join(base_parts)
977
 
        if not path.startswith('/'):
978
 
            path = '/' + path
979
 
        return path
980
 
 
981
 
    def clone(self, offset=None):
982
 
        """Return a new URL for a path relative to this URL.
983
 
 
984
 
        :param offset: A relative path, already urlencoded
985
 
        :return: `URL` instance
986
 
        """
987
 
        if offset is not None:
988
 
            relative = unescape(offset)
989
 
            if sys.version_info[0] == 2:
990
 
                relative = relative.encode('utf-8')
991
 
            path = self._combine_paths(self.path, relative)
992
 
            path = quote(path, safe="/~")
993
 
        else:
994
 
            path = self.quoted_path
995
 
        return self.__class__(self.scheme, self.quoted_user,
996
 
                self.quoted_password, self.quoted_host, self.port,
997
 
                path)
998
 
 
999
 
 
1000
 
def parse_url(url):
1001
 
    """Extract the server address, the credentials and the path from the url.
1002
 
 
1003
 
    user, password, host and path should be quoted if they contain reserved
1004
 
    chars.
1005
 
 
1006
 
    :param url: an quoted url
1007
 
    :return: (scheme, user, password, host, port, path) tuple, all fields
1008
 
        are unquoted.
1009
 
    """
1010
 
    parsed_url = URL.from_string(url)
1011
 
    return (parsed_url.scheme, parsed_url.user, parsed_url.password,
1012
 
        parsed_url.host, parsed_url.port, parsed_url.path)