img: add _IfdEntryFactory()

Steve Canny · Steve Canny · commit f01746985ad3 · 2014-02-27T12:08:36.000-08:00
diff --git a/docx/image/constants.py b/docx/image/constants.py
@@ -111,3 +111,22 @@ class TAG(object):
     HORZ_PX_PER_UNIT = 'horz_px_per_unit'
     VERT_PX_PER_UNIT = 'vert_px_per_unit'
     UNITS_SPECIFIER = 'units_specifier'
+
+
+class TIFF_FLD_TYPE(object):
+    """
+    Tag codes for TIFF Image File Directory (IFD) entries.
+    """
+    BYTE = 1
+    ASCII = 2
+    SHORT = 3
+    LONG = 4
+    RATIONAL = 5
+
+    field_type_names = {
+        1: 'BYTE', 2: 'ASCII char', 3: 'SHORT', 4: 'LONG',
+        5: 'RATIONAL'
+    }
+
+
+TIFF_FLD = TIFF_FLD_TYPE
diff --git a/docx/image/tiff.py b/docx/image/tiff.py
@@ -2,6 +2,7 @@
 
 from __future__ import absolute_import, division, print_function
 
+from .constants import TIFF_FLD
 from .helpers import BIG_ENDIAN, LITTLE_ENDIAN, StreamReader
 from .image import Image
 
@@ -151,14 +152,35 @@ def _IfdEntryFactory(stream_rdr, offset):
     Return an |_IfdEntry| subclass instance containing the value of the
     directory entry at *offset* in *stream_rdr*.
     """
-    raise NotImplementedError
+    ifd_entry_classes = {
+        TIFF_FLD.ASCII:    _AsciiIfdEntry,
+        TIFF_FLD.SHORT:    _ShortIfdEntry,
+        TIFF_FLD.LONG:     _LongIfdEntry,
+        TIFF_FLD.RATIONAL: _RationalIfdEntry,
+    }
+    field_type = stream_rdr.read_short(offset, 2)
+    if field_type in ifd_entry_classes:
+        entry_cls = ifd_entry_classes[field_type]
+    else:
+        entry_cls = _IfdEntry
+    return entry_cls.from_stream(stream_rdr, offset)
 
 
 class _IfdEntry(object):
     """
     Base class for IFD entry classes. Subclasses are differentiated by value
     type, e.g. ASCII, long int, etc.
     """
+    @classmethod
+    def from_stream(cls, stream_rdr, offset):
+        """
+        Return an |_IfdEntry| subclass instance parsed from *stream_rdr* at
+        *offset*. Note this method is common to all subclasses. Override the
+        ``_parse_value()`` method to provide distinctive behavior based on
+        field type.
+        """
+        raise NotImplementedError
+
     @property
     def tag(self):
         """
@@ -172,3 +194,27 @@ def value(self):
         Value of this tag, its type being dependent on the tag.
         """
         raise NotImplementedError
+
+
+class _AsciiIfdEntry(_IfdEntry):
+    """
+    IFD entry having the form of a NULL-terminated ASCII string
+    """
+
+
+class _ShortIfdEntry(_IfdEntry):
+    """
+    IFD entry expressed as a short (2-byte) integer
+    """
+
+
+class _LongIfdEntry(_IfdEntry):
+    """
+    IFD entry expressed as a long (4-byte) integer
+    """
+
+
+class _RationalIfdEntry(_IfdEntry):
+    """
+    IFD entry expressed as a numerator, denominator pair
+    """
diff --git a/tests/image/test_tiff.py b/tests/image/test_tiff.py
@@ -13,7 +13,7 @@
 from docx.compat import BytesIO
 from docx.image.helpers import BIG_ENDIAN, LITTLE_ENDIAN, StreamReader
 from docx.image.tiff import (
-    _IfdEntries, _IfdEntry, _IfdParser, Tiff, _TiffParser
+    _IfdEntries, _IfdEntry, _IfdEntryFactory, _IfdParser, Tiff, _TiffParser
 )
 
 from ..unitutil import (
@@ -251,3 +251,80 @@ def iter_fixture(self, _IfdEntryFactory_, ifd_entry_, ifd_entry_2_):
             ifd_parser, _IfdEntryFactory_, stream_rdr, offsets,
             expected_entries
         )
+
+
+class Describe_IfdEntryFactory(object):
+
+    def it_constructs_the_right_class_for_a_given_ifd_entry(self, fixture):
+        stream_rdr, offset, entry_cls_, ifd_entry_ = fixture
+        ifd_entry = _IfdEntryFactory(stream_rdr, offset)
+        entry_cls_.from_stream.assert_called_once_with(stream_rdr, offset)
+        assert ifd_entry is ifd_entry_
+
+    # fixtures -------------------------------------------------------
+
+    @pytest.fixture(params=[
+        (b'\x66\x66\x00\x01', 'BYTE'),
+        (b'\x66\x66\x00\x02', 'ASCII'),
+        (b'\x66\x66\x00\x03', 'SHORT'),
+        (b'\x66\x66\x00\x04', 'LONG'),
+        (b'\x66\x66\x00\x05', 'RATIONAL'),
+        (b'\x66\x66\x00\x06', 'CUSTOM'),
+    ])
+    def fixture(
+            self, request, ifd_entry_, _IfdEntry_, _AsciiIfdEntry_,
+            _ShortIfdEntry_, _LongIfdEntry_, _RationalIfdEntry_):
+        bytes_, entry_type = request.param
+        entry_cls_ = {
+            'BYTE':     _IfdEntry_,
+            'ASCII':    _AsciiIfdEntry_,
+            'SHORT':    _ShortIfdEntry_,
+            'LONG':     _LongIfdEntry_,
+            'RATIONAL': _RationalIfdEntry_,
+            'CUSTOM':   _IfdEntry_,
+        }[entry_type]
+        stream_rdr = StreamReader(BytesIO(bytes_), BIG_ENDIAN)
+        offset = 0
+        return stream_rdr, offset, entry_cls_, ifd_entry_
+
+    @pytest.fixture
+    def ifd_entry_(self, request):
+        return instance_mock(request, _IfdEntry)
+
+    @pytest.fixture
+    def _IfdEntry_(self, request, ifd_entry_):
+        _IfdEntry_ = class_mock(request, 'docx.image.tiff._IfdEntry')
+        _IfdEntry_.from_stream.return_value = ifd_entry_
+        return _IfdEntry_
+
+    @pytest.fixture
+    def _AsciiIfdEntry_(self, request, ifd_entry_):
+        _AsciiIfdEntry_ = class_mock(
+            request, 'docx.image.tiff._AsciiIfdEntry')
+        _AsciiIfdEntry_.from_stream.return_value = ifd_entry_
+        return _AsciiIfdEntry_
+
+    @pytest.fixture
+    def _ShortIfdEntry_(self, request, ifd_entry_):
+        _ShortIfdEntry_ = class_mock(
+            request, 'docx.image.tiff._ShortIfdEntry')
+        _ShortIfdEntry_.from_stream.return_value = ifd_entry_
+        return _ShortIfdEntry_
+
+    @pytest.fixture
+    def _LongIfdEntry_(self, request, ifd_entry_):
+        _LongIfdEntry_ = class_mock(
+            request, 'docx.image.tiff._LongIfdEntry')
+        _LongIfdEntry_.from_stream.return_value = ifd_entry_
+        return _LongIfdEntry_
+
+    @pytest.fixture
+    def _RationalIfdEntry_(self, request, ifd_entry_):
+        _RationalIfdEntry_ = class_mock(
+            request, 'docx.image.tiff._RationalIfdEntry')
+        _RationalIfdEntry_.from_stream.return_value = ifd_entry_
+        return _RationalIfdEntry_
+
+    @pytest.fixture
+    def offset_(self, request):
+        return instance_mock(request, int)
