← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: John Arbash Meinel
  • Date: 2006-06-10 14:53:51 UTC
  • mto: (1711.7.2 win32)
  • mto: This revision was merged to the branch mainline in revision 1796.
  • Revision ID: john@arbash-meinel.com-20060610145351-9da0c1f8ba8a57e0
the _posix_* routines should use posixpath not os.path, so tests pass on win32

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Bazaar-NG -- distributed version control
 
2
#
 
3
# Copyright (C) 2006 by 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
 
19
21
import os
 
22
from posixpath import split as _posix_split, normpath as _posix_normpath
20
23
import re
21
24
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
26
25
import urllib
27
 
import urlparse
28
26
 
29
 
from bzrlib import (
30
 
    errors,
31
 
    osutils,
32
 
    )
33
 
""")
 
27
import bzrlib.errors as errors
 
28
import bzrlib.osutils
34
29
 
35
30
 
36
31
def basename(url, exclude_trailing_slash=True):
66
61
        relpath = relpath.encode('utf-8')
67
62
    # After quoting and encoding, the path should be perfectly
68
63
    # safe as a plain ASCII string, str() just enforces this
69
 
    return str(urllib.quote(relpath, safe='/~'))
 
64
    return str(urllib.quote(relpath))
70
65
 
71
66
 
72
67
def file_relpath(base, path):
73
68
    """Compute just the relative sub-portion of a url
74
 
 
 
69
    
75
70
    This assumes that both paths are already fully specified file:// URLs.
76
71
    """
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))
 
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
 
81
76
    base = local_path_from_url(base)
82
77
    path = local_path_from_url(path)
83
 
    return escape(osutils.relpath(base, path))
 
78
    return escape(bzrlib.osutils.relpath(base, path))
84
79
 
85
80
 
86
81
def _find_scheme_and_separator(url):
101
96
    first_path_slash = path.find('/')
102
97
    if first_path_slash == -1:
103
98
        return len(scheme), None
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
 
99
    return len(scheme), first_path_slash+len(scheme)+3
110
100
 
111
101
 
112
102
def join(base, *args):
121
111
        join('http://foo', 'bar') => 'http://foo/bar'
122
112
        join('http://foo', 'bar', '../baz') => 'http://foo/baz'
123
113
    """
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:]
 
114
    m = _url_scheme_re.match(base)
 
115
    scheme = None
 
116
    if m:
 
117
        scheme = m.group('scheme')
 
118
        path = m.group('path').split('/')
 
119
    else:
 
120
        path = base.split('/')
 
121
 
132
122
    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
 
123
        m = _url_scheme_re.match(arg)
 
124
        if m:
 
125
            # Absolute URL
 
126
            scheme = m.group('scheme')
 
127
            path = m.group('path').split('/')
143
128
        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 '/'
177
 
    else:
 
129
            for chunk in arg.split('/'):
 
130
                if chunk == '.':
 
131
                    continue
 
132
                elif chunk == '..':
 
133
                    if len(path) >= 2:
 
134
                        # Don't pop off the host portion
 
135
                        path.pop()
 
136
                    else:
 
137
                        raise errors.InvalidURLJoin('Cannot go above root',
 
138
                                base, args)
 
139
                else:
 
140
                    path.append(chunk)
 
141
 
 
142
    if scheme is None:
178
143
        return '/'.join(path)
 
144
    return scheme + '://' + '/'.join(path)
179
145
 
180
146
 
181
147
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
182
148
def _posix_local_path_from_url(url):
183
149
    """Convert a url like file:///path/to/foo into /path/to/foo"""
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://'):]
 
150
    if not url.startswith('file:///'):
 
151
        raise errors.InvalidURL(url, 'local urls must start with file:///')
193
152
    # We only strip off 2 slashes
194
 
    return unescape(path)
 
153
    return unescape(url[len('file://'):])
195
154
 
196
155
 
197
156
def _posix_local_path_to_url(path):
199
158
 
200
159
    This also handles transforming escaping unicode characters, etc.
201
160
    """
202
 
    # importing directly from posixpath allows us to test this
 
161
    # importing directly from posixpath allows us to test this 
203
162
    # on non-posix platforms
204
163
    return 'file://' + escape(_posix_normpath(
205
 
        osutils._posix_abspath(path)))
 
164
        bzrlib.osutils._posix_abspath(path)))
206
165
 
207
166
 
208
167
def _win32_local_path_from_url(url):
209
168
    """Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
210
 
    if not url.startswith('file://'):
211
 
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
212
 
                                     'UNC path urls must start with file://')
213
 
    url = split_segment_parameters_raw(url)[0]
 
169
    if not url.startswith('file:///'):
 
170
        raise errors.InvalidURL(url, 'local urls must start with file:///')
214
171
    # We strip off all 3 slashes
215
 
    win32_url = url[len('file:'):]
216
 
    # check for UNC path: //HOST/path
217
 
    if not win32_url.startswith('///'):
218
 
        if (win32_url[2] == '/'
219
 
            or win32_url[3] in '|:'):
220
 
            raise errors.InvalidURL(url, 'Win32 UNC path urls'
221
 
                ' have form file://HOST/path')
222
 
        return unescape(win32_url)
223
 
 
224
 
    # allow empty paths so we can serve all roots
225
 
    if win32_url == '///':
226
 
        return '/'
227
 
 
228
 
    # usual local path with drive letter
229
 
    if (len(win32_url) < 6
230
 
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
231
 
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
232
 
        or win32_url[4] not in  '|:'
233
 
        or win32_url[5] != '/'):
 
172
    win32_url = url[len('file:///'):]
 
173
    if (win32_url[0] not in ('abcdefghijklmnopqrstuvwxyz'
 
174
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
175
        or win32_url[1] not in  '|:'
 
176
        or win32_url[2] != '/'):
234
177
        raise errors.InvalidURL(url, 'Win32 file urls start with'
235
 
                ' file:///x:/, where x is a valid drive letter')
236
 
    return win32_url[3].upper() + u':' + unescape(win32_url[5:])
 
178
                ' file:///X:/, where X is a valid drive letter')
 
179
    return win32_url[0].upper() + u':' + unescape(win32_url[2:])
237
180
 
238
181
 
239
182
def _win32_local_path_to_url(path):
241
184
 
242
185
    This also handles transforming escaping unicode characters, etc.
243
186
    """
244
 
    # importing directly from ntpath allows us to test this
 
187
    # importing directly from ntpath allows us to test this 
245
188
    # on non-win32 platform
246
189
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
247
190
    #       which actually strips trailing space characters.
248
 
    #       The worst part is that on linux ntpath.abspath has different
 
191
    #       The worst part is that under linux ntpath.abspath has different
249
192
    #       semantics, since 'nt' is not an available module.
250
 
    if path == '/':
251
 
        return 'file:///'
252
 
 
253
 
    win32_path = osutils._win32_abspath(path)
254
 
    # check for UNC path \\HOST\path
255
 
    if win32_path.startswith('//'):
256
 
        return 'file:' + escape(win32_path)
257
 
    return ('file:///' + str(win32_path[0].upper()) + ':' +
258
 
        escape(win32_path[2:]))
 
193
    win32_path = bzrlib.osutils._nt_normpath(
 
194
        bzrlib.osutils._win32_abspath(path)).replace('\\', '/')
 
195
    return 'file:///' + win32_path[0].upper() + ':' + escape(win32_path[2:])
259
196
 
260
197
 
261
198
local_path_to_url = _posix_local_path_to_url
262
199
local_path_from_url = _posix_local_path_from_url
263
200
MIN_ABS_FILEURL_LENGTH = len('file:///')
264
 
WIN32_MIN_ABS_FILEURL_LENGTH = len('file:///C:/')
265
201
 
266
202
if sys.platform == 'win32':
267
203
    local_path_to_url = _win32_local_path_to_url
268
204
    local_path_from_url = _win32_local_path_from_url
269
205
 
270
 
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
271
 
 
272
 
 
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()
 
206
    MIN_ABS_FILEURL_LENGTH = len('file:///C:/')
 
207
 
 
208
 
 
209
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
288
210
 
289
211
 
290
212
def normalize_url(url):
291
213
    """Make sure that a path string is in fully normalized URL form.
292
 
 
293
 
    This handles URLs which have unicode characters, spaces,
 
214
    
 
215
    This handles URLs which have unicode characters, spaces, 
294
216
    special characters, etc.
295
217
 
296
218
    It has two basic modes of operation, depending on whether the
306
228
    :param url: Either a hybrid URL or a local path
307
229
    :return: A normalized URL which only includes 7-bit ASCII characters.
308
230
    """
309
 
    scheme_end, path_start = _find_scheme_and_separator(url)
310
 
    if scheme_end is None:
 
231
    m = _url_scheme_re.match(url)
 
232
    if not m:
311
233
        return local_path_to_url(url)
312
 
    prefix = url[:path_start]
313
 
    path = url[path_start:]
314
234
    if not isinstance(url, unicode):
315
235
        for c in url:
316
236
            if c not in _url_safe_characters:
317
237
                raise errors.InvalidURL(url, 'URLs can only contain specific'
318
238
                                            ' safe characters (not %r)' % c)
319
 
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
320
 
        return str(prefix + ''.join(path))
321
 
 
 
239
        return url
322
240
    # We have a unicode (hybrid) url
323
 
    path_chars = list(path)
 
241
    scheme = m.group('scheme')
 
242
    path = list(m.group('path'))
324
243
 
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)
 
244
    for i in xrange(len(path)):
 
245
        if path[i] not in _url_safe_characters:
 
246
            chars = path[i].encode('utf-8')
 
247
            path[i] = ''.join(['%%%02X' % ord(c) for c in path[i].encode('utf-8')])
 
248
    return scheme + '://' + ''.join(path)
333
249
 
334
250
 
335
251
def relative_url(base, other):
341
257
    dummy, base_first_slash = _find_scheme_and_separator(base)
342
258
    if base_first_slash is None:
343
259
        return other
344
 
 
 
260
    
345
261
    dummy, other_first_slash = _find_scheme_and_separator(other)
346
262
    if other_first_slash is None:
347
263
        return other
351
267
    other_scheme = other[:other_first_slash]
352
268
    if base_scheme != other_scheme:
353
269
        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
359
270
 
360
271
    base_path = base[base_first_slash+1:]
361
272
    other_path = other[other_first_slash+1:]
384
295
    return "/".join(output_sections) or "."
385
296
 
386
297
 
387
 
def _win32_extract_drive_letter(url_base, path):
388
 
    """On win32 the drive letter needs to be added to the url base."""
389
 
    # Strip off the drive letter
390
 
    # path is currently /C:/foo
391
 
    if len(path) < 4 or path[2] not in ':|' or path[3] != '/':
392
 
        raise errors.InvalidURL(url_base + path,
393
 
            'win32 file:/// paths need a drive letter')
394
 
    url_base += path[0:3] # file:// + /C:
395
 
    path = path[3:] # /foo
396
 
    return url_base, path
397
 
 
398
 
 
399
298
def split(url, exclude_trailing_slash=True):
400
299
    """Split a URL into its parent directory and a child directory.
401
300
 
403
302
    :param exclude_trailing_slash: Strip off a final '/' if it is part
404
303
        of the path (but not if it is part of the protocol specification)
405
304
 
406
 
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at
 
305
    :return: (parent_url, child_dir).  child_dir may be the empty string if we're at 
407
306
        the root.
408
307
    """
409
308
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
425
324
 
426
325
    if sys.platform == 'win32' and url.startswith('file:///'):
427
326
        # Strip off the drive letter
428
 
        # url_base is currently file://
429
327
        # path is currently /C:/foo
430
 
        url_base, path = _win32_extract_drive_letter(url_base, path)
431
 
        # now it should be file:///C: and /foo
 
328
        if path[2:3] not in ':|' or path[3:4] not in '\\/':
 
329
            raise errors.InvalidURL(url, 
 
330
                'win32 file:/// paths need a drive letter')
 
331
        url_base += path[0:3] # file:// + /C:
 
332
        path = path[3:] # /foo
432
333
 
433
334
    if exclude_trailing_slash and len(path) > 1 and path.endswith('/'):
434
335
        path = path[:-1]
436
337
    return url_base + head, tail
437
338
 
438
339
 
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
 
 
511
 
def _win32_strip_local_trailing_slash(url):
512
 
    """Strip slashes after the drive letter"""
513
 
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
514
 
        return url[:-1]
515
 
    else:
516
 
        return url
517
 
 
518
 
 
519
340
def strip_trailing_slash(url):
520
341
    """Strip trailing slash, except for root paths.
521
342
 
535
356
        file:///foo/      => file:///foo
536
357
        # This is unique on win32 platforms, and is the only URL
537
358
        # format which does it differently.
538
 
        file:///c|/       => file:///c:/
 
359
        file:///C|/       => file:///C:/
539
360
    """
540
361
    if not url.endswith('/'):
541
362
        # Nothing to do
542
363
        return url
543
 
    if sys.platform == 'win32' and url.startswith('file://'):
544
 
        return _win32_strip_local_trailing_slash(url)
 
364
    if sys.platform == 'win32' and url.startswith('file:///'):
 
365
        # This gets handled specially, because the 'top-level'
 
366
        # of a win32 path is actually the drive letter
 
367
        if len(url) > MIN_ABS_FILEURL_LENGTH:
 
368
            return url[:-1]
 
369
        else:
 
370
            return url
545
371
 
546
372
    scheme_loc, first_path_slash = _find_scheme_and_separator(url)
547
373
    if scheme_loc is None:
585
411
# These are characters that if escaped, should stay that way
586
412
_no_decode_chars = ';/?:@&=+$,#'
587
413
_no_decode_ords = [ord(c) for c in _no_decode_chars]
588
 
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
 
414
_no_decode_hex = (['%02x' % o for o in _no_decode_ords] 
589
415
                + ['%02X' % o for o in _no_decode_ords])
590
416
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
591
417
                    + [('%02X' % o, chr(o)) for o in range(256)]))
592
418
#These entries get mapped to themselves
593
419
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
594
420
 
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
 
 
604
421
# These characters should not be escaped
605
 
_url_safe_characters = set(
606
 
   "abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
607
 
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
608
 
   "0123456789" # Numbers
609
 
   "_.-!~*'()"  # Unreserved characters
610
 
   "/;?:@&=+$," # Reserved characters
611
 
   "%#"         # Extra reserved characters
612
 
)
 
422
_url_safe_characters = set('abcdefghijklmnopqrstuvwxyz'
 
423
                        'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
424
                        '0123456789' '_.-/'
 
425
                        ';?:@&=+$,%#')
 
426
 
613
427
 
614
428
def unescape_for_display(url, encoding):
615
429
    """Decode what you can for a URL, so that we get a nice looking path.
617
431
    This will turn file:// urls into local paths, and try to decode
618
432
    any portions of a http:// style url that it can.
619
433
 
620
 
    Any sections of the URL which can't be represented in the encoding or
 
434
    Any sections of the URL which can't be represented in the encoding or 
621
435
    need to stay as escapes are left alone.
622
436
 
623
437
    :param url: A 7-bit ASCII URL
624
438
    :param encoding: The final output encoding
625
439
 
626
 
    :return: A unicode string which can be safely encoded into the
 
440
    :return: A unicode string which can be safely encoded into the 
627
441
         specified encoding.
628
442
    """
629
 
    if encoding is None:
630
 
        raise ValueError('you cannot specify None for the display encoding')
 
443
    assert encoding is not None, 'you cannot specify None for the display encoding.'
631
444
    if url.startswith('file://'):
632
445
        try:
633
446
            path = local_path_from_url(url)
667
480
                # Otherwise take the url decoded one
668
481
                res[i] = decoded
669
482
    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)