emf 0.1.2 → 0.2.0

data/lib/emf/emf_plus/object_chain.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    # Joins continued EmfPlusObject chunks into logical objects. A chain ends
+    # when TotalObjectSize bytes of ObjectData are accumulated, not when the C
+    # flag clears: Windows leaves C set on the final chunk. A final chunk with C
+    # clear (the layout the spec describes) also ends the chain.
+    module ObjectChain
+      # One object, possibly spread over several records. Chunk boundaries and
+      # source records are kept so `split` can return them unchanged.
+      class LogicalObject
+        attr_reader :object_type, :emf_object_id, :data, :chunk_sizes, :offset
+
+        def initialize(chunks)
+          @chunks = chunks.freeze
+          @object_type = chunks.first.object_type
+          @offset = chunks.first.offset
+          @emf_object_id = chunks.first.emf_object_id
+          @data = chunks.map(&:object_data).join.b.freeze
+          @chunk_sizes = chunks.map { |chunk| chunk.object_data.bytesize }.freeze
+          @chunk_flags = chunks.map(&:flags).freeze
+        end
+
+        def total_size = data.bytesize
+
+        # Joined ObjectData decoded by type; works for chained objects, which
+        # no single Records::Object chunk can describe.
+        def body = @body ||= Objects.decode(self)
+
+        # With the original chunk sizes the source records come back as read:
+        # padding, offsets and comment indexes included. Other sizes re-chunk
+        # the data with zero padding, every chunk continued.
+        def split(sizes = chunk_sizes)
+          return @chunks.dup if sizes == chunk_sizes
+
+          check_sizes(sizes)
+          offset = 0
+          sizes.each_with_index.map do |size, index|
+            chunk = data.byteslice(offset, size)
+            offset += size
+            Records.decode(rechunked_frame(chunk, @chunks.fetch(index, @chunks.last)))
+          end
+        end
+
+        private
+
+        def check_sizes(sizes)
+          return if sizes.any? && sizes.all? { |size| size.is_a?(Integer) && size.positive? } && sizes.sum == total_size
+
+          raise ArgumentError, "split sizes #{sizes.inspect} must be positive and sum to #{total_size}"
+        end
+
+        def rechunked_frame(chunk, source)
+          flags = @chunk_flags.first | Records::Object::CONTINUED_FLAG
+          Frame.new(type: Records::Object::TYPE, flags: flags, size: 0, data_size: 0, data: "".b,
+                    offset: source.offset, comment_index: source.comment_index)
+               .with_data([total_size].pack("V") + chunk)
+        end
+      end
+
+      module_function
+
+      # Returns the records with each object (single or chained) as a
+      # LogicalObject; every other record passes through unchanged.
+      def call(records)
+        entries = []
+        queue = records.dup
+        until queue.empty?
+          record = queue.shift
+          entries << (record.is_a?(Records::Object) ? LogicalObject.new(take_chain(record, queue)) : record)
+        end
+        entries
+      end
+
+      def take_chain(first, queue)
+        return [first] unless first.continued?
+
+        chunks = [first]
+        accumulated = first.object_data.bytesize
+        while accumulated < first.total_object_size
+          chunk = next_chunk(first, chunks.last, queue.shift)
+          chunks << chunk
+          accumulated += chunk.object_data.bytesize
+          break unless chunk.continued?
+        end
+        unless accumulated == first.total_object_size
+          fail_chain(first,
+                     "chain holds #{accumulated} bytes, TotalObjectSize is #{first.total_object_size}")
+        end
+        chunks
+      end
+
+      def next_chunk(first, previous, candidate)
+        matches = candidate.is_a?(Records::Object) &&
+                  candidate.object_type == first.object_type && candidate.emf_object_id == first.emf_object_id &&
+                  (!candidate.continued? || candidate.total_object_size == first.total_object_size)
+        fail_chain(previous, "continued EmfPlusObject chain not completed by a matching chunk") unless matches
+        candidate
+      end
+
+      def fail_chain(record, message)
+        raise ParseError.new(offset: record.offset, record_code: record.type,
+                             message: "#{message} (chain started near offset #{record.offset})")
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/object_table.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    # An object ID outside the 64-slot table (0..63).
+    class ObjectIdError < Emf::Error; end
+
+    # The EMF+ object table (MS-EMFPLUS 2.3.5.1): 64 slots, IDs 0..63, over a
+    # sequence of framed records. A stream index is a record's position in that
+    # sequence. A new EmfPlusObject with an existing ID replaces the slot from
+    # its position on, so lookups are time-indexed: `lookup(id, at: n)` returns
+    # the object defined most recently before position n, and ID reuse never
+    # changes what an earlier draw resolved to.
+    #
+    # An object's position is that of its last chunk, the point where it is
+    # complete. Problems found while building are collected in `errors` and
+    # never raised; a record or chain that cannot be placed keeps its records.
+    class ObjectTable
+      SLOTS = 64
+
+      Diagnostic = Struct.new(:kind, :stream_index, :id, :message, :records, keyword_init: true)
+      Resolution = Struct.new(:role, :raw_id, :object, :diagnostic, :solid_color, keyword_init: true)
+      Placement = Struct.new(:stream_index, :logical)
+      private_constant :Placement
+
+      # Reads chain records off a queue of [record, stream index] pairs and
+      # remembers them, so a failed chain can hand back everything it consumed.
+      class Tape
+        attr_reader :taken
+
+        def initialize(queue)
+          @queue = queue
+          @taken = []
+        end
+
+        def shift
+          pair = @queue.shift
+          @taken << pair if pair
+          pair&.first
+        end
+      end
+      private_constant :Tape
+
+      # What each draw record references: [role, object type, reader for the
+      # ID, reader for the S flag or nil].
+      module References
+        PEN = [:pen, Objects::PEN, :pen_id, nil].freeze
+        BRUSH = [:brush, Objects::BRUSH, :brush_id, :solid_color?].freeze
+        FONT = [:font, Objects::FONT, :font_object_id, nil].freeze
+        FORMAT = [:string_format, Objects::STRING_FORMAT, :format_id, nil].freeze
+        IMAGE = [:image, Objects::IMAGE, :image_object_id, nil].freeze
+        IMAGE_ATTRIBUTES = [:image_attributes, Objects::IMAGE_ATTRIBUTES, :image_attributes_id, nil].freeze
+        PATH = [:path, Objects::PATH, :path_id, nil].freeze
+        REGION = [:region, Objects::REGION, :region_id, nil].freeze
+        CLIP_PATH = [:path, Objects::PATH, :emf_object_id, nil].freeze
+        CLIP_REGION = [:region, Objects::REGION, :emf_object_id, nil].freeze
+
+        BY_RECORD = {
+          Records::DrawRects => [PEN], Records::DrawLines => [PEN], Records::DrawEllipse => [PEN],
+          Records::DrawPie => [PEN], Records::DrawArc => [PEN], Records::DrawClosedCurve => [PEN],
+          Records::DrawCurve => [PEN], Records::DrawBeziers => [PEN], Records::DrawPath => [PATH, PEN],
+          Records::FillRects => [BRUSH], Records::FillPolygon => [BRUSH], Records::FillEllipse => [BRUSH],
+          Records::FillPie => [BRUSH], Records::FillClosedCurve => [BRUSH], Records::FillPath => [PATH, BRUSH],
+          Records::FillRegion => [REGION, BRUSH],
+          Records::DrawString => [FONT, BRUSH, FORMAT], Records::DrawDriverString => [FONT, BRUSH],
+          Records::DrawImage => [IMAGE, IMAGE_ATTRIBUTES], Records::DrawImagePoints => [IMAGE, IMAGE_ATTRIBUTES],
+          Records::SetClipPath => [CLIP_PATH], Records::SetClipRegion => [CLIP_REGION]
+        }.freeze
+      end
+      private_constant :References
+
+      attr_reader :errors
+
+      def initialize(records)
+        @placements = Hash.new { |hash, id| hash[id] = [] }
+        @errors = []
+        build(records.to_a)
+        @placements.default_proc = nil
+        @placements.each_value(&:freeze)
+        @errors.freeze
+      end
+
+      # The LogicalObject in slot `id` as of stream position `at` (objects
+      # defined at earlier positions only), or nil when the slot is empty then.
+      def lookup(id, at:) # rubocop:disable Naming/MethodParameterName
+        check_id!(id)
+        placements = @placements.fetch(id, [])
+        placements.reverse_each { |placement| return placement.logical if placement.stream_index < at }
+        nil
+      end
+
+      # All 64 slots as of stream position `at`.
+      def at(stream_index)
+        Array.new(SLOTS) { |id| lookup(id, at: stream_index) }
+      end
+
+      # One Resolution per object reference the record carries, resolved as of
+      # its stream position `at`: the slot's object, or nil with a Diagnostic
+      # (empty slot, wrong object type, ID outside the table). A solid-colour
+      # BrushId is kept raw and not looked up. A record with no references
+      # gives an empty array.
+      def resolve(record, at:) # rubocop:disable Naming/MethodParameterName
+        References::BY_RECORD.fetch(record.class, []).map { |reference| resolution(record, reference, at) }
+      end
+
+      private
+
+      def build(records)
+        queue = records.each_with_index.to_a
+        until queue.empty?
+          record, index = queue.shift
+          place_chain(record, index, queue) if record.is_a?(Records::Object)
+        end
+      end
+
+      def place_chain(first, first_index, queue)
+        tape = Tape.new(queue)
+        chunks = ObjectChain.take_chain(first, tape)
+        place(ObjectChain::LogicalObject.new(chunks), tape.taken.last&.last || first_index)
+      rescue ParseError => e
+        unplaced_chain(first, first_index, queue, tape.taken, e)
+      end
+
+      def place(logical, index)
+        id = logical.emf_object_id
+        if id < SLOTS
+          @placements[id] << Placement.new(index, logical)
+        else
+          add_error(:object_id_out_of_range, index, id, "object ID #{id} is outside 0..#{SLOTS - 1}", logical.split)
+        end
+      end
+
+      def unplaced_chain(first, first_index, queue, taken, error)
+        stray = taken.last
+        queue.unshift(taken.pop) if stray && !chunk_of?(first, stray.first)
+        records = [first] + taken.map(&:first)
+        add_error(:incomplete_chain, taken.last&.last || first_index, first.emf_object_id, error.message, records)
+      end
+
+      def chunk_of?(first, record)
+        record.is_a?(Records::Object) && record.object_type == first.object_type &&
+          record.emf_object_id == first.emf_object_id
+      end
+
+      def add_error(kind, index, id, message, records)
+        @errors << Diagnostic.new(kind: kind, stream_index: index, id: id, message: message, records: records).freeze
+      end
+
+      def check_id!(id)
+        return if id.is_a?(Integer) && id >= 0 && id < SLOTS
+
+        raise ObjectIdError, "object ID #{id.inspect} is outside 0..#{SLOTS - 1}"
+      end
+
+      def resolution(record, (role, type, id_reader, solid_reader), position)
+        raw_id = record.public_send(id_reader).to_i
+        return Resolution.new(role: role, raw_id: raw_id, solid_color: true) if solid_reader && record.public_send(solid_reader)
+
+        found = lookup(raw_id, at: position)
+        kind = problem(found, type)
+        return Resolution.new(role: role, raw_id: raw_id, object: found) unless kind
+
+        diagnostic = Diagnostic.new(kind: kind, stream_index: position, id: raw_id, records: [record],
+                                    message: "#{role} reference #{raw_id}: #{kind.to_s.tr('_', ' ')}").freeze
+        Resolution.new(role: role, raw_id: raw_id, diagnostic: diagnostic)
+      rescue ObjectIdError
+        Resolution.new(role: role, raw_id: raw_id, diagnostic: out_of_range(record, role, raw_id, position))
+      end
+
+      def out_of_range(record, role, raw_id, position)
+        Diagnostic.new(kind: :object_id_out_of_range, stream_index: position, id: raw_id, records: [record],
+                       message: "#{role} reference #{raw_id}: object ID outside 0..#{SLOTS - 1}").freeze
+      end
+
+      def problem(found, type)
+        return :empty_slot unless found
+
+        :wrong_type unless found.object_type == type
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/objects/brush.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require "emf/emf_plus/records/primitives/graphics_version"
+require "emf/emf_plus/records/primitives/argb"
+require "emf/emf_plus/records/primitives/point_f"
+require "emf/emf_plus/records/primitives/rect_f"
+require "emf/emf_plus/records/primitives/transform_matrix"
+require "emf/emf_plus/records/primitives/blend_colors"
+require "emf/emf_plus/records/primitives/blend_factors"
+require "emf/emf_plus/records/primitives/focus_scale_data"
+
+module Emf
+  module EmfPlus
+    module Objects
+      # EmfPlusBrush (2.2.1.1): Version, Type, then the BrushData the Type
+      # selects. Every count is checked against the bytes left before BinData
+      # allocates, so a hostile count cannot hang or exhaust memory.
+      #
+      # The nested EmfPlusPath of a path gradient boundary (BoundaryPathData)
+      # and the EmfPlusImage of a texture brush decode through the Path and
+      # Image objects. A nested body that does not parse stays raw bytes, so
+      # the brush still round-trips.
+      class Brush < Typed
+        SOLID = 0
+        HATCH = 1
+        TEXTURE = 2
+        PATH_GRADIENT = 3
+        LINEAR_GRADIENT = 4
+
+        DATA_PATH = 0x01
+        DATA_TRANSFORM = 0x02
+        DATA_PRESET_COLORS = 0x04
+        DATA_BLEND_FACTORS_H = 0x08
+        DATA_BLEND_FACTORS_V = 0x10
+        DATA_FOCUS_SCALES = 0x40
+
+        P = Records::Primitives
+        private_constant :P
+
+        class BrushHeader < Records::Body
+          endian :little
+          graphics_version :version
+          uint32 :brush_type
+        end
+
+        # EmfPlusSolidBrushData (2.2.2.43).
+        class SolidBrushData < Records::Body
+          endian :little
+          argb :solid_color
+        end
+
+        # EmfPlusHatchBrushData (2.2.2.20).
+        class HatchBrushData < Records::Body
+          endian :little
+          uint32 :hatch_style
+          argb :fore_color
+          argb :back_color
+        end
+
+        # EmfPlusTextureBrushData (2.2.2.45) without OptionalData.
+        class TextureBrushData < Records::Body
+          endian :little
+          uint32 :brush_data_flags
+          int32 :wrap_mode
+        end
+
+        # EmfPlusLinearGradientBrushData (2.2.2.24) without OptionalData.
+        class LinearGradientBrushData < Records::Body
+          endian :little
+          uint32 :brush_data_flags
+          int32 :wrap_mode
+          rect_f :rect_f
+          argb :start_color
+          argb :end_color
+          uint32 :reserved1
+          uint32 :reserved2
+        end
+
+        # EmfPlusPathGradientBrushData (2.2.2.29) up to SurroundingColorCount.
+        class PathGradientBrushData < Records::Body
+          endian :little
+          uint32 :brush_data_flags
+          int32 :wrap_mode
+          argb :center_color
+          point_f :center_point_f
+        end
+
+        class SurroundingColors < Records::Body
+          endian :little
+          uint32 :surrounding_color_count
+          array :surrounding_color, type: :argb, initial_length: :surrounding_color_count
+        end
+
+        # EmfPlusBoundaryPathData (2.2.2.6).
+        class BoundaryPathData < Records::Body
+          endian :little
+          int32 :boundary_path_size
+          string :boundary_path_data, read_length: :boundary_path_size
+        end
+
+        # EmfPlusBoundaryPointData (2.2.2.7).
+        class BoundaryPointData < Records::Body
+          endian :little
+          int32 :boundary_point_count
+          array :boundary_point_data, type: :point_f, initial_length: :boundary_point_count
+        end
+
+        class Malformed < StandardError; end
+        private_constant :Malformed
+
+        module Nested
+          Source = Struct.new(:object_type, :data, :offset)
+
+          module_function
+
+          # The decoded nested object, or nil when its bytes do not parse.
+          def decode(klass, object_type, data)
+            klass.new(Source.new(object_type, data, 0))
+          rescue Emf::ParseError
+            nil
+          end
+        end
+        private_constant :Nested
+
+        # BoundaryPathData with its EmfPlusPath decoded. Size and bytes follow
+        # the path, so an edit to it re-serializes with the right size.
+        class BoundaryPath
+          attr_reader :path
+
+          def initialize(record)
+            @raw = record.boundary_path_data.to_s.b.freeze
+            @path = Nested.decode(Path, PATH, @raw)
+          end
+
+          def boundary_path_data = path ? path.to_binary : @raw
+          def boundary_path_size = boundary_path_data.bytesize
+          def to_binary_s = [boundary_path_size].pack("l<") + boundary_path_data
+          def num_bytes = 4 + boundary_path_size
+        end
+
+        # Ordered pieces of the object; strings are raw nested objects.
+        class Body
+          attr_reader :parts
+
+          def initialize(parts) = @parts = parts
+
+          def version = parts.fetch(:header).version
+
+          def num_bytes = parts.each_value.sum { |part| bytes(part).bytesize }
+
+          def to_binary_s = parts.each_value.map { |part| bytes(part) }.join.b
+
+          private
+
+          def bytes(part)
+            case part
+            when String then part
+            when Typed then part.to_binary
+            else part.to_binary_s
+            end
+          end
+        end
+
+        # Walks the data once, reading each piece the flags select.
+        class Reader
+          def initialize(data)
+            @data = data
+            @pos = 0
+            @parts = {}
+          end
+
+          def read
+            take(:header, BrushHeader)
+            read_brush_data(@parts.fetch(:header).brush_type)
+            Body.new(@parts)
+          end
+
+          private
+
+          def read_brush_data(brush_type)
+            case brush_type
+            when SOLID then take(:data, SolidBrushData)
+            when HATCH then take(:data, HatchBrushData)
+            when TEXTURE then read_texture
+            when PATH_GRADIENT then read_path_gradient
+            when LINEAR_GRADIENT then read_linear_gradient
+            else take_rest(:unknown_data)
+            end
+          end
+
+          def read_texture
+            take(:data, TextureBrushData)
+            take(:transform, P::TransformMatrix) if flag?(DATA_TRANSFORM)
+            take_rest(:image)
+            decode_image
+          end
+
+          def decode_image
+            raw = @parts[:image]
+            return unless raw
+
+            @parts[:image] = Nested.decode(Image, IMAGE, raw) || raw
+          end
+
+          def read_linear_gradient
+            take(:data, LinearGradientBrushData)
+            take(:transform, P::TransformMatrix) if flag?(DATA_TRANSFORM)
+            if flag?(DATA_PRESET_COLORS)
+              take_counted(:blend_colors, P::BlendColors, 8)
+            else
+              # The spec lists the vertical pattern before the horizontal one.
+              take_counted(:blend_factors_v, P::BlendFactors, 8) if flag?(DATA_BLEND_FACTORS_V)
+              take_counted(:blend_factors_h, P::BlendFactors, 8) if flag?(DATA_BLEND_FACTORS_H)
+            end
+          end
+
+          def read_path_gradient
+            take(:data, PathGradientBrushData)
+            take_counted(:surrounding_colors, SurroundingColors, 4)
+            flag?(DATA_PATH) ? read_boundary_path : take_counted(:boundary_points, BoundaryPointData, 8, signed: true)
+            read_path_gradient_optional
+          end
+
+          def read_boundary_path
+            take_counted(:boundary_path, BoundaryPathData, 1, signed: true)
+            @parts[:boundary_path] = BoundaryPath.new(@parts[:boundary_path])
+          end
+
+          def read_path_gradient_optional
+            take(:transform, P::TransformMatrix) if flag?(DATA_TRANSFORM)
+            if flag?(DATA_PRESET_COLORS)
+              take_counted(:blend_colors, P::BlendColors, 8)
+            elsif flag?(DATA_BLEND_FACTORS_H)
+              take_counted(:blend_factors_h, P::BlendFactors, 8)
+            end
+            take(:focus_scales, P::FocusScaleData) if flag?(DATA_FOCUS_SCALES)
+          end
+
+          def flag?(mask) = @parts.fetch(:data).brush_data_flags.anybits?(mask)
+
+          def take(name, klass)
+            record = klass.new
+            raise Malformed, "#{name} needs #{record.num_bytes} bytes, #{remaining} left" if record.num_bytes > remaining
+
+            @parts[name] = record.read(@data.byteslice(@pos..))
+            @pos += record.num_bytes
+          end
+
+          # `item_size` bytes per counted element after the 4-byte count.
+          def take_counted(name, klass, item_size, signed: false)
+            raise Malformed, "#{name} count needs 4 bytes, #{remaining} left" if remaining < 4
+
+            count = @data.byteslice(@pos, 4).unpack1(signed ? "l<" : "V")
+            raise Malformed, "#{name} count #{count} is negative" if count.negative?
+
+            needed = 4 + (count * item_size)
+            raise Malformed, "#{name} of #{count} entries needs #{needed} bytes, #{remaining} left" if needed > remaining
+
+            @parts[name] = klass.read(@data.byteslice(@pos..))
+            @pos += @parts[name].num_bytes
+          end
+
+          def take_rest(name)
+            rest = @data.byteslice(@pos..)
+            @parts[name] = rest.freeze unless rest.empty?
+            @pos += rest.bytesize
+          end
+
+          def remaining = @data.bytesize - @pos
+        end
+
+        def brush_type = body.parts.fetch(:header).brush_type
+        def data = body.parts[:data]
+        def brush_data_flags = data.brush_data_flags
+        def transform = body.parts[:transform]
+        def surrounding_colors = body.parts[:surrounding_colors]
+        def boundary_path = body.parts[:boundary_path]
+        def boundary_points = body.parts[:boundary_points]
+        def blend_colors = body.parts[:blend_colors]
+        def blend_factors_h = body.parts[:blend_factors_h]
+        def blend_factors_v = body.parts[:blend_factors_v]
+        def focus_scales = body.parts[:focus_scales]
+        def image = body.parts[:image]
+        def unknown_data = body.parts[:unknown_data]
+
+        private
+
+        def read_body(data, logical)
+          Reader.new(data).read
+        rescue IOError, BinData::ValidityError, Malformed => e
+          fail_parse(logical, e.message)
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/objects/custom_line_cap.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "emf/binary/float32_le"
+require "emf/emf_plus/records/primitives/graphics_version"
+require "emf/emf_plus/records/primitives/point_f"
+require "emf/emf_plus/records/primitives/path"
+
+module Emf
+  module EmfPlus
+    module Objects
+      # EmfPlusCustomLineCap (2.2.1.2): Version, Type, then the default
+      # (2.2.2.13) or adjustable arrow (2.2.2.12) data the Type selects.
+      class CustomLineCap < Typed
+        DEFAULT = 0
+        ADJUSTABLE_ARROW = 1
+
+        DATA_FILL_PATH = 0x01
+        DATA_LINE_PATH = 0x02
+
+        class CustomLineCapHeader < Records::Body
+          endian :little
+          graphics_version :version
+          uint32 :cap_type
+        end
+
+        # EmfPlusCustomLineCapData (2.2.2.13) without OptionalData.
+        class CustomLineCapDefaultData < Records::Body
+          endian :little
+          uint32 :custom_line_cap_data_flags
+          uint32 :base_cap
+          float32_le :base_inset
+          uint32 :stroke_start_cap
+          uint32 :stroke_end_cap
+          uint32 :stroke_join
+          float32_le :stroke_miter_limit
+          float32_le :width_scale
+          point_f :fill_hot_spot
+          point_f :stroke_hot_spot
+        end
+
+        # EmfPlusCustomLineCapArrowData (2.2.2.12).
+        class CustomLineCapArrowData < Records::Body
+          endian :little
+          float32_le :width
+          float32_le :height
+          float32_le :middle_inset
+          uint32 :fill_state
+          uint32 :line_start_cap
+          uint32 :line_end_cap
+          uint32 :line_join
+          float32_le :line_miter_limit
+          float32_le :width_scale
+          point_f :fill_hot_spot
+          point_f :line_hot_spot
+        end
+
+        P = Records::Primitives
+        private_constant :P
+
+        # Walks the data once, reading the optional paths the flags select.
+        class Reader
+          def initialize(data)
+            @cursor = Parts::Cursor.new(data)
+          end
+
+          def read
+            @cursor.take(:header, CustomLineCapHeader)
+            read_cap_data(@cursor.parts.fetch(:header).cap_type)
+            Parts::Body.new(@cursor.parts)
+          end
+
+          private
+
+          def read_cap_data(cap_type)
+            case cap_type
+            when DEFAULT then read_default
+            when ADJUSTABLE_ARROW then @cursor.take(:data, CustomLineCapArrowData)
+            else @cursor.take_rest(:unknown_data)
+            end
+          end
+
+          def read_default
+            @cursor.take(:data, CustomLineCapDefaultData)
+            flags = @cursor.parts.fetch(:data).custom_line_cap_data_flags
+            @cursor.take_sized(:fill_path) { |bytes| P::Path.new.read(bytes) } if flags.anybits?(DATA_FILL_PATH)
+            @cursor.take_sized(:line_path) { |bytes| P::Path.new.read(bytes) } if flags.anybits?(DATA_LINE_PATH)
+          end
+        end
+
+        def cap_type = body.parts.fetch(:header).cap_type
+        def data = body.parts[:data]
+        def fill_path = body.parts[:fill_path]&.inner
+        def line_path = body.parts[:line_path]&.inner
+        def unknown_data = body.parts[:unknown_data]
+
+        private
+
+        def read_body(data, logical)
+          Reader.new(data).read
+        rescue IOError, BinData::ValidityError, Parts::Malformed => e
+          fail_parse(logical, e.message)
+        end
+      end
+    end
+  end
+end