Merge branch 'development' into plaintext_http20_via_http11_upgrade

Conflicts:
	hyper/common/connection.py

Author: fredthomsen

HISTORY.rst

@@ -1,6 +1,14 @@
 Release History
 ===============
 
+dev
+---
+
+*New Features*
+
+- ``HTTP11Connection`` and ``HTTPConnection`` objects are now both context
+  managers.
+
 0.3.1 (2015-04-03)
 ------------------
 

examples/ip.hy

@@ -0,0 +1,8 @@
+(import hyper json)
+
+(defn http2bin [path]
+  (with [[conn (hyper.HTTPConnection "http2bin.org")]]
+    (.request conn "GET" path)
+    (-> (.get_response conn) (.read) (json.loads))))
+
+(-> (http2bin "/ip") (get "origin") (print))

examples/twscrape.hy

@@ -0,0 +1,35 @@
+; Reports the users mentioned in the initially loaded tweets on a user's
+; Twitter page.
+
+(import hyper bs4)
+
+(setv results {})
+
+; Get hold of a stream ID for the data for a single page.
+(defn request-page [conn path]
+  (.request conn "GET" path))
+
+; Read the stream to exhaustion.
+(defn get-page-data [conn req-id]
+  (-> (.get_response conn req-id) (.read)))
+
+; Yield all at-reply elements from the html.
+(defn at-replies [html]
+  (let [[soup (bs4.BeautifulSoup html)]]
+    (apply .find_all [soup] {"class_" "twitter-atreply"})))
+
+(defn get-refs [replies]
+  (list-comp (.get reply "href") [reply replies]))
+
+(defn mentions [html]
+  (for [ref (remove none? (get-refs (at-replies html)))]
+    (-> (.lstrip ref "/") (yield))))
+
+; Simple test: print the people referenced on the most recent tweets page.
+(defn main []
+  (with [[conn (hyper.HTTPConnection "twitter.com" 443)]]
+    (let [[req-id (request-page conn "/Lukasaoz")]]
+      (for [mention (mentions (get-page-data conn req-id))]
+        (print mention)))))
+
+(main)

hyper/common/connection.py

@@ -132,6 +132,15 @@ def get_response(self):
 
             return self._conn.get_response(1)
 
+    # The following two methods are the implementation of the context manager
+    # protocol.
+    def __enter__(self):  # pragma: no cover
+        return self
+
+    def __exit__(self, type, value, tb):  # pragma: no cover
+        self._conn.close()
+        return False  # Never swallow exceptions.
+
     # Can anyone say 'proxy object pattern'?
     def __getattr__(self, name):
         return getattr(self._conn, name)

hyper/http11/connection.py

@@ -301,14 +301,23 @@ def _send_body(self, body, body_type):
     def close(self):
         """
         Closes the connection. This closes the socket and then abandons the
-        reference to it. After calling this method, it any outstanding
+        reference to it. After calling this method, any outstanding
         :class:`Response <hyper.http11.response.Response>` objects will throw
         exceptions if attempts are made to read their bodies.
 
-        This method should absolutely only be called when you are certain the
-        connection object is no longer needed.
-
         In some cases this method will automatically be called.
+
+        .. warning:: This method should absolutely only be called when you are
+                     certain the connection object is no longer needed.
         """
         self._sock.close()
         self._sock = None
+
+    # The following two methods are the implementation of the context manager
+    # protocol.
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, tb):
+        self.close()
+        return False  # Never swallow exceptions.

test/test_integration_http11.py

@@ -165,3 +165,52 @@ def socket_handler(listener):
         assert r.headers[b'content-length'] == [b'15']
 
         assert r.read() == b'hellotherehello'
+
+    def test_connection_context_manager(self):
+        self.set_up()
+
+        send_event = threading.Event()
+
+        def socket_handler(listener):
+            sock = listener.accept()[0]
+
+            # We should get the initial request.
+            data = b''
+            while not data.endswith(b'\r\n\r\n'):
+                data += sock.recv(65535)
+
+            send_event.wait()
+
+            # We need to send back a response.
+            resp = (
+                b'HTTP/1.1 200 OK\r\n'
+                b'Server: socket-level-server\r\n'
+                b'Content-Length: 15\r\n'
+                b'\r\n'
+            )
+            sock.send(resp)
+
+            chunks = [
+                b'hello',
+                b'there',
+                b'hello',
+            ]
+
+            for chunk in chunks:
+                sock.send(chunk)
+
+            sock.close()
+
+        self._start_server(socket_handler)
+        with self.get_connection() as c:
+            c.request('GET', '/')
+            send_event.set()
+            r = c.get_response()
+            data = r.read()
+
+        assert r.status == 200
+        assert r.reason == b'OK'
+        assert len(r.headers) == 2
+        assert data == b'hellotherehello'
+
+        assert c._sock is None