← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: Jelmer Vernooij
  • Date: 2011-08-19 22:34:02 UTC
  • mto: This revision was merged to the branch mainline in revision 6089.
  • Revision ID: jelmer@samba.org-20110819223402-wjywqb0fa1xxx522
Use get_transport_from_{url,path} in more places.

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
 
26
24
lazy_import(globals(), """
27
25
from posixpath import split as _posix_split, normpath as _posix_normpath
28
26
import urllib
 
27
import urlparse
29
28
 
30
29
from bzrlib import (
31
30
    errors,
67
66
        relpath = relpath.encode('utf-8')
68
67
    # After quoting and encoding, the path should be perfectly
69
68
    # safe as a plain ASCII string, str() just enforces this
70
 
    return str(urllib.quote(relpath))
 
69
    return str(urllib.quote(relpath, safe='/~'))
71
70
 
72
71
 
73
72
def file_relpath(base, path):
74
73
    """Compute just the relative sub-portion of a url
75
 
    
 
74
 
76
75
    This assumes that both paths are already fully specified file:// URLs.
77
76
    """
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
 
 
 
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))
82
81
    base = local_path_from_url(base)
83
82
    path = local_path_from_url(path)
84
83
    return escape(osutils.relpath(base, path))
102
101
    first_path_slash = path.find('/')
103
102
    if first_path_slash == -1:
104
103
        return len(scheme), None
105
 
    return len(scheme), first_path_slash+len(scheme)+3
 
104
    return len(scheme), first_path_slash+m.start('path')
 
105
 
 
106
 
 
107
def is_url(url):
 
108
    """Tests whether a URL is in actual fact a URL."""
 
109
    return _url_scheme_re.match(url) is not None
106
110
 
107
111
 
108
112
def join(base, *args):
117
121
        join('http://foo', 'bar') => 'http://foo/bar'
118
122
        join('http://foo', 'bar', '../baz') => 'http://foo/baz'
119
123
    """
120
 
    m = _url_scheme_re.match(base)
121
 
    scheme = None
122
 
    if m:
123
 
        scheme = m.group('scheme')
124
 
        path = m.group('path').split('/')
125
 
        if path[-1:] == ['']:
126
 
            # Strip off a trailing slash
127
 
            # This helps both when we are at the root, and when
128
 
            # 'base' has an extra slash at the end
129
 
            path = path[:-1]
 
124
    if not args:
 
125
        return base
 
126
    scheme_end, path_start = _find_scheme_and_separator(base)
 
127
    if scheme_end is None and path_start is None:
 
128
        path_start = 0
 
129
    elif path_start is None:
 
130
        path_start = len(base)
 
131
    path = base[path_start:]
 
132
    for arg in args:
 
133
        arg_scheme_end, arg_path_start = _find_scheme_and_separator(arg)
 
134
        if arg_scheme_end is None and arg_path_start is None:
 
135
            arg_path_start = 0
 
136
        elif arg_path_start is None:
 
137
            arg_path_start = len(arg)
 
138
        if arg_scheme_end is not None:
 
139
            base = arg
 
140
            path = arg[arg_path_start:]
 
141
            scheme_end = arg_scheme_end
 
142
            path_start = arg_path_start
 
143
        else:
 
144
            path = joinpath(path, arg)
 
145
    return base[:path_start] + path
 
146
 
 
147
 
 
148
def joinpath(base, *args):
 
149
    """Join URL path segments to a URL path segment.
 
150
 
 
151
    This is somewhat like osutils.joinpath, but intended for URLs.
 
152
 
 
153
    XXX: this duplicates some normalisation logic, and also duplicates a lot of
 
154
    path handling logic that already exists in some Transport implementations.
 
155
    We really should try to have exactly one place in the code base responsible
 
156
    for combining paths of URLs.
 
157
    """
 
158
    path = base.split('/')
 
159
    if len(path) > 1 and path[-1] == '':
 
160
        #If the path ends in a trailing /, remove it.
 
161
        path.pop()
 
162
    for arg in args:
 
163
        if arg.startswith('/'):
 
164
            path = []
 
165
        for chunk in arg.split('/'):
 
166
            if chunk == '.':
 
167
                continue
 
168
            elif chunk == '..':
 
169
                if path == ['']:
 
170
                    raise errors.InvalidURLJoin('Cannot go above root',
 
171
                            base, args)
 
172
                path.pop()
 
173
            else:
 
174
                path.append(chunk)
 
175
    if path == ['']:
 
176
        return '/'
130
177
    else:
131
 
        path = base.split('/')
132
 
 
133
 
    for arg in args:
134
 
        m = _url_scheme_re.match(arg)
135
 
        if m:
136
 
            # Absolute URL
137
 
            scheme = m.group('scheme')
138
 
            # this skips .. normalisation, making http://host/../../..
139
 
            # be rather strange.
140
 
            path = m.group('path').split('/')
141
 
        else:
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)
154
 
 
155
 
    if scheme is None:
156
178
        return '/'.join(path)
157
 
    return scheme + '://' + '/'.join(path)
158
179
 
159
180
 
160
181
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
161
182
def _posix_local_path_from_url(url):
162
183
    """Convert a url like file:///path/to/foo into /path/to/foo"""
163
 
    if not url.startswith('file:///'):
164
 
        raise errors.InvalidURL(url, 'local urls must start with file:///')
 
184
    url = split_segment_parameters_raw(url)[0]
 
185
    file_localhost_prefix = 'file://localhost/'
 
186
    if url.startswith(file_localhost_prefix):
 
187
        path = url[len(file_localhost_prefix) - 1:]
 
188
    elif not url.startswith('file:///'):
 
189
        raise errors.InvalidURL(
 
190
            url, 'local urls must start with file:/// or file://localhost/')
 
191
    else:
 
192
        path = url[len('file://'):]
165
193
    # We only strip off 2 slashes
166
 
    return unescape(url[len('file://'):])
 
194
    return unescape(path)
167
195
 
168
196
 
169
197
def _posix_local_path_to_url(path):
171
199
 
172
200
    This also handles transforming escaping unicode characters, etc.
173
201
    """
174
 
    # importing directly from posixpath allows us to test this 
 
202
    # importing directly from posixpath allows us to test this
175
203
    # on non-posix platforms
176
204
    return 'file://' + escape(_posix_normpath(
177
205
        osutils._posix_abspath(path)))
182
210
    if not url.startswith('file://'):
183
211
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
184
212
                                     'UNC path urls must start with file://')
 
213
    url = split_segment_parameters_raw(url)[0]
185
214
    # We strip off all 3 slashes
186
215
    win32_url = url[len('file:'):]
187
216
    # check for UNC path: //HOST/path
191
220
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
192
221
                ' have form file://HOST/path')
193
222
        return unescape(win32_url)
 
223
 
 
224
    # allow empty paths so we can serve all roots
 
225
    if win32_url == '///':
 
226
        return '/'
 
227
 
194
228
    # usual local path with drive letter
195
 
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
196
 
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
229
    if (len(win32_url) < 6
 
230
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
231
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
197
232
        or win32_url[4] not in  '|:'
198
233
        or win32_url[5] != '/'):
199
234
        raise errors.InvalidURL(url, 'Win32 file urls start with'
206
241
 
207
242
    This also handles transforming escaping unicode characters, etc.
208
243
    """
209
 
    # importing directly from ntpath allows us to test this 
 
244
    # importing directly from ntpath allows us to test this
210
245
    # on non-win32 platform
211
246
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
212
247
    #       which actually strips trailing space characters.
213
 
    #       The worst part is that under linux ntpath.abspath has different
 
248
    #       The worst part is that on linux ntpath.abspath has different
214
249
    #       semantics, since 'nt' is not an available module.
 
250
    if path == '/':
 
251
        return 'file:///'
 
252
 
215
253
    win32_path = osutils._win32_abspath(path)
216
254
    # check for UNC path \\HOST\path
217
255
    if win32_path.startswith('//'):
218
256
        return 'file:' + escape(win32_path)
219
 
    return 'file:///' + win32_path[0].upper() + ':' + escape(win32_path[2:])
 
257
    return ('file:///' + str(win32_path[0].upper()) + ':' +
 
258
        escape(win32_path[2:]))
220
259
 
221
260
 
222
261
local_path_to_url = _posix_local_path_to_url
231
270
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
232
271
 
233
272
 
234
 
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
 
273
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
 
274
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
 
275
 
 
276
 
 
277
def _unescape_safe_chars(matchobj):
 
278
    """re.sub callback to convert hex-escapes to plain characters (if safe).
 
279
 
 
280
    e.g. '%7E' will be converted to '~'.
 
281
    """
 
282
    hex_digits = matchobj.group(0)[1:]
 
283
    char = chr(int(hex_digits, 16))
 
284
    if char in _url_dont_escape_characters:
 
285
        return char
 
286
    else:
 
287
        return matchobj.group(0).upper()
235
288
 
236
289
 
237
290
def normalize_url(url):
238
291
    """Make sure that a path string is in fully normalized URL form.
239
 
    
240
 
    This handles URLs which have unicode characters, spaces, 
 
292
 
 
293
    This handles URLs which have unicode characters, spaces,
241
294
    special characters, etc.
242
295
 
243
296
    It has two basic modes of operation, depending on whether the
253
306
    :param url: Either a hybrid URL or a local path
254
307
    :return: A normalized URL which only includes 7-bit ASCII characters.
255
308
    """
256
 
    m = _url_scheme_re.match(url)
257
 
    if not m:
 
309
    scheme_end, path_start = _find_scheme_and_separator(url)
 
310
    if scheme_end is None:
258
311
        return local_path_to_url(url)
 
312
    prefix = url[:path_start]
 
313
    path = url[path_start:]
259
314
    if not isinstance(url, unicode):
260
315
        for c in url:
261
316
            if c not in _url_safe_characters:
262
317
                raise errors.InvalidURL(url, 'URLs can only contain specific'
263
318
                                            ' safe characters (not %r)' % c)
264
 
        return url
 
319
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
 
320
        return str(prefix + ''.join(path))
 
321
 
265
322
    # We have a unicode (hybrid) url
266
 
    scheme = m.group('scheme')
267
 
    path = list(m.group('path'))
 
323
    path_chars = list(path)
268
324
 
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))
 
325
    for i in xrange(len(path_chars)):
 
326
        if path_chars[i] not in _url_safe_characters:
 
327
            chars = path_chars[i].encode('utf-8')
 
328
            path_chars[i] = ''.join(
 
329
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
 
330
    path = ''.join(path_chars)
 
331
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
 
332
    return str(prefix + path)
274
333
 
275
334
 
276
335
def relative_url(base, other):
282
341
    dummy, base_first_slash = _find_scheme_and_separator(base)
283
342
    if base_first_slash is None:
284
343
        return other
285
 
    
 
344
 
286
345
    dummy, other_first_slash = _find_scheme_and_separator(other)
287
346
    if other_first_slash is None:
288
347
        return other
292
351
    other_scheme = other[:other_first_slash]
293
352
    if base_scheme != other_scheme:
294
353
        return other
 
354
    elif sys.platform == 'win32' and base_scheme == 'file://':
 
355
        base_drive = base[base_first_slash+1:base_first_slash+3]
 
356
        other_drive = other[other_first_slash+1:other_first_slash+3]
 
357
        if base_drive != other_drive:
 
358
            return other
295
359
 
296
360
    base_path = base[base_first_slash+1:]
297
361
    other_path = other[other_first_slash+1:]
325
389
    # Strip off the drive letter
326
390
    # path is currently /C:/foo
327
391
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
328
 
        raise errors.InvalidURL(url_base + path, 
 
392
        raise errors.InvalidURL(url_base + path,
329
393
            'win32 file:/// paths need a drive letter')
330
394
    url_base += path[0:3] # file:// + /C:
331
395
    path = path[3:] # /foo
339
403
    :param exclude_trailing_slash: Strip off a final '/' if it is part
340
404
        of the path (but not if it is part of the protocol specification)
341
405
 
342
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at 
 
406
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
343
407
        the root.
344
408
    """
345
409
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
372
436
    return url_base + head, tail
373
437
 
374
438
 
 
439
def split_segment_parameters_raw(url):
 
440
    """Split the subsegment of the last segment of a URL.
 
441
 
 
442
    :param url: A relative or absolute URL
 
443
    :return: (url, subsegments)
 
444
    """
 
445
    (parent_url, child_dir) = split(url)
 
446
    subsegments = child_dir.split(",")
 
447
    if len(subsegments) == 1:
 
448
        return (url, [])
 
449
    return (join(parent_url, subsegments[0]), subsegments[1:])
 
450
 
 
451
 
 
452
def split_segment_parameters(url):
 
453
    """Split the segment parameters of the last segment of a URL.
 
454
 
 
455
    :param url: A relative or absolute URL
 
456
    :return: (url, segment_parameters)
 
457
    """
 
458
    (base_url, subsegments) = split_segment_parameters_raw(url)
 
459
    parameters = {}
 
460
    for subsegment in subsegments:
 
461
        (key, value) = subsegment.split("=", 1)
 
462
        parameters[key] = value
 
463
    return (base_url, parameters)
 
464
 
 
465
 
 
466
def join_segment_parameters_raw(base, *subsegments):
 
467
    """Create a new URL by adding subsegments to an existing one. 
 
468
 
 
469
    This adds the specified subsegments to the last path in the specified
 
470
    base URL. The subsegments should be bytestrings.
 
471
 
 
472
    :note: You probably want to use join_segment_parameters instead.
 
473
    """
 
474
    if not subsegments:
 
475
        return base
 
476
    for subsegment in subsegments:
 
477
        if type(subsegment) is not str:
 
478
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
 
479
        if "," in subsegment:
 
480
            raise errors.InvalidURLJoin(", exists in subsegments",
 
481
                                        base, subsegments)
 
482
    return ",".join((base,) + subsegments)
 
483
 
 
484
 
 
485
def join_segment_parameters(url, parameters):
 
486
    """Create a new URL by adding segment parameters to an existing one.
 
487
 
 
488
    The parameters of the last segment in the URL will be updated; if a
 
489
    parameter with the same key already exists it will be overwritten.
 
490
 
 
491
    :param url: A URL, as string
 
492
    :param parameters: Dictionary of parameters, keys and values as bytestrings
 
493
    """
 
494
    (base, existing_parameters) = split_segment_parameters(url)
 
495
    new_parameters = {}
 
496
    new_parameters.update(existing_parameters)
 
497
    for key, value in parameters.iteritems():
 
498
        if type(key) is not str:
 
499
            raise TypeError("parameter key %r is not a bytestring" % key)
 
500
        if type(value) is not str:
 
501
            raise TypeError("parameter value %r for %s is not a bytestring" %
 
502
                (key, value))
 
503
        if "=" in key:
 
504
            raise errors.InvalidURLJoin("= exists in parameter key", url,
 
505
                parameters)
 
506
        new_parameters[key] = value
 
507
    return join_segment_parameters_raw(base, 
 
508
        *["%s=%s" % item for item in sorted(new_parameters.items())])
 
509
 
 
510
 
375
511
def _win32_strip_local_trailing_slash(url):
376
512
    """Strip slashes after the drive letter"""
377
513
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
449
585
# These are characters that if escaped, should stay that way
450
586
_no_decode_chars = ';/?:@&=+$,#'
451
587
_no_decode_ords = [ord(c) for c in _no_decode_chars]
452
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
 
588
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
453
589
                + ['%02X' % o for o in _no_decode_ords])
454
590
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
455
591
                    + [('%02X' % o, chr(o)) for o in range(256)]))
456
592
#These entries get mapped to themselves
457
593
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
458
594
 
 
595
# These characters shouldn't be percent-encoded, and it's always safe to
 
596
# unencode them if they are.
 
597
_url_dont_escape_characters = set(
 
598
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
 
599
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
 
600
   "0123456789" # Numbers
 
601
   "-._~"  # Unreserved characters
 
602
)
 
603
 
459
604
# These characters should not be escaped
460
605
_url_safe_characters = set(
461
606
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
472
617
    This will turn file:// urls into local paths, and try to decode
473
618
    any portions of a http:// style url that it can.
474
619
 
475
 
    Any sections of the URL which can't be represented in the encoding or 
 
620
    Any sections of the URL which can't be represented in the encoding or
476
621
    need to stay as escapes are left alone.
477
622
 
478
623
    :param url: A 7-bit ASCII URL
479
624
    :param encoding: The final output encoding
480
625
 
481
 
    :return: A unicode string which can be safely encoded into the 
 
626
    :return: A unicode string which can be safely encoded into the
482
627
         specified encoding.
483
628
    """
484
 
    assert encoding is not None, 'you cannot specify None for the display encoding.'
 
629
    if encoding is None:
 
630
        raise ValueError('you cannot specify None for the display encoding')
485
631
    if url.startswith('file://'):
486
632
        try:
487
633
            path = local_path_from_url(url)
521
667
                # Otherwise take the url decoded one
522
668
                res[i] = decoded
523
669
    return u'/'.join(res)
 
670
 
 
671
 
 
672
def derive_to_location(from_location):
 
673
    """Derive a TO_LOCATION given a FROM_LOCATION.
 
674
 
 
675
    The normal case is a FROM_LOCATION of http://foo/bar => bar.
 
676
    The Right Thing for some logical destinations may differ though
 
677
    because no / may be present at all. In that case, the result is
 
678
    the full name without the scheme indicator, e.g. lp:foo-bar => foo-bar.
 
679
    This latter case also applies when a Windows drive
 
680
    is used without a path, e.g. c:foo-bar => foo-bar.
 
681
    If no /, path separator or : is found, the from_location is returned.
 
682
    """
 
683
    if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
 
684
        return os.path.basename(from_location.rstrip("/\\"))
 
685
    else:
 
686
        sep = from_location.find(":")
 
687
        if sep > 0:
 
688
            return from_location[sep+1:]
 
689
        else:
 
690
            return from_location
 
691
 
 
692
 
 
693
def _is_absolute(url):
 
694
    return (osutils.pathjoin('/foo', url) == url)
 
695
 
 
696
 
 
697
def rebase_url(url, old_base, new_base):
 
698
    """Convert a relative path from an old base URL to a new base URL.
 
699
 
 
700
    The result will be a relative path.
 
701
    Absolute paths and full URLs are returned unaltered.
 
702
    """
 
703
    scheme, separator = _find_scheme_and_separator(url)
 
704
    if scheme is not None:
 
705
        return url
 
706
    if _is_absolute(url):
 
707
        return url
 
708
    old_parsed = urlparse.urlparse(old_base)
 
709
    new_parsed = urlparse.urlparse(new_base)
 
710
    if (old_parsed[:2]) != (new_parsed[:2]):
 
711
        raise errors.InvalidRebaseURLs(old_base, new_base)
 
712
    return determine_relative_path(new_parsed[2],
 
713
                                   join(old_parsed[2], url))
 
714
 
 
715
 
 
716
def determine_relative_path(from_path, to_path):
 
717
    """Determine a relative path from from_path to to_path."""
 
718
    from_segments = osutils.splitpath(from_path)
 
719
    to_segments = osutils.splitpath(to_path)
 
720
    count = -1
 
721
    for count, (from_element, to_element) in enumerate(zip(from_segments,
 
722
                                                       to_segments)):
 
723
        if from_element != to_element:
 
724
            break
 
725
    else:
 
726
        count += 1
 
727
    unique_from = from_segments[count:]
 
728
    unique_to = to_segments[count:]
 
729
    segments = (['..'] * len(unique_from) + unique_to)
 
730
    if len(segments) == 0:
 
731
        return '.'
 
732
    return osutils.pathjoin(*segments)
 
733
 
 
734
 
 
735
class URL(object):
 
736
    """Parsed URL."""
 
737
 
 
738
    def __init__(self, scheme, quoted_user, quoted_password, quoted_host,
 
739
            port, quoted_path):
 
740
        self.scheme = scheme
 
741
        self.quoted_host = quoted_host
 
742
        self.host = urllib.unquote(self.quoted_host)
 
743
        self.quoted_user = quoted_user
 
744
        if self.quoted_user is not None:
 
745
            self.user = urllib.unquote(self.quoted_user)
 
746
        else:
 
747
            self.user = None
 
748
        self.quoted_password = quoted_password
 
749
        if self.quoted_password is not None:
 
750
            self.password = urllib.unquote(self.quoted_password)
 
751
        else:
 
752
            self.password = None
 
753
        self.port = port
 
754
        self.quoted_path = quoted_path
 
755
        self.path = urllib.unquote(self.quoted_path)
 
756
 
 
757
    def __eq__(self, other):
 
758
        return (isinstance(other, self.__class__) and
 
759
                self.scheme == other.scheme and
 
760
                self.host == other.host and
 
761
                self.user == other.user and
 
762
                self.password == other.password and
 
763
                self.path == other.path)
 
764
 
 
765
    def __repr__(self):
 
766
        return "<%s(%r, %r, %r, %r, %r, %r)>" % (
 
767
            self.__class__.__name__,
 
768
            self.scheme, self.quoted_user, self.quoted_password,
 
769
            self.quoted_host, self.port, self.quoted_path)
 
770
 
 
771
    @classmethod
 
772
    def from_string(cls, url):
 
773
        """Create a URL object from a string.
 
774
 
 
775
        :param url: URL as bytestring
 
776
        """
 
777
        if isinstance(url, unicode):
 
778
            raise errors.InvalidURL('should be ascii:\n%r' % url)
 
779
        url = url.encode('utf-8')
 
780
        (scheme, netloc, path, params,
 
781
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
782
        user = password = host = port = None
 
783
        if '@' in netloc:
 
784
            user, host = netloc.rsplit('@', 1)
 
785
            if ':' in user:
 
786
                user, password = user.split(':', 1)
 
787
        else:
 
788
            host = netloc
 
789
 
 
790
        if ':' in host and not (host[0] == '[' and host[-1] == ']'):
 
791
            # there *is* port
 
792
            host, port = host.rsplit(':',1)
 
793
            try:
 
794
                port = int(port)
 
795
            except ValueError:
 
796
                raise errors.InvalidURL('invalid port number %s in url:\n%s' %
 
797
                                        (port, url))
 
798
        if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
 
799
            host = host[1:-1]
 
800
 
 
801
        return cls(scheme, user, password, host, port, path)
 
802
 
 
803
    def __str__(self):
 
804
        netloc = self.quoted_host
 
805
        if ":" in netloc:
 
806
            netloc = "[%s]" % netloc
 
807
        if self.quoted_user is not None:
 
808
            # Note that we don't put the password back even if we
 
809
            # have one so that it doesn't get accidentally
 
810
            # exposed.
 
811
            netloc = '%s@%s' % (self.quoted_user, netloc)
 
812
        if self.port is not None:
 
813
            netloc = '%s:%d' % (netloc, self.port)
 
814
        return urlparse.urlunparse(
 
815
            (self.scheme, netloc, self.quoted_path, None, None, None))
 
816
 
 
817
    @staticmethod
 
818
    def _combine_paths(base_path, relpath):
 
819
        """Transform a Transport-relative path to a remote absolute path.
 
820
 
 
821
        This does not handle substitution of ~ but does handle '..' and '.'
 
822
        components.
 
823
 
 
824
        Examples::
 
825
 
 
826
            t._combine_paths('/home/sarah', 'project/foo')
 
827
                => '/home/sarah/project/foo'
 
828
            t._combine_paths('/home/sarah', '../../etc')
 
829
                => '/etc'
 
830
            t._combine_paths('/home/sarah', '/etc')
 
831
                => '/etc'
 
832
 
 
833
        :param base_path: base path
 
834
        :param relpath: relative url string for relative part of remote path.
 
835
        :return: urlencoded string for final path.
 
836
        """
 
837
        if not isinstance(relpath, str):
 
838
            raise errors.InvalidURL(relpath)
 
839
        if relpath.startswith('/'):
 
840
            base_parts = []
 
841
        else:
 
842
            base_parts = base_path.split('/')
 
843
        if len(base_parts) > 0 and base_parts[-1] == '':
 
844
            base_parts = base_parts[:-1]
 
845
        for p in relpath.split('/'):
 
846
            if p == '..':
 
847
                if len(base_parts) == 0:
 
848
                    # In most filesystems, a request for the parent
 
849
                    # of root, just returns root.
 
850
                    continue
 
851
                base_parts.pop()
 
852
            elif p == '.':
 
853
                continue # No-op
 
854
            elif p != '':
 
855
                base_parts.append(p)
 
856
        path = '/'.join(base_parts)
 
857
        if not path.startswith('/'):
 
858
            path = '/' + path
 
859
        return path
 
860
 
 
861
    def clone(self, offset=None):
 
862
        """Return a new URL for a path relative to this URL.
 
863
 
 
864
        :param offset: A relative path, already urlencoded
 
865
        :return: `URL` instance
 
866
        """
 
867
        if offset is not None:
 
868
            relative = unescape(offset).encode('utf-8')
 
869
            path = self._combine_paths(self.path, relative)
 
870
            path = urllib.quote(path)
 
871
        else:
 
872
            path = self.quoted_path
 
873
        return self.__class__(self.scheme, self.quoted_user,
 
874
                self.quoted_password, self.quoted_host, self.port,
 
875
                path)
 
876
 
 
877
 
 
878
def parse_url(url):
 
879
    """Extract the server address, the credentials and the path from the url.
 
880
 
 
881
    user, password, host and path should be quoted if they contain reserved
 
882
    chars.
 
883
 
 
884
    :param url: an quoted url
 
885
    :return: (scheme, user, password, host, port, path) tuple, all fields
 
886
        are unquoted.
 
887
    """
 
888
    parsed_url = URL.from_string(url)
 
889
    return (parsed_url.scheme, parsed_url.user, parsed_url.password,
 
890
        parsed_url.host, parsed_url.port, parsed_url.path)