Ticket #2970: http_response_insensitive.3.patch

django/http/__init__.py

@@ -2 +2 @@
 from Cookie import SimpleCookie
 from pprint import pformat
 from urllib import urlencode, quote
-from django.utils.datastructures import MultiValueDict
+from django.utils.datastructures import MultiValueDict, CaseInsensitiveDict
 
 RESERVED_CHARS="!*'();:@&=+$,/?%#[]"
 
@@ -188 +188 @@
     def __getitem__(self, header):
         return self.headers[header]
 
+    def get_headers(self):
+        return self._headers
+    
+    def set_headers(self, headers):
+        self._headers = CaseInsensitiveDict(headers)
+        
+    headers = property(get_headers, set_headers)
+
     def has_header(self, header):
         "Case-insensitive check for a header"
-        header = header.lower()
-        for key in self.headers.keys():
-            if key.lower() == header:
-                return True
-        return False
+        return self.headers.has_key(header)
 
     def set_cookie(self, key, value='', max_age=None, expires=None, path='/', domain=None, secure=None):
         self.cookies[key] = value

django/utils/datastructures.py

@@ -242 +242 @@
                 current[bits[-1]] = v
             except TypeError: # Special-case if current isn't a dict.
                 current = {bits[-1] : v}
+
+class CaseInsensitiveDict(dict):
+    """
+    A dictionary which uses case-insensitive keys. Original case is preserved,
+    but can be read or overwritten by the same key of any mix of upper and
+    lower case.
+    """
+    def __init__(self, *kw, **kwargs):
+        super(CaseInsensitiveDict, self).__init__(*kw, **kwargs)
+        # Set up case insensitive keys dict for future reference.
+        keys = {}
+        for key in self.keys():
+            if isinstance(key, basestring):
+                keys[key.lower()] = key
+        self._case_insensitive_keys = keys
+
+    def _get_case_sensitive_key(self, key):
+        if isinstance(key, basestring):
+            key = self._case_insensitive_keys.get(key.lower(), key)
+        return key
+
+    def __getitem__(self, key):
+        key = self._get_case_sensitive_key(key)
+        return super(CaseInsensitiveDict, self).__getitem__(key)
+
+    def __setitem__(self, key, value):
+        if isinstance(key, basestring):
+            key_lower = key.lower()
+            if key_lower in self._case_insensitive_keys.keys():
+                # Delete old key (since it may be a different case).
+                old_key = self._case_insensitive_keys[key_lower]
+                super(CaseInsensitiveDict, self).__delitem__(old_key)
+            # Save new key in case insensitive dict.
+            self._case_insensitive_keys[key_lower] = key
+        return super(CaseInsensitiveDict, self).__setitem__(key, value)
+
+    def __delitem__(self, key):
+        key = self._get_case_sensitive_key(key)
+        if isinstance(key, basestring):
+            # Delete key from case insensitive dict.
+            del self._case_insensitive_keys[key.lower()]
+        return super(CaseInsensitiveDict, self).__delitem__(key)
+
+    def __contains__(self, key):
+        key = self._get_case_sensitive_key(key)
+        return super(CaseInsensitiveDict, self).__contains__(key)
+
+    def get(self, key, default=None):
+        key = self._get_case_sensitive_key(key)
+        return super(CaseInsensitiveDict, self).get(key, default)
+
+    def has_key(self, key):
+        key = self._get_case_sensitive_key(key)
+        return super(CaseInsensitiveDict, self).has_key(key)
+
+    def pop(self, key):
+        key = self._get_case_sensitive_key(key)
+        # Delete key from case insensitive dict. Could raise KeyError, but
+        # that's what is raised on a non-existant .pop(key) anyway.
+        del self._case_insensitive_keys[key.lower()]
+        return super(CaseInsensitiveDict, self).pop(key)
+
+    def update(self, dict=None, **kwargs):
+        if dict is None:
+            # Handle it the alternate way introduced in Python 2.4
+            dict = kwargs
+        if dict:
+            # Check for keys in new dict which may differ to the current keys.
+            for key in dict.keys():
+                existing_key = self._get_case_sensitive_key(key)
+                if key != existing_key:
+                    # Delete existing key (with different case).
+                    del self[existing_key]
+                    # Change existing case insensitive key to match new key case.
+                    self._case_insensitive_keys[key.lower()] = key
+        return super(CaseInsensitiveDict, self).update(dict)
+
+    def clear(self):
+        # Reset case insensitive dict
+        self._case_insensitive_keys = {}
+        return super(CaseInsensitiveDict, self).clear()
+
+    def setdefault(self, key, default=None):
+        if not self.has_key(key):
+            # Update case insensitive dict, since dict.setdefault() doesn't
+            # use internal __setitem__ method.
+            self._case_insensitive_keys[key.lower()] = key
+        return super(CaseInsensitiveDict, self).setdefault(key, default)

tests/regressiontests/datastructures/tests.py

@@ +1 @@
+r"""
+#########################
+# CASE INSENSITIVE DICT #
+#########################
+>>> from django.utils.datastructures import CaseInsensitiveDict
+>>> d = CaseInsensitiveDict()
+
+# Non string keys should still work exactly the same.
+>>> d[5] = 'five'
+>>> d[5]
+'five'
+>>> d.get(5)
+'five'
+>>> d.has_key(5)
+True
+
+# String keys will preserve case, but be replaced or read with any case.
+>>> d['one'] = 1
+>>> d['TWO'] = 2
+>>> d['Three'] = 3
+
+# Basic tests.
+>>> d['one'], d['two'], d['three']
+(1, 2, 3)
+>>> d['ONE'], d['TWO'], d['THREE']
+(1, 2, 3)
+>>> d['oNe'], d['tWo'], d['tHree']
+(1, 2, 3)
+
+# Replace a key.
+>>> d['thrEE'] = 33
+>>> d['Three']
+33
+>>> len(d.keys())
+4
+>>> d[5] = 'FIVE'
+>>> d[5]
+'FIVE'
+
+# Check .get()
+>>> d.get('four', 'does not exist')
+'does not exist'
+>>> d.get(5)
+'FIVE'
+
+>>> d.has_key('one')
+True
+>>> d.has_key('onE')
+True
+>>> d.has_key('four')
+False
+>>> d.has_key(5)
+True
+>>> d.has_key(6)
+False
+
+>>> d.setdefault(5)
+'FIVE'
+>>> d.setdefault('fOUr', 4)
+4
+>>> keys = d.keys()
+>>> keys.sort()
+>>> keys
+[5, 'TWO', 'fOUr', 'one', 'thrEE']
+
+>>> 'fouR' in d
+True
+>>> 'six' in d
+False
+
+>>> del d['THREE']
+>>> len(d)
+4
+
+>>> d.pop('tWo')
+2
+>>> len(d)
+3
+
+>>> d.update({'ONE': 111, 'Two': 222, 'three': 333})
+>>> values = d.values()
+>>> values.sort()
+>>> values
+[4, 111, 222, 333, 'FIVE']
+
+>>> d.clear()
+>>> d
+{}
+"""