← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: Martin Pool
  • Date: 2010-06-11 07:25:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5309.
  • Revision ID: mbp@canonical.com-20100611072510-q4buzoxswzemg36m
Remove obsolete test helper; add a new local one

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
 
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.
277
 
    #       The worst part is that under linux ntpath.abspath has different
 
281
    #       The worst part is that on linux ntpath.abspath has different
278
282
    #       semantics, since 'nt' is not an available module.
279
283
    if path == '/':
280
284
        return 'file:///'
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)
465
469
    return url_base + head, tail
466
470
 
467
471
 
 
472
def split_segment_parameters_raw(url):
 
473
    """Split the subsegment of the last segment of a URL.
 
474
 
 
475
    :param url: A relative or absolute URL
 
476
    :return: (url, subsegments)
 
477
    """
 
478
    (parent_url, child_dir) = split(url)
 
479
    subsegments = child_dir.split(",")
 
480
    if len(subsegments) == 1:
 
481
        return (url, [])
 
482
    return (join(parent_url, subsegments[0]), subsegments[1:])
 
483
 
 
484
 
 
485
def split_segment_parameters(url):
 
486
    """Split the segment parameters of the last segment of a URL.
 
487
 
 
488
    :param url: A relative or absolute URL
 
489
    :return: (url, segment_parameters)
 
490
    """
 
491
    (base_url, subsegments) = split_segment_parameters_raw(url)
 
492
    parameters = {}
 
493
    for subsegment in subsegments:
 
494
        (key, value) = subsegment.split("=", 1)
 
495
        parameters[key] = value
 
496
    return (base_url, parameters)
 
497
 
 
498
 
 
499
def join_segment_parameters_raw(base, *subsegments):
 
500
    """Create a new URL by adding subsegments to an existing one. 
 
501
 
 
502
    This adds the specified subsegments to the last path in the specified
 
503
    base URL. The subsegments should be bytestrings.
 
504
 
 
505
    :note: You probably want to use join_segment_parameters instead.
 
506
    """
 
507
    if not subsegments:
 
508
        return base
 
509
    for subsegment in subsegments:
 
510
        if type(subsegment) is not str:
 
511
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
 
512
        if "," in subsegment:
 
513
            raise errors.InvalidURLJoin(", exists in subsegments",
 
514
                                        base, subsegments)
 
515
    return ",".join((base,) + subsegments)
 
516
 
 
517
 
 
518
def join_segment_parameters(url, parameters):
 
519
    """Create a new URL by adding segment parameters to an existing one.
 
520
 
 
521
    The parameters of the last segment in the URL will be updated; if a
 
522
    parameter with the same key already exists it will be overwritten.
 
523
 
 
524
    :param url: A URL, as string
 
525
    :param parameters: Dictionary of parameters, keys and values as bytestrings
 
526
    """
 
527
    (base, existing_parameters) = split_segment_parameters(url)
 
528
    new_parameters = {}
 
529
    new_parameters.update(existing_parameters)
 
530
    for key, value in parameters.iteritems():
 
531
        if type(key) is not str:
 
532
            raise TypeError("parameter key %r is not a bytestring" % key)
 
533
        if type(value) is not str:
 
534
            raise TypeError("parameter value %r for %s is not a bytestring" %
 
535
                (key, value))
 
536
        if "=" in key:
 
537
            raise errors.InvalidURLJoin("= exists in parameter key", url,
 
538
                parameters)
 
539
        new_parameters[key] = value
 
540
    return join_segment_parameters_raw(base, 
 
541
        *["%s=%s" % item for item in sorted(new_parameters.items())])
 
542
 
 
543
 
468
544
def _win32_strip_local_trailing_slash(url):
469
545
    """Strip slashes after the drive letter"""
470
546
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
542
618
# These are characters that if escaped, should stay that way
543
619
_no_decode_chars = ';/?:@&=+$,#'
544
620
_no_decode_ords = [ord(c) for c in _no_decode_chars]
545
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
 
621
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
546
622
                + ['%02X' % o for o in _no_decode_ords])
547
623
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
548
624
                    + [('%02X' % o, chr(o)) for o in range(256)]))
574
650
    This will turn file:// urls into local paths, and try to decode
575
651
    any portions of a http:// style url that it can.
576
652
 
577
 
    Any sections of the URL which can't be represented in the encoding or 
 
653
    Any sections of the URL which can't be represented in the encoding or
578
654
    need to stay as escapes are left alone.
579
655
 
580
656
    :param url: A 7-bit ASCII URL
581
657
    :param encoding: The final output encoding
582
658
 
583
 
    :return: A unicode string which can be safely encoded into the 
 
659
    :return: A unicode string which can be safely encoded into the
584
660
         specified encoding.
585
661
    """
586
662
    if encoding is None:
687
763
    if len(segments) == 0:
688
764
        return '.'
689
765
    return osutils.pathjoin(*segments)
 
766
 
 
767
 
 
768
 
 
769
def parse_url(url):
 
770
    """Extract the server address, the credentials and the path from the url.
 
771
 
 
772
    user, password, host and path should be quoted if they contain reserved
 
773
    chars.
 
774
 
 
775
    :param url: an quoted url
 
776
 
 
777
    :return: (scheme, user, password, host, port, path) tuple, all fields
 
778
        are unquoted.
 
779
    """
 
780
    if isinstance(url, unicode):
 
781
        raise errors.InvalidURL('should be ascii:\n%r' % url)
 
782
    url = url.encode('utf-8')
 
783
    (scheme, netloc, path, params,
 
784
     query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
785
    user = password = host = port = None
 
786
    if '@' in netloc:
 
787
        user, host = netloc.rsplit('@', 1)
 
788
        if ':' in user:
 
789
            user, password = user.split(':', 1)
 
790
            password = urllib.unquote(password)
 
791
        user = urllib.unquote(user)
 
792
    else:
 
793
        host = netloc
 
794
 
 
795
    if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port
 
796
        host, port = host.rsplit(':',1)
 
797
        try:
 
798
            port = int(port)
 
799
        except ValueError:
 
800
            raise errors.InvalidURL('invalid port number %s in url:\n%s' %
 
801
                                    (port, url))
 
802
    if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
 
803
        host = host[1:-1]
 
804
 
 
805
    host = urllib.unquote(host)
 
806
    path = urllib.unquote(path)
 
807
 
 
808
    return (scheme, user, password, host, port, path)