/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: 2007-03-01 01:02:30 UTC
  • mto: (2255.11.3 dirstate)
  • mto: This revision was merged to the branch mainline in revision 2322.
  • Revision ID: robertc@robertcollins.net-20070301010230-fh8p34iloqh7ua5j
Dont use a basis tree that is not in the tree's parents for revert testing - its not guaranteed usable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
131
130
    else:
132
131
        path = base.split('/')
133
132
 
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
 
 
146
133
    for arg in args:
147
 
        match = _url_scheme_re.match(arg)
148
 
        if match:
 
134
        m = _url_scheme_re.match(arg)
 
135
        if m:
149
136
            # Absolute URL
150
 
            scheme = match.group('scheme')
 
137
            scheme = m.group('scheme')
151
138
            # this skips .. normalisation, making http://host/../../..
152
139
            # be rather strange.
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 = []
 
140
            path = m.group('path').split('/')
166
141
        else:
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
 
142
            for chunk in arg.split('/'):
 
143
                if chunk == '.':
 
144
                    continue
 
145
                elif chunk == '..':
 
146
                    if len(path) >= 2:
 
147
                        # Don't pop off the host portion
 
148
                        path.pop()
 
149
                    else:
 
150
                        raise errors.InvalidURLJoin('Cannot go above root',
 
151
                                base, args)
 
152
                else:
 
153
                    path.append(chunk)
178
154
 
179
155
    if scheme is None:
180
156
        return '/'.join(path)
181
157
    return scheme + '://' + '/'.join(path)
182
158
 
183
159
 
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
 
 
217
160
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
218
161
def _posix_local_path_from_url(url):
219
162
    """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://'):]
 
163
    if not url.startswith('file:///'):
 
164
        raise errors.InvalidURL(url, 'local urls must start with file:///')
228
165
    # We only strip off 2 slashes
229
 
    return unescape(path)
 
166
    return unescape(url[len('file://'):])
230
167
 
231
168
 
232
169
def _posix_local_path_to_url(path):
234
171
 
235
172
    This also handles transforming escaping unicode characters, etc.
236
173
    """
237
 
    # importing directly from posixpath allows us to test this
 
174
    # importing directly from posixpath allows us to test this 
238
175
    # on non-posix platforms
239
176
    return 'file://' + escape(_posix_normpath(
240
177
        osutils._posix_abspath(path)))
254
191
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
255
192
                ' have form file://HOST/path')
256
193
        return unescape(win32_url)
257
 
 
258
 
    # allow empty paths so we can serve all roots
259
 
    if win32_url == '///':
260
 
        return '/'
261
 
 
262
194
    # usual local path with drive letter
263
195
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
264
196
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
274
206
 
275
207
    This also handles transforming escaping unicode characters, etc.
276
208
    """
277
 
    # importing directly from ntpath allows us to test this
 
209
    # importing directly from ntpath allows us to test this 
278
210
    # on non-win32 platform
279
211
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
280
212
    #       which actually strips trailing space characters.
281
 
    #       The worst part is that on linux ntpath.abspath has different
 
213
    #       The worst part is that under linux ntpath.abspath has different
282
214
    #       semantics, since 'nt' is not an available module.
283
 
    if path == '/':
284
 
        return 'file:///'
285
 
 
286
215
    win32_path = osutils._win32_abspath(path)
287
216
    # check for UNC path \\HOST\path
288
217
    if win32_path.startswith('//'):
289
218
        return 'file:' + escape(win32_path)
290
 
    return ('file:///' + str(win32_path[0].upper()) + ':' +
291
 
        escape(win32_path[2:]))
 
219
    return 'file:///' + win32_path[0].upper() + ':' + escape(win32_path[2:])
292
220
 
293
221
 
294
222
local_path_to_url = _posix_local_path_to_url
304
232
 
305
233
 
306
234
_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
235
 
322
236
 
323
237
def normalize_url(url):
324
238
    """Make sure that a path string is in fully normalized URL form.
325
 
 
326
 
    This handles URLs which have unicode characters, spaces,
 
239
    
 
240
    This handles URLs which have unicode characters, spaces, 
327
241
    special characters, etc.
328
242
 
329
243
    It has two basic modes of operation, depending on whether the
342
256
    m = _url_scheme_re.match(url)
343
257
    if not m:
344
258
        return local_path_to_url(url)
345
 
    scheme = m.group('scheme')
346
 
    path = m.group('path')
347
259
    if not isinstance(url, unicode):
348
260
        for c in url:
349
261
            if c not in _url_safe_characters:
350
262
                raise errors.InvalidURL(url, 'URLs can only contain specific'
351
263
                                            ' safe characters (not %r)' % c)
352
 
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
353
 
        return str(scheme + '://' + ''.join(path))
354
 
 
 
264
        return url
355
265
    # We have a unicode (hybrid) url
356
 
    path_chars = list(path)
 
266
    scheme = m.group('scheme')
 
267
    path = list(m.group('path'))
357
268
 
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)
 
269
    for i in xrange(len(path)):
 
270
        if path[i] not in _url_safe_characters:
 
271
            chars = path[i].encode('utf-8')
 
272
            path[i] = ''.join(['%%%02X' % ord(c) for c in path[i].encode('utf-8')])
 
273
    return str(scheme + '://' + ''.join(path))
366
274
 
367
275
 
368
276
def relative_url(base, other):
374
282
    dummy, base_first_slash = _find_scheme_and_separator(base)
375
283
    if base_first_slash is None:
376
284
        return other
377
 
 
 
285
    
378
286
    dummy, other_first_slash = _find_scheme_and_separator(other)
379
287
    if other_first_slash is None:
380
288
        return other
384
292
    other_scheme = other[:other_first_slash]
385
293
    if base_scheme != other_scheme:
386
294
        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
295
 
393
296
    base_path = base[base_first_slash+1:]
394
297
    other_path = other[other_first_slash+1:]
422
325
    # Strip off the drive letter
423
326
    # path is currently /C:/foo
424
327
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
425
 
        raise errors.InvalidURL(url_base + path,
 
328
        raise errors.InvalidURL(url_base + path, 
426
329
            'win32 file:/// paths need a drive letter')
427
330
    url_base += path[0:3] # file:// + /C:
428
331
    path = path[3:] # /foo
436
339
    :param exclude_trailing_slash: Strip off a final '/' if it is part
437
340
        of the path (but not if it is part of the protocol specification)
438
341
 
439
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
 
342
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at 
440
343
        the root.
441
344
    """
442
345
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
469
372
    return url_base + head, tail
470
373
 
471
374
 
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
 
 
544
375
def _win32_strip_local_trailing_slash(url):
545
376
    """Strip slashes after the drive letter"""
546
377
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
618
449
# These are characters that if escaped, should stay that way
619
450
_no_decode_chars = ';/?:@&=+$,#'
620
451
_no_decode_ords = [ord(c) for c in _no_decode_chars]
621
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
 
452
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
622
453
                + ['%02X' % o for o in _no_decode_ords])
623
454
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
624
455
                    + [('%02X' % o, chr(o)) for o in range(256)]))
625
456
#These entries get mapped to themselves
626
457
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
627
458
 
628
 
# These characters shouldn't be percent-encoded, and it's always safe to
629
 
# unencode them if they are.
630
 
_url_dont_escape_characters = set(
631
 
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
632
 
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
633
 
   "0123456789" # Numbers
634
 
   "-._~"  # Unreserved characters
635
 
)
636
 
 
637
459
# These characters should not be escaped
638
460
_url_safe_characters = set(
639
461
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
650
472
    This will turn file:// urls into local paths, and try to decode
651
473
    any portions of a http:// style url that it can.
652
474
 
653
 
    Any sections of the URL which can't be represented in the encoding or
 
475
    Any sections of the URL which can't be represented in the encoding or 
654
476
    need to stay as escapes are left alone.
655
477
 
656
478
    :param url: A 7-bit ASCII URL
657
479
    :param encoding: The final output encoding
658
480
 
659
 
    :return: A unicode string which can be safely encoded into the
 
481
    :return: A unicode string which can be safely encoded into the 
660
482
         specified encoding.
661
483
    """
662
 
    if encoding is None:
663
 
        raise ValueError('you cannot specify None for the display encoding')
 
484
    assert encoding is not None, 'you cannot specify None for the display encoding.'
664
485
    if url.startswith('file://'):
665
486
        try:
666
487
            path = local_path_from_url(url)
700
521
                # Otherwise take the url decoded one
701
522
                res[i] = decoded
702
523
    return u'/'.join(res)
703
 
 
704
 
 
705
 
def derive_to_location(from_location):
706
 
    """Derive a TO_LOCATION given a FROM_LOCATION.
707
 
 
708
 
    The normal case is a FROM_LOCATION of http://foo/bar => bar.
709
 
    The Right Thing for some logical destinations may differ though
710
 
    because no / may be present at all. In that case, the result is
711
 
    the full name without the scheme indicator, e.g. lp:foo-bar => foo-bar.
712
 
    This latter case also applies when a Windows drive
713
 
    is used without a path, e.g. c:foo-bar => foo-bar.
714
 
    If no /, path separator or : is found, the from_location is returned.
715
 
    """
716
 
    if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
717
 
        return os.path.basename(from_location.rstrip("/\\"))
718
 
    else:
719
 
        sep = from_location.find(":")
720
 
        if sep > 0:
721
 
            return from_location[sep+1:]
722
 
        else:
723
 
            return from_location
724
 
 
725
 
 
726
 
def _is_absolute(url):
727
 
    return (osutils.pathjoin('/foo', url) == url)
728
 
 
729
 
 
730
 
def rebase_url(url, old_base, new_base):
731
 
    """Convert a relative path from an old base URL to a new base URL.
732
 
 
733
 
    The result will be a relative path.
734
 
    Absolute paths and full URLs are returned unaltered.
735
 
    """
736
 
    scheme, separator = _find_scheme_and_separator(url)
737
 
    if scheme is not None:
738
 
        return url
739
 
    if _is_absolute(url):
740
 
        return url
741
 
    old_parsed = urlparse.urlparse(old_base)
742
 
    new_parsed = urlparse.urlparse(new_base)
743
 
    if (old_parsed[:2]) != (new_parsed[:2]):
744
 
        raise errors.InvalidRebaseURLs(old_base, new_base)
745
 
    return determine_relative_path(new_parsed[2],
746
 
                                   join(old_parsed[2], url))
747
 
 
748
 
 
749
 
def determine_relative_path(from_path, to_path):
750
 
    """Determine a relative path from from_path to to_path."""
751
 
    from_segments = osutils.splitpath(from_path)
752
 
    to_segments = osutils.splitpath(to_path)
753
 
    count = -1
754
 
    for count, (from_element, to_element) in enumerate(zip(from_segments,
755
 
                                                       to_segments)):
756
 
        if from_element != to_element:
757
 
            break
758
 
    else:
759
 
        count += 1
760
 
    unique_from = from_segments[count:]
761
 
    unique_to = to_segments[count:]
762
 
    segments = (['..'] * len(unique_from) + unique_to)
763
 
    if len(segments) == 0:
764
 
        return '.'
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)