← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-02-23 17:00:36 UTC
  • mfrom: (4032.1.4 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090223170036-3q1v68ewdt8i0to5
(Marius Kruger) Remove all trailing whitespace and add tests to
        enforce this.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
73
73
 
74
74
def file_relpath(base, path):
75
75
    """Compute just the relative sub-portion of a url
76
 
    
 
76
 
77
77
    This assumes that both paths are already fully specified file:// URLs.
78
78
    """
79
79
    if len(base) < MIN_ABS_FILEURL_LENGTH:
185
185
 
186
186
def joinpath(base, *args):
187
187
    """Join URL path segments to a URL path segment.
188
 
    
 
188
 
189
189
    This is somewhat like osutils.joinpath, but intended for URLs.
190
190
 
191
191
    XXX: this duplicates some normalisation logic, and also duplicates a lot of
230
230
 
231
231
    This also handles transforming escaping unicode characters, etc.
232
232
    """
233
 
    # importing directly from posixpath allows us to test this 
 
233
    # importing directly from posixpath allows us to test this
234
234
    # on non-posix platforms
235
235
    return 'file://' + escape(_posix_normpath(
236
236
        osutils._posix_abspath(path)))
254
254
    # allow empty paths so we can serve all roots
255
255
    if win32_url == '///':
256
256
        return '/'
257
 
    
 
257
 
258
258
    # usual local path with drive letter
259
259
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
260
260
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
270
270
 
271
271
    This also handles transforming escaping unicode characters, etc.
272
272
    """
273
 
    # importing directly from ntpath allows us to test this 
 
273
    # importing directly from ntpath allows us to test this
274
274
    # on non-win32 platform
275
275
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
276
276
    #       which actually strips trailing space characters.
305
305
 
306
306
def _unescape_safe_chars(matchobj):
307
307
    """re.sub callback to convert hex-escapes to plain characters (if safe).
308
 
    
 
308
 
309
309
    e.g. '%7E' will be converted to '~'.
310
310
    """
311
311
    hex_digits = matchobj.group(0)[1:]
318
318
 
319
319
def normalize_url(url):
320
320
    """Make sure that a path string is in fully normalized URL form.
321
 
    
 
321
 
322
322
    This handles URLs which have unicode characters, spaces,
323
323
    special characters, etc.
324
324
 
370
370
    dummy, base_first_slash = _find_scheme_and_separator(base)
371
371
    if base_first_slash is None:
372
372
        return other
373
 
    
 
373
 
374
374
    dummy, other_first_slash = _find_scheme_and_separator(other)
375
375
    if other_first_slash is None:
376
376
        return other
418
418
    # Strip off the drive letter
419
419
    # path is currently /C:/foo
420
420
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
421
 
        raise errors.InvalidURL(url_base + path, 
 
421
        raise errors.InvalidURL(url_base + path,
422
422
            'win32 file:/// paths need a drive letter')
423
423
    url_base += path[0:3] # file:// + /C:
424
424
    path = path[3:] # /foo
432
432
    :param exclude_trailing_slash: Strip off a final '/' if it is part
433
433
        of the path (but not if it is part of the protocol specification)
434
434
 
435
 
    :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
436
436
        the root.
437
437
    """
438
438
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
542
542
# These are characters that if escaped, should stay that way
543
543
_no_decode_chars = ';/?:@&=+$,#'
544
544
_no_decode_ords = [ord(c) for c in _no_decode_chars]
545
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
 
545
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
546
546
                + ['%02X' % o for o in _no_decode_ords])
547
547
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
548
548
                    + [('%02X' % o, chr(o)) for o in range(256)]))
574
574
    This will turn file:// urls into local paths, and try to decode
575
575
    any portions of a http:// style url that it can.
576
576
 
577
 
    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
578
578
    need to stay as escapes are left alone.
579
579
 
580
580
    :param url: A 7-bit ASCII URL
581
581
    :param encoding: The final output encoding
582
582
 
583
 
    :return: A unicode string which can be safely encoded into the 
 
583
    :return: A unicode string which can be safely encoded into the
584
584
         specified encoding.
585
585
    """
586
586
    if encoding is None: