/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/urlutils.py

  • Committer: Vincent Ladeuil
  • Date: 2011-08-12 14:47:42 UTC
  • mto: This revision was merged to the branch mainline in revision 6075.
  • Revision ID: v.ladeuil+lp@free.fr-20110812144742-g12l2cgakyulg935
Migrate bzr.workingtree.worth_saving_limit to stack-based config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/urlutils.py
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+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
105
110
 
106
111
 
107
112
def join(base, *args):
118
123
    """
119
124
    if not args:
120
125
        return base
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
 
 
 
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:]
146
132
    for arg in args:
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 = []
 
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
166
143
        else:
167
 
            path = '/'.join(path)
168
144
            path = joinpath(path, arg)
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)
 
145
    return base[:path_start] + path
182
146
 
183
147
 
184
148
def joinpath(base, *args):
260
224
        return '/'
261
225
 
262
226
    # usual local path with drive letter
263
 
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
264
 
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
227
    if (len(win32_url) < 6
 
228
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
229
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
265
230
        or win32_url[4] not in  '|:'
266
231
        or win32_url[5] != '/'):
267
232
        raise errors.InvalidURL(url, 'Win32 file urls start with'
278
243
    # on non-win32 platform
279
244
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
280
245
    #       which actually strips trailing space characters.
281
 
    #       The worst part is that under linux ntpath.abspath has different
 
246
    #       The worst part is that on linux ntpath.abspath has different
282
247
    #       semantics, since 'nt' is not an available module.
283
248
    if path == '/':
284
249
        return 'file:///'
303
268
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
304
269
 
305
270
 
306
 
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
 
271
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
307
272
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
308
273
 
309
274
 
339
304
    :param url: Either a hybrid URL or a local path
340
305
    :return: A normalized URL which only includes 7-bit ASCII characters.
341
306
    """
342
 
    m = _url_scheme_re.match(url)
343
 
    if not m:
 
307
    scheme_end, path_start = _find_scheme_and_separator(url)
 
308
    if scheme_end is None:
344
309
        return local_path_to_url(url)
345
 
    scheme = m.group('scheme')
346
 
    path = m.group('path')
 
310
    prefix = url[:path_start]
 
311
    path = url[path_start:]
347
312
    if not isinstance(url, unicode):
348
313
        for c in url:
349
314
            if c not in _url_safe_characters:
350
315
                raise errors.InvalidURL(url, 'URLs can only contain specific'
351
316
                                            ' safe characters (not %r)' % c)
352
317
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
353
 
        return str(scheme + '://' + ''.join(path))
 
318
        return str(prefix + ''.join(path))
354
319
 
355
320
    # We have a unicode (hybrid) url
356
321
    path_chars = list(path)
362
327
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
363
328
    path = ''.join(path_chars)
364
329
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
365
 
    return str(scheme + '://' + path)
 
330
    return str(prefix + path)
366
331
 
367
332
 
368
333
def relative_url(base, other):
469
434
    return url_base + head, tail
470
435
 
471
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
 
472
509
def _win32_strip_local_trailing_slash(url):
473
510
    """Strip slashes after the drive letter"""
474
511
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
693
730
    return osutils.pathjoin(*segments)
694
731
 
695
732
 
 
733
class URL(object):
 
734
    """Parsed URL."""
 
735
 
 
736
    def __init__(self, scheme, quoted_user, quoted_password, quoted_host,
 
737
            port, quoted_path):
 
738
        self.scheme = scheme
 
739
        self.quoted_host = quoted_host
 
740
        self.host = urllib.unquote(self.quoted_host)
 
741
        self.quoted_user = quoted_user
 
742
        if self.quoted_user is not None:
 
743
            self.user = urllib.unquote(self.quoted_user)
 
744
        else:
 
745
            self.user = None
 
746
        self.quoted_password = quoted_password
 
747
        if self.quoted_password is not None:
 
748
            self.password = urllib.unquote(self.quoted_password)
 
749
        else:
 
750
            self.password = None
 
751
        self.port = port
 
752
        self.quoted_path = quoted_path
 
753
        self.path = urllib.unquote(self.quoted_path)
 
754
 
 
755
    def __eq__(self, other):
 
756
        return (isinstance(other, self.__class__) and
 
757
                self.scheme == other.scheme and
 
758
                self.host == other.host and
 
759
                self.user == other.user and
 
760
                self.password == other.password and
 
761
                self.path == other.path)
 
762
 
 
763
    def __repr__(self):
 
764
        return "<%s(%r, %r, %r, %r, %r, %r)>" % (
 
765
            self.__class__.__name__,
 
766
            self.scheme, self.quoted_user, self.quoted_password,
 
767
            self.quoted_host, self.port, self.quoted_path)
 
768
 
 
769
    @classmethod
 
770
    def from_string(cls, url):
 
771
        """Create a URL object from a string.
 
772
 
 
773
        :param url: URL as bytestring
 
774
        """
 
775
        if isinstance(url, unicode):
 
776
            raise errors.InvalidURL('should be ascii:\n%r' % url)
 
777
        url = url.encode('utf-8')
 
778
        (scheme, netloc, path, params,
 
779
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
 
780
        user = password = host = port = None
 
781
        if '@' in netloc:
 
782
            user, host = netloc.rsplit('@', 1)
 
783
            if ':' in user:
 
784
                user, password = user.split(':', 1)
 
785
        else:
 
786
            host = netloc
 
787
 
 
788
        if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port
 
789
            host, port = host.rsplit(':',1)
 
790
            try:
 
791
                port = int(port)
 
792
            except ValueError:
 
793
                raise errors.InvalidURL('invalid port number %s in url:\n%s' %
 
794
                                        (port, url))
 
795
        if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
 
796
            host = host[1:-1]
 
797
 
 
798
        return cls(scheme, user, password, host, port, path)
 
799
 
696
800
 
697
801
def parse_url(url):
698
802
    """Extract the server address, the credentials and the path from the url.
701
805
    chars.
702
806
 
703
807
    :param url: an quoted url
704
 
 
705
808
    :return: (scheme, user, password, host, port, path) tuple, all fields
706
809
        are unquoted.
707
810
    """
708
 
    if isinstance(url, unicode):
709
 
        raise errors.InvalidURL('should be ascii:\n%r' % url)
710
 
    url = url.encode('utf-8')
711
 
    (scheme, netloc, path, params,
712
 
     query, fragment) = urlparse.urlparse(url, allow_fragments=False)
713
 
    user = password = host = port = None
714
 
    if '@' in netloc:
715
 
        user, host = netloc.rsplit('@', 1)
716
 
        if ':' in user:
717
 
            user, password = user.split(':', 1)
718
 
            password = urllib.unquote(password)
719
 
        user = urllib.unquote(user)
720
 
    else:
721
 
        host = netloc
722
 
 
723
 
    if ':' in host and not (host[0] == '[' and host[-1] == ']'): #there *is* port
724
 
        host, port = host.rsplit(':',1)
725
 
        try:
726
 
            port = int(port)
727
 
        except ValueError:
728
 
            raise errors.InvalidURL('invalid port number %s in url:\n%s' %
729
 
                                    (port, url))
730
 
    if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
731
 
        host = host[1:-1]
732
 
 
733
 
    host = urllib.unquote(host)
734
 
    path = urllib.unquote(path)
735
 
 
736
 
    return (scheme, user, password, host, port, path)
 
811
    parsed_url = URL.from_string(url)
 
812
    return (parsed_url.scheme, parsed_url.user, parsed_url.password,
 
813
        parsed_url.host, parsed_url.port, parsed_url.path)