Roll back the introduction of urlsplit() and urlunsplit() to

urlparse.py.  These were new features in 2.2, and shouldn't be added
to 2.1 this late in the game.  There was one use of urlsplit() in
httplib.py (the urlparse.py change was done as part of a backport of a
bugfix to httplib.py); this use is replaced with a call to urlparse()
without changing the effect (only the returned netloc is used).

diff --git a/Lib/httplib.py b/Lib/httplib.py
index 2b277e079941f0b3870d9396c6954360110eb6b8..021a76236a66b23679d305c5f5aa5b660584be97 100644 (file)
--- a/Lib/httplib.py
+++ b/Lib/httplib.py
@@ -69,7 +69,7 @@ Req-sent-unread-response       _CS_REQ_SENT       <response_class>
 import errno
 import mimetools
 import socket
-from urlparse import urlsplit
+from urlparse import urlparse
 
 try:
     from cStringIO import StringIO
@@ -610,7 +610,7 @@ class HTTPConnection:
 
                 netloc = ''
                 if url.startswith('http'):
-                    nil, netloc, nil, nil, nil = urlsplit(url)
+                    nil, netloc, nil, nil, nil, nil = urlparse(url)
 
                 if netloc:
                     self.putheader('Host', netloc)

diff --git a/Lib/urlparse.py b/Lib/urlparse.py
index ee99645d59b7ce3937021c203a6c8b3fd16c5953..1df83d68d31b13b895c069657e149271cbf2fcac 100644 (file)
--- a/Lib/urlparse.py
+++ b/Lib/urlparse.py
@@ -43,42 +43,19 @@ def clear_cache():
     _parse_cache = {}
 
 
-def urlparse(url, scheme='', allow_fragments=1):
+def urlparse(url, scheme = '', allow_fragments = 1):
     """Parse a URL into 6 components:
     <scheme>://<netloc>/<path>;<params>?<query>#<fragment>
     Return a 6-tuple: (scheme, netloc, path, params, query, fragment).
     Note that we don't break the components up in smaller bits
     (e.g. netloc is a single string) and we don't expand % escapes."""
-    tuple = urlsplit(url, scheme, allow_fragments)
-    scheme, netloc, url, query, fragment = tuple
-    if scheme in uses_params and ';' in url:
-        url, params = _splitparams(url)
-    else:
-        params = ''
-    return scheme, netloc, url, params, query, fragment
-
-def _splitparams(url):
-    if '/'  in url:
-        i = url.find(';', url.rfind('/'))
-        if i < 0:
-            return url, ''
-    else:
-        i = url.find(';')
-    return url[:i], url[i+1:]
-
-def urlsplit(url, scheme='', allow_fragments=1):
-    """Parse a URL into 5 components:
-    <scheme>://<netloc>/<path>?<query>#<fragment>
-    Return a 5-tuple: (scheme, netloc, path, query, fragment).
-    Note that we don't break the components up in smaller bits
-    (e.g. netloc is a single string) and we don't expand % escapes."""
     key = url, scheme, allow_fragments
     cached = _parse_cache.get(key, None)
     if cached:
         return cached
     if len(_parse_cache) >= MAX_CACHE_SIZE: # avoid runaway growth
         clear_cache()
-    netloc = query = fragment = ''
+    netloc = path = params = query = fragment = ''
     i = url.find(':')
     if i > 0:
         if url[:i] == 'http': # optimize the common case
@@ -87,16 +64,23 @@ def urlsplit(url, scheme='', allow_fragments=1):
             if url[:2] == '//':
                 i = url.find('/', 2)
                 if i < 0:
-                    i = url.find('#')
-                    if i < 0:
-                        i = len(url)
+                    i = len(url)
                 netloc = url[2:i]
                 url = url[i:]
-            if allow_fragments and '#' in url:
-                url, fragment = url.split('#', 1)
-            if '?' in url:
-                url, query = url.split('?', 1)
-            tuple = scheme, netloc, url, query, fragment
+            if allow_fragments:
+                i = url.rfind('#')
+                if i >= 0:
+                    fragment = url[i+1:]
+                    url = url[:i]
+            i = url.find('?')
+            if i >= 0:
+                query = url[i+1:]
+                url = url[:i]
+            i = url.find(';')
+            if i >= 0:
+                params = url[i+1:]
+                url = url[:i]
+            tuple = scheme, netloc, url, params, query, fragment
             _parse_cache[key] = tuple
             return tuple
         for c in url[:i]:
@@ -110,11 +94,19 @@ def urlsplit(url, scheme='', allow_fragments=1):
             if i < 0:
                 i = len(url)
             netloc, url = url[2:i], url[i:]
-    if allow_fragments and scheme in uses_fragment and '#' in url:
-        url, fragment = url.split('#', 1)
-    if scheme in uses_query and '?' in url:
-        url, query = url.split('?', 1)
-    tuple = scheme, netloc, url, query, fragment
+    if allow_fragments and scheme in uses_fragment:
+        i = url.rfind('#')
+        if i >= 0:
+            url, fragment = url[:i], url[i+1:]
+    if scheme in uses_query:
+        i = url.find('?')
+        if i >= 0:
+            url, query = url[:i], url[i+1:]
+    if scheme in uses_params:
+        i = url.find(';')
+        if i >= 0:
+            url, params = url[:i], url[i+1:]
+    tuple = scheme, netloc, url, params, query, fragment
     _parse_cache[key] = tuple
     return tuple
 
@@ -123,16 +115,13 @@ def urlunparse((scheme, netloc, url, params, query, fragment)):
     slightly different, but equivalent URL, if the URL that was parsed
     originally had redundant delimiters, e.g. a ? with an empty query
     (the draft states that these are equivalent)."""
-    if params:
-        url = "%s;%s" % (url, params)
-    return urlunsplit((scheme, netloc, url, query, fragment))
-
-def urlunsplit((scheme, netloc, url, query, fragment)):
     if netloc or (scheme in uses_netloc and url[:2] == '//'):
         if url and url[:1] != '/': url = '/' + url
         url = '//' + (netloc or '') + url
     if scheme:
         url = scheme + ':' + url
+    if params:
+        url = url + ';' + params
     if query:
         url = url + '?' + query
     if fragment:
@@ -198,12 +187,9 @@ def urldefrag(url):
     the URL contained no fragments, the second element is the
     empty string.
     """
-    if '#' in url:
-        s, n, p, a, q, frag = urlparse(url)
-        defrag = urlunparse((s, n, p, a, q, ''))
-        return defrag, frag
-    else:
-        return url, ''
+    s, n, p, a, q, frag = urlparse(url)
+    defrag = urlunparse((s, n, p, a, q, ''))
+    return defrag, frag
 
 
 test_input = """