← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: INADA Naoki
  • Date: 2011-05-05 09:15:34 UTC
  • mto: (5830.3.3 i18n-msgfmt)
  • mto: This revision was merged to the branch mainline in revision 5873.
  • Revision ID: songofacandy@gmail.com-20110505091534-7sv835xpofwrmpt4
Add update-pot command to Makefile and tools/bzrgettext script that
extracts help text from bzr commands.

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
77
75
    This assumes that both paths are already fully specified file:// URLs.
78
76
    """
79
77
    if len(base) < MIN_ABS_FILEURL_LENGTH:
80
 
        raise ValueError('Length of base must be equal or'
 
78
        raise ValueError('Length of base (%r) must equal or'
81
79
            ' exceed the platform minimum url length (which is %d)' %
82
 
            MIN_ABS_FILEURL_LENGTH)
 
80
            (base, MIN_ABS_FILEURL_LENGTH))
83
81
    base = local_path_from_url(base)
84
82
    path = local_path_from_url(path)
85
83
    return escape(osutils.relpath(base, path))
103
101
    first_path_slash = path.find('/')
104
102
    if first_path_slash == -1:
105
103
        return len(scheme), None
106
 
    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
107
110
 
108
111
 
109
112
def join(base, *args):
120
123
    """
121
124
    if not args:
122
125
        return base
123
 
    match = _url_scheme_re.match(base)
124
 
    scheme = None
125
 
    if match:
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
132
 
            path = path[:-1]
133
 
    else:
134
 
        path = base.split('/')
135
 
 
136
 
    if scheme is not None and len(path) >= 1:
137
 
        host = 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.
140
 
        remove_root = True
141
 
        path = [''] + path[1:]
142
 
    else:
143
 
        # create an empty host, but dont alter the path - this might be a
144
 
        # relative url fragment.
145
 
        host = []
146
 
        remove_root = False
147
 
 
 
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:]
148
132
    for arg in args:
149
 
        match = _url_scheme_re.match(arg)
150
 
        if match:
151
 
            # Absolute URL
152
 
            scheme = match.group('scheme')
153
 
            # this skips .. normalisation, making http://host/../../..
154
 
            # be rather strange.
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:
161
 
                host = path[:1]
162
 
                path = path[1:]
163
 
                # url scheme implies absolute path.
164
 
                path = [''] + path
165
 
            else:
166
 
                # no url scheme we take the path as is.
167
 
                host = []
 
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
168
143
        else:
169
 
            path = '/'.join(path)
170
144
            path = joinpath(path, arg)
171
 
            path = path.split('/')
172
 
    if remove_root and path[0:1] == ['']:
173
 
        del path[0]
174
 
    if host:
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:
178
 
            del path[0]
179
 
        path = host + path
180
 
 
181
 
    if scheme is None:
182
 
        return '/'.join(path)
183
 
    return scheme + '://' + '/'.join(path)
 
145
    return base[:path_start] + path
184
146
 
185
147
 
186
148
def joinpath(base, *args):
219
181
# jam 20060502 Sorted to 'l' because the final target is 'local_path_from_url'
220
182
def _posix_local_path_from_url(url):
221
183
    """Convert a url like file:///path/to/foo into /path/to/foo"""
222
 
    if not url.startswith('file:///'):
223
 
        raise errors.InvalidURL(url, 'local urls must start with file:///')
 
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://'):]
224
192
    # We only strip off 2 slashes
225
 
    return unescape(url[len('file://'):])
 
193
    return unescape(path)
226
194
 
227
195
 
228
196
def _posix_local_path_to_url(path):
256
224
        return '/'
257
225
 
258
226
    # usual local path with drive letter
259
 
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
260
 
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
227
    if (len(win32_url) < 6
 
228
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
229
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
261
230
        or win32_url[4] not in  '|:'
262
231
        or win32_url[5] != '/'):
263
232
        raise errors.InvalidURL(url, 'Win32 file urls start with'
274
243
    # on non-win32 platform
275
244
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
276
245
    #       which actually strips trailing space characters.
277
 
    #       The worst part is that under linux ntpath.abspath has different
 
246
    #       The worst part is that on linux ntpath.abspath has different
278
247
    #       semantics, since 'nt' is not an available module.
279
248
    if path == '/':
280
249
        return 'file:///'
299
268
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
300
269
 
301
270
 
302
 
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
 
271
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
303
272
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
304
273
 
305
274
 
335
304
    :param url: Either a hybrid URL or a local path
336
305
    :return: A normalized URL which only includes 7-bit ASCII characters.
337
306
    """
338
 
    m = _url_scheme_re.match(url)
339
 
    if not m:
 
307
    scheme_end, path_start = _find_scheme_and_separator(url)
 
308
    if scheme_end is None:
340
309
        return local_path_to_url(url)
341
 
    scheme = m.group('scheme')
342
 
    path = m.group('path')
 
310
    prefix = url[:path_start]
 
311
    path = url[path_start:]
343
312
    if not isinstance(url, unicode):
344
313
        for c in url:
345
314
            if c not in _url_safe_characters:
346
315
                raise errors.InvalidURL(url, 'URLs can only contain specific'
347
316
                                            ' safe characters (not %r)' % c)
348
317
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
349
 
        return str(scheme + '://' + ''.join(path))
 
318
        return str(prefix + ''.join(path))
350
319
 
351
320
    # We have a unicode (hybrid) url
352
321
    path_chars = list(path)
358
327
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
359
328
    path = ''.join(path_chars)
360
329
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
361
 
    return str(scheme + '://' + path)
 
330
    return str(prefix + path)
362
331
 
363
332
 
364
333
def relative_url(base, other):
465
434
    return url_base + head, tail
466
435
 
467
436
 
 
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
 
468
509
def _win32_strip_local_trailing_slash(url):
469
510
    """Strip slashes after the drive letter"""
470
511
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
687
728
    if len(segments) == 0:
688
729
        return '.'
689
730
    return osutils.pathjoin(*segments)
 
731
 
 
732
 
 
733
 
 
734
def parse_url(url):
 
735
    """Extract the server address, the credentials and the path from the url.
 
736
 
 
737
    user, password, host and path should be quoted if they contain reserved
 
738
    chars.
 
739
 
 
740
    :param url: an quoted url
 
741
 
 
742
    :return: (scheme, user, password, host, port, path) tuple, all fields
 
743
        are unquoted.
 
744
    """
 
745
    if isinstance(url, unicode):
 
746
        raise errors.InvalidURL('should be ascii:\n%r' % url)
 
747
    url = url.encode('utf-8')
 
748
    (scheme, netloc, path, params,
 
749
     query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
750
    user = password = host = port = None
 
751
    if '@' in netloc:
 
752
        user, host = netloc.rsplit('@', 1)
 
753
        if ':' in user:
 
754
            user, password = user.split(':', 1)
 
755
            password = urllib.unquote(password)
 
756
        user = urllib.unquote(user)
 
757
    else:
 
758
        host = netloc
 
759
 
 
760
    if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port
 
761
        host, port = host.rsplit(':',1)
 
762
        try:
 
763
            port = int(port)
 
764
        except ValueError:
 
765
            raise errors.InvalidURL('invalid port number %s in url:\n%s' %
 
766
                                    (port, url))
 
767
    if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
 
768
        host = host[1:-1]
 
769
 
 
770
    host = urllib.unquote(host)
 
771
    path = urllib.unquote(path)
 
772
 
 
773
    return (scheme, user, password, host, port, path)