← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-04-27 22:07:03 UTC
  • mfrom: (4301.2.5 bzr.ab.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090427220703-oy9b0mxobrksvuyq
(gbache) Handle symlinks better in bzr add

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
75
75
    This assumes that both paths are already fully specified file:// URLs.
76
76
    """
77
77
    if len(base) < MIN_ABS_FILEURL_LENGTH:
78
 
        raise ValueError('Length of base (%r) must equal or'
 
78
        raise ValueError('Length of base must be equal or'
79
79
            ' exceed the platform minimum url length (which is %d)' %
80
 
            (base, MIN_ABS_FILEURL_LENGTH))
 
80
            MIN_ABS_FILEURL_LENGTH)
81
81
    base = local_path_from_url(base)
82
82
    path = local_path_from_url(path)
83
83
    return escape(osutils.relpath(base, path))
101
101
    first_path_slash = path.find('/')
102
102
    if first_path_slash == -1:
103
103
        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
 
104
    return len(scheme), first_path_slash+len(scheme)+3
110
105
 
111
106
 
112
107
def join(base, *args):
123
118
    """
124
119
    if not args:
125
120
        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:]
 
121
    match = _url_scheme_re.match(base)
 
122
    scheme = None
 
123
    if match:
 
124
        scheme = match.group('scheme')
 
125
        path = match.group('path').split('/')
 
126
        if path[-1:] == ['']:
 
127
            # Strip off a trailing slash
 
128
            # This helps both when we are at the root, and when
 
129
            # 'base' has an extra slash at the end
 
130
            path = path[:-1]
 
131
    else:
 
132
        path = base.split('/')
 
133
 
 
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
 
132
146
    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
 
147
        match = _url_scheme_re.match(arg)
 
148
        if match:
 
149
            # Absolute URL
 
150
            scheme = match.group('scheme')
 
151
            # this skips .. normalisation, making http://host/../../..
 
152
            # 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 = []
143
166
        else:
 
167
            path = '/'.join(path)
144
168
            path = joinpath(path, arg)
145
 
    return base[:path_start] + path
 
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
 
178
 
 
179
    if scheme is None:
 
180
        return '/'.join(path)
 
181
    return scheme + '://' + '/'.join(path)
146
182
 
147
183
 
148
184
def joinpath(base, *args):
181
217
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
182
218
def _posix_local_path_from_url(url):
183
219
    """Convert a url like file:///path/to/foo into /path/to/foo"""
184
 
    file_localhost_prefix = 'file://localhost/'
185
 
    if url.startswith(file_localhost_prefix):
186
 
        path = url[len(file_localhost_prefix) - 1:]
187
 
    elif not url.startswith('file:///'):
188
 
        raise errors.InvalidURL(
189
 
            url, 'local urls must start with file:/// or file://localhost/')
190
 
    else:
191
 
        path = url[len('file://'):]
 
220
    if not url.startswith('file:///'):
 
221
        raise errors.InvalidURL(url, 'local urls must start with file:///')
192
222
    # We only strip off 2 slashes
193
 
    return unescape(path)
 
223
    return unescape(url[len('file://'):])
194
224
 
195
225
 
196
226
def _posix_local_path_to_url(path):
224
254
        return '/'
225
255
 
226
256
    # usual local path with drive letter
227
 
    if (len(win32_url) < 6
228
 
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
229
 
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
257
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
258
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
230
259
        or win32_url[4] not in  '|:'
231
260
        or win32_url[5] != '/'):
232
261
        raise errors.InvalidURL(url, 'Win32 file urls start with'
243
272
    # on non-win32 platform
244
273
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
245
274
    #       which actually strips trailing space characters.
246
 
    #       The worst part is that on linux ntpath.abspath has different
 
275
    #       The worst part is that under linux ntpath.abspath has different
247
276
    #       semantics, since 'nt' is not an available module.
248
277
    if path == '/':
249
278
        return 'file:///'
268
297
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
269
298
 
270
299
 
271
 
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
 
300
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
272
301
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
273
302
 
274
303
 
304
333
    :param url: Either a hybrid URL or a local path
305
334
    :return: A normalized URL which only includes 7-bit ASCII characters.
306
335
    """
307
 
    scheme_end, path_start = _find_scheme_and_separator(url)
308
 
    if scheme_end is None:
 
336
    m = _url_scheme_re.match(url)
 
337
    if not m:
309
338
        return local_path_to_url(url)
310
 
    prefix = url[:path_start]
311
 
    path = url[path_start:]
 
339
    scheme = m.group('scheme')
 
340
    path = m.group('path')
312
341
    if not isinstance(url, unicode):
313
342
        for c in url:
314
343
            if c not in _url_safe_characters:
315
344
                raise errors.InvalidURL(url, 'URLs can only contain specific'
316
345
                                            ' safe characters (not %r)' % c)
317
346
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
318
 
        return str(prefix + ''.join(path))
 
347
        return str(scheme + '://' + ''.join(path))
319
348
 
320
349
    # We have a unicode (hybrid) url
321
350
    path_chars = list(path)
327
356
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
328
357
    path = ''.join(path_chars)
329
358
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
330
 
    return str(prefix + path)
 
359
    return str(scheme + '://' + path)
331
360
 
332
361
 
333
362
def relative_url(base, other):
434
463
    return url_base + head, tail
435
464
 
436
465
 
437
 
def split_segment_parameters_raw(url):
438
 
    """Split the subsegment of the last segment of a URL.
439
 
 
440
 
    :param url: A relative or absolute URL
441
 
    :return: (url, subsegments)
442
 
    """
443
 
    (parent_url, child_dir) = split(url)
444
 
    subsegments = child_dir.split(",")
445
 
    if len(subsegments) == 1:
446
 
        return (url, [])
447
 
    return (join(parent_url, subsegments[0]), subsegments[1:])
448
 
 
449
 
 
450
 
def split_segment_parameters(url):
451
 
    """Split the segment parameters of the last segment of a URL.
452
 
 
453
 
    :param url: A relative or absolute URL
454
 
    :return: (url, segment_parameters)
455
 
    """
456
 
    (base_url, subsegments) = split_segment_parameters_raw(url)
457
 
    parameters = {}
458
 
    for subsegment in subsegments:
459
 
        (key, value) = subsegment.split("=", 1)
460
 
        parameters[key] = value
461
 
    return (base_url, parameters)
462
 
 
463
 
 
464
 
def join_segment_parameters_raw(base, *subsegments):
465
 
    """Create a new URL by adding subsegments to an existing one. 
466
 
 
467
 
    This adds the specified subsegments to the last path in the specified
468
 
    base URL. The subsegments should be bytestrings.
469
 
 
470
 
    :note: You probably want to use join_segment_parameters instead.
471
 
    """
472
 
    if not subsegments:
473
 
        return base
474
 
    for subsegment in subsegments:
475
 
        if type(subsegment) is not str:
476
 
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
477
 
        if "," in subsegment:
478
 
            raise errors.InvalidURLJoin(", exists in subsegments",
479
 
                                        base, subsegments)
480
 
    return ",".join((base,) + subsegments)
481
 
 
482
 
 
483
 
def join_segment_parameters(url, parameters):
484
 
    """Create a new URL by adding segment parameters to an existing one.
485
 
 
486
 
    The parameters of the last segment in the URL will be updated; if a
487
 
    parameter with the same key already exists it will be overwritten.
488
 
 
489
 
    :param url: A URL, as string
490
 
    :param parameters: Dictionary of parameters, keys and values as bytestrings
491
 
    """
492
 
    (base, existing_parameters) = split_segment_parameters(url)
493
 
    new_parameters = {}
494
 
    new_parameters.update(existing_parameters)
495
 
    for key, value in parameters.iteritems():
496
 
        if type(key) is not str:
497
 
            raise TypeError("parameter key %r is not a bytestring" % key)
498
 
        if type(value) is not str:
499
 
            raise TypeError("parameter value %r for %s is not a bytestring" %
500
 
                (key, value))
501
 
        if "=" in key:
502
 
            raise errors.InvalidURLJoin("= exists in parameter key", url,
503
 
                parameters)
504
 
        new_parameters[key] = value
505
 
    return join_segment_parameters_raw(base, 
506
 
        *["%s=%s" % item for item in sorted(new_parameters.items())])
507
 
 
508
 
 
509
466
def _win32_strip_local_trailing_slash(url):
510
467
    """Strip slashes after the drive letter"""
511
468
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH: