← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: Patch Queue Manager
  • Date: 2013-05-23 10:35:23 UTC
  • mfrom: (6574.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20130523103523-2wt6jmauja1n1vdt
(jameinel) Merge bzr/2.5 into trunk. (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
1
 
# Bazaar-NG -- distributed version control
2
 
#
3
 
# Copyright (C) 2006 by Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
4
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
14
12
#
15
13
# You should have received a copy of the GNU General Public License
16
14
# along with this program; if not, write to the Free Software
17
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
16
 
19
17
"""A collection of function for handling URL operations."""
20
18
 
 
19
from __future__ import absolute_import
 
20
 
21
21
import os
22
 
from posixpath import split as _posix_split, normpath as _posix_normpath
23
22
import re
24
23
import sys
25
 
import urllib
26
 
 
27
 
import bzrlib.errors as errors
28
 
import bzrlib.osutils
 
24
 
 
25
from bzrlib.lazy_import import lazy_import
 
26
lazy_import(globals(), """
 
27
from posixpath import split as _posix_split
 
28
import urlparse
 
29
 
 
30
from bzrlib import (
 
31
    errors,
 
32
    osutils,
 
33
    )
 
34
""")
29
35
 
30
36
 
31
37
def basename(url, exclude_trailing_slash=True):
55
61
    return split(url, exclude_trailing_slash=exclude_trailing_slash)[0]
56
62
 
57
63
 
 
64
# Private copies of quote and unquote, copied from Python's
 
65
# urllib module because urllib unconditionally imports socket, which imports
 
66
# ssl.
 
67
 
 
68
always_safe = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
69
               'abcdefghijklmnopqrstuvwxyz'
 
70
               '0123456789' '_.-')
 
71
_safe_map = {}
 
72
for i, c in zip(xrange(256), str(bytearray(xrange(256)))):
 
73
    _safe_map[c] = c if (i < 128 and c in always_safe) else '%{0:02X}'.format(i)
 
74
_safe_quoters = {}
 
75
 
 
76
 
 
77
def quote(s, safe='/'):
 
78
    """quote('abc def') -> 'abc%20def'
 
79
 
 
80
    Each part of a URL, e.g. the path info, the query, etc., has a
 
81
    different set of reserved characters that must be quoted.
 
82
 
 
83
    RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
 
84
    the following reserved characters.
 
85
 
 
86
    reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
 
87
                  "$" | ","
 
88
 
 
89
    Each of these characters is reserved in some component of a URL,
 
90
    but not necessarily in all of them.
 
91
 
 
92
    By default, the quote function is intended for quoting the path
 
93
    section of a URL.  Thus, it will not encode '/'.  This character
 
94
    is reserved, but in typical usage the quote function is being
 
95
    called on a path where the existing slash characters are used as
 
96
    reserved characters.
 
97
    """
 
98
    # fastpath
 
99
    if not s:
 
100
        if s is None:
 
101
            raise TypeError('None object cannot be quoted')
 
102
        return s
 
103
    cachekey = (safe, always_safe)
 
104
    try:
 
105
        (quoter, safe) = _safe_quoters[cachekey]
 
106
    except KeyError:
 
107
        safe_map = _safe_map.copy()
 
108
        safe_map.update([(c, c) for c in safe])
 
109
        quoter = safe_map.__getitem__
 
110
        safe = always_safe + safe
 
111
        _safe_quoters[cachekey] = (quoter, safe)
 
112
    if not s.rstrip(safe):
 
113
        return s
 
114
    return ''.join(map(quoter, s))
 
115
 
 
116
 
 
117
_hexdig = '0123456789ABCDEFabcdef'
 
118
_hextochr = dict((a + b, chr(int(a + b, 16)))
 
119
                 for a in _hexdig for b in _hexdig)
 
120
 
 
121
def unquote(s):
 
122
    """unquote('abc%20def') -> 'abc def'."""
 
123
    res = s.split('%')
 
124
    # fastpath
 
125
    if len(res) == 1:
 
126
        return s
 
127
    s = res[0]
 
128
    for item in res[1:]:
 
129
        try:
 
130
            s += _hextochr[item[:2]] + item[2:]
 
131
        except KeyError:
 
132
            s += '%' + item
 
133
        except UnicodeDecodeError:
 
134
            s += unichr(int(item[:2], 16)) + item[2:]
 
135
    return s
 
136
 
 
137
 
58
138
def escape(relpath):
59
139
    """Escape relpath to be a valid url."""
60
140
    if isinstance(relpath, unicode):
61
141
        relpath = relpath.encode('utf-8')
62
142
    # After quoting and encoding, the path should be perfectly
63
143
    # safe as a plain ASCII string, str() just enforces this
64
 
    return str(urllib.quote(relpath))
 
144
    return str(quote(relpath, safe='/~'))
65
145
 
66
146
 
67
147
def file_relpath(base, path):
68
148
    """Compute just the relative sub-portion of a url
69
 
    
 
149
 
70
150
    This assumes that both paths are already fully specified file:// URLs.
71
151
    """
72
 
    assert len(base) >= MIN_ABS_FILEURL_LENGTH, ('Length of base must be equal or'
73
 
        ' exceed the platform minimum url length (which is %d)' % 
74
 
        MIN_ABS_FILEURL_LENGTH)
75
 
 
76
 
    base = local_path_from_url(base)
77
 
    path = local_path_from_url(path)
78
 
    return escape(bzrlib.osutils.relpath(base, path))
 
152
    if len(base) < MIN_ABS_FILEURL_LENGTH:
 
153
        raise ValueError('Length of base (%r) must equal or'
 
154
            ' exceed the platform minimum url length (which is %d)' %
 
155
            (base, MIN_ABS_FILEURL_LENGTH))
 
156
    base = osutils.normpath(local_path_from_url(base))
 
157
    path = osutils.normpath(local_path_from_url(path))
 
158
    return escape(osutils.relpath(base, path))
79
159
 
80
160
 
81
161
def _find_scheme_and_separator(url):
96
176
    first_path_slash = path.find('/')
97
177
    if first_path_slash == -1:
98
178
        return len(scheme), None
99
 
    return len(scheme), first_path_slash+len(scheme)+3
 
179
    return len(scheme), first_path_slash+m.start('path')
 
180
 
 
181
 
 
182
def is_url(url):
 
183
    """Tests whether a URL is in actual fact a URL."""
 
184
    return _url_scheme_re.match(url) is not None
100
185
 
101
186
 
102
187
def join(base, *args):
111
196
        join('http://foo', 'bar') => 'http://foo/bar'
112
197
        join('http://foo', 'bar', '../baz') => 'http://foo/baz'
113
198
    """
114
 
    m = _url_scheme_re.match(base)
115
 
    scheme = None
116
 
    if m:
117
 
        scheme = m.group('scheme')
118
 
        path = m.group('path').split('/')
119
 
        if path[-1:] == ['']:
120
 
            # Strip off a trailing slash
121
 
            # This helps both when we are at the root, and when
122
 
            # 'base' has an extra slash at the end
123
 
            path = path[:-1]
 
199
    if not args:
 
200
        return base
 
201
    scheme_end, path_start = _find_scheme_and_separator(base)
 
202
    if scheme_end is None and path_start is None:
 
203
        path_start = 0
 
204
    elif path_start is None:
 
205
        path_start = len(base)
 
206
    path = base[path_start:]
 
207
    for arg in args:
 
208
        arg_scheme_end, arg_path_start = _find_scheme_and_separator(arg)
 
209
        if arg_scheme_end is None and arg_path_start is None:
 
210
            arg_path_start = 0
 
211
        elif arg_path_start is None:
 
212
            arg_path_start = len(arg)
 
213
        if arg_scheme_end is not None:
 
214
            base = arg
 
215
            path = arg[arg_path_start:]
 
216
            scheme_end = arg_scheme_end
 
217
            path_start = arg_path_start
 
218
        else:
 
219
            path = joinpath(path, arg)
 
220
    return base[:path_start] + path
 
221
 
 
222
 
 
223
def joinpath(base, *args):
 
224
    """Join URL path segments to a URL path segment.
 
225
 
 
226
    This is somewhat like osutils.joinpath, but intended for URLs.
 
227
 
 
228
    XXX: this duplicates some normalisation logic, and also duplicates a lot of
 
229
    path handling logic that already exists in some Transport implementations.
 
230
    We really should try to have exactly one place in the code base responsible
 
231
    for combining paths of URLs.
 
232
    """
 
233
    path = base.split('/')
 
234
    if len(path) > 1 and path[-1] == '':
 
235
        #If the path ends in a trailing /, remove it.
 
236
        path.pop()
 
237
    for arg in args:
 
238
        if arg.startswith('/'):
 
239
            path = []
 
240
        for chunk in arg.split('/'):
 
241
            if chunk == '.':
 
242
                continue
 
243
            elif chunk == '..':
 
244
                if path == ['']:
 
245
                    raise errors.InvalidURLJoin('Cannot go above root',
 
246
                            base, args)
 
247
                path.pop()
 
248
            else:
 
249
                path.append(chunk)
 
250
    if path == ['']:
 
251
        return '/'
124
252
    else:
125
 
        path = base.split('/')
126
 
 
127
 
    for arg in args:
128
 
        m = _url_scheme_re.match(arg)
129
 
        if m:
130
 
            # Absolute URL
131
 
            scheme = m.group('scheme')
132
 
            path = m.group('path').split('/')
133
 
        else:
134
 
            for chunk in arg.split('/'):
135
 
                if chunk == '.':
136
 
                    continue
137
 
                elif chunk == '..':
138
 
                    if len(path) >= 2:
139
 
                        # Don't pop off the host portion
140
 
                        path.pop()
141
 
                    else:
142
 
                        raise errors.InvalidURLJoin('Cannot go above root',
143
 
                                base, args)
144
 
                else:
145
 
                    path.append(chunk)
146
 
 
147
 
    if scheme is None:
148
253
        return '/'.join(path)
149
 
    return scheme + '://' + '/'.join(path)
150
254
 
151
255
 
152
256
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
153
257
def _posix_local_path_from_url(url):
154
258
    """Convert a url like file:///path/to/foo into /path/to/foo"""
155
 
    if not url.startswith('file:///'):
156
 
        raise errors.InvalidURL(url, 'local urls must start with file:///')
 
259
    url = split_segment_parameters_raw(url)[0]
 
260
    file_localhost_prefix = 'file://localhost/'
 
261
    if url.startswith(file_localhost_prefix):
 
262
        path = url[len(file_localhost_prefix) - 1:]
 
263
    elif not url.startswith('file:///'):
 
264
        raise errors.InvalidURL(
 
265
            url, 'local urls must start with file:/// or file://localhost/')
 
266
    else:
 
267
        path = url[len('file://'):]
157
268
    # We only strip off 2 slashes
158
 
    return unescape(url[len('file://'):])
 
269
    return unescape(path)
159
270
 
160
271
 
161
272
def _posix_local_path_to_url(path):
163
274
 
164
275
    This also handles transforming escaping unicode characters, etc.
165
276
    """
166
 
    # importing directly from posixpath allows us to test this 
 
277
    # importing directly from posixpath allows us to test this
167
278
    # on non-posix platforms
168
 
    return 'file://' + escape(_posix_normpath(
169
 
        bzrlib.osutils._posix_abspath(path)))
 
279
    return 'file://' + escape(osutils._posix_abspath(path))
170
280
 
171
281
 
172
282
def _win32_local_path_from_url(url):
173
283
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
174
 
    if not url.startswith('file:///'):
175
 
        raise errors.InvalidURL(url, 'local urls must start with file:///')
 
284
    if not url.startswith('file://'):
 
285
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
 
286
                                     'UNC path urls must start with file://')
 
287
    url = split_segment_parameters_raw(url)[0]
176
288
    # We strip off all 3 slashes
177
 
    win32_url = url[len('file:///'):]
178
 
    if (win32_url[0] not in ('abcdefghijklmnopqrstuvwxyz'
179
 
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
180
 
        or win32_url[1] not in  '|:'
181
 
        or win32_url[2] != '/'):
 
289
    win32_url = url[len('file:'):]
 
290
    # check for UNC path: //HOST/path
 
291
    if not win32_url.startswith('///'):
 
292
        if (win32_url[2] == '/'
 
293
            or win32_url[3] in '|:'):
 
294
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
 
295
                ' have form file://HOST/path')
 
296
        return unescape(win32_url)
 
297
 
 
298
    # allow empty paths so we can serve all roots
 
299
    if win32_url == '///':
 
300
        return '/'
 
301
 
 
302
    # usual local path with drive letter
 
303
    if (len(win32_url) < 6
 
304
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
305
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
306
        or win32_url[4] not in  '|:'
 
307
        or win32_url[5] != '/'):
182
308
        raise errors.InvalidURL(url, 'Win32 file urls start with'
183
309
                ' file:///x:/, where x is a valid drive letter')
184
 
    return win32_url[0].upper() + u':' + unescape(win32_url[2:])
 
310
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
185
311
 
186
312
 
187
313
def _win32_local_path_to_url(path):
189
315
 
190
316
    This also handles transforming escaping unicode characters, etc.
191
317
    """
192
 
    # importing directly from ntpath allows us to test this 
 
318
    # importing directly from ntpath allows us to test this
193
319
    # on non-win32 platform
194
320
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
195
321
    #       which actually strips trailing space characters.
196
 
    #       The worst part is that under linux ntpath.abspath has different
 
322
    #       The worst part is that on linux ntpath.abspath has different
197
323
    #       semantics, since 'nt' is not an available module.
198
 
    win32_path = bzrlib.osutils._nt_normpath(
199
 
        bzrlib.osutils._win32_abspath(path)).replace('\\', '/')
200
 
    return 'file:///' + win32_path[0].upper() + ':' + escape(win32_path[2:])
 
324
    if path == '/':
 
325
        return 'file:///'
 
326
 
 
327
    win32_path = osutils._win32_abspath(path)
 
328
    # check for UNC path \\HOST\path
 
329
    if win32_path.startswith('//'):
 
330
        return 'file:' + escape(win32_path)
 
331
    return ('file:///' + str(win32_path[0].upper()) + ':' +
 
332
        escape(win32_path[2:]))
201
333
 
202
334
 
203
335
local_path_to_url = _posix_local_path_to_url
212
344
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
213
345
 
214
346
 
215
 
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
 
347
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
 
348
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
 
349
 
 
350
 
 
351
def _unescape_safe_chars(matchobj):
 
352
    """re.sub callback to convert hex-escapes to plain characters (if safe).
 
353
 
 
354
    e.g. '%7E' will be converted to '~'.
 
355
    """
 
356
    hex_digits = matchobj.group(0)[1:]
 
357
    char = chr(int(hex_digits, 16))
 
358
    if char in _url_dont_escape_characters:
 
359
        return char
 
360
    else:
 
361
        return matchobj.group(0).upper()
216
362
 
217
363
 
218
364
def normalize_url(url):
219
365
    """Make sure that a path string is in fully normalized URL form.
220
 
    
221
 
    This handles URLs which have unicode characters, spaces, 
 
366
 
 
367
    This handles URLs which have unicode characters, spaces,
222
368
    special characters, etc.
223
369
 
224
370
    It has two basic modes of operation, depending on whether the
234
380
    :param url: Either a hybrid URL or a local path
235
381
    :return: A normalized URL which only includes 7-bit ASCII characters.
236
382
    """
237
 
    m = _url_scheme_re.match(url)
238
 
    if not m:
 
383
    scheme_end, path_start = _find_scheme_and_separator(url)
 
384
    if scheme_end is None:
239
385
        return local_path_to_url(url)
 
386
    prefix = url[:path_start]
 
387
    path = url[path_start:]
240
388
    if not isinstance(url, unicode):
241
389
        for c in url:
242
390
            if c not in _url_safe_characters:
243
391
                raise errors.InvalidURL(url, 'URLs can only contain specific'
244
392
                                            ' safe characters (not %r)' % c)
245
 
        return url
 
393
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
 
394
        return str(prefix + ''.join(path))
 
395
 
246
396
    # We have a unicode (hybrid) url
247
 
    scheme = m.group('scheme')
248
 
    path = list(m.group('path'))
 
397
    path_chars = list(path)
249
398
 
250
 
    for i in xrange(len(path)):
251
 
        if path[i] not in _url_safe_characters:
252
 
            chars = path[i].encode('utf-8')
253
 
            path[i] = ''.join(['%%%02X' % ord(c) for c in path[i].encode('utf-8')])
254
 
    return scheme + '://' + ''.join(path)
 
399
    for i in xrange(len(path_chars)):
 
400
        if path_chars[i] not in _url_safe_characters:
 
401
            chars = path_chars[i].encode('utf-8')
 
402
            path_chars[i] = ''.join(
 
403
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
 
404
    path = ''.join(path_chars)
 
405
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
 
406
    return str(prefix + path)
255
407
 
256
408
 
257
409
def relative_url(base, other):
263
415
    dummy, base_first_slash = _find_scheme_and_separator(base)
264
416
    if base_first_slash is None:
265
417
        return other
266
 
    
 
418
 
267
419
    dummy, other_first_slash = _find_scheme_and_separator(other)
268
420
    if other_first_slash is None:
269
421
        return other
273
425
    other_scheme = other[:other_first_slash]
274
426
    if base_scheme != other_scheme:
275
427
        return other
 
428
    elif sys.platform == 'win32' and base_scheme == 'file://':
 
429
        base_drive = base[base_first_slash+1:base_first_slash+3]
 
430
        other_drive = other[other_first_slash+1:other_first_slash+3]
 
431
        if base_drive != other_drive:
 
432
            return other
276
433
 
277
434
    base_path = base[base_first_slash+1:]
278
435
    other_path = other[other_first_slash+1:]
305
462
    """On win32 the drive letter needs to be added to the url base."""
306
463
    # Strip off the drive letter
307
464
    # path is currently /C:/foo
308
 
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
309
 
        raise errors.InvalidURL(url_base + path, 
 
465
    if len(path) < 4 or path[2] not in ':|' or path[3] != '/':
 
466
        raise errors.InvalidURL(url_base + path,
310
467
            'win32 file:/// paths need a drive letter')
311
468
    url_base += path[0:3] # file:// + /C:
312
469
    path = path[3:] # /foo
320
477
    :param exclude_trailing_slash: Strip off a final '/' if it is part
321
478
        of the path (but not if it is part of the protocol specification)
322
479
 
323
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at 
 
480
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
324
481
        the root.
325
482
    """
326
483
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
353
510
    return url_base + head, tail
354
511
 
355
512
 
 
513
def split_segment_parameters_raw(url):
 
514
    """Split the subsegment of the last segment of a URL.
 
515
 
 
516
    :param url: A relative or absolute URL
 
517
    :return: (url, subsegments)
 
518
    """
 
519
    # GZ 2011-11-18: Dodgy removing the terminal slash like this, function
 
520
    #                operates on urls not url+segments, and Transport classes
 
521
    #                should not be blindly adding slashes in the first place. 
 
522
    lurl = strip_trailing_slash(url)
 
523
    # Segments begin at first comma after last forward slash, if one exists
 
524
    segment_start = lurl.find(",", lurl.rfind("/")+1)
 
525
    if segment_start == -1:
 
526
        return (url, [])
 
527
    return (lurl[:segment_start], lurl[segment_start+1:].split(","))
 
528
 
 
529
 
 
530
def split_segment_parameters(url):
 
531
    """Split the segment parameters of the last segment of a URL.
 
532
 
 
533
    :param url: A relative or absolute URL
 
534
    :return: (url, segment_parameters)
 
535
    """
 
536
    (base_url, subsegments) = split_segment_parameters_raw(url)
 
537
    parameters = {}
 
538
    for subsegment in subsegments:
 
539
        (key, value) = subsegment.split("=", 1)
 
540
        parameters[key] = value
 
541
    return (base_url, parameters)
 
542
 
 
543
 
 
544
def join_segment_parameters_raw(base, *subsegments):
 
545
    """Create a new URL by adding subsegments to an existing one. 
 
546
 
 
547
    This adds the specified subsegments to the last path in the specified
 
548
    base URL. The subsegments should be bytestrings.
 
549
 
 
550
    :note: You probably want to use join_segment_parameters instead.
 
551
    """
 
552
    if not subsegments:
 
553
        return base
 
554
    for subsegment in subsegments:
 
555
        if type(subsegment) is not str:
 
556
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
 
557
        if "," in subsegment:
 
558
            raise errors.InvalidURLJoin(", exists in subsegments",
 
559
                                        base, subsegments)
 
560
    return ",".join((base,) + subsegments)
 
561
 
 
562
 
 
563
def join_segment_parameters(url, parameters):
 
564
    """Create a new URL by adding segment parameters to an existing one.
 
565
 
 
566
    The parameters of the last segment in the URL will be updated; if a
 
567
    parameter with the same key already exists it will be overwritten.
 
568
 
 
569
    :param url: A URL, as string
 
570
    :param parameters: Dictionary of parameters, keys and values as bytestrings
 
571
    """
 
572
    (base, existing_parameters) = split_segment_parameters(url)
 
573
    new_parameters = {}
 
574
    new_parameters.update(existing_parameters)
 
575
    for key, value in parameters.iteritems():
 
576
        if type(key) is not str:
 
577
            raise TypeError("parameter key %r is not a bytestring" % key)
 
578
        if type(value) is not str:
 
579
            raise TypeError("parameter value %r for %s is not a bytestring" %
 
580
                (key, value))
 
581
        if "=" in key:
 
582
            raise errors.InvalidURLJoin("= exists in parameter key", url,
 
583
                parameters)
 
584
        new_parameters[key] = value
 
585
    return join_segment_parameters_raw(base, 
 
586
        *["%s=%s" % item for item in sorted(new_parameters.items())])
 
587
 
 
588
 
356
589
def _win32_strip_local_trailing_slash(url):
357
590
    """Strip slashes after the drive letter"""
358
591
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
385
618
    if not url.endswith('/'):
386
619
        # Nothing to do
387
620
        return url
388
 
    if sys.platform == 'win32' and url.startswith('file:///'):
 
621
    if sys.platform == 'win32' and url.startswith('file://'):
389
622
        return _win32_strip_local_trailing_slash(url)
390
623
 
391
624
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
408
641
    This returns a Unicode path from a URL
409
642
    """
410
643
    # jam 20060427 URLs are supposed to be ASCII only strings
411
 
    #       If they are passed in as unicode, urllib.unquote
 
644
    #       If they are passed in as unicode, unquote
412
645
    #       will return a UNICODE string, which actually contains
413
646
    #       utf-8 bytes. So we have to ensure that they are
414
647
    #       plain ASCII strings, or the final .decode will
419
652
    except UnicodeError, e:
420
653
        raise errors.InvalidURL(url, 'URL was not a plain ASCII url: %s' % (e,))
421
654
 
422
 
    unquoted = urllib.unquote(url)
 
655
    unquoted = unquote(url)
423
656
    try:
424
657
        unicode_path = unquoted.decode('utf-8')
425
658
    except UnicodeError, e:
430
663
# These are characters that if escaped, should stay that way
431
664
_no_decode_chars = ';/?:@&=+$,#'
432
665
_no_decode_ords = [ord(c) for c in _no_decode_chars]
433
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
 
666
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
434
667
                + ['%02X' % o for o in _no_decode_ords])
435
668
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
436
669
                    + [('%02X' % o, chr(o)) for o in range(256)]))
437
670
#These entries get mapped to themselves
438
671
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
439
672
 
 
673
# These characters shouldn't be percent-encoded, and it's always safe to
 
674
# unencode them if they are.
 
675
_url_dont_escape_characters = set(
 
676
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
 
677
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
 
678
   "0123456789" # Numbers
 
679
   "-._~"  # Unreserved characters
 
680
)
 
681
 
440
682
# These characters should not be escaped
441
 
_url_safe_characters = set('abcdefghijklmnopqrstuvwxyz'
442
 
                        'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
443
 
                        '0123456789' '_.-/'
444
 
                        ';?:@&=+$,%#')
445
 
 
 
683
_url_safe_characters = set(
 
684
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
 
685
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
 
686
   "0123456789" # Numbers
 
687
   "_.-!~*'()"  # Unreserved characters
 
688
   "/;?:@&=+$," # Reserved characters
 
689
   "%#"         # Extra reserved characters
 
690
)
446
691
 
447
692
def unescape_for_display(url, encoding):
448
693
    """Decode what you can for a URL, so that we get a nice looking path.
450
695
    This will turn file:// urls into local paths, and try to decode
451
696
    any portions of a http:// style url that it can.
452
697
 
453
 
    Any sections of the URL which can't be represented in the encoding or 
 
698
    Any sections of the URL which can't be represented in the encoding or
454
699
    need to stay as escapes are left alone.
455
700
 
456
701
    :param url: A 7-bit ASCII URL
457
702
    :param encoding: The final output encoding
458
703
 
459
 
    :return: A unicode string which can be safely encoded into the 
 
704
    :return: A unicode string which can be safely encoded into the
460
705
         specified encoding.
461
706
    """
462
 
    assert encoding is not None, 'you cannot specify None for the display encoding.'
 
707
    if encoding is None:
 
708
        raise ValueError('you cannot specify None for the display encoding')
463
709
    if url.startswith('file://'):
464
710
        try:
465
711
            path = local_path_from_url(url)
499
745
                # Otherwise take the url decoded one
500
746
                res[i] = decoded
501
747
    return u'/'.join(res)
 
748
 
 
749
 
 
750
def derive_to_location(from_location):
 
751
    """Derive a TO_LOCATION given a FROM_LOCATION.
 
752
 
 
753
    The normal case is a FROM_LOCATION of http://foo/bar => bar.
 
754
    The Right Thing for some logical destinations may differ though
 
755
    because no / may be present at all. In that case, the result is
 
756
    the full name without the scheme indicator, e.g. lp:foo-bar => foo-bar.
 
757
    This latter case also applies when a Windows drive
 
758
    is used without a path, e.g. c:foo-bar => foo-bar.
 
759
    If no /, path separator or : is found, the from_location is returned.
 
760
    """
 
761
    if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
 
762
        return os.path.basename(from_location.rstrip("/\\"))
 
763
    else:
 
764
        sep = from_location.find(":")
 
765
        if sep > 0:
 
766
            return from_location[sep+1:]
 
767
        else:
 
768
            return from_location
 
769
 
 
770
 
 
771
def _is_absolute(url):
 
772
    return (osutils.pathjoin('/foo', url) == url)
 
773
 
 
774
 
 
775
def rebase_url(url, old_base, new_base):
 
776
    """Convert a relative path from an old base URL to a new base URL.
 
777
 
 
778
    The result will be a relative path.
 
779
    Absolute paths and full URLs are returned unaltered.
 
780
    """
 
781
    scheme, separator = _find_scheme_and_separator(url)
 
782
    if scheme is not None:
 
783
        return url
 
784
    if _is_absolute(url):
 
785
        return url
 
786
    old_parsed = urlparse.urlparse(old_base)
 
787
    new_parsed = urlparse.urlparse(new_base)
 
788
    if (old_parsed[:2]) != (new_parsed[:2]):
 
789
        raise errors.InvalidRebaseURLs(old_base, new_base)
 
790
    return determine_relative_path(new_parsed[2],
 
791
                                   join(old_parsed[2], url))
 
792
 
 
793
 
 
794
def determine_relative_path(from_path, to_path):
 
795
    """Determine a relative path from from_path to to_path."""
 
796
    from_segments = osutils.splitpath(from_path)
 
797
    to_segments = osutils.splitpath(to_path)
 
798
    count = -1
 
799
    for count, (from_element, to_element) in enumerate(zip(from_segments,
 
800
                                                       to_segments)):
 
801
        if from_element != to_element:
 
802
            break
 
803
    else:
 
804
        count += 1
 
805
    unique_from = from_segments[count:]
 
806
    unique_to = to_segments[count:]
 
807
    segments = (['..'] * len(unique_from) + unique_to)
 
808
    if len(segments) == 0:
 
809
        return '.'
 
810
    return osutils.pathjoin(*segments)
 
811
 
 
812
 
 
813
class URL(object):
 
814
    """Parsed URL."""
 
815
 
 
816
    def __init__(self, scheme, quoted_user, quoted_password, quoted_host,
 
817
            port, quoted_path):
 
818
        self.scheme = scheme
 
819
        self.quoted_host = quoted_host
 
820
        self.host = unquote(self.quoted_host)
 
821
        self.quoted_user = quoted_user
 
822
        if self.quoted_user is not None:
 
823
            self.user = unquote(self.quoted_user)
 
824
        else:
 
825
            self.user = None
 
826
        self.quoted_password = quoted_password
 
827
        if self.quoted_password is not None:
 
828
            self.password = unquote(self.quoted_password)
 
829
        else:
 
830
            self.password = None
 
831
        self.port = port
 
832
        self.quoted_path = _url_hex_escapes_re.sub(_unescape_safe_chars, quoted_path)
 
833
        self.path = unquote(self.quoted_path)
 
834
 
 
835
    def __eq__(self, other):
 
836
        return (isinstance(other, self.__class__) and
 
837
                self.scheme == other.scheme and
 
838
                self.host == other.host and
 
839
                self.user == other.user and
 
840
                self.password == other.password and
 
841
                self.path == other.path)
 
842
 
 
843
    def __repr__(self):
 
844
        return "<%s(%r, %r, %r, %r, %r, %r)>" % (
 
845
            self.__class__.__name__,
 
846
            self.scheme, self.quoted_user, self.quoted_password,
 
847
            self.quoted_host, self.port, self.quoted_path)
 
848
 
 
849
    @classmethod
 
850
    def from_string(cls, url):
 
851
        """Create a URL object from a string.
 
852
 
 
853
        :param url: URL as bytestring
 
854
        """
 
855
        if isinstance(url, unicode):
 
856
            raise errors.InvalidURL('should be ascii:\n%r' % url)
 
857
        url = url.encode('utf-8')
 
858
        (scheme, netloc, path, params,
 
859
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
860
        user = password = host = port = None
 
861
        if '@' in netloc:
 
862
            user, host = netloc.rsplit('@', 1)
 
863
            if ':' in user:
 
864
                user, password = user.split(':', 1)
 
865
        else:
 
866
            host = netloc
 
867
 
 
868
        if ':' in host and not (host[0] == '[' and host[-1] == ']'):
 
869
            # there *is* port
 
870
            host, port = host.rsplit(':',1)
 
871
            try:
 
872
                port = int(port)
 
873
            except ValueError:
 
874
                raise errors.InvalidURL('invalid port number %s in url:\n%s' %
 
875
                                        (port, url))
 
876
        if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
 
877
            host = host[1:-1]
 
878
 
 
879
        return cls(scheme, user, password, host, port, path)
 
880
 
 
881
    def __str__(self):
 
882
        netloc = self.quoted_host
 
883
        if ":" in netloc:
 
884
            netloc = "[%s]" % netloc
 
885
        if self.quoted_user is not None:
 
886
            # Note that we don't put the password back even if we
 
887
            # have one so that it doesn't get accidentally
 
888
            # exposed.
 
889
            netloc = '%s@%s' % (self.quoted_user, netloc)
 
890
        if self.port is not None:
 
891
            netloc = '%s:%d' % (netloc, self.port)
 
892
        return urlparse.urlunparse(
 
893
            (self.scheme, netloc, self.quoted_path, None, None, None))
 
894
 
 
895
    @staticmethod
 
896
    def _combine_paths(base_path, relpath):
 
897
        """Transform a Transport-relative path to a remote absolute path.
 
898
 
 
899
        This does not handle substitution of ~ but does handle '..' and '.'
 
900
        components.
 
901
 
 
902
        Examples::
 
903
 
 
904
            t._combine_paths('/home/sarah', 'project/foo')
 
905
                => '/home/sarah/project/foo'
 
906
            t._combine_paths('/home/sarah', '../../etc')
 
907
                => '/etc'
 
908
            t._combine_paths('/home/sarah', '/etc')
 
909
                => '/etc'
 
910
 
 
911
        :param base_path: base path
 
912
        :param relpath: relative url string for relative part of remote path.
 
913
        :return: urlencoded string for final path.
 
914
        """
 
915
        if not isinstance(relpath, str):
 
916
            raise errors.InvalidURL(relpath)
 
917
        relpath = _url_hex_escapes_re.sub(_unescape_safe_chars, relpath)
 
918
        if relpath.startswith('/'):
 
919
            base_parts = []
 
920
        else:
 
921
            base_parts = base_path.split('/')
 
922
        if len(base_parts) > 0 and base_parts[-1] == '':
 
923
            base_parts = base_parts[:-1]
 
924
        for p in relpath.split('/'):
 
925
            if p == '..':
 
926
                if len(base_parts) == 0:
 
927
                    # In most filesystems, a request for the parent
 
928
                    # of root, just returns root.
 
929
                    continue
 
930
                base_parts.pop()
 
931
            elif p == '.':
 
932
                continue # No-op
 
933
            elif p != '':
 
934
                base_parts.append(p)
 
935
        path = '/'.join(base_parts)
 
936
        if not path.startswith('/'):
 
937
            path = '/' + path
 
938
        return path
 
939
 
 
940
    def clone(self, offset=None):
 
941
        """Return a new URL for a path relative to this URL.
 
942
 
 
943
        :param offset: A relative path, already urlencoded
 
944
        :return: `URL` instance
 
945
        """
 
946
        if offset is not None:
 
947
            relative = unescape(offset).encode('utf-8')
 
948
            path = self._combine_paths(self.path, relative)
 
949
            path = quote(path, safe="/~")
 
950
        else:
 
951
            path = self.quoted_path
 
952
        return self.__class__(self.scheme, self.quoted_user,
 
953
                self.quoted_password, self.quoted_host, self.port,
 
954
                path)
 
955
 
 
956
 
 
957
def parse_url(url):
 
958
    """Extract the server address, the credentials and the path from the url.
 
959
 
 
960
    user, password, host and path should be quoted if they contain reserved
 
961
    chars.
 
962
 
 
963
    :param url: an quoted url
 
964
    :return: (scheme, user, password, host, port, path) tuple, all fields
 
965
        are unquoted.
 
966
    """
 
967
    parsed_url = URL.from_string(url)
 
968
    return (parsed_url.scheme, parsed_url.user, parsed_url.password,
 
969
        parsed_url.host, parsed_url.port, parsed_url.path)