~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: 2010-05-11 11:47:36 UTC
  • mfrom: (5200.3.8 lock_return)
  • Revision ID: pqm@pqm.ubuntu.com-20100511114736-mc1sq9zyo3vufec7
(lifeless) Provide a consistent interface to Tree, Branch,
 Repository where lock methods return an object with an unlock method to
 unlock the lock. This breaks the API for Branch,
 Repository on their lock_write methods. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
    url = split_segment_parameters_raw(url)[0]
185
220
    file_localhost_prefix = 'file://localhost/'
186
221
    if url.startswith(file_localhost_prefix):
187
222
        path = url[len(file_localhost_prefix) - 1:]
210
245
    if not url.startswith('file://'):
211
246
        raise errors.InvalidURL(url, 'local urls must start with file:///, '
212
247
                                     'UNC path urls must start with file://')
213
 
    url = split_segment_parameters_raw(url)[0]
214
248
    # We strip off all 3 slashes
215
249
    win32_url = url[len('file:'):]
216
250
    # check for UNC path: //HOST/path
226
260
        return '/'
227
261
 
228
262
    # usual local path with drive letter
229
 
    if (len(win32_url) < 6
230
 
        or win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
231
 
                                'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
263
    if (win32_url[3] not in ('abcdefghijklmnopqrstuvwxyz'
 
264
                             'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
232
265
        or win32_url[4] not in  '|:'
233
266
        or win32_url[5] != '/'):
234
267
        raise errors.InvalidURL(url, 'Win32 file urls start with'
245
278
    # on non-win32 platform
246
279
    # FIXME: It turns out that on nt, ntpath.abspath uses nt._getfullpathname
247
280
    #       which actually strips trailing space characters.
248
 
    #       The worst part is that on linux ntpath.abspath has different
 
281
    #       The worst part is that under linux ntpath.abspath has different
249
282
    #       semantics, since 'nt' is not an available module.
250
283
    if path == '/':
251
284
        return 'file:///'
270
303
    MIN_ABS_FILEURL_LENGTH = WIN32_MIN_ABS_FILEURL_LENGTH
271
304
 
272
305
 
273
 
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,}):(//)?(?P<path>.*)$')
 
306
_url_scheme_re = re.compile(r'^(?P<scheme>[^:/]{2,})://(?P<path>.*)$')
274
307
_url_hex_escapes_re = re.compile(r'(%[0-9a-fA-F]{2})')
275
308
 
276
309
 
306
339
    :param url: Either a hybrid URL or a local path
307
340
    :return: A normalized URL which only includes 7-bit ASCII characters.
308
341
    """
309
 
    scheme_end, path_start = _find_scheme_and_separator(url)
310
 
    if scheme_end is None:
 
342
    m = _url_scheme_re.match(url)
 
343
    if not m:
311
344
        return local_path_to_url(url)
312
 
    prefix = url[:path_start]
313
 
    path = url[path_start:]
 
345
    scheme = m.group('scheme')
 
346
    path = m.group('path')
314
347
    if not isinstance(url, unicode):
315
348
        for c in url:
316
349
            if c not in _url_safe_characters:
317
350
                raise errors.InvalidURL(url, 'URLs can only contain specific'
318
351
                                            ' safe characters (not %r)' % c)
319
352
        path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
320
 
        return str(prefix + ''.join(path))
 
353
        return str(scheme + '://' + ''.join(path))
321
354
 
322
355
    # We have a unicode (hybrid) url
323
356
    path_chars = list(path)
329
362
                ['%%%02X' % ord(c) for c in path_chars[i].encode('utf-8')])
330
363
    path = ''.join(path_chars)
331
364
    path = _url_hex_escapes_re.sub(_unescape_safe_chars, path)
332
 
    return str(prefix + path)
 
365
    return str(scheme + '://' + path)
333
366
 
334
367
 
335
368
def relative_url(base, other):
388
421
    """On win32 the drive letter needs to be added to the url base."""
389
422
    # Strip off the drive letter
390
423
    # path is currently /C:/foo
391
 
    if len(path) < 4 or path[2] not in ':|' or path[3] != '/':
 
424
    if len(path) < 3 or path[2] not in ':|' or path[3] != '/':
392
425
        raise errors.InvalidURL(url_base + path,
393
426
            'win32 file:/// paths need a drive letter')
394
427
    url_base += path[0:3] # file:// + /C:
436
469
    return url_base + head, tail
437
470
 
438
471
 
439
 
def split_segment_parameters_raw(url):
440
 
    """Split the subsegment of the last segment of a URL.
441
 
 
442
 
    :param url: A relative or absolute URL
443
 
    :return: (url, subsegments)
444
 
    """
445
 
    (parent_url, child_dir) = split(url)
446
 
    subsegments = child_dir.split(",")
447
 
    if len(subsegments) == 1:
448
 
        return (url, [])
449
 
    return (join(parent_url, subsegments[0]), subsegments[1:])
450
 
 
451
 
 
452
 
def split_segment_parameters(url):
453
 
    """Split the segment parameters of the last segment of a URL.
454
 
 
455
 
    :param url: A relative or absolute URL
456
 
    :return: (url, segment_parameters)
457
 
    """
458
 
    (base_url, subsegments) = split_segment_parameters_raw(url)
459
 
    parameters = {}
460
 
    for subsegment in subsegments:
461
 
        (key, value) = subsegment.split("=", 1)
462
 
        parameters[key] = value
463
 
    return (base_url, parameters)
464
 
 
465
 
 
466
 
def join_segment_parameters_raw(base, *subsegments):
467
 
    """Create a new URL by adding subsegments to an existing one. 
468
 
 
469
 
    This adds the specified subsegments to the last path in the specified
470
 
    base URL. The subsegments should be bytestrings.
471
 
 
472
 
    :note: You probably want to use join_segment_parameters instead.
473
 
    """
474
 
    if not subsegments:
475
 
        return base
476
 
    for subsegment in subsegments:
477
 
        if type(subsegment) is not str:
478
 
            raise TypeError("Subsegment %r is not a bytestring" % subsegment)
479
 
        if "," in subsegment:
480
 
            raise errors.InvalidURLJoin(", exists in subsegments",
481
 
                                        base, subsegments)
482
 
    return ",".join((base,) + subsegments)
483
 
 
484
 
 
485
 
def join_segment_parameters(url, parameters):
486
 
    """Create a new URL by adding segment parameters to an existing one.
487
 
 
488
 
    The parameters of the last segment in the URL will be updated; if a
489
 
    parameter with the same key already exists it will be overwritten.
490
 
 
491
 
    :param url: A URL, as string
492
 
    :param parameters: Dictionary of parameters, keys and values as bytestrings
493
 
    """
494
 
    (base, existing_parameters) = split_segment_parameters(url)
495
 
    new_parameters = {}
496
 
    new_parameters.update(existing_parameters)
497
 
    for key, value in parameters.iteritems():
498
 
        if type(key) is not str:
499
 
            raise TypeError("parameter key %r is not a bytestring" % key)
500
 
        if type(value) is not str:
501
 
            raise TypeError("parameter value %r for %s is not a bytestring" %
502
 
                (key, value))
503
 
        if "=" in key:
504
 
            raise errors.InvalidURLJoin("= exists in parameter key", url,
505
 
                parameters)
506
 
        new_parameters[key] = value
507
 
    return join_segment_parameters_raw(base, 
508
 
        *["%s=%s" % item for item in sorted(new_parameters.items())])
509
 
 
510
 
 
511
472
def _win32_strip_local_trailing_slash(url):
512
473
    """Strip slashes after the drive letter"""
513
474
    if len(url) > WIN32_MIN_ABS_FILEURL_LENGTH:
732
693
    return osutils.pathjoin(*segments)
733
694
 
734
695
 
735
 
class URL(object):
736
 
    """Parsed URL."""
737
 
 
738
 
    def __init__(self, scheme, quoted_user, quoted_password, quoted_host,
739
 
            port, quoted_path):
740
 
        self.scheme = scheme
741
 
        self.quoted_host = quoted_host
742
 
        self.host = urllib.unquote(self.quoted_host)
743
 
        self.quoted_user = quoted_user
744
 
        if self.quoted_user is not None:
745
 
            self.user = urllib.unquote(self.quoted_user)
746
 
        else:
747
 
            self.user = None
748
 
        self.quoted_password = quoted_password
749
 
        if self.quoted_password is not None:
750
 
            self.password = urllib.unquote(self.quoted_password)
751
 
        else:
752
 
            self.password = None
753
 
        self.port = port
754
 
        self.quoted_path = quoted_path
755
 
        self.path = urllib.unquote(self.quoted_path)
756
 
 
757
 
    def __eq__(self, other):
758
 
        return (isinstance(other, self.__class__) and
759
 
                self.scheme == other.scheme and
760
 
                self.host == other.host and
761
 
                self.user == other.user and
762
 
                self.password == other.password and
763
 
                self.path == other.path)
764
 
 
765
 
    def __repr__(self):
766
 
        return "<%s(%r, %r, %r, %r, %r, %r)>" % (
767
 
            self.__class__.__name__,
768
 
            self.scheme, self.quoted_user, self.quoted_password,
769
 
            self.quoted_host, self.port, self.quoted_path)
770
 
 
771
 
    @classmethod
772
 
    def from_string(cls, url):
773
 
        """Create a URL object from a string.
774
 
 
775
 
        :param url: URL as bytestring
776
 
        """
777
 
        if isinstance(url, unicode):
778
 
            raise errors.InvalidURL('should be ascii:\n%r' % url)
779
 
        url = url.encode('utf-8')
780
 
        (scheme, netloc, path, params,
781
 
         query, fragment) = urlparse.urlparse(url, allow_fragments=False)
782
 
        user = password = host = port = None
783
 
        if '@' in netloc:
784
 
            user, host = netloc.rsplit('@', 1)
785
 
            if ':' in user:
786
 
                user, password = user.split(':', 1)
787
 
        else:
788
 
            host = netloc
789
 
 
790
 
        if ':' in host and not (host[0] == '[' and host[-1] == ']'):
791
 
            # there *is* port
792
 
            host, port = host.rsplit(':',1)
793
 
            try:
794
 
                port = int(port)
795
 
            except ValueError:
796
 
                raise errors.InvalidURL('invalid port number %s in url:\n%s' %
797
 
                                        (port, url))
798
 
        if host != "" and host[0] == '[' and host[-1] == ']': #IPv6
799
 
            host = host[1:-1]
800
 
 
801
 
        return cls(scheme, user, password, host, port, path)
802
 
 
803
 
    def __str__(self):
804
 
        netloc = self.quoted_host
805
 
        if ":" in netloc:
806
 
            netloc = "[%s]" % netloc
807
 
        if self.quoted_user is not None:
808
 
            # Note that we don't put the password back even if we
809
 
            # have one so that it doesn't get accidentally
810
 
            # exposed.
811
 
            netloc = '%s@%s' % (self.quoted_user, netloc)
812
 
        if self.port is not None:
813
 
            netloc = '%s:%d' % (netloc, self.port)
814
 
        return urlparse.urlunparse(
815
 
            (self.scheme, netloc, self.quoted_path, None, None, None))
816
 
 
817
 
    @staticmethod
818
 
    def _combine_paths(base_path, relpath):
819
 
        """Transform a Transport-relative path to a remote absolute path.
820
 
 
821
 
        This does not handle substitution of ~ but does handle '..' and '.'
822
 
        components.
823
 
 
824
 
        Examples::
825
 
 
826
 
            t._combine_paths('/home/sarah', 'project/foo')
827
 
                => '/home/sarah/project/foo'
828
 
            t._combine_paths('/home/sarah', '../../etc')
829
 
                => '/etc'
830
 
            t._combine_paths('/home/sarah', '/etc')
831
 
                => '/etc'
832
 
 
833
 
        :param base_path: base path
834
 
        :param relpath: relative url string for relative part of remote path.
835
 
        :return: urlencoded string for final path.
836
 
        """
837
 
        if not isinstance(relpath, str):
838
 
            raise errors.InvalidURL(relpath)
839
 
        if relpath.startswith('/'):
840
 
            base_parts = []
841
 
        else:
842
 
            base_parts = base_path.split('/')
843
 
        if len(base_parts) > 0 and base_parts[-1] == '':
844
 
            base_parts = base_parts[:-1]
845
 
        for p in relpath.split('/'):
846
 
            if p == '..':
847
 
                if len(base_parts) == 0:
848
 
                    # In most filesystems, a request for the parent
849
 
                    # of root, just returns root.
850
 
                    continue
851
 
                base_parts.pop()
852
 
            elif p == '.':
853
 
                continue # No-op
854
 
            elif p != '':
855
 
                base_parts.append(p)
856
 
        path = '/'.join(base_parts)
857
 
        if not path.startswith('/'):
858
 
            path = '/' + path
859
 
        return path
860
 
 
861
 
    def clone(self, offset=None):
862
 
        """Return a new URL for a path relative to this URL.
863
 
 
864
 
        :param offset: A relative path, already urlencoded
865
 
        :return: `URL` instance
866
 
        """
867
 
        if offset is not None:
868
 
            relative = unescape(offset).encode('utf-8')
869
 
            path = self._combine_paths(self.path, relative)
870
 
            path = urllib.quote(path)
871
 
        else:
872
 
            path = self.quoted_path
873
 
        return self.__class__(self.scheme, self.quoted_user,
874
 
                self.quoted_password, self.quoted_host, self.port,
875
 
                path)
876
 
 
877
696
 
878
697
def parse_url(url):
879
698
    """Extract the server address, the credentials and the path from the url.
882
701
    chars.
883
702
 
884
703
    :param url: an quoted url
 
704
 
885
705
    :return: (scheme, user, password, host, port, path) tuple, all fields
886
706
        are unquoted.
887
707
    """
888
 
    parsed_url = URL.from_string(url)
889
 
    return (parsed_url.scheme, parsed_url.user, parsed_url.password,
890
 
        parsed_url.host, parsed_url.port, parsed_url.path)
 
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)