img: add _MarkerParser.iter_markers()

Steve Canny · Steve Canny · commit b7d39cd35e1b · 2014-02-27T12:08:34.000-08:00
diff --git a/docx/image/jpeg.py b/docx/image/jpeg.py
@@ -123,13 +123,38 @@ def iter_markers(self):
         Generate a (marker_code, segment_offset) 2-tuple for each marker in
         the JPEG *stream*, in the order they occur in the stream.
         """
-        raise NotImplementedError
+        marker_finder = _MarkerFinder.from_stream(self._stream)
+        start = 0
+        marker_code = None
+        while marker_code != JPEG_MARKER_CODE.EOI:
+            marker_code, segment_offset = marker_finder.next(start)
+            marker = _MarkerFactory(
+                marker_code, self._stream, segment_offset
+            )
+            yield marker
+            start = segment_offset + marker.segment_length
 
 
 class _MarkerFinder(object):
     """
     Service class that knows how to find the next JFIF marker in a stream.
     """
+    @classmethod
+    def from_stream(cls, stream):
+        """
+        Return a |_MarkerFinder| instance to find JFIF markers in *stream*.
+        """
+        raise NotImplementedError
+
+    def next(self, start):
+        """
+        Return a (marker_code, segment_offset) 2-tuple identifying and
+        locating the first marker in *stream* occuring after offset *start*.
+        The returned *segment_offset* points to the position immediately
+        following the 2-byte marker code, the start of the marker segment,
+        for those markers that have a segment.
+        """
+        raise NotImplementedError
 
 
 def _MarkerFactory(marker_code, stream, offset):
@@ -153,6 +178,13 @@ def marker_code(self):
         """
         raise NotImplementedError
 
+    @property
+    def segment_length(self):
+        """
+        The length in bytes of this marker's segment
+        """
+        raise NotImplementedError
+
 
 class _App0Marker(_Marker):
     """
diff --git a/tests/image/test_jpeg.py b/tests/image/test_jpeg.py
@@ -8,11 +8,14 @@
 
 import pytest
 
+from mock import call
+
 from docx.compat import BytesIO
 from docx.image.constants import JPEG_MARKER_CODE
 from docx.image.helpers import BIG_ENDIAN, StreamReader
 from docx.image.jpeg import (
-    _App0Marker, Jfif, _JfifMarkers, _Marker, _MarkerParser, _SofMarker
+    _App0Marker, Jfif, _JfifMarkers, _Marker, _MarkerFinder, _MarkerParser,
+    _SofMarker
 )
 
 from ..unitutil import class_mock, initializer_mock, instance_mock
@@ -159,18 +162,84 @@ def it_can_construct_from_a_jfif_stream(self, from_stream_fixture):
         _MarkerParser__init_.assert_called_once_with(stream_reader_)
         assert isinstance(marker_parser, _MarkerParser)
 
+    def it_can_iterate_over_the_jfif_markers_in_its_stream(
+            self, iter_markers_fixture):
+        (marker_parser, stream_, _MarkerFinder_, marker_finder_,
+         _MarkerFactory_, marker_codes, offsets,
+         marker_lst) = iter_markers_fixture
+        markers = [marker for marker in marker_parser.iter_markers()]
+        _MarkerFinder_.from_stream.assert_called_once_with(stream_)
+        assert marker_finder_.next.call_args_list == [
+            call(0), call(2), call(20)
+        ]
+        assert _MarkerFactory_.call_args_list == [
+            call(marker_codes[0], stream_, offsets[0]),
+            call(marker_codes[1], stream_, offsets[1]),
+            call(marker_codes[2], stream_, offsets[2]),
+        ]
+        assert markers == marker_lst
+
     # fixtures -------------------------------------------------------
 
+    @pytest.fixture
+    def app0_(self, request):
+        return instance_mock(request, _App0Marker, segment_length=16)
+
+    @pytest.fixture
+    def eoi_(self, request):
+        return instance_mock(request, _Marker, segment_length=0)
+
     @pytest.fixture
     def from_stream_fixture(
             self, stream_, StreamReader_, _MarkerParser__init_,
             stream_reader_):
         return stream_, StreamReader_, _MarkerParser__init_, stream_reader_
 
+    @pytest.fixture
+    def iter_markers_fixture(
+            self, stream_reader_, _MarkerFinder_, marker_finder_,
+            _MarkerFactory_, soi_, app0_, eoi_):
+        marker_parser = _MarkerParser(stream_reader_)
+        offsets = [2, 4, 22]
+        marker_lst = [soi_, app0_, eoi_]
+        marker_finder_.next.side_effect = [
+            (JPEG_MARKER_CODE.SOI,  offsets[0]),
+            (JPEG_MARKER_CODE.APP0, offsets[1]),
+            (JPEG_MARKER_CODE.EOI,  offsets[2]),
+        ]
+        marker_codes = [
+            JPEG_MARKER_CODE.SOI, JPEG_MARKER_CODE.APP0, JPEG_MARKER_CODE.EOI
+        ]
+        return (
+            marker_parser, stream_reader_, _MarkerFinder_, marker_finder_,
+            _MarkerFactory_, marker_codes, offsets, marker_lst
+        )
+
+    @pytest.fixture
+    def _MarkerFactory_(self, request, soi_, app0_, eoi_):
+        return class_mock(
+            request, 'docx.image.jpeg._MarkerFactory',
+            side_effect=[soi_, app0_, eoi_]
+        )
+
+    @pytest.fixture
+    def _MarkerFinder_(self, request, marker_finder_):
+        _MarkerFinder_ = class_mock(request, 'docx.image.jpeg._MarkerFinder')
+        _MarkerFinder_.from_stream.return_value = marker_finder_
+        return _MarkerFinder_
+
+    @pytest.fixture
+    def marker_finder_(self, request):
+        return instance_mock(request, _MarkerFinder)
+
     @pytest.fixture
     def _MarkerParser__init_(self, request):
         return initializer_mock(request, _MarkerParser)
 
+    @pytest.fixture
+    def soi_(self, request):
+        return instance_mock(request, _Marker, segment_length=0)
+
     @pytest.fixture
     def stream_(self, request):
         return instance_mock(request, BytesIO)
