← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: John Arbash Meinel
  • Author(s): Mark Hammond
  • Date: 2008-09-09 17:02:21 UTC
  • mto: This revision was merged to the branch mainline in revision 3697.
  • Revision ID: john@arbash-meinel.com-20080909170221-svim3jw2mrz0amp3
An updated transparent icon for bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
1
 
# Copyright (C) 2006, 2008 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
 
66
68
        relpath = relpath.encode('utf-8')
67
69
    # After quoting and encoding, the path should be perfectly
68
70
    # safe as a plain ASCII string, str() just enforces this
69
 
    return str(urllib.quote(relpath, safe='/~'))
 
71
    return str(urllib.quote(relpath))
70
72
 
71
73
 
72
74
def file_relpath(base, path):
73
75
    """Compute just the relative sub-portion of a url
74
 
 
 
76
    
75
77
    This assumes that both paths are already fully specified file:// URLs.
76
78
    """
77
79
    if len(base) < MIN_ABS_FILEURL_LENGTH:
78
 
        raise ValueError('Length of base (%r) must equal or'
 
80
        raise ValueError('Length of base must be equal or'
79
81
            ' exceed the platform minimum url length (which is %d)' %
80
 
            (base, MIN_ABS_FILEURL_LENGTH))
 
82
            MIN_ABS_FILEURL_LENGTH)
81
83
    base = local_path_from_url(base)
82
84
    path = local_path_from_url(path)
83
85
    return escape(osutils.relpath(base, path))
183
185
 
184
186
def joinpath(base, *args):
185
187
    """Join URL path segments to a URL path segment.
186
 
 
 
188
    
187
189
    This is somewhat like osutils.joinpath, but intended for URLs.
188
190
 
189
191
    XXX: this duplicates some normalisation logic, and also duplicates a lot of
228
230
 
229
231
    This also handles transforming escaping unicode characters, etc.
230
232
    """
231
 
    # importing directly from posixpath allows us to test this
 
233
    # importing directly from posixpath allows us to test this 
232
234
    # on non-posix platforms
233
235
    return 'file://' + escape(_posix_normpath(
234
236
        osutils._posix_abspath(path)))
252
254
    # allow empty paths so we can serve all roots
253
255
    if win32_url == '///':
254
256
        return '/'
255
 
 
 
257
    
256
258
    # usual local path with drive letter
257
259
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
258
260
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
268
270
 
269
271
    This also handles transforming escaping unicode characters, etc.
270
272
    """
271
 
    # importing directly from ntpath allows us to test this
 
273
    # importing directly from ntpath allows us to test this 
272
274
    # on non-win32 platform
273
275
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
274
276
    #       which actually strips trailing space characters.
303
305
 
304
306
def _unescape_safe_chars(matchobj):
305
307
    """re.sub callback to convert hex-escapes to plain characters (if safe).
306
 
 
 
308
    
307
309
    e.g. '%7E' will be converted to '~'.
308
310
    """
309
311
    hex_digits = matchobj.group(0)[1:]
316
318
 
317
319
def normalize_url(url):
318
320
    """Make sure that a path string is in fully normalized URL form.
319
 
 
 
321
    
320
322
    This handles URLs which have unicode characters, spaces,
321
323
    special characters, etc.
322
324
 
368
370
    dummy, base_first_slash = _find_scheme_and_separator(base)
369
371
    if base_first_slash is None:
370
372
        return other
371
 
 
 
373
    
372
374
    dummy, other_first_slash = _find_scheme_and_separator(other)
373
375
    if other_first_slash is None:
374
376
        return other
416
418
    # Strip off the drive letter
417
419
    # path is currently /C:/foo
418
420
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
419
 
        raise errors.InvalidURL(url_base + path,
 
421
        raise errors.InvalidURL(url_base + path, 
420
422
            'win32 file:/// paths need a drive letter')
421
423
    url_base += path[0:3] # file:// + /C:
422
424
    path = path[3:] # /foo
430
432
    :param exclude_trailing_slash: Strip off a final '/' if it is part
431
433
        of the path (but not if it is part of the protocol specification)
432
434
 
433
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
 
435
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at 
434
436
        the root.
435
437
    """
436
438
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
540
542
# These are characters that if escaped, should stay that way
541
543
_no_decode_chars = ';/?:@&=+$,#'
542
544
_no_decode_ords = [ord(c) for c in _no_decode_chars]
543
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
 
545
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
544
546
                + ['%02X' % o for o in _no_decode_ords])
545
547
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
546
548
                    + [('%02X' % o, chr(o)) for o in range(256)]))
572
574
    This will turn file:// urls into local paths, and try to decode
573
575
    any portions of a http:// style url that it can.
574
576
 
575
 
    Any sections of the URL which can't be represented in the encoding or
 
577
    Any sections of the URL which can't be represented in the encoding or 
576
578
    need to stay as escapes are left alone.
577
579
 
578
580
    :param url: A 7-bit ASCII URL
579
581
    :param encoding: The final output encoding
580
582
 
581
 
    :return: A unicode string which can be safely encoded into the
 
583
    :return: A unicode string which can be safely encoded into the 
582
584
         specified encoding.
583
585
    """
584
586
    if encoding is None:
685
687
    if len(segments) == 0:
686
688
        return '.'
687
689
    return osutils.pathjoin(*segments)
688
 
 
689
 
 
690
 
 
691
 
def parse_url(url):
692
 
    """Extract the server address, the credentials and the path from the url.
693
 
 
694
 
    user, password, host and path should be quoted if they contain reserved
695
 
    chars.
696
 
 
697
 
    :param url: an quoted url
698
 
 
699
 
    :return: (scheme, user, password, host, port, path) tuple, all fields
700
 
        are unquoted.
701
 
    """
702
 
    if isinstance(url, unicode):
703
 
        raise errors.InvalidURL('should be ascii:\n%r' % url)
704
 
    url = url.encode('utf-8')
705
 
    (scheme, netloc, path, params,
706
 
     query, fragment) = urlparse.urlparse(url, allow_fragments=False)
707
 
    user = password = host = port = None
708
 
    if '@' in netloc:
709
 
        user, host = netloc.rsplit('@', 1)
710
 
        if ':' in user:
711
 
            user, password = user.split(':', 1)
712
 
            password = urllib.unquote(password)
713
 
        user = urllib.unquote(user)
714
 
    else:
715
 
        host = netloc
716
 
 
717
 
    if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port
718
 
        host, port = host.rsplit(':',1)
719
 
        try:
720
 
            port = int(port)
721
 
        except ValueError:
722
 
            raise errors.InvalidURL('invalid port number %s in url:\n%s' %
723
 
                                    (port, url))
724
 
    if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
725
 
        host = host[1:-1]
726
 
 
727
 
    host = urllib.unquote(host)
728
 
    path = urllib.unquote(path)
729
 
 
730
 
    return (scheme, user, password, host, port, path)