/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

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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 by 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
 
21
19
import os
22
 
from posixpath import split as _posix_split, normpath as _posix_normpath
23
20
import re
24
21
import sys
 
22
 
 
23
from bzrlib.lazy_import import lazy_import
 
24
lazy_import(globals(), """
 
25
from posixpath import split as _posix_split, normpath as _posix_normpath
25
26
import urllib
 
27
import urlparse
26
28
 
27
 
import bzrlib.errors as errors
28
 
import bzrlib.osutils
 
29
from bzrlib import (
 
30
    errors,
 
31
    osutils,
 
32
    )
 
33
""")
29
34
 
30
35
 
31
36
def basename(url, exclude_trailing_slash=True):
61
66
        relpath = relpath.encode('utf-8')
62
67
    # After quoting and encoding, the path should be perfectly
63
68
    # safe as a plain ASCII string, str() just enforces this
64
 
    return str(urllib.quote(relpath))
 
69
    return str(urllib.quote(relpath, safe='/~'))
65
70
 
66
71
 
67
72
def file_relpath(base, path):
68
73
    """Compute just the relative sub-portion of a url
69
 
    
 
74
 
70
75
    This assumes that both paths are already fully specified file:// URLs.
71
76
    """
72
 
    assert len(base) >= MIN_ABS_FILEURL_LENGTH, ('Length of base must be equal or'
73
 
        ' exceed the platform minimum url length (which is %d)' % 
74
 
        MIN_ABS_FILEURL_LENGTH)
75
 
 
 
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))
76
81
    base = local_path_from_url(base)
77
82
    path = local_path_from_url(path)
78
 
    return escape(bzrlib.osutils.relpath(base, path))
 
83
    return escape(osutils.relpath(base, path))
79
84
 
80
85
 
81
86
def _find_scheme_and_separator(url):
111
116
        join('http://foo', 'bar') => 'http://foo/bar'
112
117
        join('http://foo', 'bar', '../baz') => 'http://foo/baz'
113
118
    """
114
 
    m = _url_scheme_re.match(base)
 
119
    if not args:
 
120
        return base
 
121
    match = _url_scheme_re.match(base)
115
122
    scheme = None
116
 
    if m:
117
 
        scheme = m.group('scheme')
118
 
        path = m.group('path').split('/')
 
123
    if match:
 
124
        scheme = match.group('scheme')
 
125
        path = match.group('path').split('/')
119
126
        if path[-1:] == ['']:
120
127
            # Strip off a trailing slash
121
128
            # This helps both when we are at the root, and when
124
131
    else:
125
132
        path = base.split('/')
126
133
 
 
134
    if scheme is not None and len(path) >= 1:
 
135
        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:]
 
140
    else:
 
141
        # create an empty host, but dont alter the path - this might be a
 
142
        # relative url fragment.
 
143
        host = []
 
144
        remove_root = False
 
145
 
127
146
    for arg in args:
128
 
        m = _url_scheme_re.match(arg)
129
 
        if m:
 
147
        match = _url_scheme_re.match(arg)
 
148
        if match:
130
149
            # Absolute URL
131
 
            scheme = m.group('scheme')
 
150
            scheme = match.group('scheme')
132
151
            # this skips .. normalisation, making http://host/../../..
133
152
            # be rather strange.
134
 
            path = m.group('path').split('/')
 
153
            path = match.group('path').split('/')
 
154
            # set the host and path according to new absolute URL, discarding
 
155
            # any previous values.
 
156
            # XXX: duplicates mess from earlier in this function.  This URL
 
157
            # manipulation code needs some cleaning up.
 
158
            if scheme is not None and len(path) >= 1:
 
159
                host = path[:1]
 
160
                path = path[1:]
 
161
                # url scheme implies absolute path.
 
162
                path = [''] + path
 
163
            else:
 
164
                # no url scheme we take the path as is.
 
165
                host = []
135
166
        else:
136
 
            for chunk in arg.split('/'):
137
 
                if chunk == '.':
138
 
                    continue
139
 
                elif chunk == '..':
140
 
                    if len(path) >= 2:
141
 
                        # Don't pop off the host portion
142
 
                        path.pop()
143
 
                    else:
144
 
                        raise errors.InvalidURLJoin('Cannot go above root',
145
 
                                base, args)
146
 
                else:
147
 
                    path.append(chunk)
 
167
            path = '/'.join(path)
 
168
            path = joinpath(path, arg)
 
169
            path = path.split('/')
 
170
    if remove_root and path[0:1] == ['']:
 
171
        del path[0]
 
172
    if host:
 
173
        # Remove the leading slash from the path, so long as it isn't also the
 
174
        # trailing slash, which we want to keep if present.
 
175
        if path and path[0] == '' and len(path) > 1:
 
176
            del path[0]
 
177
        path = host + path
148
178
 
149
179
    if scheme is None:
150
180
        return '/'.join(path)
151
181
    return scheme + '://' + '/'.join(path)
152
182
 
153
183
 
 
184
def joinpath(base, *args):
 
185
    """Join URL path segments to a URL path segment.
 
186
 
 
187
    This is somewhat like osutils.joinpath, but intended for URLs.
 
188
 
 
189
    XXX: this duplicates some normalisation logic, and also duplicates a lot of
 
190
    path handling logic that already exists in some Transport implementations.
 
191
    We really should try to have exactly one place in the code base responsible
 
192
    for combining paths of URLs.
 
193
    """
 
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()
 
198
    for arg in args:
 
199
        if arg.startswith('/'):
 
200
            path = []
 
201
        for chunk in arg.split('/'):
 
202
            if chunk == '.':
 
203
                continue
 
204
            elif chunk == '..':
 
205
                if path == ['']:
 
206
                    raise errors.InvalidURLJoin('Cannot go above root',
 
207
                            base, args)
 
208
                path.pop()
 
209
            else:
 
210
                path.append(chunk)
 
211
    if path == ['']:
 
212
        return '/'
 
213
    else:
 
214
        return '/'.join(path)
 
215
 
 
216
 
154
217
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
155
218
def _posix_local_path_from_url(url):
156
219
    """Convert a url like file:///path/to/foo into /path/to/foo"""
157
 
    if not url.startswith('file:///'):
158
 
        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://'):]
159
228
    # We only strip off 2 slashes
160
 
    return unescape(url[len('file://'):])
 
229
    return unescape(path)
161
230
 
162
231
 
163
232
def _posix_local_path_to_url(path):
165
234
 
166
235
    This also handles transforming escaping unicode characters, etc.
167
236
    """
168
 
    # importing directly from posixpath allows us to test this 
 
237
    # importing directly from posixpath allows us to test this
169
238
    # on non-posix platforms
170
239
    return 'file://' + escape(_posix_normpath(
171
 
        bzrlib.osutils._posix_abspath(path)))
 
240
        osutils._posix_abspath(path)))
172
241
 
173
242
 
174
243
def _win32_local_path_from_url(url):
175
244
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
176
 
    if not url.startswith('file:///'):
177
 
        raise errors.InvalidURL(url, 'local urls must start with file:///')
 
245
    if not url.startswith('file://'):
 
246
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
 
247
                                     'UNC path urls must start with file://')
178
248
    # We strip off all 3 slashes
179
 
    win32_url = url[len('file:///'):]
180
 
    if (win32_url[0] not in ('abcdefghijklmnopqrstuvwxyz'
 
249
    win32_url = url[len('file:'):]
 
250
    # check for UNC path: //HOST/path
 
251
    if not win32_url.startswith('///'):
 
252
        if (win32_url[2] == '/'
 
253
            or win32_url[3] in '|:'):
 
254
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
 
255
                ' have form file://HOST/path')
 
256
        return unescape(win32_url)
 
257
 
 
258
    # allow empty paths so we can serve all roots
 
259
    if win32_url == '///':
 
260
        return '/'
 
261
 
 
262
    # usual local path with drive letter
 
263
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
181
264
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
182
 
        or win32_url[1] not in  '|:'
183
 
        or win32_url[2] != '/'):
 
265
        or win32_url[4] not in  '|:'
 
266
        or win32_url[5] != '/'):
184
267
        raise errors.InvalidURL(url, 'Win32 file urls start with'
185
268
                ' file:///x:/, where x is a valid drive letter')
186
 
    return win32_url[0].upper() + u':' + unescape(win32_url[2:])
 
269
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
187
270
 
188
271
 
189
272
def _win32_local_path_to_url(path):
191
274
 
192
275
    This also handles transforming escaping unicode characters, etc.
193
276
    """
194
 
    # importing directly from ntpath allows us to test this 
 
277
    # importing directly from ntpath allows us to test this
195
278
    # on non-win32 platform
196
279
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
197
280
    #       which actually strips trailing space characters.
198
281
    #       The worst part is that under linux ntpath.abspath has different
199
282
    #       semantics, since 'nt' is not an available module.
200
 
    win32_path = bzrlib.osutils._nt_normpath(
201
 
        bzrlib.osutils._win32_abspath(path)).replace('\\', '/')
202
 
    return 'file:///' + win32_path[0].upper() + ':' + escape(win32_path[2:])
 
283
    if path == '/':
 
284
        return 'file:///'
 
285
 
 
286
    win32_path = osutils._win32_abspath(path)
 
287
    # check for UNC path \\HOST\path
 
288
    if win32_path.startswith('//'):
 
289
        return 'file:' + escape(win32_path)
 
290
    return ('file:///' + str(win32_path[0].upper()) + ':' +
 
291
        escape(win32_path[2:]))
203
292
 
204
293
 
205
294
local_path_to_url = _posix_local_path_to_url
215
304
 
216
305
 
217
306
_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()
218
321
 
219
322
 
220
323
def normalize_url(url):
221
324
    """Make sure that a path string is in fully normalized URL form.
222
 
    
223
 
    This handles URLs which have unicode characters, spaces, 
 
325
 
 
326
    This handles URLs which have unicode characters, spaces,
224
327
    special characters, etc.
225
328
 
226
329
    It has two basic modes of operation, depending on whether the
239
342
    m = _url_scheme_re.match(url)
240
343
    if not m:
241
344
        return local_path_to_url(url)
 
345
    scheme = m.group('scheme')
 
346
    path = m.group('path')
242
347
    if not isinstance(url, unicode):
243
348
        for c in url:
244
349
            if c not in _url_safe_characters:
245
350
                raise errors.InvalidURL(url, 'URLs can only contain specific'
246
351
                                            ' safe characters (not %r)' % c)
247
 
        return url
 
352
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
 
353
        return str(scheme + '://' + ''.join(path))
 
354
 
248
355
    # We have a unicode (hybrid) url
249
 
    scheme = m.group('scheme')
250
 
    path = list(m.group('path'))
 
356
    path_chars = list(path)
251
357
 
252
 
    for i in xrange(len(path)):
253
 
        if path[i] not in _url_safe_characters:
254
 
            chars = path[i].encode('utf-8')
255
 
            path[i] = ''.join(['%%%02X' % ord(c) for c in path[i].encode('utf-8')])
256
 
    return scheme + '://' + ''.join(path)
 
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)
257
366
 
258
367
 
259
368
def relative_url(base, other):
265
374
    dummy, base_first_slash = _find_scheme_and_separator(base)
266
375
    if base_first_slash is None:
267
376
        return other
268
 
    
 
377
 
269
378
    dummy, other_first_slash = _find_scheme_and_separator(other)
270
379
    if other_first_slash is None:
271
380
        return other
275
384
    other_scheme = other[:other_first_slash]
276
385
    if base_scheme != other_scheme:
277
386
        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
278
392
 
279
393
    base_path = base[base_first_slash+1:]
280
394
    other_path = other[other_first_slash+1:]
308
422
    # Strip off the drive letter
309
423
    # path is currently /C:/foo
310
424
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
311
 
        raise errors.InvalidURL(url_base + path, 
 
425
        raise errors.InvalidURL(url_base + path,
312
426
            'win32 file:/// paths need a drive letter')
313
427
    url_base += path[0:3] # file:// + /C:
314
428
    path = path[3:] # /foo
322
436
    :param exclude_trailing_slash: Strip off a final '/' if it is part
323
437
        of the path (but not if it is part of the protocol specification)
324
438
 
325
 
    :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
326
440
        the root.
327
441
    """
328
442
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
387
501
    if not url.endswith('/'):
388
502
        # Nothing to do
389
503
        return url
390
 
    if sys.platform == 'win32' and url.startswith('file:///'):
 
504
    if sys.platform == 'win32' and url.startswith('file://'):
391
505
        return _win32_strip_local_trailing_slash(url)
392
506
 
393
507
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
432
546
# These are characters that if escaped, should stay that way
433
547
_no_decode_chars = ';/?:@&=+$,#'
434
548
_no_decode_ords = [ord(c) for c in _no_decode_chars]
435
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
 
549
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
436
550
                + ['%02X' % o for o in _no_decode_ords])
437
551
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
438
552
                    + [('%02X' % o, chr(o)) for o in range(256)]))
439
553
#These entries get mapped to themselves
440
554
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
441
555
 
 
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
 
442
565
# These characters should not be escaped
443
 
_url_safe_characters = set('abcdefghijklmnopqrstuvwxyz'
444
 
                        'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
445
 
                        '0123456789' '_.-/'
446
 
                        ';?:@&=+$,%#')
447
 
 
 
566
_url_safe_characters = set(
 
567
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
 
568
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
 
569
   "0123456789" # Numbers
 
570
   "_.-!~*'()"  # Unreserved characters
 
571
   "/;?:@&=+$," # Reserved characters
 
572
   "%#"         # Extra reserved characters
 
573
)
448
574
 
449
575
def unescape_for_display(url, encoding):
450
576
    """Decode what you can for a URL, so that we get a nice looking path.
452
578
    This will turn file:// urls into local paths, and try to decode
453
579
    any portions of a http:// style url that it can.
454
580
 
455
 
    Any sections of the URL which can't be represented in the encoding or 
 
581
    Any sections of the URL which can't be represented in the encoding or
456
582
    need to stay as escapes are left alone.
457
583
 
458
584
    :param url: A 7-bit ASCII URL
459
585
    :param encoding: The final output encoding
460
586
 
461
 
    :return: A unicode string which can be safely encoded into the 
 
587
    :return: A unicode string which can be safely encoded into the
462
588
         specified encoding.
463
589
    """
464
 
    assert encoding is not None, 'you cannot specify None for the display encoding.'
 
590
    if encoding is None:
 
591
        raise ValueError('you cannot specify None for the display encoding')
465
592
    if url.startswith('file://'):
466
593
        try:
467
594
            path = local_path_from_url(url)
501
628
                # Otherwise take the url decoded one
502
629
                res[i] = decoded
503
630
    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)