118
111
join('http://foo', 'bar') => 'http://foo/bar'
119
112
join('http://foo', 'bar', '../baz') => 'http://foo/baz'
123
match = _url_scheme_re.match(base)
114
m = _url_scheme_re.match(base)
126
scheme = match.group('scheme')
127
path = match.group('path').split('/')
128
if path[-1:] == ['']:
129
# Strip off a trailing slash
130
# This helps both when we are at the root, and when
131
# 'base' has an extra slash at the end
117
scheme = m.group('scheme')
118
path = m.group('path').split('/')
134
120
path = base.split('/')
136
if scheme is not None and len(path) >= 1:
138
# the path should be represented as an abs path.
139
# we know this must be absolute because of the presence of a URL scheme.
141
path = [''] + path[1:]
143
# create an empty host, but dont alter the path - this might be a
144
# relative url fragment.
149
match = _url_scheme_re.match(arg)
123
m = _url_scheme_re.match(arg)
152
scheme = match.group('scheme')
153
# this skips .. normalisation, making http://host/../../..
155
path = match.group('path').split('/')
156
# set the host and path according to new absolute URL, discarding
157
# any previous values.
158
# XXX: duplicates mess from earlier in this function. This URL
159
# manipulation code needs some cleaning up.
160
if scheme is not None and len(path) >= 1:
163
# url scheme implies absolute path.
166
# no url scheme we take the path as is.
126
scheme = m.group('scheme')
127
path = m.group('path').split('/')
169
path = '/'.join(path)
170
path = joinpath(path, arg)
171
path = path.split('/')
172
if remove_root and path[0:1] == ['']:
175
# Remove the leading slash from the path, so long as it isn't also the
176
# trailing slash, which we want to keep if present.
177
if path and path[0] == '' and len(path) > 1:
129
for chunk in arg.split('/'):
134
# Don't pop off the host portion
137
raise errors.InvalidURLJoin('Cannot go above root',
181
141
if scheme is None:
182
142
return '/'.join(path)
183
143
return scheme + '://' + '/'.join(path)
186
def joinpath(base, *args):
187
"""Join URL path segments to a URL path segment.
189
This is somewhat like osutils.joinpath, but intended for URLs.
191
XXX: this duplicates some normalisation logic, and also duplicates a lot of
192
path handling logic that already exists in some Transport implementations.
193
We really should try to have exactly one place in the code base responsible
194
for combining paths of URLs.
196
path = base.split('/')
197
if len(path) > 1 and path[-1] == '':
198
#If the path ends in a trailing /, remove it.
201
if arg.startswith('/'):
203
for chunk in arg.split('/'):
208
raise errors.InvalidURLJoin('Cannot go above root',
216
return '/'.join(path)
219
146
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
220
147
def _posix_local_path_from_url(url):
221
148
"""Convert a url like file:///path/to/foo into /path/to/foo"""
233
160
# importing directly from posixpath allows us to test this
234
161
# on non-posix platforms
235
return 'file://' + escape(_posix_normpath(
236
osutils._posix_abspath(path)))
162
from posixpath import normpath
163
return 'file://' + escape(normpath(bzrlib.osutils._posix_abspath(path)))
239
166
def _win32_local_path_from_url(url):
240
"""Convert a url like file:///C:/path/to/foo into C:/path/to/foo"""
241
if not url.startswith('file://'):
242
raise errors.InvalidURL(url, 'local urls must start with file:///, '
243
'UNC path urls must start with file://')
167
"""Convert a url like file:///C|/path/to/foo into C:/path/to/foo"""
168
if not url.startswith('file:///'):
169
raise errors.InvalidURL(url, 'local urls must start with file:///')
244
170
# We strip off all 3 slashes
245
win32_url = url[len('file:'):]
246
# check for UNC path: //HOST/path
247
if not win32_url.startswith('///'):
248
if (win32_url[2] == '/'
249
or win32_url[3] in '|:'):
250
raise errors.InvalidURL(url, 'Win32 UNC path urls'
251
' have form file://HOST/path')
252
return unescape(win32_url)
254
# allow empty paths so we can serve all roots
255
if win32_url == '///':
258
# usual local path with drive letter
259
if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
260
'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
261
or win32_url[4] not in '|:'
262
or win32_url[5] != '/'):
263
raise errors.InvalidURL(url, 'Win32 file urls start with'
264
' file:///x:/, where x is a valid drive letter')
265
return win32_url[3].upper() + u':' + unescape(win32_url[5:])
171
win32_url = url[len('file:///'):]
172
if (win32_url[0] not in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
173
or win32_url[1] not in '|:'
174
or win32_url[2] != '/'):
175
raise errors.InvalidURL(url, 'Win32 file urls start with file:///X|/, where X is a valid drive letter')
176
# TODO: jam 20060426, we could .upper() or .lower() the drive letter
177
# for better consistency.
178
return win32_url[0].upper() + u':' + unescape(win32_url[2:])
268
181
def _win32_local_path_to_url(path):
269
"""Convert a local path like ./foo into a URL like file:///C:/path/to/foo
182
"""Convert a local path like ./foo into a URL like file:///C|/path/to/foo
271
184
This also handles transforming escaping unicode characters, etc.
273
186
# importing directly from ntpath allows us to test this
274
# on non-win32 platform
275
# FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
276
# which actually strips trailing space characters.
277
# The worst part is that under linux ntpath.abspath has different
278
# semantics, since 'nt' is not an available module.
282
win32_path = osutils._win32_abspath(path)
283
# check for UNC path \\HOST\path
284
if win32_path.startswith('//'):
285
return 'file:' + escape(win32_path)
286
return ('file:///' + str(win32_path[0].upper()) + ':' +
287
escape(win32_path[2:]))
187
# on non-win32 platforms
188
# TODO: jam 20060426 consider moving this import outside of the function
189
win32_path = bzrlib.osutils._nt_normpath(
190
bzrlib.osutils._win32_abspath(path)).replace('\\', '/')
191
return 'file:///' + win32_path[0].upper() + '|' + escape(win32_path[2:])
290
194
local_path_to_url = _posix_local_path_to_url
291
195
local_path_from_url = _posix_local_path_from_url
292
196
MIN_ABS_FILEURL_LENGTH = len('file:///')
293
WIN32_MIN_ABS_FILEURL_LENGTH = len('file:///C:/')
295
198
if sys.platform == 'win32':
296
199
local_path_to_url = _win32_local_path_to_url
297
200
local_path_from_url = _win32_local_path_from_url
299
MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
202
MIN_ABS_FILEURL_LENGTH = len('file:///C|/')
302
205
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
303
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
306
def _unescape_safe_chars(matchobj):
307
"""re.sub callback to convert hex-escapes to plain characters (if safe).
309
e.g. '%7E' will be converted to '~'.
311
hex_digits = matchobj.group(0)[1:]
312
char = chr(int(hex_digits, 16))
313
if char in _url_dont_escape_characters:
316
return matchobj.group(0).upper()
319
208
def normalize_url(url):
320
209
"""Make sure that a path string is in fully normalized URL form.
322
This handles URLs which have unicode characters, spaces,
211
This handles URLs which have unicode characters, spaces,
323
212
special characters, etc.
325
214
It has two basic modes of operation, depending on whether the
338
227
m = _url_scheme_re.match(url)
340
229
return local_path_to_url(url)
341
scheme = m.group('scheme')
342
path = m.group('path')
343
230
if not isinstance(url, unicode):
231
# TODO: jam 20060510 We need to test for ascii characters that
232
# shouldn't be allowed in URLs
345
234
if c not in _url_safe_characters:
346
235
raise errors.InvalidURL(url, 'URLs can only contain specific'
347
236
' safe characters (not %r)' % c)
348
path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
349
return str(scheme + '://' + ''.join(path))
351
238
# We have a unicode (hybrid) url
352
path_chars = list(path)
239
scheme = m.group('scheme')
240
path = list(m.group('path'))
354
for i in xrange(len(path_chars)):
355
if path_chars[i] not in _url_safe_characters:
356
chars = path_chars[i].encode('utf-8')
357
path_chars[i] = ''.join(
358
['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
359
path = ''.join(path_chars)
360
path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
361
return str(scheme + '://' + path)
242
for i in xrange(len(path)):
243
if path[i] not in _url_safe_characters:
244
chars = path[i].encode('utf-8')
245
path[i] = ''.join(['%%%02X' % ord(c) for c in path[i].encode('utf-8')])
246
return scheme + '://' + ''.join(path)
364
249
def relative_url(base, other):
492
357
file:///foo/ => file:///foo
493
358
# This is unique on win32 platforms, and is the only URL
494
359
# format which does it differently.
495
file:///c|/ => file:///c:/
360
file:///C|/ => file:///C|/
497
362
if not url.endswith('/'):
500
if sys.platform == 'win32' and url.startswith('file://'):
501
return _win32_strip_local_trailing_slash(url)
365
if sys.platform == 'win32' and url.startswith('file:///'):
366
# This gets handled specially, because the 'top-level'
367
# of a win32 path is actually the drive letter
368
if len(url) > MIN_ABS_FILEURL_LENGTH:
503
372
scheme_loc, first_path_slash = _find_scheme_and_separator(url)
504
373
if scheme_loc is None:
505
374
# This is a relative path, as it has no scheme
549
417
#These entries get mapped to themselves
550
418
_hex_display_map.update((hex,'%'+hex) for hex in _no_decode_hex)
552
# These characters shouldn't be percent-encoded, and it's always safe to
553
# unencode them if they are.
554
_url_dont_escape_characters = set(
555
"abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
556
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
557
"0123456789" # Numbers
558
"-._~" # Unreserved characters
561
420
# These characters should not be escaped
562
_url_safe_characters = set(
563
"abcdefghijklmnopqrstuvwxyz" # Lowercase alpha
564
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Uppercase alpha
565
"0123456789" # Numbers
566
"_.-!~*'()" # Unreserved characters
567
"/;?:@&=+$," # Reserved characters
568
"%#" # Extra reserved characters
421
_url_safe_characters = set('abcdefghijklmnopqrstuvwxyz'
422
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
571
427
def unescape_for_display(url, encoding):
572
428
"""Decode what you can for a URL, so that we get a nice looking path.
624
478
# Otherwise take the url decoded one
626
480
return u'/'.join(res)
629
def derive_to_location(from_location):
630
"""Derive a TO_LOCATION given a FROM_LOCATION.
632
The normal case is a FROM_LOCATION of http://foo/bar => bar.
633
The Right Thing for some logical destinations may differ though
634
because no / may be present at all. In that case, the result is
635
the full name without the scheme indicator, e.g. lp:foo-bar => foo-bar.
636
This latter case also applies when a Windows drive
637
is used without a path, e.g. c:foo-bar => foo-bar.
638
If no /, path separator or : is found, the from_location is returned.
640
if from_location.find("/") >= 0 or from_location.find(os.sep) >= 0:
641
return os.path.basename(from_location.rstrip("/\\"))
643
sep = from_location.find(":")
645
return from_location[sep+1:]
650
def _is_absolute(url):
651
return (osutils.pathjoin('/foo', url) == url)
654
def rebase_url(url, old_base, new_base):
655
"""Convert a relative path from an old base URL to a new base URL.
657
The result will be a relative path.
658
Absolute paths and full URLs are returned unaltered.
660
scheme, separator = _find_scheme_and_separator(url)
661
if scheme is not None:
663
if _is_absolute(url):
665
old_parsed = urlparse.urlparse(old_base)
666
new_parsed = urlparse.urlparse(new_base)
667
if (old_parsed[:2]) != (new_parsed[:2]):
668
raise errors.InvalidRebaseURLs(old_base, new_base)
669
return determine_relative_path(new_parsed[2],
670
join(old_parsed[2], url))
673
def determine_relative_path(from_path, to_path):
674
"""Determine a relative path from from_path to to_path."""
675
from_segments = osutils.splitpath(from_path)
676
to_segments = osutils.splitpath(to_path)
678
for count, (from_element, to_element) in enumerate(zip(from_segments,
680
if from_element != to_element:
684
unique_from = from_segments[count:]
685
unique_to = to_segments[count:]
686
segments = (['..'] * len(unique_from) + unique_to)
687
if len(segments) == 0:
689
return osutils.pathjoin(*segments)
added
removed
bzrlib/urlutils.py
