← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: Mark Hammond
  • Date: 2008-08-10 11:16:39 UTC
  • mto: (3606.5.3 1.6)
  • mto: This revision was merged to the branch mainline in revision 3626.
  • Revision ID: mhammond@skippinet.com.au-20080810111639-9upz1wig1s8lvz62
install all files with 'restartreplace uninsrestartdelete' and close
tbzrcache at uninstall time.

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