← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: Robert Collins
  • Date: 2010-04-08 04:34:03 UTC
  • mfrom: (5138 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5139.
  • Revision ID: robertc@robertcollins.net-20100408043403-56z0d07vdqrx7f3t
Update bugfix for 528114 to trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
1
 
# Bazaar -- distributed version control
2
 
#
3
 
# Copyright (C) 2006 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
 
26
24
lazy_import(globals(), """
27
25
from posixpath import split as _posix_split, normpath as _posix_normpath
28
26
import urllib
 
27
import urlparse
29
28
 
30
29
from bzrlib import (
31
30
    errors,
67
66
        relpath = relpath.encode('utf-8')
68
67
    # After quoting and encoding, the path should be perfectly
69
68
    # safe as a plain ASCII string, str() just enforces this
70
 
    return str(urllib.quote(relpath))
 
69
    return str(urllib.quote(relpath, safe='/~'))
71
70
 
72
71
 
73
72
def file_relpath(base, path):
74
73
    """Compute just the relative sub-portion of a url
75
 
    
 
74
 
76
75
    This assumes that both paths are already fully specified file:// URLs.
77
76
    """
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
 
 
 
77
    if len(base) < MIN_ABS_FILEURL_LENGTH:
 
78
        raise ValueError('Length of base (%r) must equal or'
 
79
            ' exceed the platform minimum url length (which is %d)' %
 
80
            (base, MIN_ABS_FILEURL_LENGTH))
82
81
    base = local_path_from_url(base)
83
82
    path = local_path_from_url(path)
84
83
    return escape(osutils.relpath(base, path))
184
183
 
185
184
def joinpath(base, *args):
186
185
    """Join URL path segments to a URL path segment.
187
 
    
 
186
 
188
187
    This is somewhat like osutils.joinpath, but intended for URLs.
189
188
 
190
189
    XXX: this duplicates some normalisation logic, and also duplicates a lot of
218
217
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
219
218
def _posix_local_path_from_url(url):
220
219
    """Convert a url like file:///path/to/foo into /path/to/foo"""
221
 
    if not url.startswith('file:///'):
222
 
        raise errors.InvalidURL(url, 'local urls must start with file:///')
 
220
    file_localhost_prefix = 'file://localhost/'
 
221
    if url.startswith(file_localhost_prefix):
 
222
        path = url[len(file_localhost_prefix) - 1:]
 
223
    elif not url.startswith('file:///'):
 
224
        raise errors.InvalidURL(
 
225
            url, 'local urls must start with file:/// or file://localhost/')
 
226
    else:
 
227
        path = url[len('file://'):]
223
228
    # We only strip off 2 slashes
224
 
    return unescape(url[len('file://'):])
 
229
    return unescape(path)
225
230
 
226
231
 
227
232
def _posix_local_path_to_url(path):
229
234
 
230
235
    This also handles transforming escaping unicode characters, etc.
231
236
    """
232
 
    # importing directly from posixpath allows us to test this 
 
237
    # importing directly from posixpath allows us to test this
233
238
    # on non-posix platforms
234
239
    return 'file://' + escape(_posix_normpath(
235
240
        osutils._posix_abspath(path)))
249
254
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
250
255
                ' have form file://HOST/path')
251
256
        return unescape(win32_url)
 
257
 
 
258
    # allow empty paths so we can serve all roots
 
259
    if win32_url == '///':
 
260
        return '/'
 
261
 
252
262
    # usual local path with drive letter
253
263
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
254
264
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
264
274
 
265
275
    This also handles transforming escaping unicode characters, etc.
266
276
    """
267
 
    # importing directly from ntpath allows us to test this 
 
277
    # importing directly from ntpath allows us to test this
268
278
    # on non-win32 platform
269
279
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
270
280
    #       which actually strips trailing space characters.
271
281
    #       The worst part is that under linux ntpath.abspath has different
272
282
    #       semantics, since 'nt' is not an available module.
 
283
    if path == '/':
 
284
        return 'file:///'
 
285
 
273
286
    win32_path = osutils._win32_abspath(path)
274
287
    # check for UNC path \\HOST\path
275
288
    if win32_path.startswith('//'):
276
289
        return 'file:' + escape(win32_path)
277
 
    return 'file:///' + win32_path[0].upper() + ':' + escape(win32_path[2:])
 
290
    return ('file:///' + str(win32_path[0].upper()) + ':' +
 
291
        escape(win32_path[2:]))
278
292
 
279
293
 
280
294
local_path_to_url = _posix_local_path_to_url
295
309
 
296
310
def _unescape_safe_chars(matchobj):
297
311
    """re.sub callback to convert hex-escapes to plain characters (if safe).
298
 
    
 
312
 
299
313
    e.g. '%7E' will be converted to '~'.
300
314
    """
301
315
    hex_digits = matchobj.group(0)[1:]
308
322
 
309
323
def normalize_url(url):
310
324
    """Make sure that a path string is in fully normalized URL form.
311
 
    
 
325
 
312
326
    This handles URLs which have unicode characters, spaces,
313
327
    special characters, etc.
314
328
 
360
374
    dummy, base_first_slash = _find_scheme_and_separator(base)
361
375
    if base_first_slash is None:
362
376
        return other
363
 
    
 
377
 
364
378
    dummy, other_first_slash = _find_scheme_and_separator(other)
365
379
    if other_first_slash is None:
366
380
        return other
370
384
    other_scheme = other[:other_first_slash]
371
385
    if base_scheme != other_scheme:
372
386
        return other
 
387
    elif sys.platform == 'win32' and base_scheme == 'file://':
 
388
        base_drive = base[base_first_slash+1:base_first_slash+3]
 
389
        other_drive = other[other_first_slash+1:other_first_slash+3]
 
390
        if base_drive != other_drive:
 
391
            return other
373
392
 
374
393
    base_path = base[base_first_slash+1:]
375
394
    other_path = other[other_first_slash+1:]
403
422
    # Strip off the drive letter
404
423
    # path is currently /C:/foo
405
424
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
406
 
        raise errors.InvalidURL(url_base + path, 
 
425
        raise errors.InvalidURL(url_base + path,
407
426
            'win32 file:/// paths need a drive letter')
408
427
    url_base += path[0:3] # file:// + /C:
409
428
    path = path[3:] # /foo
417
436
    :param exclude_trailing_slash: Strip off a final '/' if it is part
418
437
        of the path (but not if it is part of the protocol specification)
419
438
 
420
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at 
 
439
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
421
440
        the root.
422
441
    """
423
442
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
527
546
# These are characters that if escaped, should stay that way
528
547
_no_decode_chars = ';/?:@&=+$,#'
529
548
_no_decode_ords = [ord(c) for c in _no_decode_chars]
530
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
 
549
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
531
550
                + ['%02X' % o for o in _no_decode_ords])
532
551
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
533
552
                    + [('%02X' % o, chr(o)) for o in range(256)]))
559
578
    This will turn file:// urls into local paths, and try to decode
560
579
    any portions of a http:// style url that it can.
561
580
 
562
 
    Any sections of the URL which can't be represented in the encoding or 
 
581
    Any sections of the URL which can't be represented in the encoding or
563
582
    need to stay as escapes are left alone.
564
583
 
565
584
    :param url: A 7-bit ASCII URL
566
585
    :param encoding: The final output encoding
567
586
 
568
 
    :return: A unicode string which can be safely encoded into the 
 
587
    :return: A unicode string which can be safely encoded into the
569
588
         specified encoding.
570
589
    """
571
 
    assert encoding is not None, 'you cannot specify None for the display encoding.'
 
590
    if encoding is None:
 
591
        raise ValueError('you cannot specify None for the display encoding')
572
592
    if url.startswith('file://'):
573
593
        try:
574
594
            path = local_path_from_url(url)
629
649
            return from_location[sep+1:]
630
650
        else:
631
651
            return from_location
 
652
 
 
653
 
 
654
def _is_absolute(url):
 
655
    return (osutils.pathjoin('/foo', url) == url)
 
656
 
 
657
 
 
658
def rebase_url(url, old_base, new_base):
 
659
    """Convert a relative path from an old base URL to a new base URL.
 
660
 
 
661
    The result will be a relative path.
 
662
    Absolute paths and full URLs are returned unaltered.
 
663
    """
 
664
    scheme, separator = _find_scheme_and_separator(url)
 
665
    if scheme is not None:
 
666
        return url
 
667
    if _is_absolute(url):
 
668
        return url
 
669
    old_parsed = urlparse.urlparse(old_base)
 
670
    new_parsed = urlparse.urlparse(new_base)
 
671
    if (old_parsed[:2]) != (new_parsed[:2]):
 
672
        raise errors.InvalidRebaseURLs(old_base, new_base)
 
673
    return determine_relative_path(new_parsed[2],
 
674
                                   join(old_parsed[2], url))
 
675
 
 
676
 
 
677
def determine_relative_path(from_path, to_path):
 
678
    """Determine a relative path from from_path to to_path."""
 
679
    from_segments = osutils.splitpath(from_path)
 
680
    to_segments = osutils.splitpath(to_path)
 
681
    count = -1
 
682
    for count, (from_element, to_element) in enumerate(zip(from_segments,
 
683
                                                       to_segments)):
 
684
        if from_element != to_element:
 
685
            break
 
686
    else:
 
687
        count += 1
 
688
    unique_from = from_segments[count:]
 
689
    unique_to = to_segments[count:]
 
690
    segments = (['..'] * len(unique_from) + unique_to)
 
691
    if len(segments) == 0:
 
692
        return '.'
 
693
    return osutils.pathjoin(*segments)
 
694
 
 
695
 
 
696
 
 
697
def parse_url(url):
 
698
    """Extract the server address, the credentials and the path from the url.
 
699
 
 
700
    user, password, host and path should be quoted if they contain reserved
 
701
    chars.
 
702
 
 
703
    :param url: an quoted url
 
704
 
 
705
    :return: (scheme, user, password, host, port, path) tuple, all fields
 
706
        are unquoted.
 
707
    """
 
708
    if isinstance(url, unicode):
 
709
        raise errors.InvalidURL('should be ascii:\n%r' % url)
 
710
    url = url.encode('utf-8')
 
711
    (scheme, netloc, path, params,
 
712
     query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
713
    user = password = host = port = None
 
714
    if '@' in netloc:
 
715
        user, host = netloc.rsplit('@', 1)
 
716
        if ':' in user:
 
717
            user, password = user.split(':', 1)
 
718
            password = urllib.unquote(password)
 
719
        user = urllib.unquote(user)
 
720
    else:
 
721
        host = netloc
 
722
 
 
723
    if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port
 
724
        host, port = host.rsplit(':',1)
 
725
        try:
 
726
            port = int(port)
 
727
        except ValueError:
 
728
            raise errors.InvalidURL('invalid port number %s in url:\n%s' %
 
729
                                    (port, url))
 
730
    if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
 
731
        host = host[1:-1]
 
732
 
 
733
    host = urllib.unquote(host)
 
734
    path = urllib.unquote(path)
 
735
 
 
736
    return (scheme, user, password, host, port, path)