/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 breezy/urlutils.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2020-05-06 03:06:18 UTC
  • mfrom: (7500.1.2 trunk-merge-3.1)
  • Revision ID: breezy.the.bot@gmail.com-20200506030618-131sjbc876q7on66
Merge the 3.1 branch.

Merged from https://code.launchpad.net/~jelmer/brz/trunk-merge-3.1/+merge/383481

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/urlutils.py
16
16
 
17
17
"""A collection of function for handling URL operations."""
18
18
 
19
 
from __future__ import absolute_import
20
 
 
21
19
import os
22
20
import re
23
21
import sys
24
22
 
25
 
try:
26
 
    import urlparse
27
 
except ImportError:
28
 
    from urllib import parse as urlparse
 
23
from urllib import parse as urlparse
29
24
 
30
25
from . import (
31
26
    errors,
37
32
from posixpath import split as _posix_split
38
33
""")
39
34
 
40
 
from .sixish import (
41
 
    int2byte,
42
 
    PY3,
43
 
    text_type,
44
 
    unichr,
45
 
    )
46
35
 
47
36
 
48
37
class InvalidURL(errors.PathError):
99
88
    return split(url, exclude_trailing_slash=exclude_trailing_slash)[0]
100
89
 
101
90
 
102
 
if PY3:
103
 
    quote_from_bytes = urlparse.quote_from_bytes
104
 
    quote = urlparse.quote
105
 
    unquote_to_bytes = urlparse.unquote_to_bytes
106
 
else:
107
 
    # Private copies of quote and unquote, copied from Python's urllib module
108
 
    # because urllib unconditionally imports socket, which imports ssl.
109
 
 
110
 
    always_safe = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
111
 
                   'abcdefghijklmnopqrstuvwxyz'
112
 
                   '0123456789' '_.-')
113
 
    _safe_map = {}
114
 
    for i, c in zip(range(256), ''.join(map(chr, range(256)))):
115
 
        _safe_map[c] = c if (
116
 
            i < 128 and c in always_safe) else '%{0:02X}'.format(i)
117
 
    _safe_quoters = {}
118
 
 
119
 
    def quote_from_bytes(s, safe='/'):
120
 
        """quote('abc def') -> 'abc%20def'
121
 
 
122
 
        Each part of a URL, e.g. the path info, the query, etc., has a
123
 
        different set of reserved characters that must be quoted.
124
 
 
125
 
        RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
126
 
        the following reserved characters.
127
 
 
128
 
        reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
129
 
                      "$" | ","
130
 
 
131
 
        Each of these characters is reserved in some component of a URL,
132
 
        but not necessarily in all of them.
133
 
 
134
 
        By default, the quote function is intended for quoting the path
135
 
        section of a URL.  Thus, it will not encode '/'.  This character
136
 
        is reserved, but in typical usage the quote function is being
137
 
        called on a path where the existing slash characters are used as
138
 
        reserved characters.
139
 
        """
140
 
        # fastpath
141
 
        if not s:
142
 
            if s is None:
143
 
                raise TypeError('None object cannot be quoted')
144
 
            return s
145
 
        cachekey = (safe, always_safe)
146
 
        try:
147
 
            (quoter, safe) = _safe_quoters[cachekey]
148
 
        except KeyError:
149
 
            safe_map = _safe_map.copy()
150
 
            safe_map.update([(c, c) for c in safe])
151
 
            quoter = safe_map.__getitem__
152
 
            safe = always_safe + safe
153
 
            _safe_quoters[cachekey] = (quoter, safe)
154
 
        if not s.rstrip(safe):
155
 
            return s
156
 
        return ''.join(map(quoter, s))
157
 
 
158
 
    quote = quote_from_bytes
159
 
    unquote_to_bytes = urlparse.unquote
160
 
 
161
 
 
 
91
quote_from_bytes = urlparse.quote_from_bytes
 
92
quote = urlparse.quote
 
93
unquote_to_bytes = urlparse.unquote_to_bytes
162
94
unquote = urlparse.unquote
163
95
 
164
96
 
165
97
def escape(relpath, safe='/~'):
166
98
    """Escape relpath to be a valid url."""
167
 
    if not isinstance(relpath, str) and sys.version_info[0] == 2:
168
 
        # GZ 2019-06-16: Should use _fs_enc instead here really?
169
 
        relpath = relpath.encode('utf-8')
170
99
    return quote(relpath, safe=safe)
171
100
 
172
101
 
411
340
        return local_path_to_url(url)
412
341
    prefix = url[:path_start]
413
342
    path = url[path_start:]
414
 
    if not isinstance(url, text_type):
 
343
    if not isinstance(url, str):
415
344
        for c in url:
416
345
            if c not in _url_safe_characters:
417
346
                raise InvalidURL(url, 'URLs can only contain specific'
691
620
    #       try to encode the UNICODE => ASCII, and then decode
692
621
    #       it into utf-8.
693
622
 
694
 
    if PY3:
695
 
        if isinstance(url, text_type):
696
 
            try:
697
 
                url.encode("ascii")
698
 
            except UnicodeError as e:
699
 
                raise InvalidURL(
700
 
                    url, 'URL was not a plain ASCII url: %s' % (e,))
701
 
        return urlparse.unquote(url)
702
 
    else:
703
 
        if isinstance(url, text_type):
704
 
            try:
705
 
                url = url.encode("ascii")
706
 
            except UnicodeError as e:
707
 
                raise InvalidURL(
708
 
                    url, 'URL was not a plain ASCII url: %s' % (e,))
709
 
        unquoted = unquote(url)
 
623
    if isinstance(url, str):
710
624
        try:
711
 
            unicode_path = unquoted.decode('utf-8')
 
625
            url.encode("ascii")
712
626
        except UnicodeError as e:
713
627
            raise InvalidURL(
714
 
                url, 'Unable to encode the URL as utf-8: %s' % (e,))
715
 
        return unicode_path
 
628
                url, 'URL was not a plain ASCII url: %s' % (e,))
 
629
    return urlparse.unquote(url)
716
630
 
717
631
 
718
632
# These are characters that if escaped, should stay that way
720
634
_no_decode_ords = [ord(c) for c in _no_decode_chars]
721
635
_no_decode_hex = (['%02x' % o for o in _no_decode_ords]
722
636
                  + ['%02X' % o for o in _no_decode_ords])
723
 
_hex_display_map = dict(([('%02x' % o, int2byte(o)) for o in range(256)]
724
 
                         + [('%02X' % o, int2byte(o)) for o in range(256)]))
 
637
_hex_display_map = dict(([('%02x' % o, bytes([o])) for o in range(256)]
 
638
                         + [('%02X' % o, bytes([o])) for o in range(256)]))
725
639
# These entries get mapped to themselves
726
640
_hex_display_map.update((hex, b'%' + hex.encode('ascii'))
727
641
                        for hex in _no_decode_hex)
765
679
            escaped_chunks[j] = _hex_display_map[item[:2]]
766
680
        except KeyError:
767
681
            # Put back the percent symbol
768
 
            escaped_chunks[j] = b'%' + \
769
 
                (item[:2].encode('utf-8') if PY3 else item[:2])
 
682
            escaped_chunks[j] = b'%' + (item[:2].encode('utf-8'))
770
683
        except UnicodeDecodeError:
771
 
            escaped_chunks[j] = unichr(int(item[:2], 16)).encode('utf-8')
772
 
        escaped_chunks[j] += (item[2:].encode('utf-8') if PY3 else item[2:])
 
684
            escaped_chunks[j] = chr(int(item[:2], 16)).encode('utf-8')
 
685
        escaped_chunks[j] += (item[2:].encode('utf-8'))
773
686
    unescaped = b''.join(escaped_chunks)
774
687
    try:
775
688
        decoded = unescaped.decode('utf-8')
933
846
        # unicode.
934
847
        if isinstance(url, str):
935
848
            pass
936
 
        elif isinstance(url, text_type):
 
849
        elif isinstance(url, str):
937
850
            try:
938
851
                url = url.encode()
939
852
            except UnicodeEncodeError:
1004
917
        # unicode.
1005
918
        if isinstance(relpath, str):
1006
919
            pass
1007
 
        elif isinstance(relpath, text_type):
 
920
        elif isinstance(relpath, str):
1008
921
            try:
1009
922
                relpath = relpath.encode()
1010
923
            except UnicodeEncodeError:
1042
955
        """
1043
956
        if offset is not None:
1044
957
            relative = unescape(offset)
1045
 
            if sys.version_info[0] == 2:
1046
 
                relative = relative.encode('utf-8')
1047
958
            path = self._combine_paths(self.path, relative)
1048
959
            path = quote(path, safe="/~")
1049
960
        else: