/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

Various small changes in aid of making tests pass (including deleting one invalid test).

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
1
 
# Copyright (C) 2006-2010 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
 
24
26
lazy_import(globals(), """
25
27
from posixpath import split as _posix_split, normpath as _posix_normpath
26
28
import urllib
27
 
import urlparse
28
29
 
29
30
from bzrlib import (
30
31
    errors,
66
67
        relpath = relpath.encode('utf-8')
67
68
    # After quoting and encoding, the path should be perfectly
68
69
    # safe as a plain ASCII string, str() just enforces this
69
 
    return str(urllib.quote(relpath, safe='/~'))
 
70
    return str(urllib.quote(relpath))
70
71
 
71
72
 
72
73
def file_relpath(base, path):
73
74
    """Compute just the relative sub-portion of a url
74
 
 
 
75
    
75
76
    This assumes that both paths are already fully specified file:// URLs.
76
77
    """
77
 
    if len(base) < MIN_ABS_FILEURL_LENGTH:
78
 
        raise ValueError('Length of base (%r) must equal or'
79
 
            ' exceed the platform minimum url length (which is %d)' %
80
 
            (base, MIN_ABS_FILEURL_LENGTH))
 
78
    assert len(base) >= MIN_ABS_FILEURL_LENGTH, ('Length of base must be equal or'
 
79
        ' exceed the platform minimum url length (which is %d)' % 
 
80
        MIN_ABS_FILEURL_LENGTH)
 
81
 
81
82
    base = local_path_from_url(base)
82
83
    path = local_path_from_url(path)
83
84
    return escape(osutils.relpath(base, path))
116
117
        join('http://foo', 'bar') => 'http://foo/bar'
117
118
        join('http://foo', 'bar', '../baz') => 'http://foo/baz'
118
119
    """
119
 
    if not args:
120
 
        return base
121
 
    match = _url_scheme_re.match(base)
 
120
    m = _url_scheme_re.match(base)
122
121
    scheme = None
123
 
    if match:
124
 
        scheme = match.group('scheme')
125
 
        path = match.group('path').split('/')
 
122
    if m:
 
123
        scheme = m.group('scheme')
 
124
        path = m.group('path').split('/')
126
125
        if path[-1:] == ['']:
127
126
            # Strip off a trailing slash
128
127
            # This helps both when we are at the root, and when
133
132
 
134
133
    if scheme is not None and len(path) >= 1:
135
134
        host = path[:1]
136
 
        # the path should be represented as an abs path.
137
 
        # we know this must be absolute because of the presence of a URL scheme.
138
 
        remove_root = True
139
 
        path = [''] + path[1:]
 
135
        path = path[1:]
140
136
    else:
141
 
        # create an empty host, but dont alter the path - this might be a
142
 
        # relative url fragment.
143
137
        host = []
144
 
        remove_root = False
145
 
 
146
138
    for arg in args:
147
 
        match = _url_scheme_re.match(arg)
148
 
        if match:
 
139
        m = _url_scheme_re.match(arg)
 
140
        if m:
149
141
            # Absolute URL
150
 
            scheme = match.group('scheme')
 
142
            scheme = m.group('scheme')
151
143
            # this skips .. normalisation, making http://host/../../..
152
144
            # be rather strange.
153
 
            path = match.group('path').split('/')
 
145
            path = m.group('path').split('/')
154
146
            # set the host and path according to new absolute URL, discarding
155
147
            # any previous values.
156
148
            # XXX: duplicates mess from earlier in this function.  This URL
158
150
            if scheme is not None and len(path) >= 1:
159
151
                host = path[:1]
160
152
                path = path[1:]
161
 
                # url scheme implies absolute path.
162
 
                path = [''] + path
163
153
            else:
164
 
                # no url scheme we take the path as is.
165
154
                host = []
166
155
        else:
167
156
            path = '/'.join(path)
168
157
            path = joinpath(path, arg)
169
158
            path = path.split('/')
170
 
    if remove_root and path[0:1] == ['']:
171
 
        del path[0]
172
159
    if host:
173
160
        # Remove the leading slash from the path, so long as it isn't also the
174
161
        # trailing slash, which we want to keep if present.
183
170
 
184
171
def joinpath(base, *args):
185
172
    """Join URL path segments to a URL path segment.
186
 
 
 
173
    
187
174
    This is somewhat like osutils.joinpath, but intended for URLs.
188
175
 
189
176
    XXX: this duplicates some normalisation logic, and also duplicates a lot of
191
178
    We really should try to have exactly one place in the code base responsible
192
179
    for combining paths of URLs.
193
180
    """
194
 
    path = base.split('/')
195
 
    if len(path) > 1 and path[-1] == '':
196
 
        #If the path ends in a trailing /, remove it.
197
 
        path.pop()
 
181
    if base == '/':
 
182
        path = ['']
 
183
    else:
 
184
        base = base.rstrip('/')
 
185
        path = base.split('/')
198
186
    for arg in args:
199
187
        if arg.startswith('/'):
200
188
            path = []
217
205
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
218
206
def _posix_local_path_from_url(url):
219
207
    """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://'):]
 
208
    if not url.startswith('file:///'):
 
209
        raise errors.InvalidURL(url, 'local urls must start with file:///')
228
210
    # We only strip off 2 slashes
229
 
    return unescape(path)
 
211
    return unescape(url[len('file://'):])
230
212
 
231
213
 
232
214
def _posix_local_path_to_url(path):
234
216
 
235
217
    This also handles transforming escaping unicode characters, etc.
236
218
    """
237
 
    # importing directly from posixpath allows us to test this
 
219
    # importing directly from posixpath allows us to test this 
238
220
    # on non-posix platforms
239
221
    return 'file://' + escape(_posix_normpath(
240
222
        osutils._posix_abspath(path)))
254
236
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
255
237
                ' have form file://HOST/path')
256
238
        return unescape(win32_url)
257
 
 
258
 
    # allow empty paths so we can serve all roots
259
 
    if win32_url == '///':
260
 
        return '/'
261
 
 
262
239
    # usual local path with drive letter
263
240
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
264
241
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
274
251
 
275
252
    This also handles transforming escaping unicode characters, etc.
276
253
    """
277
 
    # importing directly from ntpath allows us to test this
 
254
    # importing directly from ntpath allows us to test this 
278
255
    # on non-win32 platform
279
256
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
280
257
    #       which actually strips trailing space characters.
281
258
    #       The worst part is that under linux ntpath.abspath has different
282
259
    #       semantics, since 'nt' is not an available module.
283
 
    if path == '/':
284
 
        return 'file:///'
285
 
 
286
260
    win32_path = osutils._win32_abspath(path)
287
261
    # check for UNC path \\HOST\path
288
262
    if win32_path.startswith('//'):
289
263
        return 'file:' + escape(win32_path)
290
 
    return ('file:///' + str(win32_path[0].upper()) + ':' +
291
 
        escape(win32_path[2:]))
 
264
    return 'file:///' + win32_path[0].upper() + ':' + escape(win32_path[2:])
292
265
 
293
266
 
294
267
local_path_to_url = _posix_local_path_to_url
304
277
 
305
278
 
306
279
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
307
 
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
308
 
 
309
 
 
310
 
def _unescape_safe_chars(matchobj):
311
 
    """re.sub callback to convert hex-escapes to plain characters (if safe).
312
 
 
313
 
    e.g. '%7E' will be converted to '~'.
314
 
    """
315
 
    hex_digits = matchobj.group(0)[1:]
316
 
    char = chr(int(hex_digits, 16))
317
 
    if char in _url_dont_escape_characters:
318
 
        return char
319
 
    else:
320
 
        return matchobj.group(0).upper()
321
280
 
322
281
 
323
282
def normalize_url(url):
324
283
    """Make sure that a path string is in fully normalized URL form.
325
 
 
326
 
    This handles URLs which have unicode characters, spaces,
 
284
    
 
285
    This handles URLs which have unicode characters, spaces, 
327
286
    special characters, etc.
328
287
 
329
288
    It has two basic modes of operation, depending on whether the
342
301
    m = _url_scheme_re.match(url)
343
302
    if not m:
344
303
        return local_path_to_url(url)
345
 
    scheme = m.group('scheme')
346
 
    path = m.group('path')
347
304
    if not isinstance(url, unicode):
348
305
        for c in url:
349
306
            if c not in _url_safe_characters:
350
307
                raise errors.InvalidURL(url, 'URLs can only contain specific'
351
308
                                            ' safe characters (not %r)' % c)
352
 
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
353
 
        return str(scheme + '://' + ''.join(path))
354
 
 
 
309
        return url
355
310
    # We have a unicode (hybrid) url
356
 
    path_chars = list(path)
 
311
    scheme = m.group('scheme')
 
312
    path = list(m.group('path'))
357
313
 
358
 
    for i in xrange(len(path_chars)):
359
 
        if path_chars[i] not in _url_safe_characters:
360
 
            chars = path_chars[i].encode('utf-8')
361
 
            path_chars[i] = ''.join(
362
 
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
363
 
    path = ''.join(path_chars)
364
 
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
365
 
    return str(scheme + '://' + path)
 
314
    for i in xrange(len(path)):
 
315
        if path[i] not in _url_safe_characters:
 
316
            chars = path[i].encode('utf-8')
 
317
            path[i] = ''.join(['%%%02X' % ord(c) for c in path[i].encode('utf-8')])
 
318
    return str(scheme + '://' + ''.join(path))
366
319
 
367
320
 
368
321
def relative_url(base, other):
374
327
    dummy, base_first_slash = _find_scheme_and_separator(base)
375
328
    if base_first_slash is None:
376
329
        return other
377
 
 
 
330
    
378
331
    dummy, other_first_slash = _find_scheme_and_separator(other)
379
332
    if other_first_slash is None:
380
333
        return other
384
337
    other_scheme = other[:other_first_slash]
385
338
    if base_scheme != other_scheme:
386
339
        return other
387
 
    elif sys.platform == 'win32' and base_scheme == 'file://':
388
 
        base_drive = base[base_first_slash+1:base_first_slash+3]
389
 
        other_drive = other[other_first_slash+1:other_first_slash+3]
390
 
        if base_drive != other_drive:
391
 
            return other
392
340
 
393
341
    base_path = base[base_first_slash+1:]
394
342
    other_path = other[other_first_slash+1:]
422
370
    # Strip off the drive letter
423
371
    # path is currently /C:/foo
424
372
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
425
 
        raise errors.InvalidURL(url_base + path,
 
373
        raise errors.InvalidURL(url_base + path, 
426
374
            'win32 file:/// paths need a drive letter')
427
375
    url_base += path[0:3] # file:// + /C:
428
376
    path = path[3:] # /foo
436
384
    :param exclude_trailing_slash: Strip off a final '/' if it is part
437
385
        of the path (but not if it is part of the protocol specification)
438
386
 
439
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
 
387
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at 
440
388
        the root.
441
389
    """
442
390
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
546
494
# These are characters that if escaped, should stay that way
547
495
_no_decode_chars = ';/?:@&=+$,#'
548
496
_no_decode_ords = [ord(c) for c in _no_decode_chars]
549
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
 
497
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
550
498
                + ['%02X' % o for o in _no_decode_ords])
551
499
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
552
500
                    + [('%02X' % o, chr(o)) for o in range(256)]))
553
501
#These entries get mapped to themselves
554
502
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
555
503
 
556
 
# These characters shouldn't be percent-encoded, and it's always safe to
557
 
# unencode them if they are.
558
 
_url_dont_escape_characters = set(
559
 
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
560
 
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
561
 
   "0123456789" # Numbers
562
 
   "-._~"  # Unreserved characters
563
 
)
564
 
 
565
504
# These characters should not be escaped
566
505
_url_safe_characters = set(
567
506
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
578
517
    This will turn file:// urls into local paths, and try to decode
579
518
    any portions of a http:// style url that it can.
580
519
 
581
 
    Any sections of the URL which can't be represented in the encoding or
 
520
    Any sections of the URL which can't be represented in the encoding or 
582
521
    need to stay as escapes are left alone.
583
522
 
584
523
    :param url: A 7-bit ASCII URL
585
524
    :param encoding: The final output encoding
586
525
 
587
 
    :return: A unicode string which can be safely encoded into the
 
526
    :return: A unicode string which can be safely encoded into the 
588
527
         specified encoding.
589
528
    """
590
 
    if encoding is None:
591
 
        raise ValueError('you cannot specify None for the display encoding')
 
529
    assert encoding is not None, 'you cannot specify None for the display encoding.'
592
530
    if url.startswith('file://'):
593
531
        try:
594
532
            path = local_path_from_url(url)
628
566
                # Otherwise take the url decoded one
629
567
                res[i] = decoded
630
568
    return u'/'.join(res)
631
 
 
632
 
 
633
 
def derive_to_location(from_location):
634
 
    """Derive a TO_LOCATION given a FROM_LOCATION.
635
 
 
636
 
    The normal case is a FROM_LOCATION of http://foo/bar => bar.
637
 
    The Right Thing for some logical destinations may differ though
638
 
    because no / may be present at all. In that case, the result is
639
 
    the full name without the scheme indicator, e.g. lp:foo-bar => foo-bar.
640
 
    This latter case also applies when a Windows drive
641
 
    is used without a path, e.g. c:foo-bar => foo-bar.
642
 
    If no /, path separator or : is found, the from_location is returned.
643
 
    """
644
 
    if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
645
 
        return os.path.basename(from_location.rstrip("/\\"))
646
 
    else:
647
 
        sep = from_location.find(":")
648
 
        if sep > 0:
649
 
            return from_location[sep+1:]
650
 
        else:
651
 
            return from_location
652
 
 
653
 
 
654
 
def _is_absolute(url):
655
 
    return (osutils.pathjoin('/foo', url) == url)
656
 
 
657
 
 
658
 
def rebase_url(url, old_base, new_base):
659
 
    """Convert a relative path from an old base URL to a new base URL.
660
 
 
661
 
    The result will be a relative path.
662
 
    Absolute paths and full URLs are returned unaltered.
663
 
    """
664
 
    scheme, separator = _find_scheme_and_separator(url)
665
 
    if scheme is not None:
666
 
        return url
667
 
    if _is_absolute(url):
668
 
        return url
669
 
    old_parsed = urlparse.urlparse(old_base)
670
 
    new_parsed = urlparse.urlparse(new_base)
671
 
    if (old_parsed[:2]) != (new_parsed[:2]):
672
 
        raise errors.InvalidRebaseURLs(old_base, new_base)
673
 
    return determine_relative_path(new_parsed[2],
674
 
                                   join(old_parsed[2], url))
675
 
 
676
 
 
677
 
def determine_relative_path(from_path, to_path):
678
 
    """Determine a relative path from from_path to to_path."""
679
 
    from_segments = osutils.splitpath(from_path)
680
 
    to_segments = osutils.splitpath(to_path)
681
 
    count = -1
682
 
    for count, (from_element, to_element) in enumerate(zip(from_segments,
683
 
                                                       to_segments)):
684
 
        if from_element != to_element:
685
 
            break
686
 
    else:
687
 
        count += 1
688
 
    unique_from = from_segments[count:]
689
 
    unique_to = to_segments[count:]
690
 
    segments = (['..'] * len(unique_from) + unique_to)
691
 
    if len(segments) == 0:
692
 
        return '.'
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)