← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-10 15:46:03 UTC
  • mfrom: (4985.3.21 update)
  • mto: This revision was merged to the branch mainline in revision 5021.
  • Revision ID: v.ladeuil+lp@free.fr-20100210154603-k4no1gvfuqpzrw7p
https://launchpad.net/bugs/113809
Update performs two merges in a more logical order but stop on conflicts

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, 2008 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
 
68
66
        relpath = relpath.encode('utf-8')
69
67
    # After quoting and encoding, the path should be perfectly
70
68
    # safe as a plain ASCII string, str() just enforces this
71
 
    return str(urllib.quote(relpath))
 
69
    return str(urllib.quote(relpath, safe='/~'))
72
70
 
73
71
 
74
72
def file_relpath(base, path):
75
73
    """Compute just the relative sub-portion of a url
76
 
    
 
74
 
77
75
    This assumes that both paths are already fully specified file:// URLs.
78
76
    """
79
77
    if len(base) < MIN_ABS_FILEURL_LENGTH:
80
 
        raise ValueError('Length of base must be equal or'
 
78
        raise ValueError('Length of base (%r) must equal or'
81
79
            ' exceed the platform minimum url length (which is %d)' %
82
 
            MIN_ABS_FILEURL_LENGTH)
 
80
            (base, MIN_ABS_FILEURL_LENGTH))
83
81
    base = local_path_from_url(base)
84
82
    path = local_path_from_url(path)
85
83
    return escape(osutils.relpath(base, path))
185
183
 
186
184
def joinpath(base, *args):
187
185
    """Join URL path segments to a URL path segment.
188
 
    
 
186
 
189
187
    This is somewhat like osutils.joinpath, but intended for URLs.
190
188
 
191
189
    XXX: this duplicates some normalisation logic, and also duplicates a lot of
219
217
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
220
218
def _posix_local_path_from_url(url):
221
219
    """Convert a url like file:///path/to/foo into /path/to/foo"""
222
 
    if not url.startswith('file:///'):
223
 
        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://'):]
224
228
    # We only strip off 2 slashes
225
 
    return unescape(url[len('file://'):])
 
229
    return unescape(path)
226
230
 
227
231
 
228
232
def _posix_local_path_to_url(path):
230
234
 
231
235
    This also handles transforming escaping unicode characters, etc.
232
236
    """
233
 
    # importing directly from posixpath allows us to test this 
 
237
    # importing directly from posixpath allows us to test this
234
238
    # on non-posix platforms
235
239
    return 'file://' + escape(_posix_normpath(
236
240
        osutils._posix_abspath(path)))
254
258
    # allow empty paths so we can serve all roots
255
259
    if win32_url == '///':
256
260
        return '/'
257
 
    
 
261
 
258
262
    # usual local path with drive letter
259
263
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
260
264
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
270
274
 
271
275
    This also handles transforming escaping unicode characters, etc.
272
276
    """
273
 
    # importing directly from ntpath allows us to test this 
 
277
    # importing directly from ntpath allows us to test this
274
278
    # on non-win32 platform
275
279
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
276
280
    #       which actually strips trailing space characters.
305
309
 
306
310
def _unescape_safe_chars(matchobj):
307
311
    """re.sub callback to convert hex-escapes to plain characters (if safe).
308
 
    
 
312
 
309
313
    e.g. '%7E' will be converted to '~'.
310
314
    """
311
315
    hex_digits = matchobj.group(0)[1:]
318
322
 
319
323
def normalize_url(url):
320
324
    """Make sure that a path string is in fully normalized URL form.
321
 
    
 
325
 
322
326
    This handles URLs which have unicode characters, spaces,
323
327
    special characters, etc.
324
328
 
370
374
    dummy, base_first_slash = _find_scheme_and_separator(base)
371
375
    if base_first_slash is None:
372
376
        return other
373
 
    
 
377
 
374
378
    dummy, other_first_slash = _find_scheme_and_separator(other)
375
379
    if other_first_slash is None:
376
380
        return other
418
422
    # Strip off the drive letter
419
423
    # path is currently /C:/foo
420
424
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
421
 
        raise errors.InvalidURL(url_base + path, 
 
425
        raise errors.InvalidURL(url_base + path,
422
426
            'win32 file:/// paths need a drive letter')
423
427
    url_base += path[0:3] # file:// + /C:
424
428
    path = path[3:] # /foo
432
436
    :param exclude_trailing_slash: Strip off a final '/' if it is part
433
437
        of the path (but not if it is part of the protocol specification)
434
438
 
435
 
    :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
436
440
        the root.
437
441
    """
438
442
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
542
546
# These are characters that if escaped, should stay that way
543
547
_no_decode_chars = ';/?:@&=+$,#'
544
548
_no_decode_ords = [ord(c) for c in _no_decode_chars]
545
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
 
549
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
546
550
                + ['%02X' % o for o in _no_decode_ords])
547
551
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
548
552
                    + [('%02X' % o, chr(o)) for o in range(256)]))
574
578
    This will turn file:// urls into local paths, and try to decode
575
579
    any portions of a http:// style url that it can.
576
580
 
577
 
    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
578
582
    need to stay as escapes are left alone.
579
583
 
580
584
    :param url: A 7-bit ASCII URL
581
585
    :param encoding: The final output encoding
582
586
 
583
 
    :return: A unicode string which can be safely encoded into the 
 
587
    :return: A unicode string which can be safely encoded into the
584
588
         specified encoding.
585
589
    """
586
590
    if encoding is None:
687
691
    if len(segments) == 0:
688
692
        return '.'
689
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)