Fixed PR remarks from #115 (comment)

1. added new tests to test_io.py
2. introduced ReceiveBuffer::_extract
3. added a newsfragment

Author: cdeler

h11/_receivebuffer.py

@@ -68,6 +68,16 @@ def __bytes__(self):
         __str__ = __bytes__
         __nonzero__ = __bool__
 
+    def _extract(self, count):
+        # extracting an initial slice of the data buffer and return it
+        out = self._data[:count]
+        del self._data[:count]
+
+        self._next_line_search = 0
+        self._multiple_lines_search = 0
+
+        return out
+
     def maybe_extract_at_most(self, count):
         """
         Extract a fixed number of bytes from the buffer.
@@ -76,65 +86,51 @@ def maybe_extract_at_most(self, count):
         if not out:
             return None
 
-        self._data[:count] = b""
-        self._next_line_search = 0
-        self._multiple_lines_search = 0
-        return out
+        return self._extract(count)
 
     def maybe_extract_next_line(self):
         """
         Extract the first line, if it is completed in the buffer.
         """
         # Only search in buffer space that we've not already looked at.
         search_start_index = max(0, self._next_line_search - 1)
-        partial_buffer = self._data[search_start_index:]
-        partial_idx = partial_buffer.find(b"\r\n")
+        partial_idx = self._data.find(b"\r\n", search_start_index)
+
         if partial_idx == -1:
             self._next_line_search = len(self._data)
             return None
 
-        # Truncate the buffer and return it.
         # + 2 is to compensate len(b"\r\n")
-        idx = search_start_index + partial_idx + 2
-        out = self._data[:idx]
-        self._data[:idx] = b""
-        self._next_line_search = 0
-        self._multiple_lines_search = 0
-        return out
+        idx = partial_idx + 2
+
+        return self._extract(idx)
 
     def maybe_extract_lines(self):
         """
         Extract everything up to the first blank line, and return a list of lines.
         """
         # Handle the case where we have an immediate empty line.
         if self._data[:1] == b"\n":
-            self._data[:1] = b""
-            self._next_line_search = 0
-            self._multiple_lines_search = 0
+            self._extract(1)
             return []
 
         if self._data[:2] == b"\r\n":
-            self._data[:2] = b""
-            self._next_line_search = 0
-            self._multiple_lines_search = 0
+            self._extract(2)
             return []
 
         # Only search in buffer space that we've not already looked at.
-        partial_buffer = self._data[self._multiple_lines_search :]
-        match = blank_line_regex.search(partial_buffer)
+        match = blank_line_regex.search(self._data, self._multiple_lines_search)
         if match is None:
             self._multiple_lines_search = max(0, len(self._data) - 2)
             return None
 
         # Truncate the buffer and return it.
-        idx = self._multiple_lines_search + match.span(0)[-1]
-        out = self._data[:idx]
+        idx = match.span(0)[-1]
+        out = self._extract(idx)
         lines = [line.rstrip(b"\r") for line in out.split(b"\n")]
 
-        self._data[:idx] = b""
-        self._next_line_search = 0
-        self._multiple_lines_search = 0
-
         assert lines[-2] == lines[-1] == b""
 
-        return lines[:-2]
+        del lines[-2:]
+
+        return lines

h11/tests/test_io.py

@@ -215,6 +215,43 @@ def test_readers_unusual():
         ),
     )
 
+    # Tolerate headers line endings (\r\n and \n)
+    #    \n\r\b between headers and body
+    tr(
+        READERS[SERVER, SEND_RESPONSE],
+        b"HTTP/1.1 200 OK\r\nSomeHeader: val\n\r\n",
+        Response(
+            status_code=200,
+            headers=[("SomeHeader", "val")],
+            http_version="1.1",
+            reason="OK",
+        ),
+    )
+
+    #   delimited only with \n
+    tr(
+        READERS[SERVER, SEND_RESPONSE],
+        b"HTTP/1.1 200 OK\nSomeHeader1: val1\nSomeHeader2: val2\n\n",
+        Response(
+            status_code=200,
+            headers=[("SomeHeader1", "val1"), ("SomeHeader2", "val2")],
+            http_version="1.1",
+            reason="OK",
+        ),
+    )
+
+    #   mixed \r\n and \n
+    tr(
+        READERS[SERVER, SEND_RESPONSE],
+        b"HTTP/1.1 200 OK\r\nSomeHeader1: val1\nSomeHeader2: val2\n\r\n",
+        Response(
+            status_code=200,
+            headers=[("SomeHeader1", "val1"), ("SomeHeader2", "val2")],
+            http_version="1.1",
+            reason="OK",
+        ),
+    )
+
     # obsolete line folding
     tr(
         READERS[CLIENT, IDLE],

newsfragments/7.feature.rst

@@ -0,0 +1,3 @@
+Added support for servers with broken line endings.
+
+After this change `h11` accepts both `\r\n` and `\n` as a headers delimiter