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))
72
73
def file_relpath(base, path):
73
74
"""Compute just the relative sub-portion of a url
75
76
This assumes that both paths are already fully specified file:// URLs.
77
if len(base) < MIN_ABS_FILEURL_LENGTH:
78
raise ValueError('Length of base must be equal or'
79
' exceed the platform minimum url length (which is %d)' %
80
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
82
base = local_path_from_url(base)
82
83
path = local_path_from_url(path)
83
84
return escape(osutils.relpath(base, path))
269
265
This also handles transforming escaping unicode characters, etc.
271
# importing directly from ntpath allows us to test this
267
# importing directly from ntpath allows us to test this
272
268
# on non-win32 platform
273
269
# FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
274
270
# which actually strips trailing space characters.
275
271
# The worst part is that under linux ntpath.abspath has different
276
272
# semantics, since 'nt' is not an available module.
280
273
win32_path = osutils._win32_abspath(path)
281
274
# check for UNC path \\HOST\path
282
275
if win32_path.startswith('//'):
283
276
return 'file:' + escape(win32_path)
284
return ('file:///' + str(win32_path[0].upper()) + ':' +
285
escape(win32_path[2:]))
277
return 'file:///' + win32_path[0].upper() + ':' + escape(win32_path[2:])
288
280
local_path_to_url = _posix_local_path_to_url
300
292
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
301
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
304
def _unescape_safe_chars(matchobj):
305
"""re.sub callback to convert hex-escapes to plain characters (if safe).
307
e.g. '%7E' will be converted to '~'.
309
hex_digits = matchobj.group(0)[1:]
310
char = chr(int(hex_digits, 16))
311
if char in _url_dont_escape_characters:
314
return matchobj.group(0).upper()
317
295
def normalize_url(url):
318
296
"""Make sure that a path string is in fully normalized URL form.
320
This handles URLs which have unicode characters, spaces,
298
This handles URLs which have unicode characters, spaces,
321
299
special characters, etc.
323
301
It has two basic modes of operation, depending on whether the
336
314
m = _url_scheme_re.match(url)
338
316
return local_path_to_url(url)
339
scheme = m.group('scheme')
340
path = m.group('path')
341
317
if not isinstance(url, unicode):
343
319
if c not in _url_safe_characters:
344
320
raise errors.InvalidURL(url, 'URLs can only contain specific'
345
321
' safe characters (not %r)' % c)
346
path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
347
return str(scheme + '://' + ''.join(path))
349
323
# We have a unicode (hybrid) url
350
path_chars = list(path)
324
scheme = m.group('scheme')
325
path = list(m.group('path'))
352
for i in xrange(len(path_chars)):
353
if path_chars[i] not in _url_safe_characters:
354
chars = path_chars[i].encode('utf-8')
355
path_chars[i] = ''.join(
356
['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
357
path = ''.join(path_chars)
358
path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
359
return str(scheme + '://' + path)
327
for i in xrange(len(path)):
328
if path[i] not in _url_safe_characters:
329
chars = path[i].encode('utf-8')
330
path[i] = ''.join(['%%%02X' % ord(c) for c in path[i].encode('utf-8')])
331
return str(scheme + '://' + ''.join(path))
362
334
def relative_url(base, other):
540
507
# These are characters that if escaped, should stay that way
541
508
_no_decode_chars = ';/?:@&=+$,#'
542
509
_no_decode_ords = [ord(c) for c in _no_decode_chars]
543
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
510
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
544
511
+ ['%02X' % o for o in _no_decode_ords])
545
512
_hex_display_map = dict(([('%02x' % o, chr(o)) for o in range(256)]
546
513
+ [('%02X' % o, chr(o)) for o in range(256)]))
547
514
#These entries get mapped to themselves
548
515
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
550
# These characters shouldn't be percent-encoded, and it's always safe to
551
# unencode them if they are.
552
_url_dont_escape_characters = set(
553
"abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
554
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
555
"0123456789" # Numbers
556
"-._~" # Unreserved characters
559
517
# These characters should not be escaped
560
518
_url_safe_characters = set(
561
519
"abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
572
530
This will turn file:// urls into local paths, and try to decode
573
531
any portions of a http:// style url that it can.
575
Any sections of the URL which can't be represented in the encoding or
533
Any sections of the URL which can't be represented in the encoding or
576
534
need to stay as escapes are left alone.
578
536
:param url: A 7-bit ASCII URL
579
537
:param encoding: The final output encoding
581
:return: A unicode string which can be safely encoded into the
539
:return: A unicode string which can be safely encoded into the
582
540
specified encoding.
585
raise ValueError('you cannot specify None for the display encoding')
542
assert encoding is not None, 'you cannot specify None for the display encoding.'
586
543
if url.startswith('file://'):
588
545
path = local_path_from_url(url)
622
579
# Otherwise take the url decoded one
624
581
return u'/'.join(res)
627
def derive_to_location(from_location):
628
"""Derive a TO_LOCATION given a FROM_LOCATION.
630
The normal case is a FROM_LOCATION of http://foo/bar => bar.
631
The Right Thing for some logical destinations may differ though
632
because no / may be present at all. In that case, the result is
633
the full name without the scheme indicator, e.g. lp:foo-bar => foo-bar.
634
This latter case also applies when a Windows drive
635
is used without a path, e.g. c:foo-bar => foo-bar.
636
If no /, path separator or : is found, the from_location is returned.
638
if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
639
return os.path.basename(from_location.rstrip("/\\"))
641
sep = from_location.find(":")
643
return from_location[sep+1:]
648
def _is_absolute(url):
649
return (osutils.pathjoin('/foo', url) == url)
652
def rebase_url(url, old_base, new_base):
653
"""Convert a relative path from an old base URL to a new base URL.
655
The result will be a relative path.
656
Absolute paths and full URLs are returned unaltered.
658
scheme, separator = _find_scheme_and_separator(url)
659
if scheme is not None:
661
if _is_absolute(url):
663
old_parsed = urlparse.urlparse(old_base)
664
new_parsed = urlparse.urlparse(new_base)
665
if (old_parsed[:2]) != (new_parsed[:2]):
666
raise errors.InvalidRebaseURLs(old_base, new_base)
667
return determine_relative_path(new_parsed[2],
668
join(old_parsed[2], url))
671
def determine_relative_path(from_path, to_path):
672
"""Determine a relative path from from_path to to_path."""
673
from_segments = osutils.splitpath(from_path)
674
to_segments = osutils.splitpath(to_path)
676
for count, (from_element, to_element) in enumerate(zip(from_segments,
678
if from_element != to_element:
682
unique_from = from_segments[count:]
683
unique_to = to_segments[count:]
684
segments = (['..'] * len(unique_from) + unique_to)
685
if len(segments) == 0:
687
return osutils.pathjoin(*segments)
692
"""Extract the server address, the credentials and the path from the url.
694
user, password, host and path should be quoted if they contain reserved
697
:param url: an quoted url
699
:return: (scheme, user, password, host, port, path) tuple, all fields
702
if isinstance(url, unicode):
703
raise errors.InvalidURL('should be ascii:\n%r' % url)
704
url = url.encode('utf-8')
705
(scheme, netloc, path, params,
706
query, fragment) = urlparse.urlparse(url, allow_fragments=False)
707
user = password = host = port = None
709
user, host = netloc.rsplit('@', 1)
711
user, password = user.split(':', 1)
712
password = urllib.unquote(password)
713
user = urllib.unquote(user)
717
if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port
718
host, port = host.rsplit(':',1)
722
raise errors.InvalidURL('invalid port number %s in url:\n%s' %
724
if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
727
host = urllib.unquote(host)
728
path = urllib.unquote(path)
730
return (scheme, user, password, host, port, path)
added
removed
bzrlib/urlutils.py
