Added Python 2.6 compatible OrderedDict

To preserver ordr of headers, parameters, etc.

httpie/compat.py

@@ -24,3 +24,137 @@ try:
 except ImportError:
     #noinspection PyCompatibility
     from urllib2 import urlopen
+
+
+try:
+    from collections import OrderedDict
+except ImportError:
+    ### Python 2.6 OrderedDict class, needed for headers, parameters, etc .###
+    ### <https://pypi.python.org/pypi/ordereddict/1.1>
+    # noinspection PyCompatibility
+    from UserDict import DictMixin
+
+    class OrderedDict(dict, DictMixin):
+        # Copyright (c) 2009 Raymond Hettinger
+        #
+        # Permission is hereby granted, free of charge, to any person
+        # obtaining a copy of this software and associated documentation files
+        # (the "Software"), to deal in the Software without restriction,
+        # including without limitation the rights to use, copy, modify, merge,
+        # publish, distribute, sublicense, and/or sell copies of the Software,
+        # and to permit persons to whom the Software is furnished to do so,
+        # subject to the following conditions:
+        #
+        #     The above copyright notice and this permission notice shall be
+        #     included in all copies or substantial portions of the Software.
+        #
+        #     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        #     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+        #     OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        #     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+        #     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+        #     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+        #     FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+        #     OTHER DEALINGS IN THE SOFTWARE.
+        def __init__(self, *args, **kwds):
+            if len(args) > 1:
+                raise TypeError('expected at most 1 arguments, got %d'
+                                % len(args))
+            try:
+                self.__end
+            except AttributeError:
+                self.clear()
+            self.update(*args, **kwds)
+
+        def clear(self):
+            self.__end = end = []
+            end += [None, end, end]     # sentinel node for doubly linked list
+            self.__map = {}             # key --> [key, prev, next]
+            dict.clear(self)
+
+        def __setitem__(self, key, value):
+            if key not in self:
+                end = self.__end
+                curr = end[1]
+                curr[2] = end[1] = self.__map[key] = [key, curr, end]
+            dict.__setitem__(self, key, value)
+
+        def __delitem__(self, key):
+            dict.__delitem__(self, key)
+            key, prev, next = self.__map.pop(key)
+            prev[2] = next
+            next[1] = prev
+
+        def __iter__(self):
+            end = self.__end
+            curr = end[2]
+            while curr is not end:
+                yield curr[0]
+                curr = curr[2]
+
+        def __reversed__(self):
+            end = self.__end
+            curr = end[1]
+            while curr is not end:
+                yield curr[0]
+                curr = curr[1]
+
+        def popitem(self, last=True):
+            if not self:
+                raise KeyError('dictionary is empty')
+            if last:
+                key = reversed(self).next()
+            else:
+                key = iter(self).next()
+            value = self.pop(key)
+            return key, value
+
+        def __reduce__(self):
+            items = [[k, self[k]] for k in self]
+            tmp = self.__map, self.__end
+            del self.__map, self.__end
+            inst_dict = vars(self).copy()
+            self.__map, self.__end = tmp
+            if inst_dict:
+                return self.__class__, (items,), inst_dict
+            return self.__class__, (items,)
+
+        def keys(self):
+            return list(self)
+
+        setdefault = DictMixin.setdefault
+        update = DictMixin.update
+        pop = DictMixin.pop
+        values = DictMixin.values
+        items = DictMixin.items
+        iterkeys = DictMixin.iterkeys
+        itervalues = DictMixin.itervalues
+        iteritems = DictMixin.iteritems
+
+        def __repr__(self):
+            if not self:
+                return '%s()' % (self.__class__.__name__,)
+            return '%s(%r)' % (self.__class__.__name__, self.items())
+
+        def copy(self):
+            return self.__class__(self)
+
+        @classmethod
+        def fromkeys(cls, iterable, value=None):
+            d = cls()
+            for key in iterable:
+                d[key] = value
+            return d
+
+        def __eq__(self, other):
+            if isinstance(other, OrderedDict):
+                if len(self) != len(other):
+                    return False
+                for p, q in zip(self.items(), other.items()):
+                    if p != q:
+                        return False
+                return True
+            return dict.__eq__(self, other)
+
+        def __ne__(self, other):
+            return not self == other

httpie/input.py

@@ -10,11 +10,7 @@ import getpass
 from io import BytesIO
 #noinspection PyCompatibility
 from argparse import ArgumentParser, ArgumentTypeError, ArgumentError
-
-try:
-    from collections import OrderedDict
-except ImportError:
-    OrderedDict = dict
+from .compat import OrderedDict
 
 # TODO: Use MultiDict for headers once added to `requests`.
 # https://github.com/jkbr/httpie/issues/130
@@ -157,6 +153,7 @@ class Parser(ArgumentParser):
     # noinspection PyShadowingBuiltins
     def _print_message(self, message, file=None):
         # Sneak in our stderr/stdout.
+        print(file)
         file = {
             sys.stdout: self.env.stdout,
             sys.stderr: self.env.stderr,

tests/test_httpie.py

@@ -22,7 +22,8 @@ class HTTPieTest(TestCase):
     def test_version(self):
         r = http('--version')
         assert r.exit_status == httpie.ExitStatus.ERROR
-        assert httpie.__version__ == r.stderr.strip()
+        # FIXME: py3 has version in stdout, py2 in stderr
+        assert httpie.__version__ == r.stderr.strip() + r.strip()
 
     def test_GET(self):
         r = http('GET', httpbin('/get'))

tests/test_output.py

@@ -15,8 +15,7 @@ class VerboseFlagTest(TestCase):
         r = http('--verbose', '--form', 'POST', httpbin('/post'),
                  'A=B', 'C=D')
         assert HTTP_OK in r
-        # Python 2.6 has no ordered dict, so we test for both orders here.
-        assert 'A=B&C=D' in r or 'C=D&A=B', r
+        assert 'A=B&C=D' in r
 
     def test_verbose_json(self):
         r = http('--verbose', 'POST', httpbin('/post'), 'foo=bar', 'baz=bar')